mime_parser_test.go

package rest

import (
	"bytes"
	"fmt"
	"github.com/googollee/go-assert"
	"io"
	"io/ioutil"
	"net/http"
	"net/http/httptest"
	"testing"
)

type FakeMarshaller struct {
	mime string
}

func (m *FakeMarshaller) Mime() string                                  { return m.mime }
func (m *FakeMarshaller) Marshal(w io.Writer, v ...interface{}) error   { return nil }
func (m *FakeMarshaller) Unmarshal(r io.Reader, v ...interface{}) error { return nil }

func TestNewMimeParser(t *testing.T) {
	m1 := &FakeMarshaller{"fake/mime1"}
	m2 := &FakeMarshaller{"fake/mime2"}
	m3 := &FakeMarshaller{"fake/mime3"}
	p := NewMimeParser(m1, m2, m3)
	assert.Equal(t, p.defaultMarshaller, m1)
	assert.Equal(t, p.marshallers, map[string]Marshaller{
		"fake/mime1": m1,
		"fake/mime2": m2,
		"fake/mime3": m3,
	})
}

func TestGetMime(t *testing.T) {
	m1 := &FakeMarshaller{"fake/mime1"}
	m2 := &FakeMarshaller{"fake/mime2"}
	m3 := &FakeMarshaller{"fake/mime3"}
	type Test struct {
		marshallers []Marshaller
		header      http.Header
		field       string
		fallback    Marshaller
		target      Marshaller
	}
	var tests = []Test{
		{[]Marshaller{m1, m2, m3}, http.Header{"Content-Type": []string{"fake/mime1"}}, "Content-Type", m2, m1},
		{[]Marshaller{m1, m2, m3}, http.Header{"Content-Type": []string{"fake/nonexist"}}, "Content-Type", m2, m2},
		{[]Marshaller{m1, m2, m3}, http.Header{"Content-Type": []string{"fake/nonexist"}}, "Content-Type", nil, nil},
	}
	for i, test := range tests {
		req := new(http.Request)
		req.Header = test.header
		ctx := &Context{
			Request: req,
		}
		p := NewMimeParser(test.marshallers...)
		m := p.getMime(ctx, test.field, test.fallback)
		assert.Equal(t, m, test.target, "test %d", i)
	}
}

func TestGetArtType(t *testing.T) {
	func1 := func() {}
	func2 := func(int) {}
	func3 := func(ctx *Context) {}
	func4 := func(w http.ResponseWriter, r *http.Request) {}
	func5 := func(str string) {}
	func6 := func(b bool) {}
	type Test struct {
		handlers []interface{}
		t        string
	}
	var tests = []Test{
		{[]interface{}{func1}, ""},
		{[]interface{}{func2}, "[int]"},
		{[]interface{}{func3}, ""},
		{[]interface{}{func4}, ""},
		{[]interface{}{func5}, "[string]"},
		{[]interface{}{func6}, "[bool]"},
		{[]interface{}{func1, func2}, "[int]"},
		{[]interface{}{func3, func2}, "[int]"},
		{[]interface{}{func4, func2}, "[int]"},
		{[]interface{}{func1, func5}, "[string]"},
		{[]interface{}{func3, func5}, "[string]"},
		{[]interface{}{func4, func5}, "[string]"},
		{[]interface{}{func1, func6}, "[bool]"},
		{[]interface{}{func3, func6}, "[bool]"},
		{[]interface{}{func4, func6}, "[bool]"},
		{[]interface{}{func1, func2, func1}, "[int]"},
		{[]interface{}{func3, func2, func1}, "[int]"},
		{[]interface{}{func4, func2, func1}, "[int]"},
		{[]interface{}{func1, func5, func1}, "[string]"},
		{[]interface{}{func3, func5, func1}, "[string]"},
		{[]interface{}{func4, func5, func1}, "[string]"},
		{[]interface{}{func1, func6, func1}, "[bool]"},
		{[]interface{}{func3, func6, func1}, "[bool]"},
		{[]interface{}{func4, func6, func1}, "[bool]"},
	}
	for i, test := range tests {
		var handlers []Handler
		for _, f := range test.handlers {
			h, err := NewHandler(f)
			if err != nil {
				h, err = newRestHandleFunc(f)
			}
			assert.MustEqual(t, err, nil, "test %d: %s", i, err)
			handlers = append(handlers, h)
		}
		ctx := &Context{
			Handlers: handlers,
		}
		parser := new(MimeParser)
		types := parser.getInputTypes(ctx)
		if types == nil || test.t == "" {
			if types != nil {
				t.Errorf("test %d: type should nil, but %s", i, types)
			}
			continue
		}
		assert.Equal(t, fmt.Sprintf("%v", types), test.t)
	}
}

type mimeMarshaller struct {
	mime string
}

func (m *mimeMarshaller) Mime() string {
	return m.mime
}

func (m *mimeMarshaller) Marshal(w io.Writer, v ...interface{}) error {
	if m.mime == "error" {
		return fmt.Errorf("marshal error")
	}
	fmt.Fprintf(w, "%v", v)
	return nil
}

func (m *mimeMarshaller) Unmarshal(r io.Reader, v ...interface{}) error {
	if m.mime == "error" {
		return fmt.Errorf("unmarshal error")
	}
	if len(v) == 0 {
		return nil
	}
	s, ok := v[0].(*string)
	if ok {
		b, err := ioutil.ReadAll(r)
		if err != nil {
			return err
		}
		*s = string(b)
	}
	return nil
}

func TestMimeParserServe(t *testing.T) {
	f1 := func(s string) {
		assert.Equal(t, s, "1")
	}
	p := Params{"data": 1}
	f2 := func(params Params, s string) int {
		assert.Equal(t, params["data"], 1)
		assert.Equal(t, s, "1")
		return 1
	}
	f3 := func() {}
	f4 := func() HttpResponse {
		return Response(http.StatusBadRequest)
	}
	type Test struct {
		marshallers []Marshaller
		reqHeader   map[string]string
		reqBody     string
		funcs       []interface{}
		code        int
		respHeader  map[string]string
		respBody    string
	}
	var tests = []Test{
		{[]Marshaller{&mimeMarshaller{"mime/type"}}, map[string]string{"Content-Type": "mime/type"}, "1", []interface{}{f1}, http.StatusOK, nil, ""},
		{[]Marshaller{&mimeMarshaller{"mime/type"}}, map[string]string{"Content-Type": "mime/type"}, "1", []interface{}{f2}, http.StatusOK, map[string]string{"Content-Type": "mime/type"}, "[1]"},
		{[]Marshaller{&mimeMarshaller{"mime/type1"}, &mimeMarshaller{"mime/type2"}}, map[string]string{"Content-Type": "mime/type1", "Accept": "mime/type2"}, "1", []interface{}{f2}, http.StatusOK, map[string]string{"Content-Type": "mime/type2"}, "[1]"},
		{[]Marshaller{&mimeMarshaller{"mime/type"}}, nil, "1", []interface{}{f2}, http.StatusOK, map[string]string{"Content-Type": "mime/type"}, "[1]"},
		{[]Marshaller{&mimeMarshaller{"mime/type"}}, nil, "", []interface{}{f4}, http.StatusBadRequest, map[string]string{"Content-Type": "text/plain; charset=utf-8"}, "\n"},
		{nil, nil, "1", []interface{}{f2}, http.StatusOK, nil, "no valid marshaller\n"},
		{nil, nil, "1", []interface{}{f3}, http.StatusOK, nil, ""},
		{[]Marshaller{&mimeMarshaller{"error"}}, nil, "1", []interface{}{f2}, http.StatusOK, nil, "Mime error unmarshal error: unmarshal error\n"},
		{[]Marshaller{&mimeMarshaller{"mime/type"}, &mimeMarshaller{"error"}}, map[string]string{"Accept": "error"}, "1", []interface{}{f2}, http.StatusOK, nil, "Mime error marshal error: marshal error\n"},
	}
	for i, test := range tests {
		parser := NewMimeParser(test.marshallers...)
		req, err := http.NewRequest("GET", "/", bytes.NewBufferString(test.reqBody))
		assert.MustEqual(t, err, nil, "test %d: %s", i, err)
		for k, v := range test.reqHeader {
			req.Header.Set(k, v)
		}
		recorder := httptest.NewRecorder()
		var handlers []Handler
		for _, f := range test.funcs {
			h, err := NewHandler(f)
			if err != nil {
				h, err = newRestHandleFunc(f)
			}
			assert.MustEqual(t, err, nil, "test %d: %s", i, err)
			handlers = append(handlers, h)
		}
		ctx := newContext(recorder, req)
		ctx.Handlers = handlers
		ctx.Params = p
		parser.Serve(ctx)
		for k, v := range test.respHeader {
			assert.Equal(t, recorder.HeaderMap.Get(k), v, "test %d", i)
		}
		assert.Equal(t, recorder.Body.String(), test.respBody, "test %d", i)
	}
}

func TestOutputHaveResponse(t *testing.T) {
	type Test struct {
		output []interface{}
		header map[string]string
		ok     bool
		code   int
		body   string
	}
	var tests = []Test{
		{nil, nil, false, 0, ""},
		{[]interface{}{}, nil, false, 0, ""},
		{[]interface{}{nil}, nil, false, 0, ""},
		{[]interface{}{HttpResponse(nil)}, nil, false, 0, ""},
		{[]interface{}{1, HttpResponse(nil)}, nil, false, 0, ""},
		{[]interface{}{1, Response(http.StatusBadRequest, "bad request")}, nil, true, http.StatusBadRequest, "bad request\n"},
		{[]interface{}{1, Response(http.StatusMovedPermanently)}, map[string]string{"Location": "http://somewhere"}, true, http.StatusBadRequest, "\n"},
	}
	for i, test := range tests {
		parser := NewMimeParser(&mimeMarshaller{"test/mime"})
		req, err := http.NewRequest("GET", "/", nil)
		assert.MustEqual(t, err, nil, "test %d error: %s", i, err)
		resp := httptest.NewRecorder()
		ctx := newContext(resp, req)
		ctx.Output = test.output
		if l := len(ctx.Output); l > 0 {
			if resp, ok := ctx.Output[l-1].(HttpResponse); ok {
				for k, v := range test.header {
					resp.Header().Set(k, v)
				}
			}
		}
		ok := parser.outputHaveResponse(ctx)
		assert.Equal(t, ok, test.ok, "test %d", i)
		if !ok || !test.ok {
			continue
		}
		for k, v := range test.header {
			assert.Equal(t, resp.Header().Get(k), v, "test %d", i)
		}
		assert.Equal(t, resp.Body.String(), test.body, "test %d", i)
	}
}

func TestParseRequestField(t *testing.T) {
	type Test struct {
		header string
		field  string
		ret    string
		pair   map[string]string
	}
	var tests = []Test{
		{"", "Abc", "", nil},
		{"text/plain", "Accept", "text/plain", nil},
		{"text/plain; charset=utf8", "Content-Type", "text/plain", map[string]string{"charset": "utf8"}},
		{"text/plain; charset=utf8;", "Content-Type", "text/plain", map[string]string{"charset": "utf8"}},
		{"text/plain; charset", "Content-Type", "text/plain", map[string]string{"charset": ""}},
		{"text/plain; charset=utf8; skin=new", "Content-Type", "text/plain", map[string]string{"charset": "utf8", "skin": "new"}},
	}

	for i, test := range tests {
		req, err := http.NewRequest("GET", "/", nil)
		if err != nil {
			t.Fatal("invalid request")
		}
		req.Header.Set(test.field, test.header)
		ctx := &Context{
			Request: req,
		}
		parser := NewMimeParser(&mimeMarshaller{"test/mime"})
		ret, pair := parser.parseRequestField(ctx, test.field)
		assert.Equal(t, ret, test.ret, "test %d", i)
		assert.Equal(t, pair, test.pair, "test %d not equal:\nexpect: %v\ngot: %v", i, test.pair, pair)
	}
}