func ResponseToJso(o *otto.Object, w *http.Response) {
o.Set("status", w.Status)
o.Set("header", w.Header)
o.Set("cookies", w.Cookies())
o.Set("statusCode", w.StatusCode)
o.Set("proto", w.Proto)
c, _ := ioutil.ReadAll(w.Body)
o.Set("body", string(c))
if w.TLS != nil {
o.Set("tlsServerName", w.TLS.ServerName)
o.Set("tlsNegotiatedProtocol", w.TLS.NegotiatedProtocol)
names := []string{}
ips := []string{}
for _, k := range w.TLS.PeerCertificates {
for _, n := range k.DNSNames {
names = append(names, n)
}
for _, n := range k.IPAddresses {
ips = append(ips, n.String())
}
}
o.Set("tlsDNSNames", names)
o.Set("tlsIPs", ips)
}
}
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)
}
// handleResp handles the responses from the etcd server
// If status code is OK, read the http body and return it as byte array
// If status code is TemporaryRedirect, update leader.
// If status code is InternalServerError, sleep for 200ms.
func (c *Client) handleResp(resp *http.Response) (bool, []byte) {
defer resp.Body.Close()
code := resp.StatusCode
if code == http.StatusTemporaryRedirect {
u, err := resp.Location()
if err != nil {
logger.Warning(err)
} else {
c.cluster.updateLeaderFromURL(u)
}
return false, nil
} else if code == http.StatusInternalServerError {
time.Sleep(time.Millisecond * 200)
} else if validHttpStatusCode[code] {
b, err := ioutil.ReadAll(resp.Body)
if err != nil {
return false, nil
}
return true, b
}
logger.Warning("bad status code ", resp.StatusCode)
return false, nil
}
func getSessionAndAppPort(url string, rPort uint16) (*http.Cookie, *http.Cookie, string) {
var client http.Client
var req *http.Request
var resp *http.Response
var err error
var port []byte
uri := fmt.Sprintf("http://%s:%d/sticky", url, rPort)
req, err = http.NewRequest("GET", uri, nil)
Expect(err).ToNot(HaveOccurred())
resp, err = client.Do(req)
Expect(err).ToNot(HaveOccurred())
port, err = ioutil.ReadAll(resp.Body)
Expect(err).ToNot(HaveOccurred())
var sessionCookie, vcapCookie *http.Cookie
for _, cookie := range resp.Cookies() {
if cookie.Name == proxy.StickyCookieKey {
sessionCookie = cookie
} else if cookie.Name == proxy.VcapCookieId {
vcapCookie = cookie
}
}
return sessionCookie, vcapCookie, string(port)
}
func TestDealWithItParentTest(t *testing.T) {
stub := StubHandler().(*stubHandler)
target := ChartHandler(make(chan bool), &Results{}, stub).(*chartHandler)
expectedData := []byte("Expected Data")
var response http.Response
response.Body = nopCloser{bytes.NewBuffer(expectedData)}
testTime := time.Now()
timer := StubTimer(testTime, testTime.Add(time.Hour))
go func() {
<-target.logger
}()
target.DealWithIt(response, &timer)
if stub.dealCalled == 0 {
t.Errorf("TestDealWithItParent: Failed to call DealWithIt on the parent")
}
result, err := ioutil.ReadAll(stub.savedBody)
if err != nil {
t.Errorf("TestDealWithItParent: Failed to read expected data from parent call, err %v", err)
}
if !bytes.Equal(result, expectedData) {
t.Errorf("TestDealWithItParent: Expected '%v' but got '%v'", expectedData, result)
}
}
func prepareResponseHeaders(res *http.Response) {
// remove global hop-by-hop headers.
for _, h := range hopHeaders {
res.Header.Del(h)
}
// remove the Upgrade header and headers referenced in the Connection
// header if HTTP < 1.1 or if Connection header didn't contain "upgrade":
// https://tools.ietf.org/html/rfc7230#section-6.7
if !res.ProtoAtLeast(1, 1) || !isConnectionUpgrade(res.Header) {
res.Header.Del("Upgrade")
// A proxy or gateway MUST parse a received Connection header field before a
// message is forwarded and, for each connection-option in this field, remove
// any header field(s) from the message with the same name as the
// connection-option, and then remove the Connection header field itself (or
// replace it with the intermediary's own connection options for the
// forwarded message): https://tools.ietf.org/html/rfc7230#section-6.1
tokens := strings.Split(res.Header.Get("Connection"), ",")
for _, hdr := range tokens {
res.Header.Del(hdr)
}
res.Header.Del("Connection")
}
}
// Do sends an HTTP request with the provided http.Client and returns an HTTP response.
// If the client is nil, http.DefaultClient is used.
// If the context is canceled or times out, ctx.Err() will be returned.
func Do(ctx context.Context, client *http.Client, req *http.Request) (*http.Response, error) {
if client == nil {
client = http.DefaultClient
}
// Request cancelation changed in Go 1.5, see cancelreq.go and cancelreq_go14.go.
cancel := canceler(client, req)
type responseAndError struct {
resp *http.Response
err error
}
result := make(chan responseAndError, 1)
// Make local copies of test hooks closed over by goroutines below.
// Prevents data races in tests.
testHookDoReturned := testHookDoReturned
testHookDidBodyClose := testHookDidBodyClose
go func() {
resp, err := client.Do(req)
testHookDoReturned()
result <- responseAndError{resp, err}
}()
var resp *http.Response
select {
case <-ctx.Done():
testHookContextDoneBeforeHeaders()
cancel()
// Clean up after the goroutine calling client.Do:
go func() {
if r := <-result; r.resp != nil {
testHookDidBodyClose()
r.resp.Body.Close()
}
}()
return nil, ctx.Err()
case r := <-result:
var err error
resp, err = r.resp, r.err
if err != nil {
return resp, err
}
}
c := make(chan struct{})
go func() {
select {
case <-ctx.Done():
cancel()
case <-c:
// The response's Body is closed.
}
}()
resp.Body = ¬ifyingReader{resp.Body, c}
return resp, nil
}
func (c *imageTransformer) transformResponse(r *http.Response) {
var images []APIImages
if err := json.NewDecoder(r.Body).Decode(&images); err != nil {
return
}
for _, im := range images {
if im.Labels == nil {
im.Labels = make(map[string]string)
}
im.Labels["hola"] = "world"
}
var b bytes.Buffer
w := bufio.NewWriter(&b)
// Now take the struct and encode it
if err := json.NewEncoder(w).Encode(&images); err != nil {
return
}
// Restore the io.ReadCloser to its original state
r.Body = ioutil.NopCloser(bytes.NewBuffer(b.Bytes()))
// Set size of modified body
r.ContentLength = int64(binary.Size(b))
}
// Code to stream the result in lock-step to the client and to a cache file.
// If conn terminates, continue streaming the response into the cache.
func streamAndCache(res *http.Response, conn net.Conn, cache_path string) int64 {
response_reader, cache_writer := io.Pipe()
defer func() {
err := cache_writer.Close()
if err != nil {
panic(err)
}
}()
n_recvd := make(chan int64)
go func() {
n_recvd <- CacheResponse(cache_path, response_reader)
}()
// Swallow write errors to `conn` since we want it to keep writing to the
// cache even if conn goes away
w := io.MultiWriter(cache_writer, writeErrorSwallower{conn})
err := res.Write(w)
if err != nil {
panic(err)
}
// Wait until CacheResponse is done copying the response to a file.
n := <-n_recvd
return n
}
func traceHttpResponse(c *Configuration, res *http.Response) {
if res == nil {
return
}
tracerx.Printf("HTTP: %d", res.StatusCode)
if c.isTracingHttp == false {
return
}
fmt.Fprintf(os.Stderr, "\n")
fmt.Fprintf(os.Stderr, "< %s %s\n", res.Proto, res.Status)
for key, _ := range res.Header {
fmt.Fprintf(os.Stderr, "< %s: %s\n", key, res.Header.Get(key))
}
traceBody := false
ctype := strings.ToLower(strings.SplitN(res.Header.Get("Content-Type"), ";", 2)[0])
for _, tracedType := range tracedTypes {
if strings.Contains(ctype, tracedType) {
traceBody = true
}
}
res.Body = newCountedResponse(res)
if traceBody {
res.Body = newTracedBody(res.Body)
}
fmt.Fprintf(os.Stderr, "\n")
}
func (srv *Server) handlerWriteResponse(request *Request, res *http.Response, c net.Conn, bw *bufio.Writer) error {
// Setup write stage
request.startPipelineStage("server.ResponseWrite")
request.CurrentStage.Type = PipelineStageTypeOverhead
// cleanup
defer func() {
request.finishPipelineStage()
request.finishRequest()
srv.requestFinished(request, res)
if res.Body != nil {
res.Body.Close()
}
}()
// Cycle nodelay flag on socket
// Note: defers for FILO so this will happen before the write
// phase is complete, which is what we want.
if nodelay := srv.setNoDelay(c, false); nodelay {
defer srv.setNoDelay(c, true)
}
var err error
// Write response
if err = res.Write(bw); err != nil {
return err
}
// Flush any remaining buffer
err = bw.Flush()
return err
}
func (session *Session) SendForTraversal(url string, data string) (string, error) {
var (
resp *http.Response // http response
buf bytes.Buffer // contains http response body
err error
)
resp, err = session.request(url, data)
if err != nil {
return "", err
}
log.Println(resp)
defer func() {
if resp.Body != nil {
resp.Body.Close()
}
}()
_, err = buf.ReadFrom(resp.Body)
if err != nil {
return "", err
}
session.StatusCode = resp.StatusCode
location, err := resp.Location()
if err != nil {
return "", err
}
session.Location = location.String()
return buf.String(), nil
}
func (lrt *LoggingRoundTripper) RoundTrip(request *http.Request) (*http.Response, error) {
var err error
var res *http.Response
log.Printf("Forwarding to: %s\n", request.URL.String())
res, err = lrt.transport.RoundTrip(request)
if err != nil {
return nil, err
}
body, err := ioutil.ReadAll(res.Body)
if err != nil {
log.Fatalln(err.Error())
}
log.Println("")
log.Printf("Response Headers: %#v\n", res.Header)
log.Println("")
log.Printf("Response Body: %s\n", string(body))
log.Println("")
res.Body = ioutil.NopCloser(bytes.NewBuffer(body))
log.Println("Sending response to GoRouter...")
return res, err
}
func (self *Surfer) Download(sp *spider.Spider, cReq *request.Request) *spider.Context {
ctx := spider.GetContext(sp, cReq)
var resp *http.Response
var err error
switch cReq.GetDownloaderID() {
case SURF_ID:
resp, err = self.surf.Download(cReq)
case PHANTOM_ID:
resp, err = self.phantom.Download(cReq)
}
if resp.StatusCode >= 400 {
err = errors.New("响应状态 " + resp.Status)
}
if resp.Header.Get("Content-Encoding") == "gzip" {
var gzipReader *gzip.Reader
gzipReader, err = gzip.NewReader(resp.Body)
resp.Body.Close()
if err == nil {
resp.Body = ioutil.NopCloser(gzipReader)
}
}
ctx.SetResponse(resp).SetError(err)
return ctx
}
//下载文件，并对字符编码做相应的处理
func (this *HttpDownLoader) downloadFile(p *page.Page, req *page.Request) (*page.Page, string) {
var err error
var httpResp *http.Response
var urlStr string
var method string
urlStr = req.GetUrl()
if len(urlStr) == 0 {
logs.GetFirstLogger().Error("url is empty")
p.SetStatus(true, "url is empty")
return p, ""
}
method = req.GetMethod()
if method == "POST" {
httpResp, err = http.Post(req.GetUrl(), "application/x-www-form-urlencoded", strings.NewReader(req.GetPostData()))
} else {
httpResp, err = http.Get(req.GetUrl())
}
if err != nil {
logs.GetFirstLogger().Error("http visit error :" + err.Error())
p.SetStatus(true, err.Error())
}
p.SetHeader(httpResp.Header)
p.SetCookies(httpResp.Cookies())
body, _ := ioutil.ReadAll(httpResp.Body)
bodyStr := string(body)
defer httpResp.Body.Close()
return p, bodyStr
}
func (codec *clientCodec) WriteRequest(request *rpc.Request, args interface{}) (err error) {
httpRequest, err := NewRequest(codec.url.String(), request.ServiceMethod, args)
if codec.cookies != nil {
for _, cookie := range codec.cookies.Cookies(codec.url) {
httpRequest.AddCookie(cookie)
}
}
if err != nil {
return err
}
var httpResponse *http.Response
httpResponse, err = codec.httpClient.Do(httpRequest)
if err != nil {
return err
}
if codec.cookies != nil {
codec.cookies.SetCookies(codec.url, httpResponse.Cookies())
}
codec.responses[request.Seq] = httpResponse
codec.ready <- request.Seq
return nil
}
func fockHTTPServer(req *http.Request, support_version bool) (error, *http.Response) {
if support_version {
contentType := req.Header.Get("Content-Type:")
if contentType != "application/octet-stream" {
return errors.New("Content-Type: unmatched"), nil
}
if strings.EqualFold(req.Method, "POST") {
return errors.New("method unmatched"), nil
}
protocol := req.Header.Get("application/X-DNSoverHTTP")
if strings.EqualFold(protocol, "UDP") || strings.EqualFold(protocol, "TCP") {
return errors.New("protocol isn't UDP or TCP"), nil
}
return nil, new(http.Response)
} else {
if strings.EqualFold(req.Method, "POST") {
return errors.New("method unmatched"), nil
}
contentType := req.Header.Get("Content-Type:")
if contentType != "application/X-DNSoverHTTP" {
return errors.New("Content-Type: unmatched"), nil
}
protocol := req.Header.Get("X-Proxy-DNS-Transport")
if strings.EqualFold(protocol, "UDP") || strings.EqualFold(protocol, "TCP") {
return errors.New("protocol isn't UDP or TCP"), nil
}
res := new(http.Response)
res.Body = req.Body
return nil, res
}
}
// UpgradeToken returns the assertion to upgrade the token on IAM to get the
// 'purchased' scopes
func (a *AssetsService) UpgradeToken() error {
var (
req *http.Request
res *http.Response
location *url.URL
err error
)
req, err = a.client.NewRequest("GET", "assets", "/v1.0/asset/access", nil)
if err != nil {
return err
}
req.Header.Add("No-Redirect", "true")
res, err = a.client.httpClient.Do(req)
if err != nil {
return err
}
location, err = res.Location()
if err != nil {
return err
}
req, err = a.client.NewRequest("GET", "iam", fmt.Sprintf("/v1.0/oauth/token/upgrade?%s", location.RawQuery), nil)
if err != nil {
return err
}
_, err = returnErrorHTTPSimple(a.client, req, err, 204)
return err
}
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 CopyHttpResponse(r *http.Response) *http.Response {
resCopy := new(http.Response)
if r == nil {
return resCopy
}
*resCopy = *r
if r.Body != nil {
defer r.Body.Close()
// Buffer body data
var bodyBuffer bytes.Buffer
bodyBuffer2 := new(bytes.Buffer)
io.Copy(&bodyBuffer, r.Body)
*bodyBuffer2 = bodyBuffer
// Create new ReadClosers so we can split output
r.Body = ioutil.NopCloser(&bodyBuffer)
resCopy.Body = ioutil.NopCloser(bodyBuffer2)
}
return resCopy
}
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)
}
}
//Couchdb returns updated AuthSession tokens
func (ca *CookieAuth) updateAuth(resp *http.Response) {
for _, cookie := range resp.Cookies() {
if cookie.Name == "AuthSession" {
ca.UpdatedAuthToken = cookie.Value
}
}
}
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) {
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 buildTestHTTPResponse(body string) *http.Response {
rsp := new(http.Response)
rsp.Body = noopCloser{bytes.NewBufferString(body)}
return rsp
}
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 getSessionAndAppPort(url string, rPort uint16, c *C) (string, string, string) {
var client http.Client
var req *http.Request
var resp *http.Response
var err error
var port []byte
uri := fmt.Sprintf("http://%s:%d/sticky", url, rPort)
req, err = http.NewRequest("GET", uri, nil)
resp, err = client.Do(req)
c.Assert(err, IsNil)
port, err = ioutil.ReadAll(resp.Body)
var session string
var path string
for _, cookie := range resp.Cookies() {
if cookie.Name == "__VCAP_ID__" {
session = cookie.Value
path = cookie.Path
}
}
return session, string(port), path
}
func (c *client) handleResponse(res *http.Response) {
if res.StatusCode != 200 {
return
}
st := res.Header.Get("ST")
if st == "" {
return
}
loc, err := res.Location()
if err != nil {
return
}
usn := res.Header.Get("USN")
if usn == "" {
usn = loc.String()
}
ev := Event{
Location: loc,
ST: st,
USN: usn,
}
select {
// events not being waited for are simply dropped
case c.eventChan <- ev:
default:
}
}
func setupStickySession(responseWriter http.ResponseWriter, response *http.Response,
endpoint *route.Endpoint,
originalEndpointId string,
secureCookies bool,
path string) {
maxAge := 0
// did the endpoint change?
sticky := originalEndpointId != "" && originalEndpointId != endpoint.PrivateInstanceId
for _, v := range response.Cookies() {
if v.Name == StickyCookieKey {
sticky = true
if v.MaxAge < 0 {
maxAge = v.MaxAge
}
break
}
}
if sticky {
cookie := &http.Cookie{
Name: VcapCookieId,
Value: endpoint.PrivateInstanceId,
Path: path,
MaxAge: maxAge,
HttpOnly: true,
Secure: secureCookies,
}
http.SetCookie(responseWriter, cookie)
}
}
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
}