public async Task GetUserByIdAsync_WithValidDAta_ShouldReturnCorrectUser()
{
//Arrange
var expectedUserId = "UserId";
var expectedUsername = "******";
var moqHttpContext = new Mock <IHttpContextAccessor>();
var userStore = new Mock <IUserStore <SellMeUser> >();
var userManager = new Mock <UserManager <SellMeUser> >(userStore.Object, null, null, null, null, null, null, null, null);
userManager.Setup(x => x.FindByIdAsync("UserId"))
.ReturnsAsync(new SellMeUser {
Id = "UserId", UserName = "******"
});
var context = InitializeContext.CreateContextForInMemory();
this.usersService = new UsersService(context, moqHttpContext.Object, userManager.Object);
var testingUser = new SellMeUser {
Id = "UserId", UserName = "******"
};
await context.SellMeUsers.AddAsync(testingUser);
await context.SaveChangesAsync();
//Act
var actual = await this.usersService.GetUserByIdAsync("UserId");
//Assert
Assert.Equal(expectedUserId, actual.Id);
Assert.Equal(expectedUsername, actual.UserName);
}
private static async Task SeedRoleAsync(RoleManager <IdentityRole> roleManager,
UserManager <SellMeUser> userManager, string roleName)
{
var role = await roleManager.FindByNameAsync(roleName);
if (role == null)
{
var result = await roleManager.CreateAsync(new IdentityRole(roleName));
if (!result.Succeeded)
{
throw new Exception(string.Join(Environment.NewLine, result.Errors.Select(e => e.Description)));
}
}
if (!await userManager.Users.AnyAsync())
{
var user = new SellMeUser
{
UserName = "******",
Email = "*****@*****.**",
EmailConfirmed = true
};
var password = "******";
var result = await userManager.CreateAsync(user, password);
if (result.Succeeded)
{
await userManager.AddToRoleAsync(user, GlobalConstants.AdministratorRoleName);
}
}
}
public async Task UnblockUserByIdAsync_WithValidDAta_ShouldReturnTrue()
{
//Arrange
var moqHttpContext = new Mock <IHttpContextAccessor>();
var userStore = new Mock <IUserStore <SellMeUser> >();
var userManager = new Mock <UserManager <SellMeUser> >(userStore.Object, null, null, null, null, null, null, null, null);
var context = InitializeContext.CreateContextForInMemory();
this.usersService = new UsersService(context, moqHttpContext.Object, userManager.Object);
var testingUser = new SellMeUser
{
Id = "UserId",
UserName = "******",
IsDeleted = true,
EmailConfirmed = true,
CreatedOn = DateTime.UtcNow.AddDays(-25),
Ads = new List <Ad> {
new Ad(), new Ad()
}
};
await context.SellMeUsers.AddAsync(testingUser);
await context.SaveChangesAsync();
//Act
var actual = await this.usersService.UnblockUserByIdAsync("UserId");
//Assert
Assert.True(actual);
Assert.False(testingUser.IsDeleted);
}
private IQueryable <FavoriteAdViewModel> GetFavoriteAdViewModelsByUser(SellMeUser user)
{
var favoriteAdsViewModels = context
.SellMeUserFavoriteProducts
.Where(x => x.SellMeUserId == user.Id)
.OrderByDescending(x => x.CreatedOn)
.To <FavoriteAdViewModel>();
return(favoriteAdsViewModels);
}
public async Task GetRatingByUserAsync_WithValidData_ShouldReturnCorrectResult()
{
//Arrange
var expected = 2;
var moqHttpContext = new Mock <IHttpContextAccessor>();
var userStore = new Mock <IUserStore <SellMeUser> >();
var userManager = new Mock <UserManager <SellMeUser> >(userStore.Object, null, null, null, null, null, null, null, null);
userManager.Setup(x => x.FindByIdAsync("UserId"))
.ReturnsAsync(new SellMeUser
{
Id = "UserId",
UserName = "******",
OwnedReviews = new List <Review>
{
new Review {
Comment = "Comment1", Rating = 5
},
new Review {
Comment = "Comment2", Rating = 2
},
new Review {
Comment = "Comment3", Rating = 1
},
new Review {
Comment = "Comment4", Rating = 1
},
new Review {
Comment = "Comment5", Rating = 1
},
}
});
var context = InitializeContext.CreateContextForInMemory();
this.usersService = new UsersService(context, moqHttpContext.Object, userManager.Object);
var testingUser = new SellMeUser {
Id = "UserId", UserName = "******"
};
await context.SellMeUsers.AddAsync(testingUser);
await context.SaveChangesAsync();
//Act
var actual = await this.usersService.GetRatingByUserAsync("UserId");
//Assert
Assert.Equal(expected, actual);
}
private async Task LoadSharedKeyAndQrCodeUriAsync(SellMeUser user)
{
// Load the authenticator key & QR code URI to display on the form
var unformattedKey = await _userManager.GetAuthenticatorKeyAsync(user);
if (string.IsNullOrEmpty(unformattedKey))
{
await _userManager.ResetAuthenticatorKeyAsync(user);
unformattedKey = await _userManager.GetAuthenticatorKeyAsync(user);
}
SharedKey = FormatKey(unformattedKey);
var email = await _userManager.GetEmailAsync(user);
AuthenticatorUri = GenerateQrCodeUri(email, unformattedKey);
}
public async Task <IActionResult> OnPostConfirmationAsync(string returnUrl = null)
{
returnUrl = returnUrl ?? Url.Content("~/");
// Get the information about the user from the external login provider
var info = await _signInManager.GetExternalLoginInfoAsync();
if (info == null)
{
ErrorMessage = "Error loading external login information during confirmation.";
return(RedirectToPage("./Login", new { ReturnUrl = returnUrl }));
}
if (ModelState.IsValid)
{
var user = new SellMeUser {
UserName = Input.Email, Email = Input.Email
};
var result = await _userManager.CreateAsync(user);
if (result.Succeeded)
{
result = await _userManager.AddLoginAsync(user, info);
if (result.Succeeded)
{
await _signInManager.SignInAsync(user, isPersistent : false);
_logger.LogInformation("User created an account using {Name} provider.", info.LoginProvider);
return(LocalRedirect(returnUrl));
}
}
foreach (var error in result.Errors)
{
ModelState.AddModelError(string.Empty, error.Description);
}
}
LoginProvider = info.LoginProvider;
ReturnUrl = returnUrl;
return(Page());
}
public async Task <IActionResult> OnPostAsync(string returnUrl = null)
{
returnUrl = returnUrl ?? Url.Content("~/");
if (ModelState.IsValid)
{
var user = new SellMeUser {
UserName = Input.Username, Email = Input.Email
};
var result = await _userManager.CreateAsync(user, Input.Password);
if (result.Succeeded)
{
_logger.LogInformation("User created a new account with password.");
var code = await _userManager.GenerateEmailConfirmationTokenAsync(user);
var callbackUrl = Url.Page(
"/Account/ConfirmEmail",
pageHandler: null,
values: new { userId = user.Id, code },
protocol: Request.Scheme);
await _emailSender.SendEmailAsync(Input.Email, "Confirm your email",
$"Please confirm your account by <a href='{HtmlEncoder.Default.Encode(callbackUrl)}'>clicking here</a>.");
AlmostDoneMessage = "Almost done...";
SuccessfulRegistration = $"We've sent and email to {Input.Email}. Open it to activate your account.";
//await _signInManager.SignInAsync(user, isPersistent: false);
return(LocalRedirect("/Identity/Account/Login"));
}
foreach (var error in result.Errors)
{
ModelState.AddModelError(string.Empty, error.Description);
}
}
// If we got this far, something failed, redisplay form
return(Page());
}
public async Task GetMessageDetailsViewModelsAsync_WithCurrentUserEqualsToRecipient_ShouldMarkMessagesAsRead()
{
//Arrange
var moqAdsService = new Mock <IAdsService>();
var moqUsersService = new Mock <IUsersService>();
moqUsersService.Setup(x => x.GetCurrentUserId())
.Returns("RecipientId");
var moqIMapper = new Mock <IMapper>();
var context = InitializeContext.CreateContextForInMemory();
messagesService = new MessagesService(context, moqAdsService.Object, moqUsersService.Object, moqIMapper.Object);
var testingAd = CreateTestingAd();
var messages = new List <Message>
{
new Message
{
AdId = 1,
SenderId = "SenderId",
RecipientId = "RecipientId",
Content = "Content1"
},
new Message
{
AdId = 1,
SenderId = "SenderId",
RecipientId = "RecipientId",
Content = "Content2"
},
new Message
{
AdId = 1,
SenderId = "FakeSenderId",
RecipientId = "FakeRecipientId",
Content = "Content3"
}
};
var sender = new SellMeUser
{
Id = "SenderId",
UserName = "******"
};
await context.SellMeUsers.AddAsync(sender);
await context.Ads.AddAsync(testingAd);
await context.Messages.AddRangeAsync(messages);
await context.SaveChangesAsync();
//Act
var result = messagesService.GetMessageDetailsViewModelsAsync(1, "SenderId", "RecipientId");
//Assert
Assert.Equal(2, context.Messages.Count(x => x.IsRead));
}
public async Task GetMessageDetailsViewModelsAsync_WithValidData_ShouldReturnCorrectResult()
{
//Arrange
var expectedCollectionCount = 2;
var expected = new List <MessageDetailsViewModel>
{
new MessageDetailsViewModel
{
AdTitle = "Iphone 6s",
Content = "Content1",
Sender = "Pesho"
},
new MessageDetailsViewModel
{
AdTitle = "Iphone 6s",
Content = "Content2",
Sender = "Pesho"
}
};
var moqAdsService = new Mock <IAdsService>();
var moqUsersService = new Mock <IUsersService>();
moqUsersService.Setup(x => x.GetCurrentUserId())
.Returns("SenderId");
var moqIMapper = new Mock <IMapper>();
var context = InitializeContext.CreateContextForInMemory();
messagesService = new MessagesService(context, moqAdsService.Object, moqUsersService.Object, moqIMapper.Object);
var testingAd = CreateTestingAd();
var messages = new List <Message>
{
new Message
{
AdId = 1,
SenderId = "SenderId",
RecipientId = "RecipientId",
Content = "Content1"
},
new Message
{
AdId = 1,
SenderId = "SenderId",
RecipientId = "RecipientId",
Content = "Content2"
},
new Message
{
AdId = 1,
SenderId = "FakeSenderId",
RecipientId = "FakeRecipientId",
Content = "Content3"
}
};
var sender = new SellMeUser
{
Id = "SenderId",
UserName = "******"
};
await context.SellMeUsers.AddAsync(sender);
await context.Ads.AddAsync(testingAd);
await context.Messages.AddRangeAsync(messages);
await context.SaveChangesAsync();
//Act
var actual = messagesService.GetMessageDetailsViewModelsAsync(1, "SenderId", "RecipientId").GetAwaiter().GetResult().ToList();
//Assert
Assert.Equal(expectedCollectionCount, actual.Count);
Assert.Collection(actual,
elem1 =>
{
Assert.Equal(expected[0].AdTitle, elem1.AdTitle);
Assert.Equal(expected[0].Content, elem1.Content);
Assert.Equal(expected[0].Sender, elem1.Sender);
},
elem2 =>
{
Assert.Equal(expected[1].AdTitle, elem2.AdTitle);
Assert.Equal(expected[1].Content, elem2.Content);
Assert.Equal(expected[1].Sender, elem2.Sender);
});
}
