func TestRateLimitUpdating(t *testing.T) { var resp http.Response resp.StatusCode = 200 resp.Header = http.Header{"Date": []string{"Tue, 10 Oct 2013 20:11:05 GMT"}, "X-Ratelimit-Limit": []string{"600,30000"}, "X-Ratelimit-Usage": []string{"300,10000"}} RateLimiting.updateRateLimits(&resp) if RateLimiting.RequestTime.IsZero() { t.Errorf("rate limiting should set request time") } if v := RateLimiting.FractionReached(); v != 0.5 { t.Errorf("fraction of rate limit computed incorrectly, got %v", v) } resp.Header = http.Header{"Date": []string{"Tue, 10 Oct 2013 20:11:05 GMT"}, "X-Ratelimit-Limit": []string{"600,30000"}, "X-Ratelimit-Usage": []string{"300,27000"}} RateLimiting.updateRateLimits(&resp) if RateLimiting.RequestTime.IsZero() { t.Errorf("rate limiting should set request time") } if v := RateLimiting.FractionReached(); v != 0.9 { t.Errorf("fraction of rate limit computed incorrectly, got %v", v) } // we'll feed it nonsense resp.Header = http.Header{"Date": []string{"Tue, 10 Oct 2013 20:11:05 GMT"}, "X-Ratelimit-Limit": []string{"xxx"}, "X-Ratelimit-Usage": []string{"zzz"}} RateLimiting.updateRateLimits(&resp) if !RateLimiting.RequestTime.IsZero() { t.Errorf("nonsense in rate limiting fields should set next reset to zero") } }
func SimpleResponse(req *http.Request, status int, headers http.Header, body string) *http.Response { res := new(http.Response) body_rdr := (*fixedResBody)(strings.NewReader(body)) res.StatusCode = status res.ProtoMajor = 1 res.ProtoMinor = 1 res.ContentLength = int64((*strings.Reader)(body_rdr).Len()) res.Request = req res.Header = make(map[string][]string) res.Body = body_rdr if headers != nil { res.Header = headers } return res }
func TestGetUser(t *testing.T) { g := New("clientID", "secret", "http://myapp.com/") creds := &common.Credentials{Map: objx.MSI()} testTripperFactory := new(test.TestTripperFactory) testTripper := new(test.TestTripper) testTripperFactory.On("NewTripper", mock.Anything, g).Return(testTripper, nil) testResponse := new(http.Response) testResponse.Header = make(http.Header) testResponse.Header.Set("Content-Type", "application/json") testResponse.StatusCode = 200 testResponse.Body = ioutil.NopCloser(strings.NewReader(`{"name":"their-name","id":"uniqueid","login":"******","email":"*****@*****.**","picture":"http://myface.com/","blog":"http://blog.com/"}`)) testTripper.On("RoundTrip", mock.Anything).Return(testResponse, nil) g.tripperFactory = testTripperFactory user, err := g.GetUser(creds) if assert.NoError(t, err) && assert.NotNil(t, user) { assert.Equal(t, user.Name(), "their-name") assert.Equal(t, user.AuthCode(), "") // doesn't come from google assert.Equal(t, user.Email(), "*****@*****.**") assert.Equal(t, user.AvatarURL(), "http://myface.com/") assert.Equal(t, user.Data()["blog"], "http://blog.com/") googleCreds := user.ProviderCredentials()[googleName] if assert.NotNil(t, googleCreds) { assert.Equal(t, "uniqueid", googleCreds.Get(common.CredentialsKeyID).Str()) } } }
func TestNtlmHeaderParseInvalid(t *testing.T) { res := http.Response{} res.Header = make(map[string][]string) res.Header.Add("Www-Authenticate", base64.StdEncoding.EncodeToString([]byte("NTLM I am a moose"))) _, err := parseChallengeResponse(&res) assert.NotEqual(t, err, nil) }
func TestGetUser(t *testing.T) { testProvider := new(test.TestProvider) creds := new(common.Credentials) testTripperFactory := new(test.TestTripperFactory) testTripper := new(test.TestTripper) testTripperFactory.On("NewTripper", creds, testProvider).Return(testTripper, nil) testResponse := new(http.Response) testResponse.Header = make(http.Header) testResponse.Header.Set("Content-Type", "application/json") testResponse.StatusCode = 200 testResponse.Body = ioutil.NopCloser(strings.NewReader(`{"name":"their-name","id":"uniqueid","login":"******","email":"*****@*****.**","avatar_url":"http://myface.com/","blog":"http://blog.com/"}`)) testTripper.On("RoundTrip", mock.Anything).Return(testResponse, nil) client := &http.Client{Transport: testTripper} testProvider.On("GetClient", creds).Return(client, nil) data, err := Get(testProvider, creds, "endpoint") if assert.NoError(t, err) && assert.NotNil(t, data) { assert.Equal(t, data["name"], "their-name") assert.Equal(t, data["id"], "uniqueid") assert.Equal(t, data["login"], "loginname") assert.Equal(t, data["email"], "*****@*****.**") assert.Equal(t, data["avatar_url"], "http://myface.com/") assert.Equal(t, data["blog"], "http://blog.com/") } }
func TestOAuth2Provider_Non200Response(t *testing.T) { config := &common.Config{ Map: objx.MSI( OAuth2KeyRedirectUrl, OAuth2KeyRedirectUrl, OAuth2KeyScope, OAuth2KeyScope, OAuth2KeyClientID, OAuth2KeyClientID, OAuth2KeySecret, OAuth2KeySecret, OAuth2KeyAuthURL, OAuth2KeyAuthURL, OAuth2KeyTokenURL, OAuth2KeyTokenURL)} testTripperFactory := new(test.TestTripperFactory) testTripper := new(test.TestTripper) testProvider := new(test.TestProvider) testResponse := new(http.Response) testResponse.Header = make(http.Header) testResponse.Header.Set("Content-Type", "text/plain") testResponse.StatusCode = 401 testResponse.Body = ioutil.NopCloser(strings.NewReader("No mate")) testTripperFactory.On("NewTripper", common.EmptyCredentials, mock.Anything).Return(testTripper, nil) testTripper.On("RoundTrip", mock.Anything).Return(testResponse, nil) data := objx.MSI(OAuth2KeyCode, []string{"123"}) _, err := CompleteAuth(testTripperFactory, data, config, testProvider) if assert.Error(t, err) { assert.IsType(t, &common.AuthServerError{}, err) } mock.AssertExpectationsForObjects(t, testTripperFactory.Mock, testTripper.Mock, testProvider.Mock) }
func TestGetUser(t *testing.T) { g := New("clientID", "secret", "http://myapp.com/") creds := &common.Credentials{Map: objx.MSI()} testTripperFactory := new(test.TestTripperFactory) testTripper := new(test.TestTripper) testTripperFactory.On("NewTripper", mock.Anything, g).Return(testTripper, nil) testResponse := new(http.Response) testResponse.Header = make(http.Header) testResponse.Header.Set("Content-Type", "application/json") testResponse.StatusCode = 200 testResponse.Body = ioutil.NopCloser(strings.NewReader(`{"full_name":"their-name","id":"uniqueid","username":"******","avatar_url":"http://myface.com/","online":true}`)) testTripper.On("RoundTrip", mock.Anything).Return(testResponse, nil) g.tripperFactory = testTripperFactory user, err := g.GetUser(creds) if assert.NoError(t, err) && assert.NotNil(t, user) { assert.Equal(t, user.Name(), "their-name") assert.Equal(t, user.AuthCode(), "") assert.Equal(t, user.Nickname(), "loginname") assert.Equal(t, user.Email(), "") // doesn't come from soundcloud assert.Equal(t, user.AvatarURL(), "http://myface.com/") assert.Equal(t, user.Data()["online"], true) } }
func NewTestResponse(status float64, data interface{}, errors []map[string]interface{}, context string, changeInfo api.ChangeInfo) *api.Response { httpResponse := new(http.Response) sro := map[string]interface{}{common.ResponseObjectFieldStatusCode: status, common.ResponseObjectFieldData: data, common.ResponseObjectFieldErrors: errors, common.ResponseObjectFieldChangeInfo: changeInfo, common.ResponseObjectFieldContext: context} session := api.NewSession("project", "company", "apiKey") responseBytes, _ := session.Codec().Marshal(sro, nil) httpResponse.Body = ioutil.NopCloser(bytes.NewBuffer(responseBytes)) httpResponse.Header = make(map[string][]string) response, newResponseErr := api.NewResponse(session, httpResponse) if newResponseErr != nil { panic(fmt.Sprintf("NewTestResponse: %s", newResponseErr)) } return response }
// SetResponseHeaderValues adds a header containing all the passed string values. func SetResponseHeaderValues(resp *http.Response, h string, values []string) { if resp.Header == nil { resp.Header = make(http.Header) } for _, v := range values { resp.Header.Add(h, v) } }
func TestNtlmHeaderParseValid(t *testing.T) { res := http.Response{} res.Header = make(map[string][]string) res.Header.Add("Www-Authenticate", "NTLM "+base64.StdEncoding.EncodeToString([]byte("I am a moose"))) bytes, err := parseChallengeResponse(&res) assert.Equal(t, err, nil) assert.Equal(t, strings.HasPrefix(string(bytes), "NTLM"), false) }
func readFakeResponse(statusCode int, file string, header http.Header) (res http.Response) { body, _ := os.Open(file) response := http.Response{} response.Body = body response.Header = header response.StatusCode = statusCode return response }
// Generate an http.Response using the basic fields func SimpleResponse(req *http.Request, status int, headers http.Header, contentLength int64, body io.Reader) *http.Response { res := new(http.Response) res.StatusCode = status res.ProtoMajor = 1 res.ProtoMinor = 1 res.ContentLength = contentLength res.Request = req res.Header = make(map[string][]string) if body_rdr, ok := body.(io.ReadCloser); ok { res.Body = body_rdr } else if body != nil { res.Body = ioutil.NopCloser(body) } if headers != nil { res.Header = headers } return res }
func TestResponse(t *testing.T) { var resp http.Response resp.StatusCode = http.StatusOK resp.Header = make(http.Header) resp.Header["SID"] = []string{"uuid:1337"} var buf bytes.Buffer resp.Write(&buf) t.Logf("%q", buf.String()) }
func (c *URLCache) Restore(res *http.Response) { res.Status = c.CachedResponse.Status res.StatusCode = c.CachedResponse.StatusCode res.Header = c.CachedResponse.Header res.ContentLength = c.CachedResponse.ContentLength res.TransferEncoding = c.CachedResponse.TransferEncoding res.Body = &ClosableBuffer{bytes.NewReader(c.CachedBody)} res.Header.Set(CachedHeader, CachedHeaderVal) res.Header.Set(CachedMD5Header, c.MD5) }
func MakeTestResponseWithBody(body string) (*Response, error) { testHTTPResponse := new(http.Response) testHTTPResponse.Body = ioutil.NopCloser(bytes.NewBufferString(body)) testHTTPResponse.StatusCode = 200 testHTTPResponse.Header = make(map[string][]string) return NewResponse(GetTestSession(), testHTTPResponse) }
// respFromRecorder builds an http response from a httptest recorder func respFromRecorder(w *httptest.ResponseRecorder) *http.Response { resp := http.Response{} resp.StatusCode = w.Code resp.Header = w.Header() // TODO: fill in the rest of response b := w.Body.Bytes() resp.Body = ioutil.NopCloser(bytes.NewReader(b)) return &resp }
func RedirectResponse(req *http.Request, url string) *http.Response { res := new(http.Response) res.StatusCode = 302 res.ProtoMajor = 1 res.ProtoMinor = 1 res.ContentLength = 0 res.Request = req res.Header = make(map[string][]string) res.Header.Set("Location", url) return res }
func TestGetUser(t *testing.T) { g := New("clientID", "secret", "http://myapp.com/") creds := &common.Credentials{Map: objx.MSI()} testTripperFactory := new(test.TestTripperFactory) testTripper := new(test.TestTripper) testTripperFactory.On("NewTripper", mock.Anything, g).Return(testTripper, nil) testResponse := new(http.Response) testResponse.Header = make(http.Header) testResponse.Header.Set("Content-Type", "application/json") testResponse.StatusCode = 200 testResponse.Body = ioutil.NopCloser(strings.NewReader(`{ "id": "631819186", "name": "their-name", "first_name": "Mat", "last_name": "Ryer", "link": "https://www.facebook.com/matryer", "username": "******", "bio": "http://www.stretchr.com/", "gender": "male", "email": "*****@*****.**", "timezone": -6, "locale": "en_GB", "verified": true, "updated_time": "2013-10-03T19:55:28+0000", "picture": { "url": "http://www.myface.com/" } }`)) testTripper.On("RoundTrip", mock.Anything).Return(testResponse, nil) g.tripperFactory = testTripperFactory user, err := g.GetUser(creds) if assert.NoError(t, err) && assert.NotNil(t, user) { assert.Equal(t, user.Name(), "their-name") assert.Equal(t, user.AuthCode(), "") // doesn't come from github assert.Equal(t, user.Nickname(), "loginname") assert.Equal(t, user.Email(), "*****@*****.**") assert.Equal(t, user.AvatarURL(), "http://www.myface.com/") assert.Equal(t, user.Data()["link"], "https://www.facebook.com/matryer") facebookCreds := user.ProviderCredentials()[facebookName] if assert.NotNil(t, facebookCreds) { assert.Equal(t, "631819186", facebookCreds.Get(common.CredentialsKeyID).Str()) } } }
func TestDecodeCustomDecodableErrorGob(t *testing.T) { buf := new(bytes.Buffer) rw := createResponseWriter(buf) ctx := context.Background() testErr := CustomDecodableError{ Code: 50, Reason: "Halp", } // server error... rw.WriteHeader(500) err := encoding.Gob(0).EncodeResponse()(ctx, rw, &testErr) if err != nil { t.Fatalf("Unable to Encode Response: %s", err) } t.Logf("Body Content: %s", buf.String()) ro := new(http.Response) ro.StatusCode = rw.statusCode ro.Body = ioutil.NopCloser(buf) ro.Header = make(http.Header) ro.Header.Set("Content-Type", "application/gob") resp := new(request) r, err := encoding.Default().DecodeResponse(resp)(ctx, ro) if err != nil { t.Fatalf("Unable to Decode Response: %s", err) } t.Logf("Decode Result: %#v", r) if got, want := reflect.TypeOf(r), reflect.TypeOf(testErr); got != want { t.Fatalf("Type Of:\ngot:\n%s\nwant:\n%s", got, want) } castErr, ok := r.(CustomDecodableError) if !ok { t.Fatal("Unable to cast returned response into an error") } if got, want := castErr.Error(), testErr.Error(); got != want { t.Errorf(".Error():\ngot:\n\t%s\nwant:\n\t%s", got, want) } if got, want := castErr.Code, testErr.Code; got != want { t.Errorf("castErr.Code:\ngot:\n\t%d\nwant:\n\t%d", got, want) } if got, want := castErr.Reason, testErr.Reason; got != want { t.Errorf("castErr.Reason:\ngot:\n\t%s\nwant:\n\t%s", got, want) } }
func TestRuntime_CustomTransport(t *testing.T) { rwrtr := client.RequestWriterFunc(func(req client.Request, _ strfmt.Registry) error { return nil }) result := []task{ {false, "task 1 content", 1}, {false, "task 2 content", 2}, } specDoc, err := spec.Load("../../fixtures/codegen/todolist.simple.yml") specDoc.Spec().BasePath = "/" specDoc.Spec().Host = "localhost:3245" specDoc.Spec().Schemes = []string{"ws", "wss", "https"} if assert.NoError(t, err) { runtime := New(specDoc) runtime.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 := runtime.Submit(&client.Operation{ ID: "getTasks", Params: rwrtr, Reader: client.ResponseReaderFunc(func(response client.Response, consumer httpkit.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 TestGetUser(t *testing.T) { g := New("clientID", "secret", "http://myapp.com/") creds := &common.Credentials{Map: objx.MSI()} testTripperFactory := new(test.TestTripperFactory) testTripper := new(test.TestTripper) testTripperFactory.On("NewTripper", mock.Anything, g).Return(testTripper, nil) testResponse := new(http.Response) testResponse.Header = make(http.Header) testResponse.Header.Set("Content-Type", "application/json") testResponse.StatusCode = 200 testResponse.Body = ioutil.NopCloser(strings.NewReader(`{ "meta": { "code": 200 }, "data": { "username": "******", "bio": "Programer who loves golang", "website": "http://website.com", "profile_picture": "http://myinsta.com", "full_name": "Raquel H", "counts": { "media": 1232323, "followed_by": 123, "follows": 123 }, "id": "12345678" } }`)) testTripper.On("RoundTrip", mock.Anything).Return(testResponse, nil) g.tripperFactory = testTripperFactory user, err := g.GetUser(creds) if assert.NoError(t, err) && assert.NotNil(t, user) { assert.Equal(t, user.Name(), "Raquel H") assert.Equal(t, user.AuthCode(), "") // doesn't come from instagram assert.Equal(t, user.Nickname(), "maggit") assert.Equal(t, user.AvatarURL(), "http://myinsta.com") assert.Equal(t, user.Data()["website"], "http://website.com") instagramCreds := user.ProviderCredentials()[instagramName] if assert.NotNil(t, instagramCreds) { assert.Equal(t, "uniqueid", instagramCreds.Get(common.CredentialsKeyID).Str()) } } }
func (res *HTTPResponseEvent) ToResponse(body bool) *http.Response { raw := new(http.Response) raw.Header = res.Headers raw.ProtoMajor = 1 raw.ProtoMinor = 1 raw.StatusCode = int(res.StatusCode) raw.Status = http.StatusText(raw.StatusCode) raw.TransferEncoding = res.Headers["TransferEncoding"] if body { raw.Body = NewHTTPBody(res.GetContentLength(), res.Content) } return raw }
func TestNtlmHeaderParseInvalidLength(t *testing.T) { res := http.Response{} res.Header = make(map[string][]string) res.Header.Add("Www-Authenticate", "NTL") ret, err := parseChallengeResponse(&res) if ret != nil { t.Errorf("Unexpected challenge response: %v", ret) } if err == nil { t.Errorf("Expected error, got none!") } }
func TestGetUser(t *testing.T) { g := New("clientID", "secret", "http://myapp.com/") creds := &common.Credentials{Map: objx.MSI()} testTripperFactory := new(test.TestTripperFactory) testTripper := new(test.TestTripper) testTripperFactory.On("NewTripper", mock.Anything, g).Return(testTripper, nil) testResponse := new(http.Response) testResponse.Header = make(http.Header) testResponse.Header.Set("Content-Type", "application/json") testResponse.StatusCode = 200 testResponse.Body = ioutil.NopCloser(strings.NewReader(`{ "display_name":"JMWizzler", "email":"*****@*****.**", "external_urls":{ "spotify":"https://open.spotify.com/user/wizzler" }, "href":"https://api.spotify.com/v1/users/wizzler", "id":"wizzler", "images":[{ "height":null, "url":"https://fbcdn.example.com/2330_n.jpg", "width":null }], "type":"user", "uri":"spotify:user:wizzler" }`)) testTripper.On("RoundTrip", mock.Anything).Return(testResponse, nil) g.tripperFactory = testTripperFactory user, err := g.GetUser(creds) if assert.NoError(t, err) && assert.NotNil(t, user) { assert.Equal(t, user.Name(), "JMWizzler") assert.Equal(t, user.AuthCode(), "") // doesn't come from spotify assert.Equal(t, user.Nickname(), "") // doesn't come from spotify assert.Equal(t, user.Email(), "*****@*****.**") assert.Equal(t, user.AvatarURL(), "https://fbcdn.example.com/2330_n.jpg") assert.Equal(t, user.Data()["href"], "https://api.spotify.com/v1/users/wizzler") spotifyCreds := user.ProviderCredentials()[spotifyName] if assert.NotNil(t, spotifyCreds) { assert.Equal(t, "wizzler", spotifyCreds.Get(common.CredentialsKeyID).Str()) } } }
func (c *filterContext) Serve(res *http.Response) { res.Request = c.Request() if res.Header == nil { res.Header = make(http.Header) } if res.Body == nil { res.Body = &bodyBuffer{&bytes.Buffer{}} } c.servedWithResponse = true c.res = res }
func TestResponse(t *testing.T) { under := new(http.Response) under.Status = "the status message" under.StatusCode = 392 under.Header = make(http.Header) under.Header.Set("Blah", "blah blah") under.Body = ioutil.NopCloser(bytes.NewBufferString("some content")) var resp runtime.ClientResponse = response{under} assert.EqualValues(t, under.StatusCode, resp.Code()) assert.Equal(t, under.Status, resp.Message()) assert.Equal(t, "blah blah", resp.GetHeader("blah")) assert.Equal(t, under.Body, resp.Body()) }
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 TestResponse_HTTPStatusCode(t *testing.T) { session := GetTestSession() httpResponse := new(http.Response) httpResponse.Body = ioutil.NopCloser(bytes.NewBufferString(`{}`)) httpResponse.StatusCode = http.StatusNotAcceptable httpResponse.Header = make(map[string][]string) response, err := NewResponse(session, httpResponse) if assert.Nil(t, err) { assert.Equal(t, http.StatusNotAcceptable, response.HTTPStatusCode()) } }
func (t *BadJSONTransport) RoundTrip(r *http.Request) (*http.Response, error) { resp := http.Response{ StatusCode: 200, Proto: "HTTP/1.0", ProtoMajor: 1, ProtoMinor: 0, } header := http.Header{} header.Set("Content-Type", "text/javascript; charset=\"UTF-8\"") resp.Header = header resp.Body = ioutil.NopCloser(bytes.NewBuffer([]byte("i'm bad"))) return &resp, nil }
func (res *HTTPResponseEvent) ToResponse() *http.Response { raw := new(http.Response) raw.Proto = "HTTP" raw.ProtoMajor = 1 raw.ProtoMinor = 1 //raw.Close = true raw.ContentLength = int64(res.Content.Len()) raw.Header = make(http.Header) raw.StatusCode = int(res.Status) res.SetHeader("Content-Length", strconv.Itoa(res.Content.Len())) for i := 0; i < len(res.Headers); i++ { header := res.Headers[i] if strings.EqualFold(header.Name, "Set-Cookie") || strings.EqualFold(header.Name, "Set-Cookie2") { tmp := strings.Split(header.Value, ",") if len(tmp) > 1 { var vlist list.List for _, v := range tmp { if (!strings.Contains(v, "=") || strings.Index(v, "=") > strings.Index(v, ";")) && vlist.Len() > 0 { v = vlist.Back().Value.(string) + "," + v vlist.Remove(vlist.Back()) vlist.PushBack(v) //headerValues.add(headerValues.removeLast() + "," + v); } else { vlist.PushBack(v) } } e := vlist.Front() for { if e == nil { break } raw.Header.Add(header.Name, e.Value.(string)) e = e.Next() } } else { raw.Header.Add(header.Name, header.Value) } } else { raw.Header.Add(header.Name, header.Value) } } if raw.ContentLength > 0 { raw.Body = ioutil.NopCloser(&res.Content) } return raw }