public async void Should_return_BadRequest_when_model_is_null()
{
//Arrange
UserUpdate user = null;
var userId = 1;
var returnExistValue = true;
var key = "Me_StatusCode_400_BadRequest";
var localizedString = new LocalizedString(key, "Bad Request");
LocalizerMock
.Setup(_ => _[key])
.Returns(localizedString);
// Service
UserServiceMock.Setup(x => x.IsExistAsync(userId)).ReturnsAsync(returnExistValue);
// set header values
ControllerUnderTest.ControllerContext.HttpContext.Request.Headers.Add("id", userId.ToString());
//Act
var result = await ControllerUnderTest.Update(user);
//Assert
Assert.IsType <BadRequestObjectResult>(result);
}
public async void Should_return_CreatedResult_when_model_Is_valid()
{
// Arrange
var returnExistValue = true;
var address = AddressData;
int userId = 1;
var resultObject = new Address
{
Address1 = "1601 Hood Avenue",
Address2 = "dolore in adipisicing et",
City = "San Diego",
CountryCode = "11",
PinCode = "92103",
StateId = 1
};
AddressServiceMock
.Setup(x => x.CreateAsync(userId, address))
.ReturnsAsync(resultObject);
UserServiceMock
.Setup(x => x.IsExistAsync(userId))
.ReturnsAsync(true);
//Act
UserServiceMock.Setup(x => x.IsExistAsync(userId)).ReturnsAsync(returnExistValue);
var result = await ControllerUnderTest.CreateAddress(userId, address);
//Assert
var okResult = Assert.IsType <CreatedResult>(result);
Assert.Same(resultObject, okResult.Value);
}
public async Task WhenAddFailsReturnsMessage()
{
var user = TestUtils.GetRandomUser();
var lobbyMessage = new LobbyMessage
{
Id = 1,
MessageDateTime = DateTime.UtcNow,
MessageText = "Test Message",
Sender = user
};
UserServiceMock.Setup(us => us.GetUserFromUsernameAsync(It.IsAny <string>())).ReturnsAsync(user);
MessageServiceMock.Setup(ms => ms.AddMessageAsync(It.IsAny <string>(), It.IsAny <string>())).ReturnsAsync(lobbyMessage);
var result = await Controller.AddMessage(new AddMessageRequest());
var response = TestUtils.GetResponseFromResult <AddMessageResponse>(result);
Assert.IsTrue(response.Success);
Assert.AreEqual(lobbyMessage.Id, response.NewMessage.Id);
Assert.AreEqual(lobbyMessage.MessageText, response.NewMessage.Message);
Assert.AreEqual(lobbyMessage.MessageDateTime, response.NewMessage.Time);
Assert.AreEqual(lobbyMessage.Sender.UserName, response.NewMessage.User);
SubscriberMock.Verify(s => s.PublishAsync(It.IsAny <RedisChannel>(), It.IsAny <RedisValue>(), It.IsAny <CommandFlags>()), Times.Once);
}
public async Task Should_return_OkObjectResult_with_users()
{
//Arrange
var expectedUsers = new User[]
{
new User {
Name = "Gabriel Meyer", Email = "*****@*****.**"
},
new User {
Name = "Renato Rezende", Email = "*****@*****.**"
}
};
UserServiceMock
.Setup(x => x.GetAllAsync())
.ReturnsAsync(expectedUsers);
//Act
var result = await ControllerUnderTest.GetAllAsync();
//Assert
var okResult = Assert.IsType <OkObjectResult>(result);
Assert.Same(expectedUsers, okResult.Value);
}
public async Task WhenUserNotFoundReturnsNotFound()
{
UserServiceMock.Setup(us => us.GetUserFromUsernameAsync(It.IsAny <string>())).ReturnsAsync((Data.Models.GametekiUser)null);
var result = await Controller.UpdateUser(TestUser, new ApiUserAdmin());
Assert.IsInstanceOfType(result, typeof(NotFoundResult));
}
public async Task WhenTokenNotFoundReturnsNotFound()
{
UserServiceMock.Setup(us => us.GetRefreshTokenByIdAsync(It.IsAny <int>()))
.ReturnsAsync((RefreshToken)null);
var result = await Controller.DeleteUserSession(TestUser, 1);
Assert.IsInstanceOfType(result, typeof(NotFoundResult));
}
public async Task WhenUsernameNotFoundReturnsNotFound()
{
UserServiceMock.Setup(us => us.GetUserFromUsernameAsync(It.IsAny <string>()))
.ReturnsAsync((GametekiUser)null);
var result = await Controller.UpdateProfile(TestUser, new UpdateProfileRequest());
Assert.IsInstanceOfType(result, typeof(NotFoundResult));
}
public async Task WhenUsernameNotFoundReturnsNotFound()
{
UserServiceMock.Setup(us => us.GetUserFromUsernameAsync(It.IsAny <string>()))
.ReturnsAsync((GametekiUser)null);
var result = await Controller.RemoveBlockListEntry(TestUser, "Blocked");
Assert.IsInstanceOfType(result, typeof(NotFoundResult));
}
public async Task WhenMessageNotFoundReturnsNotFound()
{
UserServiceMock.Setup(us => us.GetUserFromUsernameAsync(It.IsAny <string>())).ReturnsAsync(TestUtils.GetRandomUser());
MessageServiceMock.Setup(ms => ms.FindByIdAsync(It.IsAny <int>())).ReturnsAsync((LobbyMessage)null);
var result = await Controller.RemoveMessage(1);
Assert.IsInstanceOfType(result, typeof(NotFoundResult));
}
public async Task WhenUserNotFoundReturnsFailure()
{
UserServiceMock.Setup(us => us.GetUserFromUsernameAsync(It.IsAny <string>())).ReturnsAsync((GametekiUser)null);
var result = await Controller.AddMessage(new AddMessageRequest());
var response = TestUtils.GetResponseFromResult <ApiResponse>(result);
Assert.IsFalse(response.Success);
}
public async Task WhenLoginFailsReturnsUnauthorised()
{
UserServiceMock
.Setup(us => us.LoginUserAsync(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <string>()))
.ReturnsAsync((LoginResult)null);
var result = await Controller.Login(new LoginRequest());
Assert.IsInstanceOfType(result, typeof(UnauthorizedResult));
}
public async Task WhenGetUsernameFailsReturnsFailureResponse()
{
UserServiceMock.Setup(us => us.GetUserFromUsernameAsync(It.IsAny <string>()))
.ReturnsAsync((GametekiUser)null);
var result = await Controller.CheckAuth();
var response = TestUtils.GetResponseFromResult <ApiResponse>(result);
Assert.IsFalse(response.Success);
}
public async Task WhenAddFailsReturnsFailure()
{
UserServiceMock.Setup(us => us.GetUserFromUsernameAsync(It.IsAny <string>())).ReturnsAsync(TestUtils.GetRandomUser());
MessageServiceMock.Setup(ms => ms.AddMessageAsync(It.IsAny <string>(), It.IsAny <string>())).ReturnsAsync((LobbyMessage)null);
var result = await Controller.AddMessage(new AddMessageRequest());
var response = TestUtils.GetResponseFromResult <ApiResponse>(result);
Assert.IsFalse(response.Success);
}
public async Task WhenLogoutSucceedsReturnsSuccessResponse()
{
UserServiceMock.Setup(us => us.LogoutUserAsync(It.IsAny <string>(), It.IsAny <string>()))
.ReturnsAsync(true);
var result = await Controller.Logout(new RefreshTokenRequest());
var response = TestUtils.GetResponseFromResult <ApiResponse>(result);
Assert.IsTrue(response.Success);
}
public async Task WhenGetUsernameSucceedsReturnsSuccessResponse()
{
UserServiceMock.Setup(us => us.GetUserFromUsernameAsync(It.IsAny <string>()))
.ReturnsAsync(TestUtils.GetRandomUser());
var result = await Controller.CheckAuth();
var response = TestUtils.GetResponseFromResult <ApiResponse>(result);
Assert.IsTrue(response.Success);
}
public async Task WhenValidateSucceedsReturnsSuccessResponse()
{
UserServiceMock.Setup(us => us.ValidateUserAsync(It.IsAny <string>(), It.IsAny <string>()))
.ReturnsAsync(true);
var result = await Controller.ActivateAccount(new VerifyAccountRequest());
var response = TestUtils.GetResponseFromResult <ApiResponse>(result);
Assert.IsTrue(response.Success);
}
public async Task WhenUpdateFailsReturnsFailureResponse()
{
UserServiceMock.Setup(us => us.GetUserFromUsernameAsync(It.IsAny <string>())).ReturnsAsync(TestUtils.GetRandomUser());
UserServiceMock.Setup(us => us.UpdateUserAsync(It.IsAny <Data.Models.GametekiUser>(), It.IsAny <string>(), It.IsAny <string>())).ReturnsAsync(IdentityResult.Failed());
var result = await Controller.UpdateUser(TestUser, new ApiUserAdmin());
var response = TestUtils.GetResponseFromResult <ApiResponse>(result);
Assert.IsFalse(response.Success);
}
public async Task WhenRefreshTokenFailsReturnsFailureResponse()
{
UserServiceMock
.Setup(us => us.RefreshTokenAsync(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <string>()))
.ReturnsAsync((LoginResult)null);
var result = await Controller.GetNewToken(new RefreshTokenRequest());
var response = TestUtils.GetResponseFromResult <ApiResponse>(result);
Assert.IsFalse(response.Success);
}
public async Task WhenDeleteTokenFailsReturnsFailure()
{
UserServiceMock.Setup(us => us.GetRefreshTokenByIdAsync(It.IsAny <int>()))
.ReturnsAsync(new RefreshToken());
UserServiceMock.Setup(us => us.DeleteRefreshTokenAsync(It.IsAny <RefreshToken>())).ReturnsAsync(false);
var result = await Controller.DeleteUserSession(TestUser, 1);
var response = TestUtils.GetResponseFromResult <ApiResponse>(result);
Assert.IsFalse(response.Success);
}
public async Task WhenRemoveFailsReturnsFailure()
{
UserServiceMock.Setup(us => us.GetUserFromUsernameAsync(It.IsAny <string>())).ReturnsAsync(TestUtils.GetRandomUser());
MessageServiceMock.Setup(ms => ms.FindByIdAsync(It.IsAny <int>())).ReturnsAsync(new LobbyMessage());
MessageServiceMock.Setup(ms => ms.UpdateMessageAsync(It.IsAny <LobbyMessage>())).ReturnsAsync(false);
var result = await Controller.RemoveMessage(1);
var response = TestUtils.GetResponseFromResult <ApiResponse>(result);
Assert.IsFalse(response.Success);
}
public async Task WhenAddingEntryFailsReturnsFailureResponse()
{
UserServiceMock.Setup(us => us.GetUserFromUsernameAsync(It.IsAny <string>()))
.ReturnsAsync(TestUtils.GetRandomUser());
UserServiceMock.Setup(us => us.AddBlockListEntryAsync(It.IsAny <GametekiUser>(), It.IsAny <string>()))
.ReturnsAsync(false);
var result = await Controller.AddBlockListEntry(TestUser, new BlockListEntryRequest());
var response = TestUtils.GetResponseFromResult <ApiResponse>(result);
Assert.IsFalse(response.Success);
}
public async Task WhenUserCannotManagePermissionsDoesNotSetPermissions()
{
UserServiceMock.Setup(us => us.GetUserFromUsernameAsync(It.IsAny <string>())).ReturnsAsync(TestUtils.GetRandomUser());
UserServiceMock.Setup(us => us.UpdateUserAsync(It.IsAny <Data.Models.GametekiUser>(), It.IsAny <string>(), It.IsAny <string>())).ReturnsAsync(IdentityResult.Success);
var result = await Controller.UpdateUser(TestUser, new ApiUserAdmin());
var response = TestUtils.GetResponseFromResult <ApiResponse>(result);
Assert.IsTrue(response.Success);
UserServiceMock.Verify(us => us.UpdatePermissionsAsync(It.IsAny <Data.Models.GametekiUser>(), It.IsAny <Data.Models.Permissions>()), Times.Never);
}
public async Task WhenGravatarEnabledReturnsAvatar()
{
var user = TestUtils.GetRandomUser();
user.EmailHash = user.Email.Md5Hash();
user.Settings.EnableGravatar = true;
UserServiceMock.Setup(us => us.GetUserFromUsernameAsync(It.IsAny <string>())).ReturnsAsync(user);
await Controller.UpdateAvatar(user.UserName);
HttpClientMock.Verify(hc => hc.DownloadFileAsync($"https://www.gravatar.com/avatar/{user.EmailHash.ToLower()}?d=identicon&s=24", It.IsAny <string>()), Times.Once);
}
public async Task WhenDownloadFailsReturnsFailure()
{
var user = TestUtils.GetRandomUser();
user.Settings.EnableGravatar = false;
UserServiceMock.Setup(us => us.GetUserFromUsernameAsync(It.IsAny <string>())).ReturnsAsync(user);
var result = await Controller.UpdateAvatar(user.UserName);
var response = TestUtils.GetResponseFromResult <ApiResponse>(result);
Assert.IsFalse(response.Success);
}
public async Task WhenDeleteTokenSucceedsReturnsDeleteResponse()
{
UserServiceMock.Setup(us => us.GetRefreshTokenByIdAsync(It.IsAny <int>()))
.ReturnsAsync(new RefreshToken {
Id = 1
});
UserServiceMock.Setup(us => us.DeleteRefreshTokenAsync(It.IsAny <RefreshToken>())).ReturnsAsync(true);
var result = await Controller.DeleteUserSession(TestUser, 1);
var response = TestUtils.GetResponseFromResult <DeleteSessionResponse>(result);
Assert.IsTrue(response.Success);
Assert.AreEqual(1, response.TokenId);
}
public async Task WhenAddingEntrySucceedsReturnsSuccessResponse()
{
UserServiceMock.Setup(us => us.GetUserFromUsernameAsync(It.IsAny <string>()))
.ReturnsAsync(TestUtils.GetRandomUser());
UserServiceMock.Setup(us => us.AddBlockListEntryAsync(It.IsAny <GametekiUser>(), It.IsAny <string>()))
.ReturnsAsync(true);
var result =
await Controller.AddBlockListEntry(TestUser, new BlockListEntryRequest { Username = "******" });
var response = TestUtils.GetResponseFromResult <BlockListEntryResponse>(result);
Assert.IsTrue(response.Success);
Assert.AreEqual("Test", response.Username);
}
public async Task WhenEntryNotOnListReturnsNotFound()
{
var user = TestUtils.GetRandomUser();
user.BlockList = new List <BlockListEntry> {
new BlockListEntry {
BlockedUser = "******"
}
};
UserServiceMock.Setup(us => us.GetUserFromUsernameAsync(It.IsAny <string>())).ReturnsAsync(user);
var result = await Controller.RemoveBlockListEntry(TestUser, "notfound");
Assert.IsInstanceOfType(result, typeof(NotFoundResult));
}
public async Task WhenUpdateSucceedsReturnsUpdateResponse()
{
UserServiceMock.Setup(us => us.GetUserFromUsernameAsync(It.IsAny <string>()))
.ReturnsAsync(TestUtils.GetRandomUser());
UserServiceMock.Setup(us =>
us.UpdateUserAsync(It.IsAny <GametekiUser>(), It.IsAny <string>(), It.IsAny <string>()))
.ReturnsAsync(IdentityResult.Success);
var result = await Controller.UpdateProfile(
TestUser,
new UpdateProfileRequest { Settings = new ApiSettings(), Email = "*****@*****.**" });
var response = TestUtils.GetResponseFromResult <UpdateProfileResponse>(result);
Assert.IsTrue(response.Success);
}
public async void Should_return_OkResult_when_model_is_valid()
{
//Arrange
var userId = 6;
var user = UserUpdate;
var returnExistValue = true;
// Service
UserServiceMock.Setup(x => x.IsExistAsync(userId)).ReturnsAsync(returnExistValue);
//Act
var result = await ControllerUnderTest.Update(userId, user);
//Assert
Assert.IsType <OkResult>(result);
}
public async Task WhenUserCanManagePermissionsAndSettingSucceedsReturnsSuccess()
{
UserServiceMock.Setup(us => us.GetUserFromUsernameAsync(It.IsAny <string>())).ReturnsAsync(TestUtils.GetRandomUser());
UserServiceMock.Setup(us => us.UpdateUserAsync(It.IsAny <Data.Models.GametekiUser>(), It.IsAny <string>(), It.IsAny <string>())).ReturnsAsync(IdentityResult.Success);
UserServiceMock.Setup(us => us.UpdatePermissionsAsync(It.IsAny <Data.Models.GametekiUser>(), It.IsAny <Data.Models.Permissions>())).ReturnsAsync(true);
Controller.HttpContext.User.AddIdentity(new ClaimsIdentity(new List <Claim> {
new Claim(ClaimTypes.Role, Roles.PermissionsManager)
}));
var result = await Controller.UpdateUser(TestUser, new ApiUserAdmin());
var response = TestUtils.GetResponseFromResult <ApiResponse>(result);
Assert.IsTrue(response.Success);
}
