Beispiel #1
0
func TestPutFailed(t *testing.T) {
	render := new(tests.MockRender)
	repo := new(tests.MockDoorRepository)

	db := new(tests.MockExecutor)

	repositories := new(tests.MockRepositories)
	repositories.On("DoorRepository").Return(repo)
	repositories.On("DB").Return(db)
	repositories.On("AccountScope").Return(uint(1))

	params := martini.Params{
		"id": "5555",
	}

	postDoor := &doorbot.Door{
		Name: "Romanian Landlords",
	}

	repoDoor := &doorbot.Door{
		ID:   5555,
		Name: "ACME",
	}

	repo.On("Find", db, uint(5555)).Return(repoDoor, nil)
	repo.On("Update", db, repoDoor).Return(false, errors.New("failed"))

	render.On("JSON", http.StatusInternalServerError, doorbot.NewInternalServerErrorResponse([]string{})).Return()

	Put(render, repositories, params, DoorViewModel{Door: postDoor})

	render.Mock.AssertExpectations(t)
	repo.Mock.AssertExpectations(t)
	repositories.Mock.AssertExpectations(t)
}
Beispiel #2
0
func TestPost(t *testing.T) {
	render := new(tests.MockRender)
	repo := new(tests.MockDoorRepository)

	repositories := new(tests.MockRepositories)
	repositories.On("DoorRepository").Return(repo)
	repositories.On("AccountScope").Return(uint(1))

	db := new(tests.MockExecutor)
	repositories.On("DB").Return(db)

	door := &doorbot.Door{
		Name: "ACME",
	}

	repo.On("Create", db, door).Return(nil)

	render.On("JSON", http.StatusCreated, DoorViewModel{Door: door}).Return()

	Post(render, repositories, DoorViewModel{Door: door})

	render.Mock.AssertExpectations(t)
	repo.Mock.AssertExpectations(t)
	repositories.Mock.AssertExpectations(t)
}
Beispiel #3
0
func TestPostCreateError(t *testing.T) {
	render := new(tests.MockRender)
	repo := new(tests.MockDoorRepository)

	db := new(tests.MockExecutor)

	repositories := new(tests.MockRepositories)
	repositories.On("DoorRepository").Return(repo)
	repositories.On("DB").Return(db)
	repositories.On("AccountScope").Return(uint(1))

	door := &doorbot.Door{
		Name: "ACME",
	}

	repo.On("Create", db, door).Return(errors.New("errooor"))

	render.On("JSON", http.StatusInternalServerError, doorbot.NewInternalServerErrorResponse([]string{})).Return()

	Post(render, repositories, DoorViewModel{Door: door})

	render.Mock.AssertExpectations(t)
	repo.Mock.AssertExpectations(t)
	repositories.Mock.AssertExpectations(t)
}
Beispiel #4
0
func TestDisable(t *testing.T) {
	render := new(tests.MockRender)
	repo := new(tests.MockDeviceRepository)

	db := new(tests.MockExecutor)

	repositories := new(tests.MockRepositories)
	repositories.On("DeviceRepository").Return(repo)
	repositories.On("DB").Return(db)
	repositories.On("AccountScope").Return(uint(1))

	params := martini.Params{
		"id": "4443",
	}

	device := &doorbot.Device{
		ID:        4443,
		IsEnabled: false,
	}

	repo.On("Find", db, uint64(4443)).Return(device, nil)
	repo.On("Enable", db, device, false).Return(true, nil)

	render.On("Status", http.StatusNoContent).Return()

	Disable(render, repositories, params)

	render.Mock.AssertExpectations(t)
	repo.Mock.AssertExpectations(t)
	repositories.Mock.AssertExpectations(t)
}
Beispiel #5
0
func TestIndex(t *testing.T) {
	doors := []*doorbot.Door{
		&doorbot.Door{
			ID:        1,
			AccountID: 1,
			Name:      "A",
		},
	}

	render := new(tests.MockRender)
	repo := new(tests.MockDoorRepository)
	db := new(tests.MockExecutor)

	repositories := new(tests.MockRepositories)
	repositories.On("DoorRepository").Return(repo)
	repositories.On("DB").Return(db)

	repo.On("All", db).Return(doors, nil)
	render.On("JSON", http.StatusOK, DoorsViewModel{Doors: doors}).Return()

	Index(render, repositories)

	render.Mock.AssertExpectations(t)
	repo.Mock.AssertExpectations(t)
	repositories.Mock.AssertExpectations(t)
}
Beispiel #6
0
func TestGetNotFound(t *testing.T) {

	var device *doorbot.Device

	render := new(tests.MockRender)
	repo := new(tests.MockDeviceRepository)

	params := martini.Params{
		"id": "33",
	}

	db := new(tests.MockExecutor)

	repositories := new(tests.MockRepositories)
	repositories.On("DeviceRepository").Return(repo)
	repositories.On("DB").Return(db)
	repositories.On("AccountScope").Return(uint(1))

	repo.On("Find", db, uint64(33)).Return(device, nil)
	render.On("JSON", http.StatusNotFound, doorbot.NewEntityNotFoundResponse([]string{"The specified device does not exists"})).Return()

	Get(render, repositories, params)

	render.Mock.AssertExpectations(t)
	repo.Mock.AssertExpectations(t)
	repositories.Mock.AssertExpectations(t)
}
Beispiel #7
0
func TestPutNotFound(t *testing.T) {
	var device *doorbot.Device

	render := new(tests.MockRender)
	repo := new(tests.MockDeviceRepository)

	db := new(tests.MockExecutor)

	repositories := new(tests.MockRepositories)
	repositories.On("DeviceRepository").Return(repo)
	repositories.On("DB").Return(db)

	params := martini.Params{
		"id": "44",
	}

	postDevice := &doorbot.Device{
		Name: "Chicken Nick",
	}

	repo.On("Find", db, uint64(44)).Return(device, nil)
	render.On("JSON", http.StatusNotFound, doorbot.NewEntityNotFoundResponse([]string{"The specified device does not exists"})).Return()

	Put(render, repositories, params, DeviceViewModel{Device: postDevice})

	render.Mock.AssertExpectations(t)
	repo.Mock.AssertExpectations(t)
	repositories.Mock.AssertExpectations(t)
}
Beispiel #8
0
func TestGet(t *testing.T) {
	session := &auth.Authorization{
		Type: auth.AuthorizationPerson,
		Person: &doorbot.Person{
			AccountType: doorbot.AccountOwner,
		},
	}

	render := new(tests.MockRender)
	repo := new(tests.MockPersonRepository)

	db := new(tests.MockExecutor)

	repositories := new(tests.MockRepositories)
	repositories.On("PersonRepository").Return(repo)
	repositories.On("DB").Return(db)

	params := martini.Params{
		"id": "33",
	}

	person := &doorbot.Person{
		ID:   33,
		Name: "ACME",
	}

	render.On("JSON", http.StatusOK, PersonViewModel{Person: person}).Return(nil)
	repo.On("Find", db, uint(33)).Return(person, nil)

	Get(render, repositories, params, session)

	render.Mock.AssertExpectations(t)
	repo.Mock.AssertExpectations(t)
	repositories.Mock.AssertExpectations(t)
}
Beispiel #9
0
func TestIndexError(t *testing.T) {
	session := &auth.Authorization{
		Type: auth.AuthorizationPerson,
		Person: &doorbot.Person{
			AccountType: doorbot.AccountOwner,
		},
	}

	people := []*doorbot.Person{}
	err := errors.New("i like pasta")

	render := new(tests.MockRender)
	repo := new(tests.MockPersonRepository)

	db := new(tests.MockExecutor)

	repositories := new(tests.MockRepositories)
	repositories.On("PersonRepository").Return(repo)
	repositories.On("AccountScope").Return(uint(0))
	repositories.On("DB").Return(db)

	repo.On("All", db).Return(people, err)
	render.On("JSON", http.StatusInternalServerError, doorbot.NewInternalServerErrorResponse([]string{})).Return()

	Index(render, repositories, session)

	render.Mock.AssertExpectations(t)
	repo.Mock.AssertExpectations(t)
	repositories.Mock.AssertExpectations(t)
}
Beispiel #10
0
func TestDeleteNotFound(t *testing.T) {
	var person *doorbot.Person

	repo := new(tests.MockPersonRepository)
	render := new(tests.MockRender)

	db := new(tests.MockExecutor)

	repositories := new(tests.MockRepositories)
	repositories.On("PersonRepository").Return(repo)
	repositories.On("DB").Return(db)
	repositories.On("AccountScope").Return(uint(1))

	params := martini.Params{
		"id": "44",
	}

	account := &doorbot.Account{}
	session := &auth.Authorization{
		Type: auth.AuthorizationPerson,
		Person: &doorbot.Person{
			AccountType: doorbot.AccountOwner,
		},
	}

	repo.On("Find", db, uint(44)).Return(person, nil)

	render.On("JSON", http.StatusNotFound, doorbot.NewEntityNotFoundResponse([]string{"The specified person does not exists"})).Return()

	Delete(render, repositories, params, account, session)

	render.Mock.AssertExpectations(t)
	repo.Mock.AssertExpectations(t)
	repositories.Mock.AssertExpectations(t)
}
Beispiel #11
0
func TestDelete(t *testing.T) {
	render := new(tests.MockRender)
	repo := new(tests.MockDoorRepository)

	db := new(tests.MockExecutor)

	repositories := new(tests.MockRepositories)
	repositories.On("DoorRepository").Return(repo)
	repositories.On("DB").Return(db)
	repositories.On("AccountScope").Return(uint(1))

	params := martini.Params{
		"id": "33",
	}

	door := &doorbot.Door{
		ID:   33,
		Name: "ACME",
	}

	repo.On("Find", db, uint(33)).Return(door, nil)
	repo.On("Delete", db, door).Return(true, nil)

	render.On("Status", http.StatusNoContent).Return()

	Delete(render, repositories, params)

	render.Mock.AssertExpectations(t)
	repo.Mock.AssertExpectations(t)
	repositories.Mock.AssertExpectations(t)
}
Beispiel #12
0
func TestDeleteFailed(t *testing.T) {
	repo := new(tests.MockDoorRepository)
	render := new(tests.MockRender)

	db := new(tests.MockExecutor)

	repositories := new(tests.MockRepositories)
	repositories.On("DoorRepository").Return(repo)
	repositories.On("DB").Return(db)
	repositories.On("AccountScope").Return(uint(1))

	params := martini.Params{
		"id": "55",
	}

	door := &doorbot.Door{
		ID:   55,
		Name: "ACME",
	}

	repo.On("Find", db, uint(55)).Return(door, nil)
	repo.On("Delete", db, door).Return(false, errors.New("error"))

	render.On("Status", http.StatusInternalServerError).Return()

	Delete(render, repositories, params)

	render.Mock.AssertExpectations(t)
	repo.Mock.AssertExpectations(t)
	repositories.Mock.AssertExpectations(t)
}
Beispiel #13
0
func TestIndex(t *testing.T) {
	people := []*doorbot.Person{
		&doorbot.Person{
			ID:        1,
			AccountID: 1,
			Name:      "A",
		},
	}

	session := &auth.Authorization{
		Type: auth.AuthorizationPerson,
		Person: &doorbot.Person{
			AccountType: doorbot.AccountOwner,
		},
	}

	render := new(tests.MockRender)
	repo := new(tests.MockPersonRepository)

	db := new(tests.MockExecutor)

	repositories := new(tests.MockRepositories)
	repositories.On("PersonRepository").Return(repo)
	repositories.On("DB").Return(db)

	repo.On("All", db).Return(people, nil)
	render.On("JSON", http.StatusOK, PeopleViewModel{People: people}).Return()

	Index(render, repositories, session)

	render.Mock.AssertExpectations(t)
	repo.Mock.AssertExpectations(t)
	repositories.Mock.AssertExpectations(t)
}
Beispiel #14
0
func TestDelete(t *testing.T) {
	render := new(tests.MockRender)
	repo := new(tests.MockAccountRepository)
	db := new(tests.MockExecutor)

	repositories := new(tests.MockRepositories)
	repositories.On("AccountRepository").Return(repo)
	repositories.On("DB").Return(db)

	params := martini.Params{
		"id": "33",
	}

	account := &doorbot.Account{
		ID:   33,
		Name: "ACME",
	}

	admin := &doorbot.Administrator{}

	repo.On("Find", db, uint(33)).Return(account, nil)
	repo.On("Delete", db, account).Return(true, nil)

	render.On("Status", http.StatusNoContent).Return()

	Delete(render, repositories, params, admin)

	render.Mock.AssertExpectations(t)
	repo.Mock.AssertExpectations(t)
}
Beispiel #15
0
func TestDeleteNotFound(t *testing.T) {
	var account *doorbot.Account
	admin := &doorbot.Administrator{}

	repo := new(tests.MockAccountRepository)
	render := new(tests.MockRender)

	repositories := new(tests.MockRepositories)
	repositories.On("AccountRepository").Return(repo)
	repositories.On("AccountScope").Return(1)

	db := new(tests.MockExecutor)
	repositories.On("DB").Return(db)

	params := martini.Params{
		"id": "44",
	}

	repo.On("Find", db, uint(44)).Return(account, nil)

	render.On("JSON", http.StatusNotFound, doorbot.NewEntityNotFoundResponse([]string{"The specified account does not exists."})).Return()

	Delete(render, repositories, params, admin)

	render.Mock.AssertExpectations(t)
	repo.Mock.AssertExpectations(t)
}
Beispiel #16
0
func TestPut(t *testing.T) {
	render := new(tests.MockRender)
	repo := new(tests.MockAccountRepository)
	db := new(tests.MockExecutor)

	repositories := new(tests.MockRepositories)
	repositories.On("AccountRepository").Return(repo)
	repositories.On("DB").Return(db)

	postAccount := &doorbot.Account{
		Name: "Romanian Landlords",
	}

	repoAccount := &doorbot.Account{
		ID:        5555,
		Name:      "ACME",
		IsEnabled: true,
	}

	session := &auth.Authorization{
		Type: auth.AuthorizationAdministrator,
	}

	repo.On("Update", db, repoAccount).Return(true, nil)

	render.On("JSON", http.StatusOK, AccountViewModel{Account: repoAccount}).Return()

	Put(render, repoAccount, repositories, AccountViewModel{Account: postAccount}, session)

	assert.Equal(t, "Romanian Landlords", repoAccount.Name)

	render.Mock.AssertExpectations(t)
	repo.Mock.AssertExpectations(t)
}
Beispiel #17
0
func TestPutFailed(t *testing.T) {
	render := new(tests.MockRender)
	repo := new(tests.MockAccountRepository)
	db := new(tests.MockExecutor)

	repositories := new(tests.MockRepositories)
	repositories.On("AccountRepository").Return(repo)
	repositories.On("DB").Return(db)
	repositories.On("AccountScope").Return(1)

	postAccount := &doorbot.Account{
		Name: "Romanian Landlords",
	}

	repoAccount := &doorbot.Account{
		ID:        5555,
		Name:      "ACME",
		IsEnabled: true,
	}

	session := &auth.Authorization{
		Type: auth.AuthorizationAdministrator,
	}

	repo.On("Update", db, repoAccount).Return(false, errors.New("failed"))

	render.On("JSON", http.StatusInternalServerError, doorbot.NewInternalServerErrorResponse([]string{})).Return()

	Put(render, repoAccount, repositories, AccountViewModel{Account: postAccount}, session)

	render.Mock.AssertExpectations(t)
	repo.Mock.AssertExpectations(t)
}
Beispiel #18
0
func TestPost(t *testing.T) {
	render := new(tests.MockRender)
	repo := new(tests.MockAccountRepository)
	db := new(tests.MockExecutor)

	repositories := new(tests.MockRepositories)
	repositories.On("AccountRepository").Return(repo)
	repositories.On("DB").Return(db)

	account := &doorbot.Account{
		Name: "ACME",
		Host: "derp",
	}

	admin := &doorbot.Administrator{}

	// nil
	var findByHostReponse *doorbot.Account

	repo.On("Create", db, account).Return(nil)
	repo.On("FindByHost", db, "derp").Return(findByHostReponse, nil)

	render.On("JSON", http.StatusCreated, AccountViewModel{Account: account}).Return()

	Post(render, repositories, AccountViewModel{Account: account}, admin)

	render.Mock.AssertExpectations(t)
	repo.Mock.AssertExpectations(t)
}
Beispiel #19
0
func TestPostCreateError(t *testing.T) {
	render := new(tests.MockRender)
	repo := new(tests.MockAccountRepository)
	db := new(tests.MockExecutor)

	admin := &doorbot.Administrator{}

	repositories := new(tests.MockRepositories)
	repositories.On("AccountRepository").Return(repo)
	repositories.On("DB").Return(db)
	repositories.On("AccountScope").Return(1)

	account := &doorbot.Account{
		Name: "ACME",
		Host: "derp",
	}

	// nil
	var findByHostReponse *doorbot.Account

	repo.On("Create", db, account).Return(errors.New("errooor"))
	repo.On("FindByHost", db, "derp").Return(findByHostReponse, nil)

	render.On("JSON", http.StatusInternalServerError, doorbot.NewInternalServerErrorResponse([]string{})).Return()

	Post(render, repositories, AccountViewModel{Account: account}, admin)

	render.Mock.AssertExpectations(t)
	repo.Mock.AssertExpectations(t)
}
Beispiel #20
0
func TestIndex(t *testing.T) {

	accounts := []*doorbot.Account{
		&doorbot.Account{
			ID:        1,
			Name:      "ACME",
			IsEnabled: true,
		},
	}

	admin := &doorbot.Administrator{}

	render := new(tests.MockRender)
	repo := new(tests.MockAccountRepository)

	db := new(tests.MockExecutor)

	repositories := new(tests.MockRepositories)
	repositories.On("AccountRepository").Return(repo)
	repositories.On("DB").Return(db)

	repo.On("All", db).Return(accounts, nil)

	render.On("JSON", http.StatusOK, AccountsViewModel{Accounts: accounts}).Return(nil)

	Index(render, repositories, admin)

	render.Mock.AssertExpectations(t)
	repo.Mock.AssertExpectations(t)
}
Beispiel #21
0
func TestDeleteNotFound(t *testing.T) {
	var door *doorbot.Door

	repo := new(tests.MockDoorRepository)
	render := new(tests.MockRender)

	db := new(tests.MockExecutor)

	repositories := new(tests.MockRepositories)
	repositories.On("DoorRepository").Return(repo)
	repositories.On("DB").Return(db)

	params := martini.Params{
		"id": "44",
	}

	repo.On("Find", db, uint(44)).Return(door, nil)

	render.On("JSON", http.StatusNotFound, doorbot.NewEntityNotFoundResponse([]string{"The specified door does not exists"})).Return()

	Delete(render, repositories, params)

	render.Mock.AssertExpectations(t)
	repo.Mock.AssertExpectations(t)
	repositories.Mock.AssertExpectations(t)
}
Beispiel #22
0
func TestGet(t *testing.T) {

	render := new(tests.MockRender)
	repo := new(tests.MockDoorRepository)
	db := new(tests.MockExecutor)

	repositories := new(tests.MockRepositories)
	repositories.On("DoorRepository").Return(repo)
	repositories.On("DB").Return(db)

	params := martini.Params{
		"id": "33",
	}

	door := &doorbot.Door{
		ID:   33,
		Name: "ACME",
	}

	render.On("JSON", http.StatusOK, DoorViewModel{Door: door}).Return(nil)
	repo.On("Find", db, uint(33)).Return(door, nil)

	Get(render, repositories, params)

	render.Mock.AssertExpectations(t)
	repo.Mock.AssertExpectations(t)
	repositories.Mock.AssertExpectations(t)
}
Beispiel #23
0
func TestPost(t *testing.T) {
	render := new(tests.MockRender)
	repo := new(tests.MockPersonRepository)

	db := new(tests.MockExecutor)

	repositories := new(tests.MockRepositories)
	repositories.On("PersonRepository").Return(repo)
	repositories.On("DB").Return(db)
	repositories.On("AccountScope").Return(uint(0))

	person := &doorbot.Person{
		Name: "ACME",
	}

	repo.On("Create", db, person).Return(nil)

	render.On("JSON", http.StatusCreated, PersonViewModel{Person: person}).Return()

	Post(render, repositories, PersonViewModel{Person: person})

	render.Mock.AssertExpectations(t)
	repo.Mock.AssertExpectations(t)
	repositories.Mock.AssertExpectations(t)
}
Beispiel #24
0
func TestDeleteFailed(t *testing.T) {
	repo := new(tests.MockAccountRepository)
	render := new(tests.MockRender)

	admin := &doorbot.Administrator{}

	db := new(tests.MockExecutor)

	repositories := new(tests.MockRepositories)
	repositories.On("AccountRepository").Return(repo)
	repositories.On("DB").Return(db)
	repositories.On("AccountScope").Return(1)

	params := martini.Params{
		"id": "55",
	}

	account := &doorbot.Account{
		ID:   55,
		Name: "ACME",
	}

	repo.On("Find", db, uint(55)).Return(account, nil)
	repo.On("Delete", db, account).Return(false, errors.New("error"))

	render.On("JSON", http.StatusInternalServerError, doorbot.NewInternalServerErrorResponse([]string{})).Return()

	Delete(render, repositories, params, admin)

	render.Mock.AssertExpectations(t)
	repo.Mock.AssertExpectations(t)
}
Beispiel #25
0
func TestGetNotFound(t *testing.T) {

	var account *doorbot.Account

	session := &auth.Authorization{}

	render := new(tests.MockRender)
	repo := new(tests.MockAccountRepository)
	db := new(tests.MockExecutor)

	repositories := new(tests.MockRepositories)
	repositories.On("DB").Return(db)
	repositories.On("AccountRepository").Return(repo)
	repositories.On("AccountScope").Return(1)

	params := martini.Params{
		"id": "33",
	}

	repo.On("Find", db, uint(33)).Return(account, nil)

	render.On("JSON", http.StatusNotFound, doorbot.NewEntityNotFoundResponse([]string{})).Return()

	Get(render, repositories, params, session)

	render.Mock.AssertExpectations(t)
	repo.Mock.AssertExpectations(t)
}
Beispiel #26
0
func TestPassword(t *testing.T) {
	account := &doorbot.Account{
		ID:        444,
		Name:      "ACME",
		IsEnabled: true,
	}

	person := &doorbot.Person{
		ID:    1,
		Name:  "Cookie Monster",
		Email: "*****@*****.**",
	}

	passwordAuthentication := &doorbot.Authentication{
		AccountID: 444,
		PersonID:  1,
		Token:     "$2a$10$8XdprxFRIXCv1TC2cDjMNuQRiYkOX9PIivVpnSMM9b.1UjulLlrVm", // test
	}

	passwordRequest := PasswordRequest{
		Authentication: PasswordAuthentication{
			Email:    "*****@*****.**",
			Password: "******",
		},
	}

	var tokenNotFound *doorbot.Authentication

	render := new(tests.MockRender)
	personRepo := new(tests.MockPersonRepository)
	authRepo := new(tests.MockAuthenticationRepository)

	repositories := new(tests.MockRepositories)
	repositories.On("PersonRepository").Return(personRepo)
	repositories.On("AuthenticationRepository").Return(authRepo)

	db := new(tests.MockExecutor)
	repositories.On("DB").Return(db)

	personRepo.On("FindByEmail", db, "*****@*****.**").Return(person, nil)

	authRepo.On("FindByPersonIDAndProviderID", db, person.ID, auth.ProviderPassword).Return(passwordAuthentication, nil).Once()
	authRepo.On("FindByPersonIDAndProviderID", db, person.ID, auth.ProviderAPIToken).Return(tokenNotFound, nil).Once()
	authRepo.On("Create", db, mock.AnythingOfType("*doorbot.Authentication")).Return(nil).Once()

	render.On("JSON", http.StatusOK, mock.AnythingOfType("auth.APITokenResponse")).Return().Once()
	Password(render, account, repositories, passwordRequest)

	render.Mock.AssertExpectations(t)
	personRepo.Mock.AssertExpectations(t)
	repositories.Mock.AssertExpectations(t)
	authRepo.Mock.AssertExpectations(t)
}
Beispiel #27
0
func TestNotify(t *testing.T) {
	render := new(tests.MockRender)
	db := new(tests.MockExecutor)
	repositories := new(tests.MockRepositories)

	notificator := new(tests.MockNotificator)
	peopleRepo := new(tests.MockPersonRepository)
	doorRepo := new(tests.MockDoorRepository)

	account := &doorbot.Account{
		ID: 44,
	}

	person := &doorbot.Person{
		AccountID:   44,
		ID:          45,
		Name:        "John Rambo",
		Email:       "*****@*****.**",
		IsVisible:   true,
		IsAvailable: true,
	}

	door := &doorbot.Door{}

	notification := Notification{
		DoorID:   33,
		PersonID: 45,
	}

	repositories.On("PersonRepository").Return(peopleRepo)
	repositories.On("DoorRepository").Return(doorRepo)
	repositories.On("DB").Return(db)

	peopleRepo.On("Find", db, uint(45)).Return(person, nil)
	doorRepo.On("Find", db, uint(33)).Return(door, nil)

	notificator.On("Notify", account, door, person).Return(nil)

	vm := ViewModel{Notification: &notification}

	render.On("JSON", http.StatusAccepted, ViewModel{Notification: &notification}).Return()

	Notify(render, account, repositories, notificator, vm)

	render.Mock.AssertExpectations(t)
	peopleRepo.Mock.AssertExpectations(t)
	doorRepo.Mock.AssertExpectations(t)
	repositories.Mock.AssertExpectations(t)
	notificator.Mock.AssertExpectations(t)
}
Beispiel #28
0
func TestPasswordInvalid(t *testing.T) {
	person := &doorbot.Person{
		ID:    1,
		Name:  "Cookie Monster",
		Email: "*****@*****.**",
	}

	account := &doorbot.Account{
		ID:        1,
		Name:      "ACME",
		IsEnabled: true,
	}

	passwordAuthentication := &doorbot.Authentication{
		AccountID: 1,
		PersonID:  1,
		Token:     "$2a$10$8XdprxFRIXCv1TC2cDjMNuQRiYkOX9PIivVpnSMM9b.1UjulLlrVm", // test
	}

	passwordRequest := PasswordRequest{
		Authentication: PasswordAuthentication{
			Email:    "*****@*****.**",
			Password: "******",
		},
	}

	render := new(tests.MockRender)
	personRepo := new(tests.MockPersonRepository)
	authRepo := new(tests.MockAuthenticationRepository)

	db := new(tests.MockExecutor)

	repositories := new(tests.MockRepositories)
	repositories.On("PersonRepository").Return(personRepo)
	repositories.On("AuthenticationRepository").Return(authRepo)
	repositories.On("DB").Return(db)

	personRepo.On("FindByEmail", db, "*****@*****.**").Return(person, nil)
	authRepo.On("FindByPersonIDAndProviderID", db, person.ID, auth.ProviderPassword).Return(passwordAuthentication, nil)

	render.On("JSON", http.StatusUnauthorized, doorbot.NewUnauthorizedErrorResponse([]string{"Invalid email or password"})).Return()
	Password(render, account, repositories, passwordRequest)

	render.Mock.AssertExpectations(t)
	personRepo.Mock.AssertExpectations(t)
	authRepo.Mock.AssertExpectations(t)
	repositories.Mock.AssertExpectations(t)
}
Beispiel #29
0
func TestDeleteInvalidID(t *testing.T) {
	render := new(tests.MockRender)

	repositories := new(tests.MockRepositories)

	params := martini.Params{
		"id": "help",
	}

	render.On("JSON", http.StatusBadRequest, doorbot.NewBadRequestErrorResponse([]string{"The id must be an unsigned integer"})).Return()

	Delete(render, repositories, params)

	render.Mock.AssertExpectations(t)
	repositories.Mock.AssertExpectations(t)
}
Beispiel #30
0
func TestRegister(t *testing.T) {
	render := new(tests.MockRender)
	notificator := new(tests.MockNotificator)

	accountRepo := new(tests.MockAccountRepository)
	authRepo := new(tests.MockAuthenticationRepository)
	personRepo := new(tests.MockPersonRepository)

	db := new(tests.MockExecutor)
	tx := new(tests.MockTransaction)

	config := &doorbot.DoorbotConfig{}

	repositories := new(tests.MockRepositories)
	repositories.On("AccountRepository").Return(accountRepo)
	repositories.On("PersonRepository").Return(personRepo)
	repositories.On("AuthenticationRepository").Return(authRepo)
	repositories.On("SetAccountScope", uint(0)).Return()

	repositories.On("DB").Return(db)
	repositories.On("Transaction").Return(tx, nil)

	vm := RegisterViewModel{
		Account: AccountRegisterRequest{
			Name: "ACME",
		},
	}

	var noAccount *doorbot.Account

	accountRepo.On("FindByHost", db, mock.AnythingOfType("string")).Return(noAccount, nil)
	accountRepo.On("Create", tx, mock.AnythingOfType("*doorbot.Account")).Return(nil)
	personRepo.On("Create", tx, mock.AnythingOfType("*doorbot.Person")).Return(nil)
	authRepo.On("Create", tx, mock.AnythingOfType("*doorbot.Authentication")).Return(nil)

	notificator.On("AccountCreated", mock.AnythingOfType("*doorbot.Account"), mock.AnythingOfType("*doorbot.Person"), mock.AnythingOfType("string")).Return()
	tx.On("Commit").Return(nil)

	render.On("JSON", http.StatusCreated, mock.AnythingOfType("AccountViewModel")).Return()

	Register(render, config, repositories, notificator, vm)

	render.Mock.AssertExpectations(t)
	accountRepo.Mock.AssertExpectations(t)
	personRepo.Mock.AssertExpectations(t)
	authRepo.Mock.AssertExpectations(t)
}