common/prpc, tools/cmd/cproto: prpc client

server/prpc/decoding_test.go

 // Copyright 2016 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 package prpc
 
 import (
         "bytes"
         "encoding/base64"
         "io/ioutil"
@@ skipping 38 matching lines @@
 
                 test(mtJSON, formatJSONPB, nil)
                 test(mtJSON+"; whatever=true", formatJSONPB, nil)
 
                 test("x", 0, `"x" is not supported`)
                 test("x,y", 0, "mime: expected slash after first token")
         })
 
         Convey("readMessage", t, func() {
                 var msg HelloRequest
-                read := func(contentType string, body []byte) error {
+                read := func(contentType string, body []byte) *protocolError {
                         req := &http.Request{
                                 Body:   ioutil.NopCloser(bytes.NewBuffer(body)),
                                 Header: http.Header{},
                         }
                         req.Header.Set("Content-Type", contentType)
                         return readMessage(req, &msg)
                 }
 
                 testLucy := func(contentType string, body []byte) {
                         err := read(contentType, body)
                         So(err, ShouldBeNil)
                         So(msg.Name, ShouldEqual, "Lucy")
                 }
 
                 Convey("binary", func() {
                         testMsg := &HelloRequest{Name: "Lucy"}
                         body, err := proto.Marshal(testMsg)
                         So(err, ShouldBeNil)
 
                         Convey(mtPRPC, func() {
                                 testLucy(mtPRPC, body)
                         })
                         Convey(mtPRPCBinary, func() {
                                 testLucy(mtPRPCBinary, body)
                         })
                         Convey("malformed body", func() {
                                 err := read(mtPRPCBinary, []byte{0})
                                 So(err, ShouldNotBeNil)
-                                So(ErrorStatus(err), ShouldEqual, http.StatusBadRequest)
+                                So(err.status, ShouldEqual, http.StatusBadRequest)
                         })
                         Convey("empty body", func() {
                                 err := read(mtPRPCBinary, nil)
                                 So(err, ShouldBeNil)
                         })
                 })
 
                 Convey("json", func() {
                         body := []byte(`{"name": "Lucy"}`)
                         Convey(mtJSON, func() {
                                 testLucy(mtJSON, body)
                         })
                         Convey(mtPRPCJSNOPB, func() {
                                 testLucy(mtPRPCJSNOPB, body)
                         })
                         Convey("malformed body", func() {
                                 err := read(mtPRPCJSNOPB, []byte{0})
                                 So(err, ShouldNotBeNil)
-                                So(ErrorStatus(err), ShouldEqual, http.StatusBadRequest)
+                                So(err.status, ShouldEqual, http.StatusBadRequest)
                         })
                         Convey("empty body", func() {
                                 err := read(mtPRPCJSNOPB, nil)
                                 So(err, ShouldBeNil)
                         })
                 })
 
                 Convey("text", func() {
                         Convey(mtPRPCText, func() {
                                 body := []byte(`name: "Lucy"`)
                                 testLucy(mtPRPCText, body)
                         })
                         Convey("malformed body", func() {
                                 err := read(mtPRPCText, []byte{0})
                                 So(err, ShouldNotBeNil)
-                                So(ErrorStatus(err), ShouldEqual, http.StatusBadRequest)
+                                So(err.status, ShouldEqual, http.StatusBadRequest)
                         })
                         Convey("empty body", func() {
                                 err := read(mtPRPCText, nil)
                                 So(err, ShouldBeNil)
                         })
                 })
 
                 Convey("unsupported media type", func() {
                         err := read("blah", nil)
                         So(err, ShouldNotBeNil)
-                        So(ErrorStatus(err), ShouldEqual, http.StatusUnsupportedMediaType)
+                        So(err.status, ShouldEqual, http.StatusUnsupportedMediaType)
                 })
         })
 
         Convey("parseHeader", t, func() {
                 c := context.Background()
 
                 header := func(name, value string) http.Header {
                         return http.Header{
                                 name: []string{value},
                         }
@@ skipping 73 matching lines @@
                                 })
                                 Convey("Fails", func() {
                                         c2, err := parseHeader(c, header("Name-Bin", "zzz"))
                                         So(c2, ShouldEqual, c)
                                         So(err, ShouldErrLike, "Name-Bin header: illegal base64 data at input byte 0")
                                 })
                         })
                 })
         })
 }