func TestRuntime_OverrideClientOperation(t *testing.T) { client := &http.Client{} rt := NewWithClient("", "/", []string{"https"}, client) var i int rt.clientOnce.Do(func() { i++ }) assert.Equal(t, client, rt.client) assert.Equal(t, 0, i) var seen *http.Client rt.do = func(_ context.Context, cl *http.Client, _ *http.Request) (*http.Response, error) { seen = cl res := new(http.Response) res.StatusCode = 200 res.Body = ioutil.NopCloser(bytes.NewBufferString("OK")) return res, nil } client2 := new(http.Client) client2.Timeout = 3 * time.Second if assert.NotEqual(t, client, client2) { _, err := rt.Submit(&runtime.ClientOperation{ Client: client2, Params: runtime.ClientRequestWriterFunc(func(r runtime.ClientRequest, _ strfmt.Registry) error { return nil }), Reader: runtime.ClientResponseReaderFunc(func(_ runtime.ClientResponse, _ runtime.Consumer) (interface{}, error) { return nil, nil }), }) if assert.NoError(t, err) { assert.Equal(t, client2, seen) } } }
func TestBuildRequest_BuildHTTP_XMLPayload(t *testing.T) { bd := []struct { XMLName xml.Name `xml:"person"` Name string `xml:"name"` Hobby string `xml:"hobby"` }{{xml.Name{}, "Tom", "Organ trail"}, {xml.Name{}, "John", "Bird watching"}} reqWrtr := runtime.ClientRequestWriterFunc(func(req runtime.ClientRequest, reg strfmt.Registry) error { req.SetBodyParam(bd) req.SetQueryParam("hello", "world") req.SetPathParam("id", "1234") req.SetHeaderParam("X-Rate-Limit", "200") return nil }) r, _ := newRequest("GET", "/flats/{id}/", reqWrtr) r.SetHeaderParam(runtime.HeaderContentType, runtime.XMLMime) req, err := r.BuildHTTP(runtime.XMLMime, testProducers, nil) if assert.NoError(t, err) && assert.NotNil(t, req) { assert.Equal(t, "200", req.Header.Get("x-rate-limit")) assert.Equal(t, "world", req.URL.Query().Get("hello")) assert.Equal(t, "/flats/1234/", req.URL.Path) expectedBody, _ := xml.Marshal(bd) actualBody, _ := ioutil.ReadAll(req.Body) assert.Equal(t, expectedBody, actualBody) } }
func TestRuntime_CustomCookieJar(t *testing.T) { server := httptest.NewServer(http.HandlerFunc(func(rw http.ResponseWriter, req *http.Request) { authenticated := false for _, cookie := range req.Cookies() { if cookie.Name == "sessionid" && cookie.Value == "abc" { authenticated = true } } if !authenticated { username, password, ok := req.BasicAuth() if ok && username == "username" && password == "password" { authenticated = true http.SetCookie(rw, &http.Cookie{Name: "sessionid", Value: "abc"}) } } if authenticated { rw.Header().Add(runtime.HeaderContentType, runtime.JSONMime) rw.WriteHeader(http.StatusOK) jsongen := json.NewEncoder(rw) jsongen.Encode([]task{}) } else { rw.WriteHeader(http.StatusUnauthorized) } })) defer server.Close() rwrtr := runtime.ClientRequestWriterFunc(func(req runtime.ClientRequest, _ strfmt.Registry) error { return nil }) hu, _ := url.Parse(server.URL) rt := New(hu.Host, "/", []string{"http"}) rt.Jar, _ = cookiejar.New(nil) submit := func(authInfo runtime.ClientAuthInfoWriter) { _, err := rt.Submit(&runtime.ClientOperation{ ID: "getTasks", Method: "GET", PathPattern: "/", Params: rwrtr, AuthInfo: authInfo, Reader: runtime.ClientResponseReaderFunc(func(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error) { if response.Code() == 200 { return nil, nil } return nil, errors.New("Generic error") }), }) assert.NoError(t, err) } submit(BasicAuth("username", "password")) submit(nil) }
func TestRuntime_ChunkedResponse(t *testing.T) { // test that it can make a simple request // and get the response for it. // defaults all the way down result := []task{ {false, "task 1 content", 1}, {false, "task 2 content", 2}, } server := httptest.NewServer(http.HandlerFunc(func(rw http.ResponseWriter, req *http.Request) { if req.Header.Get("Authorization") != "Bearer the-super-secret-token" { rw.WriteHeader(400) return } rw.Header().Add(runtime.HeaderTransferEncoding, "chunked") rw.Header().Add(runtime.HeaderContentType, runtime.JSONMime+";charset=utf-8") rw.WriteHeader(http.StatusOK) jsongen := json.NewEncoder(rw) jsongen.Encode(result) })) defer server.Close() rwrtr := runtime.ClientRequestWriterFunc(func(req runtime.ClientRequest, _ strfmt.Registry) error { return nil }) //specDoc, err := spec.Load("../../fixtures/codegen/todolist.simple.yml") hu, _ := url.Parse(server.URL) rt := New(hu.Host, "/", []string{"http"}) res, err := rt.Submit(&runtime.ClientOperation{ ID: "getTasks", Method: "GET", PathPattern: "/", Schemes: []string{"http"}, Params: rwrtr, Reader: runtime.ClientResponseReaderFunc(func(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error) { if response.Code() == 200 { var result []task if err := consumer.Consume(response.Body(), &result); err != nil { return nil, err } return result, nil } return nil, errors.New("Generic error") }), AuthInfo: BearerToken("the-super-secret-token"), }) if assert.NoError(t, err) { assert.IsType(t, []task{}, res) actual := res.([]task) assert.EqualValues(t, result, actual) } }
func TestRuntime_PickConsumer(t *testing.T) { result := []task{ {false, "task 1 content", 1}, {false, "task 2 content", 2}, } server := httptest.NewServer(http.HandlerFunc(func(rw http.ResponseWriter, req *http.Request) { if req.Header.Get("Content-Type") != "application/octet-stream" { rw.Header().Add(runtime.HeaderContentType, runtime.JSONMime+";charset=utf-8") rw.WriteHeader(400) return } rw.Header().Add(runtime.HeaderContentType, runtime.JSONMime+";charset=utf-8") rw.WriteHeader(http.StatusOK) jsongen := json.NewEncoder(rw) jsongen.Encode(result) })) defer server.Close() rwrtr := runtime.ClientRequestWriterFunc(func(req runtime.ClientRequest, _ strfmt.Registry) error { req.SetBodyParam(bytes.NewBufferString("hello")) return nil }) hu, _ := url.Parse(server.URL) rt := New(hu.Host, "/", []string{"http"}) res, err := rt.Submit(&runtime.ClientOperation{ ID: "getTasks", Method: "POST", PathPattern: "/", Schemes: []string{"http"}, ConsumesMediaTypes: []string{"application/octet-stream"}, Params: rwrtr, Reader: runtime.ClientResponseReaderFunc(func(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error) { if response.Code() == 200 { var result []task if err := consumer.Consume(response.Body(), &result); err != nil { return nil, err } return result, nil } return nil, errors.New("Generic error") }), AuthInfo: BearerToken("the-super-secret-token"), }) if assert.NoError(t, err) { assert.IsType(t, []task{}, res) actual := res.([]task) assert.EqualValues(t, result, actual) } }
func TestRuntime_CustomTransport(t *testing.T) { rwrtr := runtime.ClientRequestWriterFunc(func(req runtime.ClientRequest, _ strfmt.Registry) error { return nil }) result := []task{ {false, "task 1 content", 1}, {false, "task 2 content", 2}, } rt := New("localhost:3245", "/", []string{"ws", "wss", "https"}) rt.Transport = roundTripperFunc(func(req *http.Request) (*http.Response, error) { if req.URL.Scheme != "https" { return nil, errors.New("this was not a https request") } var resp http.Response resp.StatusCode = 200 resp.Header = make(http.Header) resp.Header.Set("content-type", "application/json") buf := bytes.NewBuffer(nil) enc := json.NewEncoder(buf) enc.Encode(result) resp.Body = ioutil.NopCloser(buf) return &resp, nil }) res, err := rt.Submit(&runtime.ClientOperation{ ID: "getTasks", Method: "GET", PathPattern: "/", Schemes: []string{"ws", "wss", "https"}, Params: rwrtr, Reader: runtime.ClientResponseReaderFunc(func(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error) { if response.Code() == 200 { var result []task if err := consumer.Consume(response.Body(), &result); err != nil { return nil, err } return result, nil } return nil, errors.New("Generic error") }), }) if assert.NoError(t, err) { assert.IsType(t, []task{}, res) actual := res.([]task) assert.EqualValues(t, result, actual) } }
func TestRuntime_XMLCanary(t *testing.T) { // test that it can make a simple XML request // and get the response for it. result := tasks{ Tasks: []task{ {false, "task 1 content", 1}, {false, "task 2 content", 2}, }, } server := httptest.NewServer(http.HandlerFunc(func(rw http.ResponseWriter, req *http.Request) { rw.Header().Add(runtime.HeaderContentType, runtime.XMLMime) rw.WriteHeader(http.StatusOK) xmlgen := xml.NewEncoder(rw) xmlgen.Encode(result) })) defer server.Close() rwrtr := runtime.ClientRequestWriterFunc(func(req runtime.ClientRequest, _ strfmt.Registry) error { return nil }) hu, _ := url.Parse(server.URL) rt := New(hu.Host, "/", []string{"http"}) res, err := rt.Submit(&runtime.ClientOperation{ ID: "getTasks", Method: "GET", PathPattern: "/", Params: rwrtr, Reader: runtime.ClientResponseReaderFunc(func(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error) { if response.Code() == 200 { var result tasks if err := consumer.Consume(response.Body(), &result); err != nil { return nil, err } return result, nil } return nil, errors.New("Generic error") }), }) if assert.NoError(t, err) { assert.IsType(t, tasks{}, res) actual := res.(tasks) assert.EqualValues(t, result, actual) } }
func TestRuntime_PreserveTrailingSlash(t *testing.T) { var redirected bool server := httptest.NewServer(http.HandlerFunc(func(rw http.ResponseWriter, req *http.Request) { rw.Header().Add(runtime.HeaderContentType, runtime.JSONMime+";charset=utf-8") if req.URL.Path == "/api/tasks" { redirected = true return } if req.URL.Path == "/api/tasks/" { rw.WriteHeader(http.StatusOK) } })) defer server.Close() hu, _ := url.Parse(server.URL) rt := New(hu.Host, "/", []string{"http"}) rwrtr := runtime.ClientRequestWriterFunc(func(req runtime.ClientRequest, _ strfmt.Registry) error { return nil }) _, err := rt.Submit(&runtime.ClientOperation{ ID: "getTasks", Method: "GET", PathPattern: "/api/tasks/", Params: rwrtr, Reader: runtime.ClientResponseReaderFunc(func(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error) { if redirected { return nil, errors.New("expected Submit to preserve trailing slashes - this caused a redirect") } if response.Code() == http.StatusOK { return nil, nil } return nil, errors.New("Generic error") }), }) assert.NoError(t, err) }
func TestBuildRequest_BuildHTTP_Form(t *testing.T) { reqWrtr := runtime.ClientRequestWriterFunc(func(req runtime.ClientRequest, reg strfmt.Registry) error { req.SetFormParam("something", "some value") req.SetQueryParam("hello", "world") req.SetPathParam("id", "1234") req.SetHeaderParam("X-Rate-Limit", "200") return nil }) r, _ := newRequest("GET", "/flats/{id}/", reqWrtr) r.SetHeaderParam(runtime.HeaderContentType, runtime.JSONMime) req, err := r.BuildHTTP(runtime.JSONMime, testProducers, nil) if assert.NoError(t, err) && assert.NotNil(t, req) { assert.Equal(t, "200", req.Header.Get("x-rate-limit")) assert.Equal(t, "world", req.URL.Query().Get("hello")) assert.Equal(t, "/flats/1234/", req.URL.Path) expected := []byte("something=some+value") actual, _ := ioutil.ReadAll(req.Body) assert.Equal(t, expected, actual) } }
func TestBuildRequest_BuildHTTP_TextPayload(t *testing.T) { bd := "Tom: Organ trail; John: Bird watching" reqWrtr := runtime.ClientRequestWriterFunc(func(req runtime.ClientRequest, reg strfmt.Registry) error { req.SetBodyParam(bd) req.SetQueryParam("hello", "world") req.SetPathParam("id", "1234") req.SetHeaderParam("X-Rate-Limit", "200") return nil }) r, _ := newRequest("GET", "/flats/{id}/", reqWrtr) r.SetHeaderParam(runtime.HeaderContentType, runtime.TextMime) req, err := r.BuildHTTP(runtime.TextMime, testProducers, nil) if assert.NoError(t, err) && assert.NotNil(t, req) { assert.Equal(t, "200", req.Header.Get("x-rate-limit")) assert.Equal(t, "world", req.URL.Query().Get("hello")) assert.Equal(t, "/flats/1234/", req.URL.Path) expectedBody := []byte(bd) actualBody, _ := ioutil.ReadAll(req.Body) assert.Equal(t, expectedBody, actualBody) } }
func TestBuildRequest_BuildHTTP_Files(t *testing.T) { cont, _ := ioutil.ReadFile("./runtime.go") reqWrtr := runtime.ClientRequestWriterFunc(func(req runtime.ClientRequest, reg strfmt.Registry) error { req.SetFormParam("something", "some value") req.SetFileParam("file", mustGetFile("./runtime.go")) req.SetQueryParam("hello", "world") req.SetPathParam("id", "1234") req.SetHeaderParam("X-Rate-Limit", "200") return nil }) r, _ := newRequest("GET", "/flats/{id}/", reqWrtr) r.SetHeaderParam(runtime.HeaderContentType, runtime.JSONMime) req, err := r.BuildHTTP(runtime.JSONMime, testProducers, nil) if assert.NoError(t, err) && assert.NotNil(t, req) { assert.Equal(t, "200", req.Header.Get("x-rate-limit")) assert.Equal(t, "world", req.URL.Query().Get("hello")) assert.Equal(t, "/flats/1234/", req.URL.Path) mediaType, params, err := mime.ParseMediaType(req.Header.Get(runtime.HeaderContentType)) if assert.NoError(t, err) { assert.Equal(t, runtime.MultipartFormMime, mediaType) boundary := params["boundary"] mr := multipart.NewReader(req.Body, boundary) defer req.Body.Close() frm, err := mr.ReadForm(1 << 20) if assert.NoError(t, err) { assert.Equal(t, "some value", frm.Value["something"][0]) mpff := frm.File["file"][0] mpf, _ := mpff.Open() defer mpf.Close() assert.Equal(t, "runtime.go", mpff.Filename) actual, _ := ioutil.ReadAll(mpf) assert.Equal(t, cont, actual) } } } }
func TestRuntime_Concurrent(t *testing.T) { // test that it can make a simple request // and get the response for it. // defaults all the way down result := []task{ {false, "task 1 content", 1}, {false, "task 2 content", 2}, } server := httptest.NewServer(http.HandlerFunc(func(rw http.ResponseWriter, req *http.Request) { rw.Header().Add(runtime.HeaderContentType, runtime.JSONMime) rw.WriteHeader(http.StatusOK) jsongen := json.NewEncoder(rw) jsongen.Encode(result) })) defer server.Close() rwrtr := runtime.ClientRequestWriterFunc(func(req runtime.ClientRequest, _ strfmt.Registry) error { return nil }) hu, _ := url.Parse(server.URL) rt := New(hu.Host, "/", []string{"http"}) resCC := make(chan interface{}) errCC := make(chan error) var res interface{} var err error for j := 0; j < 6; j++ { go func() { resC := make(chan interface{}) errC := make(chan error) go func() { var resp interface{} var errp error for i := 0; i < 3; i++ { resp, errp = rt.Submit(&runtime.ClientOperation{ ID: "getTasks", Method: "GET", PathPattern: "/", Params: rwrtr, Reader: runtime.ClientResponseReaderFunc(func(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error) { if response.Code() == 200 { var result []task if err := consumer.Consume(response.Body(), &result); err != nil { return nil, err } return result, nil } return nil, errors.New("Generic error") }), }) <-time.After(100 * time.Millisecond) } resC <- resp errC <- errp }() resCC <- <-resC errCC <- <-errC }() } c := 6 for c > 0 { res = <-resCC err = <-errCC c-- } if assert.NoError(t, err) { assert.IsType(t, []task{}, res) actual := res.([]task) assert.EqualValues(t, result, actual) } }