func TestCreateResponderDoesNotModify(t *testing.T) { r1 := mocks.NewResponse() r2 := mocks.NewResponse() p := CreateResponder() err := p.Respond(r1) if err != nil { t.Errorf("autorest: CreateResponder failed (%v)", err) } if !reflect.DeepEqual(r1, r2) { t.Errorf("autorest: CreateResponder without decorators modified the response") } }
func TestResponseRequiresPollingIgnoresSuccess(t *testing.T) { resp := mocks.NewResponse() if ResponseRequiresPolling(resp) { t.Error("autorest: ResponseRequiresPolling did not ignore a successful response") } }
func TestResponseRequiresPollingLeavesBodyOpen(t *testing.T) { resp := mocks.NewResponse() ResponseRequiresPolling(resp) if !resp.Body.(*mocks.Body).IsOpen() { t.Error("autorest: ResponseRequiresPolling closed the responise body while ignoring a successful response") } }
func TestExtractHeaderHandlesMissingHeader(t *testing.T) { var v []string r := mocks.NewResponse() if !reflect.DeepEqual(ExtractHeader(mocks.TestHeader, r), v) { t.Errorf("autorest: ExtractHeader failed to handle a missing header -- expected %v, received %v", v, ExtractHeader(mocks.TestHeader, r)) } }
func TestExtractHeaderValueHandlesMissingHeader(t *testing.T) { r := mocks.NewResponse() v := "" if ExtractHeaderValue(mocks.TestHeader, r) != v { t.Errorf("autorest: ExtractHeader failed to retrieve the expected header -- expected [%s]%v, received [%s]%v", mocks.TestHeader, v, mocks.TestHeader, ExtractHeaderValue(mocks.TestHeader, r)) } }
func TestByIgnoring(t *testing.T) { r := mocks.NewResponse() Respond(r, (func() RespondDecorator { return func(r Responder) Responder { return ResponderFunc(func(r2 *http.Response) error { r1 := mocks.NewResponse() if !reflect.DeepEqual(r1, r2) { t.Errorf("autorest: ByIgnoring modified the HTTP Response -- received %v, expected %v", r2, r1) } return nil }) } })(), ByIgnoring(), ByClosing()) }
func TestClientIsPollingAllowedIgnoresOk(t *testing.T) { c := Client{PollingMode: PollUntilAttempts} r := mocks.NewResponse() err := c.IsPollingAllowed(r) if err != nil { t.Error("autorest: Client#IsPollingAllowed returned an error for an http.Response that does not require polling") } }
func TestByClosingIfErrorDoesNotClosesIfNoErrorOccurs(t *testing.T) { r := mocks.NewResponse() Respond(r, ByClosingIfError()) if !r.Body.(*mocks.Body).IsOpen() { t.Errorf("autorest: ByClosingIfError closed the response body even though no error occurred") } }
func TestByClosing(t *testing.T) { r := mocks.NewResponse() err := Respond(r, ByClosing()) if err != nil { t.Errorf("autorest: ByClosing failed (%v)", err) } if r.Body.(*mocks.Body).IsOpen() { t.Errorf("autorest: ByClosing did not close the response body") } }
func TestExtractRequestID(t *testing.T) { uuid := "71FDB9F4-5E49-4C12-B266-DE7B4FD999A6" resp := mocks.NewResponse() mocks.SetResponseHeader(resp, HeaderRequestID, uuid) if ExtractRequestID(resp) != uuid { t.Errorf("azure: ExtractRequestID failed to extract the %s -- expected %s, received %s", HeaderRequestID, uuid, ExtractRequestID(resp)) } }
func TestResponseGetPollingLocation(t *testing.T) { r := mocks.NewResponse() mocks.SetLocationHeader(r, mocks.TestURL) ar := Response{Response: r} if ar.GetPollingLocation() != mocks.TestURL { t.Errorf("autorest: Response#GetPollingLocation failed to return correct URL -- expected %v, received %v", mocks.TestURL, ar.GetPollingLocation()) } }
func TestExtractHeader(t *testing.T) { r := mocks.NewResponse() v := []string{"v1", "v2", "v3"} mocks.SetResponseHeaderValues(r, mocks.TestHeader, v) if !reflect.DeepEqual(ExtractHeader(mocks.TestHeader, r), v) { t.Errorf("autorest: ExtractHeader failed to retrieve the expected header -- expected [%s]%v, received [%s]%v", mocks.TestHeader, v, mocks.TestHeader, ExtractHeader(mocks.TestHeader, r)) } }
func TestResponseGetPollingDelayReturnsDefault(t *testing.T) { ar := Response{Response: mocks.NewResponse()} d1 := 10 * time.Second d2 := ar.GetPollingDelay(d1) if d1 != d2 { t.Errorf("autorest: Response#GetPollingDelay failed to return the default delay -- expected %v, received %v", d1, d2) } }
func TestExtractHeaderValueRetrievesFirstValue(t *testing.T) { r := mocks.NewResponse() v := []string{"v1", "v2", "v3"} mocks.SetResponseHeaderValues(r, mocks.TestHeader, v) if ExtractHeaderValue(mocks.TestHeader, r) != v[0] { t.Errorf("autorest: ExtractHeader failed to retrieve the expected header -- expected [%s]%v, received [%s]%v", mocks.TestHeader, v[0], mocks.TestHeader, ExtractHeaderValue(mocks.TestHeader, r)) } }
func TestWithErrorUnlessOK(t *testing.T) { r := mocks.NewResponse() r.Request = mocks.NewRequest() err := Respond(r, WithErrorUnlessOK(), ByClosingIfError()) if err != nil { t.Errorf("autorest: WithErrorUnlessOK returned an error for OK status code (%v)", err) } }
func TestByClosingIfErrorClosesIfAnErrorOccurs(t *testing.T) { var e error r := mocks.NewResponse() Respond(r, withErrorRespondDecorator(&e), ByClosingIfError()) if r.Body.(*mocks.Body).IsOpen() { t.Errorf("autorest: ByClosingIfError did not close the response body after an error occurred") } }
func TestByClosingClosesReturnsNestedErrors(t *testing.T) { var e error r := mocks.NewResponse() err := Respond(r, withErrorRespondDecorator(&e), ByClosing()) if err == nil || !reflect.DeepEqual(e, err) { t.Errorf("autorest: ByClosing failed to return a nested error") } }
func TestResponseGetPollingDelay(t *testing.T) { d1 := 10 * time.Second r := mocks.NewResponse() mocks.SetRetryHeader(r, d1) ar := Response{Response: r} d2 := ar.GetPollingDelay(time.Duration(0)) if d1 != d2 { t.Errorf("autorest: Response#GetPollingDelay failed to return the correct delay -- expected %v, received %v", d1, d2) } }
func TestWithErrorUnlessOKEmitsErrorIfNotOK(t *testing.T) { r := mocks.NewResponse() r.Request = mocks.NewRequest() r.Status = "400 BadRequest" r.StatusCode = http.StatusBadRequest err := Respond(r, WithErrorUnlessOK(), ByClosingIfError()) if err == nil { t.Errorf("autorest: WithErrorUnlessOK failed to return an error for a non-OK status code (%v)", err) } }
func TestWithErrorUnlessStatusCodeEmitsErrorForUnacceptableStatusCode(t *testing.T) { r := mocks.NewResponse() r.Request = mocks.NewRequest() r.Status = "400 BadRequest" r.StatusCode = http.StatusBadRequest err := Respond(r, WithErrorUnlessStatusCode(http.StatusOK, http.StatusUnauthorized, http.StatusInternalServerError), ByClosingIfError()) if err == nil { t.Errorf("autorest: WithErrorUnlessStatusCode failed to return an error for an unacceptable status code (%s)", r.Status) } }
func TestByClosingAcceptsNilResponse(t *testing.T) { r := mocks.NewResponse() Respond(r, (func() RespondDecorator { return func(r Responder) Responder { return ResponderFunc(func(resp *http.Response) error { resp.Body.Close() r.Respond(nil) return nil }) } })(), ByClosing()) }
func TestClientPollAsNeededLeavesBodyOpen(t *testing.T) { c := Client{} c.Sender = mocks.NewSender() r := mocks.NewResponse() resp, err := c.PollAsNeeded(r) if err != nil { t.Errorf("autorest: Client#PollAsNeeded failed when given a successful HTTP request (%v)", err) } if !resp.Body.(*mocks.Body).IsOpen() { t.Error("autorest: Client#PollAsNeeded unexpectedly closed the response body") } Respond(resp, ByClosing()) }
func TestClientPollAsNeededIgnoresOk(t *testing.T) { c := Client{} s := mocks.NewSender() c.Sender = s r := mocks.NewResponse() resp, err := c.PollAsNeeded(r) if err != nil { t.Errorf("autorest: Client#PollAsNeeded failed when given a successful HTTP request (%v)", err) } if s.Attempts() > 0 { t.Error("autorest: Client#PollAsNeeded attempted to poll a successful HTTP request") } Respond(resp, ByClosing()) }
func ExampleWithErrorUnlessOK() { r := mocks.NewResponse() r.Request = mocks.NewRequest() // Respond and leave the response body open (for a subsequent responder to close) err := Respond(r, WithErrorUnlessOK(), ByClosingIfError()) if err == nil { fmt.Printf("%s of %s returned HTTP 200", r.Request.Method, r.Request.URL) // Complete handling the response and close the body Respond(r, ByClosing()) } // Output: GET of https://microsoft.com/a/b/c/ returned HTTP 200 }
func TestServicePrincipalTokenRefreshUsesPOST(t *testing.T) { spt := newServicePrincipalToken() c := mocks.NewSender() s := autorest.DecorateSender(c, (func() autorest.SendDecorator { return func(s autorest.Sender) autorest.Sender { return autorest.SenderFunc(func(r *http.Request) (*http.Response, error) { if r.Method != "POST" { t.Errorf("azure: ServicePrincipalToken#Refresh did not correctly set HTTP method -- expected %v, received %v", "POST", r.Method) } return mocks.NewResponse(), nil }) } })()) spt.SetSender(s) spt.Refresh() }
func TestByClosingIfErrorAcceptsNilBody(t *testing.T) { var e error r := mocks.NewResponse() Respond(r, withErrorRespondDecorator(&e), (func() RespondDecorator { return func(r Responder) Responder { return ResponderFunc(func(resp *http.Response) error { resp.Body.Close() resp.Body = nil r.Respond(resp) return nil }) } })(), ByClosingIfError()) }
func TestServicePrincipalTokenRefreshClosesRequestBody(t *testing.T) { spt := newServicePrincipalToken() resp := mocks.NewResponse() c := mocks.NewSender() s := autorest.DecorateSender(c, (func() autorest.SendDecorator { return func(s autorest.Sender) autorest.Sender { return autorest.SenderFunc(func(r *http.Request) (*http.Response, error) { return resp, nil }) } })()) spt.SetSender(s) spt.Refresh() if resp.Body.(*mocks.Body).IsOpen() { t.Error("azure: ServicePrincipalToken#Refresh failed to close the HTTP Response Body") } }
func TestServicePrincipalTokenRefreshSetsMimeType(t *testing.T) { spt := newServicePrincipalToken() c := mocks.NewSender() s := autorest.DecorateSender(c, (func() autorest.SendDecorator { return func(s autorest.Sender) autorest.Sender { return autorest.SenderFunc(func(r *http.Request) (*http.Response, error) { if r.Header.Get(http.CanonicalHeaderKey("Content-Type")) != "application/x-www-form-urlencoded" { t.Errorf("azure: ServicePrincipalToken#Refresh did not correctly set Content-Type -- expected %v, received %v", "application/x-form-urlencoded", r.Header.Get(http.CanonicalHeaderKey("Content-Type"))) } return mocks.NewResponse(), nil }) } })()) spt.SetSender(s) spt.Refresh() }
func TestServicePrincipalTokenRefreshSetsURL(t *testing.T) { spt := newServicePrincipalToken() c := mocks.NewSender() s := autorest.DecorateSender(c, (func() autorest.SendDecorator { return func(s autorest.Sender) autorest.Sender { return autorest.SenderFunc(func(r *http.Request) (*http.Response, error) { u := fmt.Sprintf("https://login.microsoftonline.com/%s/oauth2/token?api-version=1.0", spt.tenantID) if r.URL.String() != u { t.Errorf("azure: ServicePrincipalToken#Refresh did not correctly set the URL -- expected %v, received %v", u, r.URL) } return mocks.NewResponse(), nil }) } })()) spt.SetSender(s) spt.Refresh() }
func TestServicePrincipalTokenEnsureFreshSkipsIfFresh(t *testing.T) { spt := newServicePrincipalToken() setTokenToExpireIn(&spt.Token, 1000*time.Second) f := false c := mocks.NewSender() s := autorest.DecorateSender(c, (func() autorest.SendDecorator { return func(s autorest.Sender) autorest.Sender { return autorest.SenderFunc(func(r *http.Request) (*http.Response, error) { f = true return mocks.NewResponse(), nil }) } })()) spt.SetSender(s) spt.EnsureFresh() if f { t.Error("azure: ServicePrincipalToken#EnsureFresh invoked Refresh for fresh token") } }