func (suite *AccountsTestSuite) TestFindConfirmationByReference() {
var (
testExpiredConfirmation, testConfirmation, confirmation *accounts.Confirmation
err error
)
// Insert test confirmations
testExpiredConfirmation, err = accounts.NewConfirmation(
suite.users[1],
-10, // expires in
)
assert.NoError(suite.T(), err, "Failed to create a new confirmation object")
err = suite.db.Create(testExpiredConfirmation).Error
assert.NoError(suite.T(), err, "Inserting test data failed")
testConfirmation, err = accounts.NewConfirmation(
suite.users[1],
suite.cnf.AppSpecific.ConfirmationLifetime,
)
assert.NoError(suite.T(), err, "Failed to create a new confirmation object")
err = suite.db.Create(testConfirmation).Error
assert.NoError(suite.T(), err, "Inserting test data failed")
// Let's try to find an expired confirmation by a valid reference
confirmation, err = suite.service.FindConfirmationByReference(testExpiredConfirmation.Reference)
// Confirmation should be nil
assert.Nil(suite.T(), confirmation)
// Correct error should be returned
if assert.NotNil(suite.T(), err) {
assert.Equal(suite.T(), accounts.ErrConfirmationNotFound, err)
}
// Let's try to find a confirmation by a bogus reference
confirmation, err = suite.service.FindConfirmationByReference("bogus")
// Confirmation should be nil
assert.Nil(suite.T(), confirmation)
// Correct error should be returned
if assert.NotNil(suite.T(), err) {
assert.Equal(suite.T(), accounts.ErrConfirmationNotFound, err)
}
// Now let's pass a valid reference
confirmation, err = suite.service.FindConfirmationByReference(testConfirmation.Reference)
// Error should be nil
assert.Nil(suite.T(), err)
// Correct confirmation should be returned with preloaded data
if assert.NotNil(suite.T(), confirmation) {
assert.Equal(suite.T(), suite.users[1].ID, confirmation.User.ID)
assert.False(suite.T(), confirmation.EmailSent)
assert.Nil(suite.T(), confirmation.EmailSentAt)
}
}
func (suite *AccountsTestSuite) TestConfirmEmail() {
var (
testOauthUser *oauth.User
testUser *accounts.User
testConfirmation *accounts.Confirmation
err error
)
// Insert a test user
testOauthUser, err = suite.service.GetOauthService().CreateUser(
roles.User,
"harold@finch",
"test_password",
)
assert.NoError(suite.T(), err, "Failed to insert a test oauth user")
testUser, err = accounts.NewUser(
suite.accounts[0],
testOauthUser,
"", //facebook ID
false, // confirmed
&accounts.UserRequest{
FirstName: "Harold",
LastName: "Finch",
},
)
assert.NoError(suite.T(), err, "Failed to create a new user object")
err = suite.db.Create(testUser).Error
assert.NoError(suite.T(), err, "Failed to insert a test user")
testUser.Account = suite.accounts[0]
testUser.OauthUser = testOauthUser
// Insert a test confirmation
testConfirmation, err = accounts.NewConfirmation(
testUser,
suite.cnf.AppSpecific.ConfirmationLifetime,
)
assert.NoError(suite.T(), err, "Failed to create a new confirmation object")
err = suite.db.Create(testConfirmation).Error
assert.NoError(suite.T(), err, "Failed to insert a test confirmation")
testConfirmation.User = testUser
// Prepare a request
r, err := http.NewRequest(
"GET",
fmt.Sprintf(
"http://1.2.3.4/v1/confirmations/%s",
testConfirmation.Reference,
),
nil,
)
assert.NoError(suite.T(), err, "Request setup should not get an error")
r.Header.Set(
"Authorization",
fmt.Sprintf(
"Basic %s",
b64.StdEncoding.EncodeToString([]byte("test_client_1:test_secret")),
),
)
// Check the routing
match := new(mux.RouteMatch)
suite.router.Match(r, match)
if assert.NotNil(suite.T(), match.Route) {
assert.Equal(suite.T(), "confirm_email", match.Route.GetName())
}
// Count before
var (
countBefore int
accessTokensCountBefore int
refreshTokensCountBefore int
)
suite.db.Model(new(accounts.Confirmation)).Count(&countBefore)
suite.db.Model(new(oauth.AccessToken)).Count(&accessTokensCountBefore)
suite.db.Model(new(oauth.RefreshToken)).Count(&refreshTokensCountBefore)
// And serve the request
w := httptest.NewRecorder()
suite.router.ServeHTTP(w, r)
// Count after
var (
countAfter int
accessTokensCountAfter int
refreshTokensCountAfter int
)
suite.db.Model(new(accounts.Confirmation)).Count(&countAfter)
suite.db.Model(new(oauth.AccessToken)).Count(&accessTokensCountAfter)
suite.db.Model(new(oauth.RefreshToken)).Count(&refreshTokensCountAfter)
assert.Equal(suite.T(), countBefore-1, countAfter)
assert.Equal(suite.T(), accessTokensCountBefore, accessTokensCountAfter)
assert.Equal(suite.T(), refreshTokensCountBefore, refreshTokensCountAfter)
// Fetch the updated user
user := new(accounts.User)
notFound := accounts.UserPreload(suite.db).First(user, testUser.ID).RecordNotFound()
assert.False(suite.T(), notFound)
// Confirmation should have been soft deleteted
assert.True(suite.T(), suite.db.Last(new(accounts.Confirmation)).RecordNotFound())
// And correct data was saved
assert.True(suite.T(), user.Confirmed)
// Check the response
expected, err := accounts.NewConfirmationResponse(testConfirmation)
assert.NoError(suite.T(), err, "Failed to create expected response object")
testutil.TestResponseObject(suite.T(), w, expected, 200)
}