func TestMarshalWithCodec_WithFacade(t *testing.T) { // func (s *WebCodecService) MarshalWithCodec(codec codecs.Codec, object interface{}, options ...interface{}) ([]byte, error) { testCodec := new(test.TestCodec) service := NewWebCodecService() // make some test stuff var bytesToReturn []byte = []byte("Hello World") testObjectWithFacade := new(test.TestObjectWithFacade) object := objx.MSI("Name", "Mat") var option1 string = "Option One" var option2 string = "Option Two" args := map[string]interface{}{option1: option1, option2: option2} // setup expectations testObjectWithFacade.On("PublicData", args).Return(object, nil) testCodec.On("Marshal", object, args).Return(bytesToReturn, nil) bytes, err := service.MarshalWithCodec(testCodec, testObjectWithFacade, args) if assert.Nil(t, err) { assert.Equal(t, string(bytesToReturn), string(bytes)) } // assert that our expectations were met mock.AssertExpectationsForObjects(t, testCodec.Mock, testObjectWithFacade.Mock) }
func TestPublicData_WithArray(t *testing.T) { o := new(test.TestObjectWithFacade) o1 := new(test.TestObjectWithFacade) o2 := new(test.TestObjectWithFacade) arr := []interface{}{o, o1, o2} o.Mock.On("PublicData", map[string]interface{}{}).Return(objx.New(map[string]interface{}{"theName": "1"}), nil) o1.Mock.On("PublicData", map[string]interface{}{}).Return(objx.New(map[string]interface{}{"theName": "2"}), nil) o2.Mock.On("PublicData", map[string]interface{}{}).Return(objx.New(map[string]interface{}{"theName": "3"}), nil) public, err := PublicData(arr, map[string]interface{}{}) if assert.Nil(t, err) { assert.Equal(t, reflect.Slice, reflect.TypeOf(public).Kind(), "Result should be array not %v", reflect.TypeOf(public)) } mock.AssertExpectationsForObjects(t, o.Mock, o1.Mock, o2.Mock) publicArray := public.([]interface{}) if assert.Equal(t, 3, len(publicArray)) { assert.Equal(t, publicArray[0].(objx.Map).Get("theName").Str(), "1", "o") assert.Equal(t, publicArray[1].(objx.Map).Get("theName").Str(), "2", "o1") assert.Equal(t, publicArray[2].(objx.Map).Get("theName").Str(), "3", "o2") } }
func TestErrorHandlerGetsUsedOnError(t *testing.T) { responseWriter := new(http_test.TestResponseWriter) testRequest, _ := http.NewRequest("GET", "http://stretchr.org/goweb", nil) codecService := codecsservices.NewWebCodecService() handler := NewHttpHandler(codecService) errorHandler := new(handlers_test.TestHandler) handler.SetErrorHandler(errorHandler) errorHandler.On("Handle", mock.Anything).Return(false, nil) // make a handler throw an error var theError error = errors.New("Test error") handler.Map(func(c context.Context) error { return theError }) handler.ServeHTTP(responseWriter, testRequest) if mock.AssertExpectationsForObjects(t, errorHandler.Mock) { // get the first context ctx := errorHandler.Calls[0].Arguments[0].(context.Context) // make sure the error data field was set assert.Equal(t, theError.Error(), ctx.Data().Get("error").Data().(HandlerError).Error(), "the error should be set in the data with the 'error' key") assert.Equal(t, responseWriter, ctx.HttpResponseWriter()) assert.Equal(t, testRequest, ctx.HttpRequest()) } }
func TestMarshalWithCodec_WithError(t *testing.T) { // func (s *WebCodecService) MarshalWithCodec(codec codecs.Codec, object interface{}, options ...interface{}) ([]byte, error) { testCodec := new(test.TestCodec) service := NewWebCodecService() // make some test stuff object := objx.MSI("Name", "Mat") var option1 string = "Option One" var option2 string = "Option Two" args := map[string]interface{}{option1: option1, option2: option2} // setup expectations testCodec.On("Marshal", object, args).Return(nil, assert.AnError) _, err := service.MarshalWithCodec(testCodec, object, args) assert.Equal(t, assert.AnError, err, "The error should get returned") // assert that our expectations were met mock.AssertExpectationsForObjects(t, testCodec.Mock) }
func TestPipe_Handle(t *testing.T) { ctx := context_test.MakeTestContext() handler1 := new(handlers_test.TestHandler) handler2 := new(handlers_test.TestHandler) handler3 := new(handlers_test.TestHandler) // add the handlers to the pipe p := Pipe{handler1, handler2, handler3} // setup expectations handler1.On("WillHandle", ctx).Return(true, nil) handler1.On("Handle", ctx).Return(false, nil) handler2.On("WillHandle", ctx).Return(false, nil) handler3.On("WillHandle", ctx).Return(true, nil) handler3.On("Handle", ctx).Return(false, nil) // call handle p.Handle(ctx) // assert expectations mock.AssertExpectationsForObjects(t, handler1.Mock, handler2.Mock, handler3.Mock) }
func TestMarshalWithCodec(t *testing.T) { testCodec := new(test.TestCodec) service := NewWebCodecService() // make some test stuff var bytesToReturn []byte = []byte("Hello World") var object objx.Map = objx.MSI("Name", "Mat") var option1 string = "Option One" var option2 string = "Option Two" args := map[string]interface{}{option1: option1, option2: option2} // setup expectations testCodec.On("Marshal", object, args).Return(bytesToReturn, nil) bytes, err := service.MarshalWithCodec(testCodec, object, args) if assert.Nil(t, err) { assert.Equal(t, string(bytesToReturn), string(bytes)) } // assert that our expectations were met mock.AssertExpectationsForObjects(t, testCodec.Mock) }
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 TestNewUser(t *testing.T) { testProvider := new(test.TestProvider) testProvider.On("Name").Return("providerName") data := objx.MSI( spotifyKeyID, "123435467890", spotifyKeyName, "Mathew", spotifyKeyEmail, "*****@*****.**", spotifyKeyNickname, "Mat", ) creds := &common.Credentials{Map: objx.MSI(oauth2.OAuth2KeyAccessToken, "ABC123")} user := NewUser(data, creds, testProvider) if assert.NotNil(t, user) { assert.Equal(t, data, user.Data()) assert.Equal(t, "Mathew", user.Name()) assert.Equal(t, "*****@*****.**", user.Email()) assert.Equal(t, "Mat", user.Nickname()) // check provider credentials creds := user.ProviderCredentials()[testProvider.Name()] if assert.NotNil(t, creds) { assert.Equal(t, "ABC123", creds.Get(oauth2.OAuth2KeyAccessToken).Str()) assert.Equal(t, "123435467890", creds.Get(common.CredentialsKeyID).Str()) } } mock.AssertExpectationsForObjects(t, testProvider.Mock) }
func TestProvider(t *testing.T) { prov1 := new(test.TestProvider) prov2 := new(test.TestProvider) prov1.On("Name").Return("prov1") prov2.On("Name").Return("prov2") // build a list list := WithProviders(prov1, prov2) returnedProv, err := list.Provider("prov1") if assert.NoError(t, err) { assert.Equal(t, returnedProv, prov1) } // check nonsense name returnedProv, err = Provider("no such provider") if assert.Nil(t, returnedProv) { assert.IsType(t, &common.MissingProviderError{}, err, "MissingProviderError expected") } mock.AssertExpectationsForObjects(t, prov1.Mock, prov2.Mock) }
func TestNewUser(t *testing.T) { testProvider := new(test.TestProvider) testProvider.On("Name").Return("providerName") data := objx.MSI( instagramKeyID, "123435467890", instagramKeyName, "Raquel", instagramKeyNickname, "maggit", instagramKeyAvatarUrl, "http://instagram.com/") creds := &common.Credentials{Map: objx.MSI(oauth2.OAuth2KeyAccessToken, "ABC12345")} user := NewUser(data, creds, testProvider) if assert.NotNil(t, user) { assert.Equal(t, data, user.Data()) assert.Equal(t, "Raquel", user.Name()) assert.Equal(t, "maggit", user.Nickname()) assert.Equal(t, "http://instagram.com/", user.AvatarURL()) // check provider credentials creds := user.ProviderCredentials()[testProvider.Name()] if assert.NotNil(t, creds) { assert.Equal(t, "ABC12345", creds.Get(oauth2.OAuth2KeyAccessToken).Str()) assert.Equal(t, "123435467890", creds.Get(common.CredentialsKeyID).Str()) } } mock.AssertExpectationsForObjects(t, testProvider.Mock) }
func TestPrependPreHandler(t *testing.T) { handler1 := new(handlers_test.TestHandler) handler2 := new(handlers_test.TestHandler) codecService := codecsservices.NewWebCodecService() h := NewHttpHandler(codecService) handler1.TestData().Set("id", 1) handler2.TestData().Set("id", 2) handler1.On("WillHandle", mock.Anything).Return(true, nil) handler1.On("Handle", mock.Anything).Return(false, nil) handler2.On("WillHandle", mock.Anything).Return(true, nil) handler2.On("Handle", mock.Anything).Return(false, nil) h.PrependPreHandler(handler1) h.PrependPreHandler(handler2) h.Handlers.Handle(nil) assert.Equal(t, 2, len(h.PreHandlersPipe())) assert.Equal(t, 2, h.PreHandlersPipe()[0].(*handlers_test.TestHandler).TestData().Get("id").Data()) assert.Equal(t, 1, h.PreHandlersPipe()[1].(*handlers_test.TestHandler).TestData().Get("id").Data()) mock.AssertExpectationsForObjects(t, handler1.Mock) }
func TestRoundTrip(t *testing.T) { underlyingTripper := new(testifyhttp.TestRoundTripper) testProvider := new(test.TestProvider) creds := &common.Credentials{Map: objx.MSI()} creds.Set(OAuth2KeyAccessToken, "This is a real access token :)") tripper := new(OAuth2Tripper) tripper.underlyingTransport = underlyingTripper tripper.credentials = creds tripper.provider = testProvider request, _ := http.NewRequest("GET", "something", nil) underlyingTripper.On("RoundTrip", mock.Anything).Return(new(http.Response), nil) response, err := tripper.RoundTrip(request) if assert.NoError(t, err) { if assert.NotNil(t, response) { actualRequest := underlyingTripper.Calls[0].Arguments[0].(*http.Request) if assert.NotEqual(t, &actualRequest, &request, "Actual request should be different") { headerK, headerV := AuthorizationHeader(creds) assert.Equal(t, actualRequest.Header.Get(headerK), headerV) } } } mock.AssertExpectationsForObjects(t, testProvider.Mock, underlyingTripper.Mock) }
func TestPublicData_WithError(t *testing.T) { o := new(test.TestObjectWithFacade) o.Mock.On("PublicData", map[string]interface{}{}).Return(nil, assert.AnError) _, err := PublicData(o, map[string]interface{}{}) assert.Equal(t, assert.AnError, err) mock.AssertExpectationsForObjects(t, o.Mock) }
func TestPublicDataMap_ReturningNil(t *testing.T) { o := new(test.TestObjectWithFacade) o.Mock.On("PublicData", map[string]interface{}{}).Return(nil, nil) public, err := PublicDataMap(o, map[string]interface{}{}) if assert.Nil(t, err) { assert.Nil(t, public) } mock.AssertExpectationsForObjects(t, o.Mock) }
func TestPublicData(t *testing.T) { o := new(test.TestObjectWithFacade) o.Mock.On("PublicData", map[string]interface{}{}).Return(objects.Map{"theName": "Mat"}, nil) public, err := PublicData(o, map[string]interface{}{}) if assert.Nil(t, err) { assert.Equal(t, public.(objects.Map)["theName"], "Mat") } mock.AssertExpectationsForObjects(t, o.Mock) }
func TestPublicDataMap_WithMSI(t *testing.T) { o := new(test.TestObjectWithFacade) o.Mock.On("PublicData", map[string]interface{}{}).Return(map[string]interface{}{"theName": "Mat"}, nil) public, err := PublicDataMap(o, map[string]interface{}{}) if assert.Nil(t, err) { assert.Equal(t, public.Get("theName").Str(), "Mat") } mock.AssertExpectationsForObjects(t, o.Mock) }
func TestAppendPostHandler(t *testing.T) { handler1 := new(handlers_test.TestHandler) codecService := codecsservices.NewWebCodecService() h := NewHttpHandler(codecService) handler1.On("WillHandle", mock.Anything).Return(true, nil) handler1.On("Handle", mock.Anything).Return(false, nil) h.AppendPostHandler(handler1) h.Handlers.Handle(nil) assert.Equal(t, 1, len(h.PostHandlersPipe())) mock.AssertExpectationsForObjects(t, handler1.Mock) }
func TestPublicData_WithRecursion(t *testing.T) { o := new(test.TestObjectWithFacade) o1 := new(test.TestObjectWithFacade) o2 := new(test.TestObjectWithFacade) o.Mock.On("PublicData", map[string]interface{}{}).Return(o1, nil) o1.Mock.On("PublicData", map[string]interface{}{}).Return(o2, nil) o2.Mock.On("PublicData", map[string]interface{}{}).Return(objx.New(map[string]interface{}{"theName": "Mat"}), nil) public, err := PublicData(o, map[string]interface{}{}) if assert.Nil(t, err) { assert.Equal(t, public.(objx.Map).Get("theName").Str(), "Mat") } mock.AssertExpectationsForObjects(t, o.Mock, o1.Mock, o2.Mock) }
func TestServeHTTPMethodOverride(t *testing.T) { responseWriter := new(http_test.TestResponseWriter) testRequest, _ := http.NewRequest("POST", "http://stretchr.org/goweb", nil) testRequest.Header.Set("X-HTTP-Method-Override", "GET") codecService := codecsservices.NewWebCodecService() handler := NewHttpHandler(codecService) // setup some test handlers handler1 := new(handlers_test.TestHandler) handler2 := new(handlers_test.TestHandler) handler3 := new(handlers_test.TestHandler) handler.Handlers = append(handler.Handlers, handler1) handler.Handlers = append(handler.Handlers, handler2) handler.Handlers = append(handler.Handlers, handler3) handler1.On("WillHandle", mock.Anything).Return(true, nil) handler1.On("Handle", mock.Anything).Return(false, nil) handler2.On("WillHandle", mock.Anything).Return(true, nil) handler2.On("Handle", mock.Anything).Return(false, nil) handler3.On("WillHandle", mock.Anything).Return(true, nil) handler3.On("Handle", mock.Anything).Return(false, nil) handler.ServeHTTP(responseWriter, testRequest) mock.AssertExpectationsForObjects(t, handler1.Mock, handler2.Mock, handler3.Mock) // get the first context ctx := handler1.Calls[0].Arguments[0].(context.Context) assert.Equal(t, responseWriter, ctx.HttpResponseWriter()) assert.Equal(t, testRequest, ctx.HttpRequest()) // make sure it's always the same context ctx1 := handler1.Calls[0].Arguments[0].(context.Context) ctx2 := handler2.Calls[0].Arguments[0].(context.Context) ctx3 := handler3.Calls[0].Arguments[0].(context.Context) assert.Equal(t, ctx1, ctx2, "Contexts should be the same") assert.Equal(t, ctx2, ctx3, "Contexts should be the same") }
func TestBeforeAndAfterHandlers(t *testing.T) { responseWriter := new(http_test.TestResponseWriter) testRequest, _ := http.NewRequest("GET", "http://stretchr.org/goweb", nil) codecService := codecsservices.NewWebCodecService() handler := NewHttpHandler(codecService) // setup some test handlers handler1 := new(handlers_test.TestHandler) handler2 := new(handlers_test.TestHandler) handler3 := new(handlers_test.TestHandler) handler.MapBefore(func(c context.Context) error { _, err := handler1.Handle(c) return err }) handler.Map(func(c context.Context) error { _, err := handler2.Handle(c) return err }) handler.MapAfter(func(c context.Context) error { _, err := handler3.Handle(c) return err }) handler1.On("Handle", mock.Anything).Return(false, nil) handler2.On("Handle", mock.Anything).Return(false, nil) handler3.On("Handle", mock.Anything).Return(false, nil) handler.ServeHTTP(responseWriter, testRequest) mock.AssertExpectationsForObjects(t, handler1.Mock, handler2.Mock, handler3.Mock) // make sure it's always the same context ctx1 := handler1.Calls[0].Arguments[0].(context.Context) ctx2 := handler2.Calls[0].Arguments[0].(context.Context) ctx3 := handler3.Calls[0].Arguments[0].(context.Context) assert.Equal(t, ctx1, ctx2, "Contexts should be the same") assert.Equal(t, ctx2, ctx3, "Contexts should be the same") }
func TestOAuth2Provider_CompleteAuth_JSON(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) creds := new(common.Credentials) 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(`{"expires_in":20,"access_token":"ACCESSTOKEN","refresh_token":"REFRESHTOKEN"}`)) testTripperFactory.On("NewTripper", common.EmptyCredentials, mock.Anything).Return(testTripper, nil) testTripper.On("RoundTrip", mock.Anything).Return(testResponse, nil) data := objx.MSI(OAuth2KeyCode, []string{"123"}) creds, err := CompleteAuth(testTripperFactory, data, config, testProvider) if assert.NoError(t, err) { if assert.NotNil(t, creds, "Creds should be returned") { assert.Equal(t, creds.Get(OAuth2KeyAccessToken).Str(), "ACCESSTOKEN") assert.Equal(t, creds.Get(OAuth2KeyRefreshToken).Str(), "REFRESHTOKEN") assert.Equal(t, creds.Get(OAuth2KeyExpiresIn).Data().(time.Duration), 20000000000) } } mock.AssertExpectationsForObjects(t, testTripperFactory.Mock, testTripper.Mock, testProvider.Mock) }
func TestUnmarshalWithCodec_WithError(t *testing.T) { // func (s *WebCodecService) UnmarshalWithCodec(codec codecs.Codec, data []byte, object interface{}) error { testCodec := new(test.TestCodec) service := NewWebCodecService() // some test objects object := struct{}{} data := []byte("Some bytes") // setup expectations testCodec.On("Unmarshal", data, object).Return(assert.AnError) // call the target method err := service.UnmarshalWithCodec(testCodec, data, object) assert.Equal(t, assert.AnError, err) mock.AssertExpectationsForObjects(t, testCodec.Mock) }
func TestPublicData_WithRecursion_WithObjects(t *testing.T) { o := new(test.TestObjectWithFacade) o1 := new(test.TestObjectWithFacade) o2 := new(test.TestObjectWithFacade) args := map[string]interface{}{constants.OptionKeyClientCallback: "~d"} o.Mock.On("PublicData", args).Return(o1, nil) o1.Mock.On("PublicData", args).Return(o2, nil) o2.Mock.On("PublicData", args).Return(objx.New(map[string]interface{}{"theName": "Mat"}), nil) public, err := PublicData(o, args) if assert.Nil(t, err) { assert.Equal(t, public.(objx.Map).Get("theName").Str(), "Mat") } mock.AssertExpectationsForObjects(t, o.Mock, o1.Mock, o2.Mock) }
func TestOAuth2ProviderGetClient(t *testing.T) { testTripperFactory := new(test.TestTripperFactory) testTripper := new(test.TestTripper) testProvider := new(test.TestProvider) creds := new(common.Credentials) testTripperFactory.On("NewTripper", creds, mock.Anything).Return(testTripper, nil) client, clientErr := GetClient(testTripperFactory, creds, testProvider) if assert.NoError(t, clientErr) { if assert.NotNil(t, client) { assert.Equal(t, client.Transport, testTripper) } } mock.AssertExpectationsForObjects(t, testTripperFactory.Mock, testTripper.Mock, testProvider.Mock) }
func TestOAuth2TripperFactoryNewTripper(t *testing.T) { testProvider := new(test.TestProvider) creds := new(common.Credentials) var tripperFactory common.TripperFactory tripperFactory = new(OAuth2TripperFactory) assert.NotNil(t, tripperFactory) var tripper common.Tripper tripper, err := tripperFactory.NewTripper(creds, testProvider) if assert.NotNil(t, tripper) && assert.NoError(t, err) { assert.Equal(t, creds, tripper.Credentials()) assert.IsType(t, new(OAuth2Tripper), tripper, "OAuth2TripperFactory should make OAuth2Trippers") } mock.AssertExpectationsForObjects(t, testProvider.Mock) }
func TestDataGetsCopiedToEachContext(t *testing.T) { codecService := codecsservices.NewWebCodecService() handler1 := new(handlers_test.TestHandler) h := NewHttpHandler(codecService) h.Data.Set("name", "Mat") handler1.On("WillHandle", mock.Anything).Return(true, nil) handler1.On("Handle", mock.Anything).Return(false, nil) h.AppendHandler(handler1) req, _ := http.NewRequest("GET", "something", nil) h.ServeHTTP(nil, req) assert.Equal(t, 1, len(h.HandlersPipe())) mock.AssertExpectationsForObjects(t, handler1.Mock) ctx := handler1.Calls[0].Arguments[0].(context.Context) assert.Equal(t, ctx.Data().Get("name").Str(), "Mat") }