private void SetupUser(string id, string email)
{
var user = UserMocks.User(id, email);
A.CallTo(() => userResolver.FindByIdOrEmailAsync(email))
.Returns(user);
}
public async Task GetLists_UserIsAdmin_ReturnsAllLists()
{
var adminList = new ShoppingList();
adminList.Owner = UserMocks.AdminUser;
var userList = new ShoppingList();
userList.Owner = UserMocks.TestUser;
var shoppingLists = new List <ShoppingList>
{
adminList,
userList
};
var shoppingListRepoMock = new Mock <IShoppingLists>();
shoppingListRepoMock.Setup(l => l.GetAllAsync())
.Returns(Task.FromResult(shoppingLists));
var currentUserRepoMock = UserMocks.GetMockUserProvider(UserMocks.AdminUser);
var controller = new ShoppingListsController(shoppingListRepoMock.Object, currentUserRepoMock, null);
var response = await controller.GetLists();
var result = response.Result as OkObjectResult;
var resultValue = result.Value as ShoppingListResult;
Assert.Equal(2, resultValue.ResultData.Count);
}
public async Task UserIsNotAbleToLoginWithIncorrectPassword()
{
// Clear headers
Client.DefaultRequestHeaders.Clear();
// Register new user
var registerFormData = UserMocks.GenerateRegisterData();
await UserMocks.RegisterNewUserAsync(Client, registerFormData);
// Clear headers
Client.DefaultRequestHeaders.Clear();
// Prepare request to login
const string accountLoginAction = "/Account/Login";
var loginResponse = await Client.GetAsync(accountLoginAction);
var antiForgeryToken = await loginResponse.ExtractAntiForgeryToken();
// User Guid like fake password
var loginDataForm = UserMocks.GenerateLoginData(registerFormData["UserName"], Guid.NewGuid().ToString(), antiForgeryToken);
// Login
var requestMessage = RequestHelper.CreatePostRequestWithCookies(accountLoginAction, loginDataForm, loginResponse);
var responseMessage = await Client.SendAsync(requestMessage);
// Get html content
var contentWithErrorMessage = await responseMessage.Content.ReadAsStringAsync();
// Assert status code
responseMessage.StatusCode.Should().Be(HttpStatusCode.OK);
// From String
var doc = new HtmlDocument();
doc.LoadHtml(contentWithErrorMessage);
// Get error messages from validation summary
var errorNodes = doc.DocumentNode
.SelectNodes("//div[contains(@class, 'validation-summary-errors')]/ul/li");
errorNodes.Should().HaveCount(1);
// Build expected error messages
var expectedErrorMessages = new List <string>
{
"Invalid username or password"
};
// Assert
var containErrors = errorNodes.Select(x => x.InnerText).ToList().SequenceEqual(expectedErrorMessages);
containErrors.Should().BeTrue();
// Check if response contain cookie with Identity
const string identityCookieName = ".AspNetCore.Identity.Application";
var existsCookie = CookiesHelper.ExistsCookie(responseMessage, identityCookieName);
// Assert Identity cookie
existsCookie.Should().BeFalse();
}
public async Task UpdateList_UpdateList_ReturnsOkObjectResultWithList()
{
var userRepoMock = UserMocks.GetMockUserProvider(UserMocks.AdminUser);
var testList = new ShoppingList()
{
Id = "123"
};
var listRepoMock = new Mock <IShoppingLists>();
listRepoMock.Setup(l => l.IsOfUserAsync(It.IsAny <string>(), It.IsAny <string>()))
.Returns(Task.FromResult(true));
listRepoMock.Setup(l => l.UpdateAsync(testList.Id, testList))
.Returns(Task.FromResult(testList));
var controller = new ShoppingListsController(listRepoMock.Object, userRepoMock, null);
var response = await controller.UpdateList(testList.Id, testList);
Assert.IsType <OkObjectResult>(response.Result);
var result = response.Result as OkObjectResult;
var list = result.Value as ShoppingListResult;
Assert.Equal(testList.Id, list.ResultData[0].Id);
}
public async Task AddItemToList_AddItemToList_ReturnsOkResultWithItem()
{
var testList = new ShoppingList
{
Id = "abc-def"
};
var item = new ShoppingListItem()
{
Id = "123-456"
};
var listRepoMock = new Mock <IShoppingLists>();
listRepoMock.Setup(l => l.GetAsync(testList.Id))
.Returns(Task.FromResult(testList));
listRepoMock.Setup(l => l.AddOrUpdateItemAsync(testList.Id, item))
.Returns(Task.FromResult(item));
var controller = new ShoppingListsController(listRepoMock.Object, UserMocks.GetMockUserProvider(UserMocks.AdminUser), null);
var response = await controller.AddItemToList(testList.Id, item);
var result = response.Result as OkObjectResult;
var itemResult = result.Value as ShoppingListItemResult;
Assert.Equal(item.Id, itemResult.ResultData[0].Id);
}
public async Task Should_create_enriched_events()
{
var user1 = UserMocks.User("1");
var user2 = UserMocks.User("2");
var users = new List <IUser> {
user1, user2
};
var userIds = users.Select(x => x.Id).ToArray();
var envelope = Envelope.Create <AppEvent>(new CommentCreated {
Mentions = userIds
});
A.CallTo(() => userResolver.QueryManyAsync(userIds))
.Returns(users.ToDictionary(x => x.Id));
var result = await sut.CreateEnrichedEventsAsync(envelope);
Assert.Equal(2, result.Count);
var enrichedEvent1 = result[0] as EnrichedCommentEvent;
var enrichedEvent2 = result[1] as EnrichedCommentEvent;
Assert.Equal(user1, enrichedEvent1 !.MentionedUser);
Assert.Equal(user2, enrichedEvent2 !.MentionedUser);
Assert.Equal("UserMentioned", enrichedEvent1.Name);
Assert.Equal("UserMentioned", enrichedEvent2.Name);
}
public async Task GetLists_ResponseType_IsOkObjectResult()
{
var adminList = new ShoppingList();
adminList.Owner = UserMocks.AdminUser;
var userList = new ShoppingList();
userList.Owner = UserMocks.TestUser;
var shoppingLists = new List <ShoppingList>
{
adminList,
userList
};
var shoppingListRepoMock = new Mock <IShoppingLists>();
shoppingListRepoMock.Setup(l => l.GetAllAsync())
.Returns(Task.FromResult(shoppingLists));
var currentUserRepoMock = UserMocks.GetMockUserProvider(UserMocks.AdminUser);
var controller = new ShoppingListsController(shoppingListRepoMock.Object, currentUserRepoMock, null);
var response = await controller.GetLists();
Assert.IsType <OkObjectResult>(response.Result);
}
public async Task GetList_UserIsNotAdminInList_ReturnsList()
{
var testListName = "TestList";
var testListId = "abc-de";
var testList = new ShoppingList
{
Id = testListId,
Name = testListName
};
var userRepoMock = UserMocks.GetMockUserProvider(UserMocks.TestUser);
var listRepoMock = new Mock <IShoppingLists>();
listRepoMock.Setup(l => l.GetAsync(testListId))
.Returns(Task.FromResult(testList));
listRepoMock.Setup(l => l.IsOfUserAsync(testList.Id, UserMocks.TestUser.Id))
.Returns(Task.FromResult(true));
var controller = new ShoppingListsController(listRepoMock.Object, userRepoMock, null);
var response = await controller.GetList(testListId);
var resultObject = response.Result as OkObjectResult;
var list = resultObject.Value as ShoppingListResult;
Assert.Equal(testListName, list.ResultData[0].Name);
}
public async Task UserIsAbleToUpdateProfile()
{
// Clear headers
_client.DefaultRequestHeaders.Clear();
// Register new user
var registerFormData = UserMocks.GenerateRegisterData();
var registerResponse = await UserMocks.RegisterNewUserAsync(_client, registerFormData);
// Get cookie with user identity for next request
_client.PutCookiesOnRequest(registerResponse);
// Prepare request to update profile
const string manageAction = "/Manage/Index";
var manageResponse = await _client.GetAsync(manageAction);
var antiForgeryToken = await manageResponse.ExtractAntiForgeryToken();
var manageProfileData = UserMocks.GenerateManageProfileData(registerFormData["Email"], antiForgeryToken);
// Update profile
var requestWithAntiForgeryCookie = RequestHelper.CreatePostRequestWithCookies(manageAction, manageProfileData, manageResponse);
var requestWithIdentityCookie = CookiesHelper.CopyCookiesFromResponse(requestWithAntiForgeryCookie, registerResponse);
var responseMessage = await _client.SendAsync(requestWithIdentityCookie);
// Assert
responseMessage.StatusCode.Should().Be(HttpStatusCode.Redirect);
//The redirect to login
responseMessage.Headers.Location.ToString().Should().Be("/Manage");
}
public UserLoginTest()
{
GlobalParameters.KeyPassword = "******";
_userMocks = new UserMocks();
_userAuthentication = new UserAuthentication(_userMocks.UserRepository.Object);
_userLoginDto = LoginBuilder.New().Build();
}
public UserRegisterTest()
{
GlobalParameters.KeyPassword = "******";
_userMocks = new UserMocks();
_userRegister = new UserRegister(_userMocks.UserRepository.Object);
_userRegisterDto = UserBuilder.New().BuildRegisterDto();
_userLog = "Admin";
}
public async Task Should_send_invitation_email_when_consent_given()
{
var withConsent = UserMocks.User("2", "*****@*****.**", "user", true);
texts.ExistingUserSubject = "email-subject";
texts.ExistingUserBody = "email-body";
await sut.SendInviteAsync(assigner, withConsent, appName);
A.CallTo(() => emailSender.SendAsync(withConsent.Email, "email-subject", "email-body", A <CancellationToken> ._))
.MustHaveHappened();
}
public void Should_trigger_check_when_email_is_correct()
{
TestForRealCondition("event.mentionedUser.email == '*****@*****.**'", (handler, trigger) =>
{
var user = UserMocks.User("1", "*****@*****.**");
var result = handler.Trigger(new EnrichedCommentEvent {
MentionedUser = user
}, trigger);
Assert.True(result);
});
}
public void Should_not_trigger_check_when_email_is_correct()
{
TestForRealCondition("event.mentionedUser.email == '*****@*****.**'", (handler, trigger) =>
{
var user = UserMocks.User("1");
var result = handler.Trigger(new EnrichedCommentEvent {
MentionedUser = user
}, trigger);
Assert.False(result);
});
}
public async Task GetList_UserIsNotAdminAndNotUserOfList_ReturnsUnauthorizedResult()
{
var userRepoMock = UserMocks.GetMockUserProvider(UserMocks.TestUser);
var listRepoMock = new Mock <IShoppingLists>();
listRepoMock.Setup(l => l.GetAsync(It.IsAny <string>())).Returns(Task.FromResult(new ShoppingList()));
var controller = new ShoppingListsController(listRepoMock.Object, userRepoMock, null);
var response = await controller.GetList("");
Assert.IsType <UnauthorizedObjectResult>(response.Result);
}
public void Should_not_trigger_check_if_email_is_not_correct()
{
TestForRealCondition("event.mentionedUser.email == '*****@*****.**'", (handler, ctx) =>
{
var @event = new EnrichedCommentEvent
{
MentionedUser = UserMocks.User("1", "*****@*****.**")
};
var result = handler.Trigger(@event, ctx);
Assert.False(result);
});
}
public GraphQLTestBase()
{
A.CallTo(() => userResolver.QueryManyAsync(A <string[]> ._, default))
.ReturnsLazily(x =>
{
var ids = x.GetArgument <string[]>(0) !;
var users = ids.Select(id => UserMocks.User(id, $"{id}@email.com", $"name_{id}"));
return(Task.FromResult(users.ToDictionary(x => x.Id)));
});
requestContext = new Context(Mocks.FrontendUser(), TestApp.Default);
}
public void GetUser_ById_ReturnsUser(int userId)
{
// Arrange
var users = UserMocks.GetUsers();
_ = _mockUserRepository.Setup(x => x.GetUser(It.IsAny <int>())).ReturnsAsync(users[1]);
// Act
var response = _userService.GetUser(userId).Result;
// Assert
Assert.IsNotNull(response);
Assert.AreEqual(response.Surname, "Santana");
}
public async Task CreateList_ItemAlreadyExists_ReturnsConflictResult()
{
var userRepoMock = UserMocks.GetMockUserProvider(UserMocks.AdminUser);
var listRepoMock = new Mock <IShoppingLists>();
listRepoMock.Setup(l => l.CreateAsync(It.IsAny <ShoppingList>()))
.Throws(new ItemAlreadyExistsException());
var controller = new ShoppingListsController(listRepoMock.Object, userRepoMock, null);
var response = await controller.CreateList(new ShoppingList());
Assert.IsType <ConflictObjectResult>(response.Result);
}
public async Task GetList_SearchForNonExistingList_ReturnsNotFoundResult()
{
var testListId = "abc-def";
var userRepoMock = UserMocks.GetMockUserProvider(UserMocks.AdminUser);
var listRepoMock = new Mock <IShoppingLists>();
listRepoMock.Setup(l => l.GetAsync(testListId))
.Throws(new ItemNotFoundException());
var controller = new ShoppingListsController(listRepoMock.Object, userRepoMock, null);
var response = await controller.GetList(testListId);
Assert.IsType <NotFoundObjectResult>(response.Result);
}
public async Task AddItemToList_WhileAddingPersistencyError_ReturnsConflictResult()
{
var listRepoMock = new Mock <IShoppingLists>();
listRepoMock.Setup(l => l.GetAsync(It.IsAny <string>()))
.Returns(Task.FromResult(new ShoppingList()));
listRepoMock.Setup(l => l.AddOrUpdateItemAsync(It.IsAny <string>(), It.IsAny <ShoppingListItem>()))
.Throws(new PersistencyException());
var controller = new ShoppingListsController(listRepoMock.Object, UserMocks.GetMockUserProvider(UserMocks.AdminUser), null);
var response = await controller.AddItemToList("", new ShoppingListItem());
Assert.IsType <ConflictObjectResult>(response.Result);
}
public async Task AddItemToList_ListDoesNotExist_ReturnsNotFoundResult()
{
var userRepoMock = UserMocks.GetMockUserProvider(UserMocks.AdminUser);
var listRepoMock = new Mock <IShoppingLists>();
listRepoMock.Setup(l => l.IsOfUserAsync(It.IsAny <string>(), It.IsAny <string>()))
.Throws(new ItemNotFoundException());
var controller = new ShoppingListsController(listRepoMock.Object, userRepoMock, null);
var response = await controller.AddItemToList("", new ShoppingListItem());
Assert.IsType <NotFoundObjectResult>(response.Result);
}
public async Task UserIsAbleToRegister()
{
// Clear headers
Client.DefaultRequestHeaders.Clear();
// Register new user
var registerFormData = UserMocks.GenerateRegisterData();
var registerResponse = await UserMocks.RegisterNewUserAsync(Client, registerFormData);
// Assert
registerResponse.StatusCode.Should().Be(HttpStatusCode.Redirect);
//The redirect to login
registerResponse.Headers.Location.ToString().Should().Be("/");
}
public async Task DeleteList_DeleteThrowsPersistencyException_ReturnsConflictResult()
{
var userRepoMock = UserMocks.GetMockUserProvider(UserMocks.AdminUser);
var listRepoMock = new Mock <IShoppingLists>();
listRepoMock.Setup(l => l.IsOfUserAsync(It.IsAny <string>(), It.IsAny <string>()))
.Returns(Task.FromResult(true));
listRepoMock.Setup(l => l.DeleteByIdAsync(It.IsAny <string>()))
.Throws(new PersistencyException());
var controller = new ShoppingListsController(listRepoMock.Object, userRepoMock, null);
var response = await controller.DeleteList("123");
Assert.IsType <ConflictObjectResult>(response.Result);
}
public async Task UserIsNotAbleToRegisterWithSameUserName()
{
// Clear headers
Client.DefaultRequestHeaders.Clear();
// Register new user
var registerFormData = UserMocks.GenerateRegisterData();
var registerResponseFirst = await UserMocks.RegisterNewUserAsync(Client, registerFormData);
// Assert
registerResponseFirst.StatusCode.Should().Be(HttpStatusCode.Redirect);
//The redirect to login
registerResponseFirst.Headers.Location.ToString().Should().Be("/");
var registerResponseSecond = await UserMocks.RegisterNewUserAsync(Client, registerFormData);
// Assert response
registerResponseSecond.StatusCode.Should().Be(HttpStatusCode.OK);
// Get html content
var contentWithErrorMessage = await registerResponseSecond.Content.ReadAsStringAsync();
// From String
var doc = new HtmlDocument();
doc.LoadHtml(contentWithErrorMessage);
// Get error messages from validation summary
var errorNodes = doc.DocumentNode
.SelectNodes("//div[contains(@class, 'validation-summary-errors')]/ul/li");
errorNodes.Should().HaveCount(2);
// Build expected error messages
var expectedErrorMessages = new List <string>
{
$"Username '{registerFormData["UserName"]}' is already taken.",
$"Email '{registerFormData["Email"]}' is already taken."
};
// Assert
var containErrors = errorNodes.Select(x => x.InnerText).ToList().SequenceEqual(expectedErrorMessages);
containErrors.Should().BeTrue();
}
public async Task Should_not_create_enriched_events_when_users_cannot_be_resolved()
{
var user1 = UserMocks.User("1");
var user2 = UserMocks.User("2");
var users = new List <IUser> {
user1, user2
};
var userIds = users.Select(x => x.Id).ToArray();
var envelope = Envelope.Create <AppEvent>(new CommentCreated {
Mentions = userIds
});
var result = await sut.CreateEnrichedEventsAsync(envelope);
Assert.Empty(result);
}
public async Task UpdateList_UpdateThrowsItemNotFoundException_ReturnsNotFoundResult()
{
var userRepoMock = UserMocks.GetMockUserProvider(UserMocks.AdminUser);
var listRepoMock = new Mock <IShoppingLists>();
listRepoMock.Setup(l => l.IsOfUserAsync(It.IsAny <string>(), It.IsAny <string>()))
.Returns(Task.FromResult(true));
listRepoMock.Setup(l => l.UpdateAsync(It.IsAny <string>(), It.IsAny <ShoppingList>()))
.Throws(new ItemNotFoundException());
var controller = new ShoppingListsController(listRepoMock.Object, userRepoMock, null);
var response = await controller.UpdateList("123", new ShoppingList()
{
Id = "123"
});
Assert.IsType <NotFoundObjectResult>(response.Result);
}
public async Task AuthorizeUserCanAccessGrantsView()
{
// Clear headers
Client.DefaultRequestHeaders.Clear();
// Register new user
var registerFormData = UserMocks.GenerateRegisterData();
var registerResponse = await UserMocks.RegisterNewUserAsync(Client, registerFormData);
// Get cookie with user identity for next request
Client.PutCookiesOnRequest(registerResponse);
// Act
var response = await Client.GetAsync("/Grants/Index");
// Assert
response.EnsureSuccessStatusCode();
response.StatusCode.Should().Be(HttpStatusCode.OK);
}
private IUser?SetupUser(string id, string?email)
{
if (email != null)
{
var user = UserMocks.User(id, email);
A.CallTo(() => userResolver.FindByIdOrEmailAsync(id))
.Returns(user);
return(user);
}
else
{
A.CallTo(() => userResolver.FindByIdOrEmailAsync(id))
.Returns(Task.FromResult <IUser?>(null));
return(null);
}
}
public async Task GetLists_UserIsNotAdmin_ReturnsListsBelongingToUser()
{
string userListName = "UserList";
var adminList = new ShoppingList();
adminList.Owner = UserMocks.AdminUser;
adminList.Name = "AdminList";
var userList = new ShoppingList();
userList.Owner = UserMocks.TestUser;
userList.Name = userListName;
var shoppingLists = new List <ShoppingList>
{
adminList,
userList
};
var shoppingListRepoMock = new Mock <IShoppingLists>();
shoppingListRepoMock.Setup(l => l.GetAllAsync())
.Returns(Task.FromResult(shoppingLists));
shoppingListRepoMock.Setup(l => l.GetAllOfUserAsync(UserMocks.TestUser.Id))
.Returns(Task.FromResult(new List <ShoppingList>
{
userList
}));
var currentUserRepoMock = UserMocks.GetMockUserProvider(UserMocks.TestUser);
var controller = new ShoppingListsController(shoppingListRepoMock.Object, currentUserRepoMock, null);
var response = await controller.GetLists();
var result = response.Result as OkObjectResult;
var resultValue = result.Value as ShoppingListResult;
Assert.Single(resultValue.ResultData);
Assert.Equal(userListName, resultValue.ResultData.First().Name);
}
