Exemplo n.º 1
0
func makeValidGoogleRequest() messages.RequestWrapper {

	googleData := make(map[string]interface{})
	googleData["id"] = "someid"
	googleData["idToken"] = "someidtoken"

	var message messages.Message
	message.Body = make(map[string]interface{})
	message.Body["google"] = googleData

	var requestWrapper messages.RequestWrapper
	requestWrapper.Message = message

	return requestWrapper
}
Exemplo n.º 2
0
func makeValidFacebookRequest() messages.RequestWrapper {

	facebookData := make(map[string]interface{})
	facebookData["id"] = "facebookuserid"
	facebookData["accessToken"] = "facebookaccesstoken"

	var message messages.Message
	message.Body = make(map[string]interface{})
	message.Body["facebook"] = facebookData

	var requestWrapper messages.RequestWrapper
	requestWrapper.Message = message

	return requestWrapper
}
Exemplo n.º 3
0
		response, hookBody, err = handlePut(a, requestWrapper)
	} else if strings.EqualFold(requestWrapper.Message.Command, "delete") {
		response, err = handleDelete(a, requestWrapper)
	}

	if err != nil {
		if response.Status == 0 {
			response.Status = err.Code
		}
		if response.Body == nil {
			response.Body = map[string]interface{}{"message": err.Message}
		}
	}

	// TODO: call hooks.ExecuteTrigger in goroutine
	var hookRequestWrapper = messages.RequestWrapper{}
	hookRequestWrapper.Message = requestWrapper.Message
	hookRequestWrapper.Message.Body = hookBody
	executeTrigger(a, user, hookRequestWrapper, "after")
	return
}

var executeTrigger = func(a *Actor, user interface{}, requestWrapper messages.RequestWrapper, when string) (response messages.Message, err *utils.Error) {

	response.Body, err = hooks.ExecuteTrigger(a.class, when,
		requestWrapper.Message.Command,
		requestWrapper.Message.Parameters,
		requestWrapper.Message.Body,
		requestWrapper.Message.MultipartForm,
		user)
	if err != nil {
Exemplo n.º 4
0
func TestResetPassword(t *testing.T) {

	config.SystemConfig = config.Config{}
	config.SystemConfig.ResetPassword = map[string]string{
		"senderEmail":         "*****@*****.**",
		"senderEmailPassword": "******",
		"smtpServer":          "mail.rihtim.com",
		"smtpPort":            "25",
		"mailSubject":         "Reset password!",
		"mailContentTemplate": "Your new password is %s.",
	}

	Convey("Should return internal server error", t, func() {

		correctConfig := config.SystemConfig.ResetPassword
		config.SystemConfig.ResetPassword = nil

		var message messages.Message
		message.Body = make(map[string]interface{})

		var requestWrapper messages.RequestWrapper
		requestWrapper.Message = message

		_, err := HandleResetPassword(requestWrapper, &adapters.MongoAdapter{})

		So(err.Code, ShouldEqual, http.StatusInternalServerError)

		config.SystemConfig.ResetPassword = correctConfig
	})

	Convey("Should return bad request", t, func() {

		var message messages.Message
		message.Body = make(map[string]interface{})

		var requestWrapper messages.RequestWrapper
		requestWrapper.Message = message

		_, err := HandleResetPassword(requestWrapper, &adapters.MongoAdapter{})

		So(err.Code, ShouldEqual, http.StatusBadRequest)
	})

	Convey("Should return not found", t, func() {

		getAccountData = func(requestWrapper messages.RequestWrapper, dbAdapter *adapters.MongoAdapter) (accountData map[string]interface{}, err *utils.Error) {
			err = &utils.Error{http.StatusNotFound, "Account not found."}
			return
		}

		var message messages.Message
		message.Body = make(map[string]interface{})
		message.Body["email"] = "*****@*****.**"

		var requestWrapper messages.RequestWrapper
		requestWrapper.Message = message

		_, err := HandleResetPassword(requestWrapper, &adapters.MongoAdapter{})

		So(err.Code, ShouldEqual, http.StatusNotFound)
	})

	Convey("Should return the error from adapters.HandlePut", t, func() {

		getAccountData = func(requestWrapper messages.RequestWrapper, dbAdapter *adapters.MongoAdapter) (accountData map[string]interface{}, err *utils.Error) {
			accountData = make(map[string]interface{})
			accountData["_id"] = "564f1a28e63bce219e1cc745"
			return
		}

		adapters.Update = func(collection string, id string, data map[string]interface{}) (response map[string]interface{}, hookBody map[string]interface{}, err *utils.Error) {
			err = &utils.Error{http.StatusInternalServerError, "Some error happened."}
			return
		}

		var message messages.Message
		message.Body = make(map[string]interface{})
		message.Body["email"] = "*****@*****.**"

		var requestWrapper messages.RequestWrapper
		requestWrapper.Message = message

		_, err := HandleResetPassword(requestWrapper, &adapters.MongoAdapter{})

		So(err, ShouldNotBeNil)
	})

	Convey("Should call adapters.HandlePut with new password and correct user resource", t, func() {

		getAccountData = func(requestWrapper messages.RequestWrapper, dbAdapter *adapters.MongoAdapter) (accountData map[string]interface{}, err *utils.Error) {
			accountData = make(map[string]interface{})
			accountData["_id"] = "564f1a28e63bce219e1cc745"
			return
		}

		var isResCorrect bool
		var isPasswordProvided bool
		adapters.Update = func(collection string, id string, data map[string]interface{}) (response map[string]interface{}, hookBody map[string]interface{}, err *utils.Error) {
			isResCorrect = strings.EqualFold("users", collection) && strings.EqualFold("564f1a28e63bce219e1cc745", id)
			isPasswordProvided = len(data["password"].(string)) > 0
			return
		}

		var called bool
		sendNewPasswordEmail = func(smtpServer, smtpPost, senderEmail, senderEmailPassword, subject, contentTemplate, recipientEmail, newPassword string) (err *utils.Error) {
			called = true
			return
		}

		var message messages.Message
		message.Body = make(map[string]interface{})
		message.Body["email"] = "*****@*****.**"

		var requestWrapper messages.RequestWrapper
		requestWrapper.Message = message

		HandleResetPassword(requestWrapper, &adapters.MongoAdapter{})

		So(isResCorrect, ShouldBeTrue)
		So(isPasswordProvided, ShouldBeTrue)
		So(called, ShouldBeTrue)
	})

}
Exemplo n.º 5
0
func TestHandleLogin(t *testing.T) {

	Convey("Should return bad request", t, func() {

		var called bool
		getAccountData = func(requestWrapper messages.RequestWrapper, dbAdapter *adapters.MongoAdapter) (accountData map[string]interface{}, err *utils.Error) {
			called = true
			return
		}

		var message messages.Message
		message.Body = make(map[string]interface{})

		var requestWrapper messages.RequestWrapper
		requestWrapper.Message = message

		_, err := HandleLogin(requestWrapper, &adapters.MongoAdapter{})

		So(err.Code, ShouldEqual, http.StatusBadRequest)
		So(called, ShouldBeFalse)
	})

	Convey("Should login with email", t, func() {

		getAccountData = func(requestWrapper messages.RequestWrapper, dbAdapter *adapters.MongoAdapter) (accountData map[string]interface{}, err *utils.Error) {
			accountData = make(map[string]interface{})
			// hased of 'zuhaha'
			accountData["password"] = "******"
			accountData["_id"] = "564f1a28e63bce219e1cc745"
			return
		}

		var message messages.Message
		message.Body = make(map[string]interface{})
		message.Body["email"] = "*****@*****.**"
		message.Body["password"] = "******"

		var requestWrapper messages.RequestWrapper
		requestWrapper.Message = message

		response, err := HandleLogin(requestWrapper, &adapters.MongoAdapter{})

		So(err, ShouldBeNil)
		So(response.Status, ShouldEqual, http.StatusOK)
	})

	Convey("Should login with username", t, func() {

		getAccountData = func(requestWrapper messages.RequestWrapper, dbAdapter *adapters.MongoAdapter) (accountData map[string]interface{}, err *utils.Error) {
			accountData = make(map[string]interface{})
			// hased of 'zuhaha'
			accountData["password"] = "******"
			accountData["_id"] = "564f1a28e63bce219e1cc745"
			return
		}

		var message messages.Message
		message.Body = make(map[string]interface{})
		message.Body["username"] = "******"
		message.Body["password"] = "******"

		var requestWrapper messages.RequestWrapper
		requestWrapper.Message = message

		response, _ := HandleLogin(requestWrapper, &adapters.MongoAdapter{})
		So(response.Status, ShouldEqual, http.StatusOK)
	})

	Convey("Should return password error", t, func() {

		getAccountData = func(requestWrapper messages.RequestWrapper, dbAdapter *adapters.MongoAdapter) (accountData map[string]interface{}, err *utils.Error) {
			accountData = make(map[string]interface{})
			// hased of 'zuhaha'
			accountData["password"] = "******"
			accountData["_id"] = "564f1a28e63bce219e1cc745"
			return
		}

		var message messages.Message
		message.Body = make(map[string]interface{})
		message.Body["email"] = "*****@*****.**"
		message.Body["password"] = "******"

		var requestWrapper messages.RequestWrapper
		requestWrapper.Message = message

		response, _ := HandleLogin(requestWrapper, &adapters.MongoAdapter{})
		So(response.Status, ShouldEqual, http.StatusUnauthorized)
	})

	Convey("Should return error if account doesn't exist", t, func() {

		getAccountData = func(requestWrapper messages.RequestWrapper, dbAdapter *adapters.MongoAdapter) (accountData map[string]interface{}, err *utils.Error) {
			err = &utils.Error{http.StatusNotFound, "Item not found."}
			return
		}

		var message messages.Message
		message.Body = make(map[string]interface{})
		message.Body["email"] = "*****@*****.**"
		message.Body["password"] = "******"

		var requestWrapper messages.RequestWrapper
		requestWrapper.Message = message

		_, err := HandleLogin(requestWrapper, &adapters.MongoAdapter{})
		So(err.Code, ShouldEqual, http.StatusUnauthorized)
	})

	Convey("Should return token generation error", t, func() {

		getAccountData = func(requestWrapper messages.RequestWrapper, dbAdapter *adapters.MongoAdapter) (accountData map[string]interface{}, err *utils.Error) {
			accountData = make(map[string]interface{})
			// hased of 'zuhaha'
			accountData["password"] = "******"
			accountData["_id"] = "564f1a28e63bce219e1cc745"
			return
		}

		generateToken = func(userId string, userData map[string]interface{}) (tokenString string, err *utils.Error) {
			err = &utils.Error{http.StatusInternalServerError, "Generating token failed."}
			return
		}

		var message messages.Message
		message.Body = make(map[string]interface{})
		message.Body["email"] = "*****@*****.**"
		message.Body["password"] = "******"

		var requestWrapper messages.RequestWrapper
		requestWrapper.Message = message

		_, err := HandleLogin(requestWrapper, &adapters.MongoAdapter{})
		So(err.Code, ShouldEqual, http.StatusInternalServerError)
	})

}
Exemplo n.º 6
0
func TestHandleSignUp(t *testing.T) {

	Convey("Should return bad request", t, func() {

		var called bool
		getAccountData = func(requestWrapper messages.RequestWrapper, dbAdapter *adapters.MongoAdapter) (accountData map[string]interface{}, err *utils.Error) {
			called = true
			return
		}

		var message messages.Message

		var requestWrapper messages.RequestWrapper
		requestWrapper.Message = message

		_, _, err := HandleSignUp(requestWrapper, &adapters.MongoAdapter{})

		So(err.Code, ShouldEqual, http.StatusBadRequest)
		So(called, ShouldBeFalse)
	})

	Convey("Should return bad request for password", t, func() {

		var called bool
		getAccountData = func(requestWrapper messages.RequestWrapper, dbAdapter *adapters.MongoAdapter) (accountData map[string]interface{}, err *utils.Error) {
			called = true
			return
		}

		var message messages.Message
		message.Body = make(map[string]interface{})
		message.Body["username"] = "******"

		var requestWrapper messages.RequestWrapper
		requestWrapper.Message = message

		_, _, err := HandleSignUp(requestWrapper, &adapters.MongoAdapter{})

		So(err.Code, ShouldEqual, http.StatusBadRequest)
		So(called, ShouldBeFalse)
	})

	Convey("Should return conflict", t, func() {

		getAccountData = func(requestWrapper messages.RequestWrapper, dbAdapter *adapters.MongoAdapter) (accountData map[string]interface{}, err *utils.Error) {
			accountData = make(map[string]interface{})
			return
		}

		var called bool
		generateToken = func(userId string, userData map[string]interface{}) (tokenString string, err *utils.Error) {
			called = true
			err = &utils.Error{http.StatusConflict, "Exists."}
			return
		}

		var message messages.Message
		message.Body = make(map[string]interface{})
		message.Body["email"] = "*****@*****.**"
		message.Body["password"] = "******"

		var requestWrapper messages.RequestWrapper
		requestWrapper.Message = message

		_, _, err := HandleSignUp(requestWrapper, &adapters.MongoAdapter{})

		So(err.Code, ShouldEqual, http.StatusConflict)
		So(called, ShouldBeFalse)
	})

	Convey("Should return internal server error", t, func() {

		getAccountData = func(requestWrapper messages.RequestWrapper, dbAdapter *adapters.MongoAdapter) (accountData map[string]interface{}, err *utils.Error) {
			return
		}

		generateToken = func(userId string, userData map[string]interface{}) (tokenString string, err *utils.Error) {
			err = &utils.Error{http.StatusInternalServerError, "Generating token failed."}
			return
		}

		adapters.Create = func(collection string, data map[string]interface{}) (response map[string]interface{}, hookBody map[string]interface{}, err *utils.Error) {
			response = make(map[string]interface{})
			response["_id"] = "564f1a28e63bce219e1cc745"
			return
		}

		var message messages.Message
		message.Body = make(map[string]interface{})
		message.Body["email"] = "*****@*****.**"
		message.Body["password"] = "******"

		var requestWrapper messages.RequestWrapper
		requestWrapper.Message = message

		response, _, _ := HandleSignUp(requestWrapper, &adapters.MongoAdapter{})

		So(response.Status, ShouldEqual, http.StatusInternalServerError)
	})

	Convey("Should call auth.getAccountData with email", t, func() {

		var called bool
		getAccountData = func(requestWrapper messages.RequestWrapper, dbAdapter *adapters.MongoAdapter) (accountData map[string]interface{}, err *utils.Error) {
			called = true
			return
		}

		adapters.Create = func(collection string, data map[string]interface{}) (response map[string]interface{}, hookBody map[string]interface{}, err *utils.Error) {
			response = make(map[string]interface{})
			response["_id"] = "564f1a28e63bce219e1cc745"
			return
		}

		var message messages.Message
		message.Body = make(map[string]interface{})
		message.Body["email"] = "*****@*****.**"
		message.Body["password"] = "******"

		var requestWrapper messages.RequestWrapper
		requestWrapper.Message = message

		HandleSignUp(requestWrapper, &adapters.MongoAdapter{})

		So(called, ShouldBeTrue)
	})

	Convey("Should call auth.getAccountData with username", t, func() {

		var called bool
		getAccountData = func(requestWrapper messages.RequestWrapper, dbAdapter *adapters.MongoAdapter) (accountData map[string]interface{}, err *utils.Error) {
			called = true
			return
		}

		adapters.Create = func(collection string, data map[string]interface{}) (response map[string]interface{}, hookBody map[string]interface{}, err *utils.Error) {
			response = make(map[string]interface{})
			response["_id"] = "564f1a28e63bce219e1cc745"
			return
		}

		var message messages.Message
		message.Body = make(map[string]interface{})
		message.Body["username"] = "******"
		message.Body["password"] = "******"

		var requestWrapper messages.RequestWrapper
		requestWrapper.Message = message

		HandleSignUp(requestWrapper, &adapters.MongoAdapter{})

		So(called, ShouldBeTrue)
	})

	Convey("Should create account", t, func() {

		getAccountData = func(requestWrapper messages.RequestWrapper, dbAdapter *adapters.MongoAdapter) (accountData map[string]interface{}, err *utils.Error) {
			return
		}

		generateToken = func(userId string, userData map[string]interface{}) (tokenString string, err *utils.Error) {
			tokenString = ""
			return
		}

		adapters.Create = func(collection string, data map[string]interface{}) (response map[string]interface{}, hookBody map[string]interface{}, err *utils.Error) {
			response = make(map[string]interface{})
			response["_id"] = "564f1a28e63bce219e1cc745"
			return
		}

		var message messages.Message
		message.Body = make(map[string]interface{})
		message.Body["email"] = "*****@*****.**"
		message.Body["password"] = "******"

		var requestWrapper messages.RequestWrapper
		requestWrapper.Message = message

		response, _, _ := HandleSignUp(requestWrapper, &adapters.MongoAdapter{})

		So(response.Status, ShouldEqual, http.StatusCreated)
	})
}
Exemplo n.º 7
0
func TestGoogleRegistration(t *testing.T) {

	// https needs to be changed to http for mock server to work
	googleTokenVerificationEndpoint = "http://mock.google.com"

	// setting configuration to default
	config.SystemConfig = config.Config{}
	config.SystemConfig.Google = map[string]string{
		"clientId": "googleclientid",
	}

	Convey("Should fail creating account with Google when idToken is missing", t, func() {

		googleData := make(map[string]interface{})
		googleData["id"] = "someid"

		var message messages.Message
		message.Body = make(map[string]interface{})
		message.Body["google"] = googleData

		var requestWrapper messages.RequestWrapper
		requestWrapper.Message = message

		_, _, err := HandleSignUp(requestWrapper, &adapters.MongoAdapter{})

		So(err.Code, ShouldEqual, http.StatusBadRequest)
	})

	Convey("Should fail creating account with Google when id is missing", t, func() {

		googleData := make(map[string]interface{})
		googleData["idToken"] = "someidtoken"

		var message messages.Message
		message.Body = make(map[string]interface{})
		message.Body["google"] = googleData

		var requestWrapper messages.RequestWrapper
		requestWrapper.Message = message

		_, _, err := HandleSignUp(requestWrapper, &adapters.MongoAdapter{})

		So(err.Code, ShouldEqual, http.StatusBadRequest)
	})

	Convey("Should fail creating account with Google when server configuration is missing", t, func() {

		// removing google configuration
		correctConfig := config.SystemConfig
		config.SystemConfig.Google = nil

		requestWrapper := makeValidGoogleRequest()

		_, _, err := HandleSignUp(requestWrapper, &adapters.MongoAdapter{})

		So(err.Code, ShouldEqual, http.StatusInternalServerError)

		// revert back the google configuration
		config.SystemConfig = correctConfig
	})

	Convey("Should fail when getting response from Google fails", t, func() {

		mockServer := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
			w.WriteHeader(500)
		}))
		defer mockServer.Close()
		setDefaultServer(mockServer)

		requestWrapper := makeValidGoogleRequest()

		_, _, err := HandleSignUp(requestWrapper, &adapters.MongoAdapter{})

		So(err.Code, ShouldEqual, http.StatusInternalServerError)
	})

	Convey("Should fail when parsing response from Google fails", t, func() {

		mockServer := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
			w.WriteHeader(200)
			fmt.Fprintln(w, `{invalidjsonresponse`)
		}))
		defer mockServer.Close()
		setDefaultServer(mockServer)

		requestWrapper := makeValidGoogleRequest()
		_, _, err := HandleSignUp(requestWrapper, &adapters.MongoAdapter{})

		So(err.Code, ShouldEqual, http.StatusInternalServerError)
	})

	Convey("Should fail when Google's response is not as expected", t, func() {

		mockServer := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
			w.WriteHeader(200)
			// the field 'aud' is removed from the response body
			fmt.Fprintln(w, `{"iss": "accounts.google.com","at_hash": "pSLbt169EwtjApOMQMoTnA","sub": "107419746647224140307","email_verified": "true","azp": "407408718192.apps.googleusercontent.com","hd": "miwi.com","email": "*****@*****.**","iat": "1449240861","exp": "1449244461","alg": "RS256","kid": "ce30d9f163852843c9a94ce1c1d711e4464d4391"}`)
		}))
		defer mockServer.Close()
		setDefaultServer(mockServer)

		requestWrapper := makeValidGoogleRequest()

		_, _, err := HandleSignUp(requestWrapper, &adapters.MongoAdapter{})

		So(err.Code, ShouldEqual, http.StatusInternalServerError)
	})

	Convey("Should fail when client ids don't match.", t, func() {

		mockServer := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
			w.WriteHeader(200)
			w.Header().Set("Content-Type", "application/json")
			fmt.Fprintln(w, `{"iss": "accounts.google.com","at_hash": "pSLbt169EwtjApOMQMoTnA","aud": "407408718192.apps.googleusercontent.com","sub": "107419746647224140307","email_verified": "true","azp": "407408718192.apps.googleusercontent.com","hd": "miwi.com","email": "*****@*****.**","iat": "1449240861","exp": "1449244461","alg": "RS256","kid": "ce30d9f163852843c9a94ce1c1d711e4464d4391"}`)
		}))
		defer mockServer.Close()
		setDefaultServer(mockServer)

		requestWrapper := makeValidGoogleRequest()

		_, _, err := HandleSignUp(requestWrapper, &adapters.MongoAdapter{})

		So(err.Code, ShouldEqual, http.StatusInternalServerError)
	})

	Convey("Should create new account.", t, func() {

		mockServer := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
			w.WriteHeader(200)
			w.Header().Set("Content-Type", "application/json")
			fmt.Fprintln(w, `{"iss": "accounts.google.com","at_hash": "pSLbt169EwtjApOMQMoTnA","aud": "googleclientid","sub": "107419746647224140307","email_verified": "true","azp": "407408718192.apps.googleusercontent.com","hd": "miwi.com","email": "*****@*****.**","iat": "1449240861","exp": "1449244461","alg": "RS256","kid": "ce30d9f163852843c9a94ce1c1d711e4464d4391"}`)
		}))
		defer mockServer.Close()
		setDefaultServer(mockServer)

		var called bool
		getAccountData = func(requestWrapper messages.RequestWrapper, dbAdapter *adapters.MongoAdapter) (accountData map[string]interface{}, err *utils.Error) {
			called = true
			// returning nil account info
			return
		}

		requestWrapper := makeValidGoogleRequest()
		response, _, err := HandleSignUp(requestWrapper, &adapters.MongoAdapter{})

		So(err, ShouldBeNil)
		So(called, ShouldBeTrue)
		So(response.Status, ShouldEqual, http.StatusCreated)
	})

	Convey("Should return existing account.", t, func() {

		mockServer := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
			w.WriteHeader(200)
			w.Header().Set("Content-Type", "application/json")
			fmt.Fprintln(w, `{"iss": "accounts.google.com","at_hash": "pSLbt169EwtjApOMQMoTnA","aud": "googleclientid","sub": "107419746647224140307","email_verified": "true","azp": "407408718192.apps.googleusercontent.com","hd": "miwi.com","email": "*****@*****.**","iat": "1449240861","exp": "1449244461","alg": "RS256","kid": "ce30d9f163852843c9a94ce1c1d711e4464d4391"}`)
		}))
		defer mockServer.Close()
		setDefaultServer(mockServer)

		var called bool
		getAccountData = func(requestWrapper messages.RequestWrapper, dbAdapter *adapters.MongoAdapter) (accountData map[string]interface{}, err *utils.Error) {
			called = true
			accountData = make(map[string]interface{})
			accountData["_id"] = "564f1a28e63bce219e1cc745"
			// returning existing account
			return
		}

		requestWrapper := makeValidGoogleRequest()
		response, _, err := HandleSignUp(requestWrapper, &adapters.MongoAdapter{})

		So(err, ShouldBeNil)
		So(called, ShouldBeTrue)
		So(response.Status, ShouldEqual, http.StatusCreated)
	})

}
Exemplo n.º 8
0
func TestFacebookRegistration(t *testing.T) {

	// https needs to be changed to http for mock server to work
	facebookTokenVerificationEndpoint = "http://graph.facebook.com/debug_token"

	config.SystemConfig = config.Config{}
	config.SystemConfig.Facebook = map[string]string{
		"appId":    "facebookappid",
		"appToken": "facebookapptoken",
	}

	Convey("Should fail creating account with Facebook when id is missing", t, func() {

		facebookData := make(map[string]interface{})
		facebookData["accessToken"] = "facebookaccesstoken"

		var message messages.Message
		message.Body = make(map[string]interface{})
		message.Body["facebook"] = facebookData

		var requestWrapper messages.RequestWrapper
		requestWrapper.Message = message

		_, _, err := HandleSignUp(requestWrapper, &adapters.MongoAdapter{})

		So(err.Code, ShouldEqual, http.StatusBadRequest)
	})

	Convey("Should fail creating account with Facebook when access token is missing", t, func() {

		facebookData := make(map[string]interface{})
		facebookData["id"] = "facebookuserid"

		var message messages.Message
		message.Body = make(map[string]interface{})
		message.Body["facebook"] = facebookData

		var requestWrapper messages.RequestWrapper
		requestWrapper.Message = message

		_, _, err := HandleSignUp(requestWrapper, &adapters.MongoAdapter{})

		So(err.Code, ShouldEqual, http.StatusBadRequest)
	})

	Convey("Should fail creating account with Facebook when server configuration is missing", t, func() {

		// removing google configuration
		originalConfig := config.SystemConfig
		config.SystemConfig.Facebook = nil

		requestWrapper := makeValidFacebookRequest()
		_, _, err := HandleSignUp(requestWrapper, &adapters.MongoAdapter{})

		So(err.Code, ShouldEqual, http.StatusInternalServerError)

		// revert back the original configuration
		config.SystemConfig = originalConfig
	})

	Convey("Should fail when getting response from Facebook fails", t, func() {

		mockServer := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
			w.WriteHeader(500)
		}))
		defer mockServer.Close()
		setDefaultServer(mockServer)

		requestWrapper := makeValidFacebookRequest()
		_, _, err := HandleSignUp(requestWrapper, &adapters.MongoAdapter{})

		So(err.Code, ShouldEqual, http.StatusInternalServerError)
	})

	Convey("Should fail when parsing response from Facebook fails", t, func() {

		mockServer := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
			w.WriteHeader(200)
			fmt.Fprintln(w, `{invalidjsonresponse`)
		}))
		defer mockServer.Close()
		setDefaultServer(mockServer)

		requestWrapper := makeValidFacebookRequest()
		_, _, err := HandleSignUp(requestWrapper, &adapters.MongoAdapter{})

		So(err.Code, ShouldEqual, http.StatusInternalServerError)
	})

	Convey("Should fail when Facebook's response is not as expected", t, func() {

		requestWrapper := makeValidFacebookRequest()

		// when 'data' is not at root
		mockServer := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
			w.WriteHeader(200)
			fmt.Fprintln(w, `{}`)
		}))
		defer mockServer.Close()
		setDefaultServer(mockServer)

		_, _, err := HandleSignUp(requestWrapper, &adapters.MongoAdapter{})

		So(err.Code, ShouldEqual, http.StatusInternalServerError)

		// when required fields are not inside 'data'
		mockServer2 := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
			w.WriteHeader(200)
			fmt.Fprintln(w, `{"data": {}}`)
		}))
		defer mockServer2.Close()
		setDefaultServer(mockServer2)

		_, _, err2 := HandleSignUp(requestWrapper, &adapters.MongoAdapter{})

		So(err2.Code, ShouldEqual, http.StatusInternalServerError)
	})

	Convey("Should fail when app ids don't match.", t, func() {

		mockServer := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
			w.WriteHeader(200)
			w.Header().Set("Content-Type", "application/json")
			fmt.Fprintln(w, `{"data": {"app_id": "invalidfacebookappid", "user_id": "facebookuserid", "is_valid": true}}`)
		}))
		defer mockServer.Close()
		setDefaultServer(mockServer)

		requestWrapper := makeValidFacebookRequest()

		_, _, err := HandleSignUp(requestWrapper, &adapters.MongoAdapter{})

		So(err.Code, ShouldEqual, http.StatusInternalServerError)
	})

	Convey("Should fail when user ids don't match.", t, func() {

		mockServer := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
			w.WriteHeader(200)
			w.Header().Set("Content-Type", "application/json")
			fmt.Fprintln(w, `{"data": {"app_id": "facebookappid", "user_id": "invalidfacebookuserid", "is_valid": true}}`)
		}))
		defer mockServer.Close()
		setDefaultServer(mockServer)

		requestWrapper := makeValidFacebookRequest()

		_, _, err := HandleSignUp(requestWrapper, &adapters.MongoAdapter{})

		So(err.Code, ShouldEqual, http.StatusBadRequest)
	})

	Convey("Should fail when token is not valid.", t, func() {

		mockServer := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
			w.WriteHeader(200)
			w.Header().Set("Content-Type", "application/json")
			fmt.Fprintln(w, `{"data": {"app_id": "facebookappid", "user_id": "facebookuserid", "is_valid": false}}`)
		}))
		defer mockServer.Close()
		setDefaultServer(mockServer)

		requestWrapper := makeValidFacebookRequest()

		_, _, err := HandleSignUp(requestWrapper, &adapters.MongoAdapter{})

		So(err.Code, ShouldEqual, http.StatusBadRequest)
	})

	Convey("Should create new account.", t, func() {

		mockServer := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
			w.WriteHeader(200)
			w.Header().Set("Content-Type", "application/json")
			fmt.Fprintln(w, `{"data": {"app_id": "facebookappid", "user_id": "facebookuserid", "is_valid": true}}`)
		}))
		defer mockServer.Close()
		setDefaultServer(mockServer)

		var called bool
		getAccountData = func(requestWrapper messages.RequestWrapper, dbAdapter *adapters.MongoAdapter) (accountData map[string]interface{}, err *utils.Error) {
			called = true
			// returning nil account info
			return
		}

		requestWrapper := makeValidFacebookRequest()
		response, _, err := HandleSignUp(requestWrapper, &adapters.MongoAdapter{})

		So(err, ShouldBeNil)
		So(called, ShouldBeTrue)
		So(response.Status, ShouldEqual, http.StatusCreated)
	})

	Convey("Should return existing account.", t, func() {

		mockServer := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
			w.WriteHeader(200)
			w.Header().Set("Content-Type", "application/json")
			fmt.Fprintln(w, `{"data": {"app_id": "facebookappid", "user_id": "facebookuserid", "is_valid": true}}`)
		}))
		defer mockServer.Close()
		setDefaultServer(mockServer)

		var called bool
		getAccountData = func(requestWrapper messages.RequestWrapper, dbAdapter *adapters.MongoAdapter) (accountData map[string]interface{}, err *utils.Error) {
			called = true
			accountData = make(map[string]interface{})
			accountData["_id"] = "564f1a28e63bce219e1cc745"
			// returning existing account
			return
		}

		requestWrapper := makeValidFacebookRequest()
		response, _, err := HandleSignUp(requestWrapper, &adapters.MongoAdapter{})

		So(err, ShouldBeNil)
		So(called, ShouldBeTrue)
		So(response.Status, ShouldEqual, http.StatusCreated)
	})
}
Exemplo n.º 9
0
func TestInbox(t *testing.T) {

	Convey("Should call actor.handleRequest", t, func() {
		var called bool
		handleRequest = func(a *Actor, requestWrapper messages.RequestWrapper) (response messages.Message) {
			called = true
			return
		}

		var requestWrapper messages.RequestWrapper
		requestWrapper.Res = "/"
		responseChannel := make(chan messages.Message)
		requestWrapper.Listener = responseChannel

		var actor Actor
		actor.class = "someclass"
		actor.res = "/"
		actor.Inbox = make(chan messages.RequestWrapper)
		go actor.Run()
		actor.Inbox <- requestWrapper
		response := <-responseChannel

		So(response, ShouldNotBeNil)
		So(called, ShouldBeTrue)
	})

	Convey("Should forward message to a child actor", t, func() {
		parentRes := "/users"
		childRes := "/users/123"

		var calledOnParent bool
		var calledOnChild bool
		handleRequest = func(a *Actor, requestWrapper messages.RequestWrapper) (response messages.Message) {
			if strings.EqualFold(a.res, parentRes) {
				calledOnParent = true
			}
			if strings.EqualFold(a.res, childRes) {
				calledOnChild = true
			}
			return
		}

		var requestWrapper messages.RequestWrapper
		requestWrapper.Res = childRes
		responseChannel := make(chan messages.Message)
		requestWrapper.Listener = responseChannel

		CreateActor = func(res string, level int, parentInbox chan messages.RequestWrapper) (a Actor) {
			a.res = childRes
			a.level = 2
			a.Inbox = make(chan messages.RequestWrapper)
			return
		}

		var actor Actor
		actor.res = parentRes
		actor.level = 1
		actor.children = make(map[string]Actor)
		actor.Inbox = make(chan messages.RequestWrapper)
		go actor.Run()
		actor.Inbox <- requestWrapper
		response := <-responseChannel

		So(response, ShouldNotBeNil)
		So(calledOnParent, ShouldBeFalse)
		So(calledOnChild, ShouldBeTrue)
	})
}
Exemplo n.º 10
0
func TestHandleRequest(t *testing.T) {

	hooks.ExecuteTrigger = func(className, when, method string,
		parameters map[string][]string, body map[string]interface{}, multipart *multipart.Form,
		user interface{}) (responseBody map[string]interface{}, err *utils.Error) {
		return
	}

	isGrantedFuncThatReturnsTrue := func(collection string, requestWrapper messages.RequestWrapper, dbAdapter *adapters.MongoAdapter) (isGranted bool, user map[string]interface{}, err *utils.Error) {
		isGranted = true
		return
	}

	isGrantedFuncThatReturnsFalse := func(collection string, requestWrapper messages.RequestWrapper, dbAdapter *adapters.MongoAdapter) (isGranted bool, user map[string]interface{}, err *utils.Error) {
		isGranted = false
		return
	}

	resetFunctions()
	Convey("Should call auth.GetPermissions", t, func() {

		var called bool
		auth.IsGranted = func(collection string, requestWrapper messages.RequestWrapper, dbAdapter *adapters.MongoAdapter) (isGranted bool, user map[string]interface{}, err *utils.Error) {
			called = true
			return
		}

		actor := &Actor{}
		actor.class = "someclass"
		handleRequest(actor, messages.RequestWrapper{})
		So(called, ShouldBeTrue)
	})

	Convey("Should return permission error", t, func() {

		auth.IsGranted = func(collection string, requestWrapper messages.RequestWrapper, dbAdapter *adapters.MongoAdapter) (isGranted bool, user map[string]interface{}, err *utils.Error) {
			err = &utils.Error{http.StatusInternalServerError, ""}
			return
		}

		actor := &Actor{}
		actor.class = "someclass"
		response := handleRequest(actor, messages.RequestWrapper{})
		So(response.Status, ShouldEqual, http.StatusInternalServerError)
	})

	/////////////////////////
	// GET
	/////////////////////////
	resetFunctions()
	Convey("Should call handleGet", t, func() {

		auth.IsGranted = isGrantedFuncThatReturnsTrue

		var called bool
		handleGet = func(a *Actor, requestWrapper messages.RequestWrapper) (response messages.Message, err *utils.Error) {
			called = true
			return
		}

		var m messages.Message
		m.Command = "get"

		var rw messages.RequestWrapper
		rw.Message = m

		actor := &Actor{}
		actor.class = "someclass"
		handleRequest(actor, rw)
		So(called, ShouldBeTrue)
	})

	Convey("Should return Authorization error for GET", t, func() {

		auth.IsGranted = isGrantedFuncThatReturnsFalse

		var m messages.Message
		m.Command = "get"

		var rw messages.RequestWrapper
		rw.Message = m

		actor := &Actor{}
		actor.class = "someclass"
		response := handleRequest(actor, rw)
		So(response.Status, ShouldEqual, http.StatusUnauthorized)

	})

	/////////////////////////
	// POST
	/////////////////////////
	Convey("Should call handlePost", t, func() {

		auth.IsGranted = isGrantedFuncThatReturnsTrue

		var called bool
		handlePost = func(a *Actor, requestWrapper messages.RequestWrapper, user interface{}) (response messages.Message, hookBody map[string]interface{}, err *utils.Error) {
			called = true
			return
		}

		var m messages.Message
		m.Command = "post"

		var rw messages.RequestWrapper
		rw.Message = m

		actor := &Actor{}
		actor.class = "someclass"
		handleRequest(actor, rw)
		So(called, ShouldBeTrue)
	})

	Convey("Should return Authorization error for POST", t, func() {

		auth.IsGranted = isGrantedFuncThatReturnsFalse

		var m messages.Message
		m.Command = "post"

		var rw messages.RequestWrapper
		rw.Message = m

		actor := &Actor{}
		actor.class = "someclass"
		response := handleRequest(actor, rw)
		So(response.Status, ShouldEqual, http.StatusUnauthorized)

	})

	/////////////////////////
	// PUT
	/////////////////////////
	Convey("Should call handlePut", t, func() {

		auth.IsGranted = isGrantedFuncThatReturnsTrue

		var called bool
		handlePut = func(a *Actor, requestWrapper messages.RequestWrapper) (response messages.Message, hookBody map[string]interface{}, err *utils.Error) {
			called = true
			return
		}

		var m messages.Message
		m.Command = "put"
		var rw messages.RequestWrapper
		rw.Message = m

		actor := &Actor{}
		actor.class = "someclass"
		handleRequest(actor, rw)
		So(called, ShouldBeTrue)
	})

	Convey("Should return Authorization error for PUT", t, func() {

		auth.IsGranted = isGrantedFuncThatReturnsFalse

		var m messages.Message
		m.Command = "put"

		var rw messages.RequestWrapper
		rw.Message = m

		actor := &Actor{}
		actor.class = "someclass"
		response := handleRequest(actor, rw)
		So(response.Status, ShouldEqual, http.StatusUnauthorized)
	})

	/////////////////////////
	// DELETE
	/////////////////////////
	Convey("Should call handleDelete", t, func() {

		auth.IsGranted = isGrantedFuncThatReturnsTrue

		var called bool
		handleDelete = func(a *Actor, requestWrapper messages.RequestWrapper) (response messages.Message, err *utils.Error) {
			called = true
			return
		}

		var m messages.Message
		m.Command = "delete"
		var rw messages.RequestWrapper
		rw.Message = m

		actor := &Actor{}
		actor.class = "someclass"
		handleRequest(actor, rw)
		So(called, ShouldBeTrue)
	})

	Convey("Should call handleDelete and return error", t, func() {

		auth.IsGranted = isGrantedFuncThatReturnsTrue

		handleDelete = func(a *Actor, requestWrapper messages.RequestWrapper) (response messages.Message, err *utils.Error) {
			err = &utils.Error{http.StatusNotFound, "Item not found."}
			return
		}

		var m messages.Message
		m.Command = "delete"
		var rw messages.RequestWrapper
		rw.Message = m

		actor := &Actor{}
		actor.class = "someclass"
		response := handleRequest(actor, rw)
		So(response.Status, ShouldEqual, http.StatusNotFound)
	})

	Convey("Should return Authorization error for DELETE", t, func() {

		auth.IsGranted = isGrantedFuncThatReturnsFalse

		var m messages.Message
		m.Command = "delete"

		var rw messages.RequestWrapper
		rw.Message = m

		actor := &Actor{}
		actor.class = "someclass"
		response := handleRequest(actor, rw)
		So(response.Status, ShouldEqual, http.StatusUnauthorized)
	})
}