public async Task Index_ViewModel_ShouldMatch_RepositoryResult()
{
var fixture = FixtureExtensions.CreateFixture();
AddCustomizations(fixture);
//Arange
var uService = fixture.Freeze <Mock <IUserService> >();
uService.Setup(u => u.GetUserId()).Returns(() => fixture.Create <string>());
var profileFromRepository = fixture.Create <UserProfile>();
var upRepo = fixture.Freeze <Mock <IUserProfileRepository> >();
upRepo.Setup(r => r.GetUserProfileAsync(It.IsAny <string>())).Returns(Task.FromResult(profileFromRepository));
var sut = fixture.CreateController <UserProfileController>();
// Act
var view = await sut.Index(profileFromRepository.User.UserName) as ViewResult;
var model = view.Model as UserProfileVM;
// Assert
Assert.Equal(profileFromRepository.Id, model.Id);
Assert.Equal(profileFromRepository.UserId, model.UserId);
Assert.Equal(profileFromRepository.AboutMe, model.AboutMe);
Assert.Equal(profileFromRepository.BirthDate, model.BirthDate);
Assert.Equal(profileFromRepository.User.UserName, model.UserName);
Assert.Equal(profileFromRepository.User.Email, model.Email);
Assert.Equal(profileFromRepository.FirstName, model.FirstName);
Assert.Equal(profileFromRepository.LastName, model.LastName);
}
public async Task Get_ShouldReturn_FilteredItems()
{
var fixture = FixtureExtensions.CreateFixture();
fixture.Customizations.Add(new ManyNavigationPropertyOmitter <UserProfileDomain.Models.UserProfile>());
// Arrange
var testBirthDate = fixture.Create <DateTime>();
var nonMatchingCount = fixture.Create <int>();
var mathcingCount = fixture.Create <int>();
var matching = fixture.Build <UserProfileDomain.Models.UserProfile>()
.With(p => p.BirthDate, testBirthDate)
.CreateMany(mathcingCount);
var profileStore = matching.Concat(fixture.CreateMany <UserProfileDomain.Models.UserProfile>(nonMatchingCount)).ToList();
var upContext = fixture.FreezeDbContext <IUserProfileContext>();
MockingHelpers.MockDbContextSet(upContext, c => c.Set <UserProfileDomain.Models.UserProfile>(), profileStore.AsQueryable());
var sut = fixture.Create <UserProfileRepository>();
// Act
var actual = sut.Get(p => p.BirthDate == testBirthDate);
var actualAsync = await sut.GetAsync(p => p.BirthDate == testBirthDate);
//Assert
Assert.Equal(matching, actual);
Assert.Equal(matching, actualAsync);
}
public async Task GetUserProfile_ShouldReturn_UserProfile()
{
var fixture = FixtureExtensions.CreateFixture();
fixture.Customizations.Add(new ManyNavigationPropertyOmitter <UserProfileDomain.Models.UserProfile>());
// Arrange
var testUserId = fixture.Create <string>();
var count = fixture.Create <int>();
var expectedProfile = fixture.Build <UserProfileDomain.Models.UserProfile>()
.With(p => p.UserId, testUserId)
.Create();
var profileStore = new List <UserProfileDomain.Models.UserProfile>()
{
expectedProfile
}
.Concat(fixture.Build <UserProfileDomain.Models.UserProfile>()
.With(p => p.UserId, fixture.Create <string>())
.CreateMany(count));
var upContext = fixture.FreezeDbContext <IUserProfileContext>();
MockingHelpers.MockDbContextSet(upContext, c => c.Set <UserProfileDomain.Models.UserProfile>(), profileStore.AsQueryable());
var sut = fixture.Create <UserProfileRepository>();
// Act
var actual = sut.GetUserProfile(testUserId);
var actualAsync = await sut.GetUserProfileAsync(testUserId);
//Assert
Assert.Equal(expectedProfile, actual);
Assert.Equal(expectedProfile, actualAsync);
}
public async Task UpdateProfile_ShouldCall_UserProfileRepo_InsertOrUpdate_ForValidUserId(string updateType)
{
var fixture = FixtureExtensions.CreateFixture();
AddCustomizations(fixture);
//Arange
var userId = fixture.Create <string>();
var uService = fixture.Freeze <Mock <IUserService> >();
uService.Setup(u => u.GetUserId()).Returns(userId);
var existingProfile = fixture.Build <UserProfile>()
.With(p => p.UserId, userId)
.Create();
UserProfile userProfile;
var upRepo = fixture.Freeze <Mock <IUserProfileRepository> >();
upRepo.Setup(r => r.GetUserProfileAsync(It.IsAny <string>())).Returns(Task.FromResult(existingProfile));
upRepo.Setup(r => r.InsertOrUpdate(It.IsAny <UserProfile>())).Callback <UserProfile>(profile => userProfile = profile);
var sut = fixture.CreateController <UserProfileController>();
var userProfileVM = fixture.Build <UserProfileVM>()
.With(p => p.UserId, userId)
.Create();
// Act
var view = await sut.UpdateProfile(userProfileVM, updateType);
// Assert
upRepo.Verify(r => r.InsertOrUpdate(It.Is <UserProfile>(_profile => _profile.UserId == userId)));
}
public async Task UpdateProfile_WithValidUser_ShouldReturn_RedirectToIndex(string currentUserId, string savedUserId, string updateType)
{
var fixture = FixtureExtensions.CreateFixture();
AddCustomizations(fixture);
//Arange
var uService = fixture.Freeze <Mock <IUserService> >();
uService.Setup(s => s.GetUserId()).Returns(currentUserId);
var sut = fixture.CreateController <UserProfileController>();
var userProfileVM = fixture.Build <UserProfileVM>()
.With(p => p.UserId, savedUserId)
.Create();
Enum.TryParse <UserProfileUpdateType>(updateType, out var uType);
// Act
var action = await sut.UpdateProfile(userProfileVM, updateType);
var redirect = action as RedirectToRouteResult;
// Assert
if (uType != UserProfileUpdateType.Unknown)
{
Assert.IsType <RedirectToRouteResult>(action);
Assert.Contains("action", redirect.RouteValues.Keys);
Assert.Equal("Index", redirect.RouteValues["action"]);
}
else
{
Assert.Contains("updateType", sut.ModelState.Keys);
}
}
public void Index_AuthenticatedUser_ShouldDisplayTaskList()
{
var fixture = FixtureExtensions.CreateFixture();
fixture.Customizations.Add(new ManyNavigationPropertyOmitter <Story>());
fixture.Customizations.Add(new ManyNavigationPropertyOmitter <Group>());
// Arrange
var userStories = fixture.CreateMany <Story>(3).ToList();
var taskRepository = fixture.Freeze <Mock <IStoryRepository> >();
taskRepository.Setup(c => c.GetUserStories(It.IsAny <string>())).Returns(userStories);
var userService = fixture.Freeze <Mock <IUserService> >();
userService.Setup(i => i.IsAuthenticated).Returns(true);
userService.Setup(i => i.GetUserId()).Returns(userStories.First().UserId);
var controller = fixture.CreateController <HomeController>();
// Act
var result = controller.Index() as ViewResult;
// Assert
Assert.NotNull(result);
Assert.Equal("StoryList", result.ViewName);
Assert.IsType <List <Story> >(result.Model);
Assert.Equal(userStories.Count, (result.Model as List <Story>).Count);
}
public async Task UpdateProfile_ShouldNot_UpdateProfileForAnotherUser(string updateType)
{
var fixture = FixtureExtensions.CreateFixture();
AddCustomizations(fixture);
//Arange
var anotherUserId = fixture.Create <string>();
var loggedInUserId = fixture.Create <string>();
var uService = fixture.Freeze <Mock <IUserService> >();
uService.Setup(u => u.GetUserId()).Returns(loggedInUserId);
var upRepo = fixture.Freeze <Mock <IUserProfileRepository> >();
upRepo.Setup(r => r.InsertOrUpdate(It.IsAny <UserProfile>()))
.Throws(new Exception("The user should not be saved. IUserProfileRepository.InsertOrUpdate should not be called."));
var sut = fixture.CreateController <UserProfileController>();
var userProfileVM = fixture.Build <UserProfileVM>()
.With(profile => profile.UserId, anotherUserId)
.Create();
// Act
var action = await sut.UpdateProfile(userProfileVM, updateType);
var view = action as ViewResult;
// Assert
Assert.False(sut.ModelState.IsValid);
Assert.True(sut.ModelState.ContainsKey("UserId"));
Assert.Equal(userProfileVM, view.Model);
}
public void GroupMember_MapsTo_UserProfileRefVM()
{
var fixture = FixtureExtensions.CreateFixture();
fixture.Customizations.Add(new ManyNavigationPropertyOmitter <UserProfileDomain.Models.UserProfile>());
fixture.Customizations.Add(new ManyNavigationPropertyOmitter <Group>());
// Arrange
var groupMembers = fixture.CreateMany <GroupMember>().ToList();
// Act
var uprVM = Mapper.Map <IList <UserBasicInfoVM> >(groupMembers);
// Assert
Assert.Equal(groupMembers.Count, uprVM.Count);
var joined = uprVM.Join(groupMembers, up => up.Id, gm => gm.UserProfile.Id, (up, gm) => new { up, gm })
.ToList();
Assert.Equal(groupMembers.Count, joined.Count);
Assert.All(joined, j => {
Assert.Equal(j.gm.UserProfile.FirstName, j.up.FirstName);
Assert.Equal(j.gm.UserProfile.LastName, j.up.LastName);
});
}
public async Task Index_WithInvalidUserName_ShouldDispaly404()
{
var fixture = FixtureExtensions.CreateFixture();
AddCustomizations(fixture);
// Arrange
var userName = fixture.Create <string>();
var uService = fixture.Freeze <Mock <IUserService> >();
uService.Setup(s => s.FindUserByNameAsync(It.IsAny <string>())).Returns(Task.FromResult <UserInfo>(null));
var sut = fixture.CreateController <UserProfileController>();
// Act
var action = await sut.Index(userName);
var view = action as ViewResult;
// Assert
Assert.IsType <ViewResult>(action);
Assert.Equal("PageNotFound", view.ViewName);
}
public async Task Dasboard_ShouldQueryRepositories()
{
var fixture = FixtureExtensions.CreateFixture();
AddFixtureCustomizations(fixture);
// Arrange
var uService = fixture.Freeze <Mock <IUserService> >();
uService.Setup(s => s.IsInRole(It.IsAny <StandardRoles>())).Returns(true);
uService.Setup(s => s.IsInRole(It.IsAny <string>())).Returns(true);
var upRepo = fixture.Freeze <Mock <IUserProfileRepository> >();
var interestRepo = fixture.Freeze <Mock <IInterestRepository> >();
var hashtagRepo = fixture.Freeze <Mock <IHashtagRepository> >();
var groupRepo = fixture.Freeze <Mock <IGroupRepository> >();
var sut = fixture.CreateController <AdminController>();
// Act
var action = await sut.Dashboard();
// Assert
upRepo.Verify(r => r.GetStrictInRoleUserProfilesAsync(It.Is <StandardRoles>(sr => sr == StandardRoles.Normal)));
upRepo.Verify(r => r.GetUsersInRoleProfileAsync(It.Is <StandardRoles>(sr => sr == StandardRoles.Coach)));
upRepo.Verify(r => r.GetStrictInRoleUserProfilesAsync(It.Is <StandardRoles>(sr => sr == StandardRoles.Admin)));
interestRepo.Verify(r => r.AllAsync);
hashtagRepo.Verify(r => r.AllAsync);
groupRepo.Verify(r => r.AllAsync);
}
public async Task AddInterest_ShouldNot_AddInvalidInterests()
{
var fixture = FixtureExtensions.CreateFixture();
fixture.Customizations.Add(new ManyNavigationPropertyOmitter <UserProfile>());
// Arrange
var interestId = fixture.Create <int>();
var interest = fixture.Build <Interest>()
.With(i => i.Id, interestId)
.Create();
var interestRepo = fixture.Freeze <Mock <IInterestRepository> >();
interestRepo.Setup(r => r.GetAsync(It.IsAny <Expression <Func <Interest, bool> >[]>())).Returns(Task.FromResult(new List <Interest>() as IList <Interest>));
var sut = fixture.CreateController <UserProfileController>();
// Act
var view = await sut.AddInterest(interestId);
// Assert
Assert.False(sut.ModelState.IsValid);
Assert.Contains("Interest", sut.ModelState.Keys);
// Check that the expression used to match interest is evaluating properly
interestRepo.Verify(r => r.GetAsync(
It.Is <Expression <Func <Interest, bool> >[]>(exprs =>
exprs.Select(e => e.Compile()(interest)).All(x => x)
)
));
}
public async Task Index_WithActionNameAsUserName_ShouldRedirectTo_CurrentUser(string userName)
{
var fixture = FixtureExtensions.CreateFixture();
AddCustomizations(fixture);
// Arrange
var uService = fixture.Freeze <Mock <IUserService> >();
uService.Setup(s => s.FindUserByNameAsync(It.IsAny <string>())).Returns(Task.FromResult <UserInfo>(null));
var sut = fixture.CreateController <UserProfileController>();
// Act
var action = await sut.Index(userName);
var redirectAction = action as RedirectToRouteResult;
// Assert
Assert.IsType <RedirectToRouteResult>(action);
Assert.True(redirectAction.RouteValues.ContainsKey("action"));
Assert.Equal("Index", redirectAction.RouteValues["action"]);
Assert.True(redirectAction.RouteValues.ContainsKey("userName"));
Assert.Equal("", redirectAction.RouteValues["userName"]);
}
public async Task GrantRole_ShouldReturnError_IfUserAlreadyInRole()
{
var fixture = FixtureExtensions.CreateFixture();
var grantRoleVM = fixture.Create <GrantRoleVM>();
var uService = fixture.Freeze <Mock <IUserService> >();
uService.Setup(s => s.FindUserByIdAsync(It.IsAny <string>()))
.Returns(Task.FromResult(new UserInfo()));
uService.Setup(s => s.IsInRole(It.IsAny <string>(), It.IsAny <string>()))
.Returns(true);
var sut = fixture.CreateController <AdminController>();
// Act
var action = await sut.GrantRole(grantRoleVM);
var pView = action as PartialViewResult;
// Assert
uService.Verify(s => s.IsInRole(It.Is <string>(v => v == grantRoleVM.UserId), It.Is <string>(v => v == grantRoleVM.RoleName)));
Assert.IsType <PartialViewResult>(action);
Assert.Equal("_AjaxValidation", pView.ViewName);
Assert.False(sut.ModelState.IsValid);
Assert.Contains("UserAlreadyInRole", sut.ModelState.Keys);
}
public void Should_ReturnAllValues_WithSameUserId(int numberOfStories)
{
var fixture = FixtureExtensions.CreateFixture();
fixture.Customizations.Add(new ManyNavigationPropertyOmitter <Story>());
fixture.Customizations.Add(new ManyNavigationPropertyOmitter <Group>());
var userId = "1";
// Arrange
var stories = fixture
.Build <Story>()
.With(t => t.UserId, userId)
.CreateMany(numberOfStories).AsQueryable();
var storyContext = fixture.FreezeDbContext <IStoryContext>();
MockingHelpers.MockDbContextSet(storyContext, c => c.Set <Story>(), stories);
var sut = fixture.Create <StoryRepository>();
// Act
var userStories = sut.GetUserStories(userId);
// Assert
Assert.NotNull(userStories);
Assert.Equal(numberOfStories, userStories.Count);
}
public void Constructor_ThrowsFor_NullUserManager()
{
var fixture = FixtureExtensions.CreateFixture();
// Arrange
fixture.Register <ApplicationUserManager>(() => null);
// Assert
Assert.Throws <ArgumentNullException>("userManager", () => new UserService(null, null));
}
public void ShouldThrow_ArgumentNullExc_WithNull_StoryDbCtx()
{
var fixture = FixtureExtensions.CreateFixture();
// Arrange
fixture.Register <IStoryContext>(() => null);
// Assert
Assert.Throws <ArgumentNullException>("context", () => new StoryRepository(null));
}
public void About()
{
var fixture = FixtureExtensions.CreateFixture();
// Arrange
var controller = fixture.CreateController <HomeController>();
// Act
ViewResult result = controller.About() as ViewResult;
// Assert
Assert.Equal("Your application description page.", result.ViewBag.Message);
}
public void Contact()
{
var fixture = FixtureExtensions.CreateFixture();
// Arrange
var controller = fixture.CreateController <HomeController>();
// Act
ViewResult result = controller.Contact() as ViewResult;
// Assert
Assert.NotNull(result);
}
public void Index_ShouldRedirectTo_Dashboard()
{
var fixture = FixtureExtensions.CreateFixture();
var sut = fixture.CreateController <AdminController>();
// Act
var action = sut.Index();
var redirect = action as RedirectToRouteResult;
// Assert
Assert.IsType <RedirectToRouteResult>(action);
Assert.Contains("action", redirect.RouteValues.Keys);
Assert.Equal("Dashboard", redirect.RouteValues["action"]);
}
public void Should_ReturnEmptyList_WithNullOrWhitespace_UserId(string userId)
{
var fixture = FixtureExtensions.CreateFixture();
// Arrange
var storyContext = fixture.FreezeDbContext <IStoryContext>();
MockingHelpers.MockDbContextSet(storyContext, c => c.Stories, null);
var sut = fixture.Create <StoryRepository>();
// Act
var userStories = sut.GetUserStories(userId);
// Assert
Assert.Equal(0, userStories.Count);
}
public async Task GrantRole_ShouldReturn_JsonResponse_OnSuccess()
{
var fixture = FixtureExtensions.CreateFixture();
var grantRoleVM = fixture.Create <GrantRoleVM>();
var urlLocation = fixture.Create <string>();
var uService = fixture.Freeze <Mock <IUserService> >();
uService.Setup(s => s.FindUserByIdAsync(It.IsAny <string>()))
.Returns(Task.FromResult(new UserInfo()));
uService.Setup(s => s.IsInRole(It.IsAny <string>(), It.IsAny <string>()))
.Returns(false);
uService.Setup(s => s.AddToRoleAsync(It.IsAny <string>(), It.IsAny <string>()))
.Returns(Task.FromResult(GrantRoleResult.Success));
var mockUrlHelper = new Mock <UrlHelper>();
mockUrlHelper.Setup(m => m.Action(It.IsAny <string>()))
.Returns(urlLocation);
var sut = fixture.CreateController <AdminController>();
sut.Url = mockUrlHelper.Object;
// Act
var action = await sut.GrantRole(grantRoleVM);
var jsonResult = action as JsonResult;
// Assert
uService.Verify(s => s.IsInRole(It.Is <string>(v => v == grantRoleVM.UserId), It.Is <string>(v => v == grantRoleVM.RoleName)));
Assert.IsType <JsonResult>(action);
var jsonType = jsonResult.Data.GetType();
Assert.Contains("location", jsonType.GetProperties().Select(m => m.Name));
Assert.Equal(urlLocation, jsonType.GetProperty("location").GetValue(jsonResult.Data));
Assert.True(sut.ModelState.IsValid);
}
public async Task GetUsersInRoleProfileAsync()
{
var fixture = FixtureExtensions.CreateFixture();
fixture.Customizations.Add(new ManyNavigationPropertyOmitter <UserProfileDomain.Models.UserProfile>());
// Arrange
var testRole = fixture.Create <StandardRoles>();
var matchCount = fixture.Create <int>();
var count = fixture.Create <int>();
var expectedProfiles = fixture.CreateUsers(matchCount, () =>
fixture.CreateMany <StandardRoles>()
.Concat(new[] { testRole })
.Distinct()
.ToList()
).ToList();
var profileStore = expectedProfiles.Concat(
fixture.CreateUsers(count, () =>
fixture.CreateMany <StandardRoles>()
.Where(r => r != testRole)
.Distinct()
.ToList()
)
).ToList();
var upContext = fixture.FreezeDbContext <IUserProfileContext>();
MockingHelpers.MockDbContextSet(upContext, c => c.UserProfiles, profileStore.AsQueryable());
var sut = fixture.Create <UserProfileRepository>();
// Act
var actualAsync = await sut.GetUsersInRoleProfileAsync(testRole);
//Assert
Assert.Equal(expectedProfiles, actualAsync);
if (expectedProfiles.Any(p => p.User.Roles.Count > 1))
{
Assert.Contains(actualAsync, p => p.User.Roles.Count > 1);
}
}
public void IsAuthenticated_ReturnsFalse_GetUserId_GetUserName_ReturnsNull_WithNullUser()
{
var fixture = FixtureExtensions.CreateFixture();
// Arrange
fixture.Register <IPrincipal>(() => null);
var sut = fixture.Create <UserService>();
// Act
bool isAuthenticated = sut.IsAuthenticated;
string userId = sut.GetUserId();
string userName = sut.GetUserName();
// Assert
Assert.False(isAuthenticated, "IsAuthenticated must be false for null IPrincipal.");
Assert.Null(userId);
Assert.Null(userName);
}
public async Task FindUserByName_CallsUserManager()
{
var fixture = FixtureExtensions.CreateFixture();
// Arrange
var userInfo = fixture.Create <UserInfo>();
var userMgr = fixture.Freeze <Mock <ApplicationUserManager> >();
userMgr.Setup(mgr => mgr.FindByNameAsync(It.IsAny <string>())).Returns(Task.FromResult(userInfo));
var sut = new UserService(userMgr.Object, null);
// Act
var actualUserInfo = await sut.FindUserByNameAsync(userInfo.UserName);
// Assert
userMgr.Verify(mgr => mgr.FindByNameAsync(It.Is <string>(_uName => _uName == userInfo.UserName)));
Assert.Equal(userInfo, actualUserInfo);
}
public void Index_AnonymousUser_ShouldDisplayLandingPage()
{
var fixture = FixtureExtensions.CreateFixture();
// Arrange
var userService = fixture.Freeze <Mock <IUserService> >();
userService.Setup(i => i.IsAuthenticated).Returns(false);
var storyRepository = fixture.Freeze <Mock <IStoryRepository> >();
var controller = fixture.CreateController <HomeController>();
// Act
ViewResult result = controller.Index() as ViewResult;
// Assert
Assert.NotNull(result);
Assert.Equal("", result.ViewName);
}
public async Task AddInterest_ShouldRetrieve_CurrentUserProfile()
{
var fixture = FixtureExtensions.CreateFixture();
fixture.Customizations.Add(new ManyNavigationPropertyOmitter <UserProfile>());
fixture.Customizations.Add(new ManyNavigationPropertyOmitter <Group>());
// Arrange
var currentUserId = fixture.Create <string>();
var currentUserProfile = fixture.Build <UserProfile>()
.With(p => p.Interests, new List <UserInterest>())
.Create();
var group = fixture.Build <Group>()
.With(g => g.Members, new List <GroupMember>())
.CreateMany(1)
.ToList() as IList <Group>;
var uService = fixture.Freeze <Mock <IUserService> >();
uService.Setup(s => s.GetUserId()).Returns(currentUserId);
var upRepo = fixture.Freeze <Mock <IUserProfileRepository> >();
upRepo.Setup(r => r.GetUserProfileAsync(It.IsAny <string>()))
.Returns(Task.FromResult(currentUserProfile));
var storyUOW = fixture.Freeze <Mock <IStoryUnitOfWork> >();
storyUOW.Setup(uow => uow.Groups.GetAsync(It.IsAny <Expression <Func <Group, bool> >[]>()))
.Returns(Task.FromResult(group));
var interestId = fixture.Create <int>();
var sut = fixture.CreateController <UserProfileController>();
// Act
var view = await sut.AddInterest(interestId);
// Assert
upRepo.Verify(r => r.GetUserProfileAsync(It.Is <string>(i => i == currentUserId)));
}
public async Task UpdateProfile_TypeName_ShouldSave_TheUpdatedVM(string updateType)
{
var fixture = FixtureExtensions.CreateFixture();
AddCustomizations(fixture);
//Arange
var loggedInUserId = fixture.Create <string>();
var uService = fixture.Freeze <Mock <IUserService> >();
uService.Setup(u => u.GetUserId()).Returns(loggedInUserId);
var repositoryProfile = fixture.Build <UserProfile>()
.With(p => p.UserId, loggedInUserId)
.Create();
var originalProfile = new UserProfile();
mapper.Map(repositoryProfile, originalProfile, opts => opts.ConfigureMap());
var upUOF = fixture.Freeze <Mock <IUserProfileUnitOfWork> >();
upUOF.Setup(uof => uof.UserProfiles.GetUserProfileAsync(It.IsAny <string>()))
.Returns(() => Task.FromResult(repositoryProfile));
var sut = fixture.CreateController <UserProfileController>();
var expectedVM = fixture.Build <UserProfileVM>()
.With(profile => profile.UserId, loggedInUserId)
.Create();
// Act
var action = await sut.UpdateProfile(expectedVM, updateType);
// Assert
upUOF.Verify(r => r.UserProfiles.GetUserProfileAsync(It.IsAny <string>()));
upUOF.Verify(r => r.CompleteAsync());
AssertUpdatedVMBasedOnUpdateType(originalProfile, expectedVM, repositoryProfile, updateType);
}
public void StoryComments_AreMappedTo_StoryVM()
{
var fixture = FixtureExtensions.CreateFixture();
fixture.Customizations.Add(new ManyNavigationPropertyOmitter <Story>());
fixture.Customizations.Add(new ManyNavigationPropertyOmitter <Comment>());
fixture.Customizations.Add(new ManyNavigationPropertyOmitter <Group>());
fixture.Customizations.Add(new NavigationPropertyOmitter <Comment, Comment>());
// Arrange
var comments = fixture.CreateMany <Comment>(2).ToList();
var likes = fixture.CreateMany <Like>(2).ToList();
var sut = fixture.Build <Story>()
.With(x => x.Comments, comments)
.With(x => x.Likes, likes)
.Create();
// Act
var storyVM = Mapper.Map <StoryVM>(sut);
// Assert
Assert.NotNull(storyVM.Comments);
Assert.NotEmpty(storyVM.Comments);
Assert.All(storyVM.Comments, commentVM => {
var expectedComment = comments.First(c => c.Id == commentVM.Id);
Assert.Equal(expectedComment.Text, commentVM.Text);
Assert.Equal(expectedComment.UserId, commentVM.UserId);
});
Assert.NotNull(storyVM.Likes);
Assert.NotEmpty(storyVM.Likes);
Assert.All(storyVM.Likes, likeVM => {
var expectedLike = likes.First(c => c.Id == likeVM.Id);
Assert.Equal(expectedLike.StoryId, likeVM.StoryId);
Assert.Equal(expectedLike.Date, likeVM.Date);
Assert.Equal(expectedLike.UserId, likeVM.UserId);
});
}
public void IsAuthenticated_ReturnsValueOf_UserIdentityIsAuthenticated(bool isAuthVal)
{
var fixture = FixtureExtensions.CreateFixture();
// Arrange
var id = fixture.Freeze <Mock <IIdentity> >();
id.Setup(i => i.IsAuthenticated).Returns(isAuthVal);
var usr = fixture.Freeze <Mock <IPrincipal> >();
usr.Setup(i => i.Identity).Returns(id.Object);
var sut = fixture.Create <UserService>();
// Act
bool isAuthenticated = sut.IsAuthenticated;
// Assert
Assert.Equal(isAuthVal, isAuthenticated);
}
public void IsAuthenticated_ReturnsFalse_GetUserId_GetUserName_ReturnsNull_WithNullIdentity()
{
var fixture = FixtureExtensions.CreateFixture();
// Arrange
var usr = fixture.Freeze <Mock <IPrincipal> >();
usr.Setup(i => i.Identity).Returns((IIdentity)null);
var sut = fixture.Create <UserService>();
// Act
bool isAuthenticated = sut.IsAuthenticated;
string userId = sut.GetUserId();
string userName = sut.GetUserName();
// Assert
Assert.False(isAuthenticated, "IsAuthenticated must be false for null IIdentity.");
Assert.Null(userId);
Assert.Null(userName);
}
