Golang Marshaler.Marshal方法代码示例

func (*JSONPBResponseProcessor) Process(w http.ResponseWriter, model interface{}) error {
	msg := model.(proto.Message)
	w.Header().Set("Content-Type", "application/json")
	marshaler := jsonpb.Marshaler{}

	w.WriteHeader(http.StatusOK)
	marshaler.Marshal(w, msg)
	return nil
}

func handleCollection(collection string, getFunc func(*http.Request) (interface{}, error)) {
	handleAPI(collection+"/", func(w http.ResponseWriter, r *http.Request) error {
		// Get the requested object.
		obj, err := getFunc(r)
		if err != nil {
			if err == topo.ErrNoNode {
				http.NotFound(w, r)
				return nil
			}
			return fmt.Errorf("can't get %v: %v", collection, err)
		}

		// JSON marshals a nil slice as "null", but we prefer "[]".
		if val := reflect.ValueOf(obj); val.Kind() == reflect.Slice && val.IsNil() {
			w.Header().Set("Content-Type", jsonContentType)
			w.Write([]byte("[]"))
			return nil
		}

		// JSON encode response.
		var data []byte
		switch obj := obj.(type) {
		case proto.Message:
			// We use jsonpb for protobuf messages because it is the only supported
			// way to marshal protobuf messages to JSON.
			// In addition to that, it's the only way to emit zero values in the JSON
			// output.
			// Unfortunately, it works only for protobuf messages. Therefore, we use
			// the default marshaler for the remaining structs (which are possibly
			// mixed protobuf and non-protobuf).
			// TODO(mberlin): Switch "EnumAsInts" to "false" once the frontend is
			//                updated and mixed types will use jsonpb as well.
			// Note: jsonpb may panic if the "proto.Message" is an embedded field
			// of "obj" and "obj" has non-exported fields.

			// Marshal the protobuf message.
			var b bytes.Buffer
			m := jsonpb.Marshaler{EnumsAsInts: true, EmitDefaults: true, Indent: "  ", OrigName: true}
			if err := m.Marshal(&b, obj); err != nil {
				return fmt.Errorf("jsonpb error: %v", err)
			}
			data = b.Bytes()
		default:
			data, err = json.MarshalIndent(obj, "", "  ")
			if err != nil {
				return fmt.Errorf("json error: %v", err)
			}
		}
		w.Header().Set("Content-Type", jsonContentType)
		w.Write(data)
		return nil
	})
}

// Returns a valid json collection in bytes and the related jobs
func GetTestJSONCollectionBody(userId uint32, numberOfPayloads int) (*TrackBodyCollection, []*EventAction) {
	collection, wrongCollection, incompleteCollection := GetTestCollectionPairs(userId, numberOfPayloads)
	var collectionBytestream bytes.Buffer
	var disturbedCollectionBytestream bytes.Buffer
	var incompleteCollectionByteStream bytes.Buffer

	m := jsonpb.Marshaler{false, false, "", true}
	m.Marshal(&collectionBytestream, collection)
	m.Marshal(&disturbedCollectionBytestream, wrongCollection)
	m.Marshal(&incompleteCollectionByteStream, incompleteCollection)

	t := &TrackBodyCollection{
		collectionBytestream.Bytes(),
		disturbedCollectionBytestream.Bytes(),
		incompleteCollectionByteStream.Bytes()}
	return t, GetJobsFromCollection(collection)
}

func testABEBulkCreate(t *testing.T) {
	count := 0
	r, w := io.Pipe()
	go func(w io.WriteCloser) {
		defer func() {
			if cerr := w.Close(); cerr != nil {
				t.Errorf("w.Close() failed with %v; want success", cerr)
			}
		}()
		for _, val := range []string{
			"foo", "bar", "baz", "qux", "quux",
		} {
			want := gw.ABitOfEverything{
				FloatValue:               1.5,
				DoubleValue:              2.5,
				Int64Value:               4294967296,
				Uint64Value:              9223372036854775807,
				Int32Value:               -2147483648,
				Fixed64Value:             9223372036854775807,
				Fixed32Value:             4294967295,
				BoolValue:                true,
				StringValue:              fmt.Sprintf("strprefix/%s", val),
				Uint32Value:              4294967295,
				Sfixed32Value:            2147483647,
				Sfixed64Value:            -4611686018427387904,
				Sint32Value:              2147483647,
				Sint64Value:              4611686018427387903,
				NonConventionalNameValue: "camelCase",

				Nested: []*gw.ABitOfEverything_Nested{
					{
						Name:   "hoge",
						Amount: 10,
					},
					{
						Name:   "fuga",
						Amount: 20,
					},
				},
			}
			var m jsonpb.Marshaler
			if err := m.Marshal(w, &want); err != nil {
				t.Fatalf("m.Marshal(%#v, w) failed with %v; want success", want, err)
			}
			if _, err := io.WriteString(w, "\n"); err != nil {
				t.Errorf("w.Write(%q) failed with %v; want success", "\n", err)
				return
			}
			count++
		}
	}(w)
	url := "http://localhost:8080/v1/example/a_bit_of_everything/bulk"
	resp, err := http.Post(url, "application/json", r)
	if err != nil {
		t.Errorf("http.Post(%q) failed with %v; want success", url, err)
		return
	}
	defer resp.Body.Close()
	buf, err := ioutil.ReadAll(resp.Body)
	if err != nil {
		t.Errorf("iotuil.ReadAll(resp.Body) failed with %v; want success", err)
		return
	}

	if got, want := resp.StatusCode, http.StatusOK; got != want {
		t.Errorf("resp.StatusCode = %d; want %d", got, want)
		t.Logf("%s", buf)
	}

	var msg empty.Empty
	if err := jsonpb.UnmarshalString(string(buf), &msg); err != nil {
		t.Errorf("jsonpb.UnmarshalString(%s, &msg) failed with %v; want success", buf, err)
		return
	}

	if got, want := resp.Header.Get("Grpc-Metadata-Count"), fmt.Sprintf("%d", count); got != want {
		t.Errorf("Grpc-Header-Count was %q, wanted %q", got, want)
	}

	if got, want := resp.Trailer.Get("Grpc-Trailer-Foo"), "foo2"; got != want {
		t.Errorf("Grpc-Trailer-Foo was %q, wanted %q", got, want)
	}
	if got, want := resp.Trailer.Get("Grpc-Trailer-Bar"), "bar2"; got != want {
		t.Errorf("Grpc-Trailer-Bar was %q, wanted %q", got, want)
	}
}