public void GetAllUsersReturnsRightUserModelEmail()
{
//Arrange
var options = new DbContextOptionsBuilder <MarketplaceDbContext>()
.UseInMemoryDatabase("GetAllUsersReturnsRightUserModelEmail")
.Options;
var dbContext = new MarketplaceDbContext(options);
var profile = new MarketplaceProfile();
var configuration = new MapperConfiguration(x => x.AddProfile(profile));
var mapper = new Mapper(configuration);
var userStoreMock = new Mock <IUserStore <MarketplaceUser> >();
var userManagerMock = new Mock <UserManager <MarketplaceUser> >(userStoreMock.Object, null, null, null, null, null, null, null, null);
var userService = new UserService(dbContext, mapper, userManagerMock.Object);
var user1 = new MarketplaceUser()
{
Id = "eb243391-a7ee-42f6-bb4e-f28c74a68d84", FirstName = "Georgi", LastName = "Horozov", Email = "*****@*****.**"
};
dbContext.Users.Add(user1);
dbContext.SaveChanges();
//Act
var result = userService.GetAllUsers <UserViewModel>();
var actual = result.First().Email;
var expected = "*****@*****.**";
//Assert
Assert.Equal(expected, actual);
}
public async Task <bool> ClearAll(MarketplaceUser user)
{
if (user == null)
{
return(false);
}
var userFromDb = await this.userService.GetUserById(user.Id);
if (userFromDb.WishProducts.Count == 0)
{
return(true);
}
userFromDb.WishProducts.Clear();
this.context.Users.Update(userFromDb);
var allWishProducts = this.context
.WishProducts
.Where(x => x.MarketplaceUserId == userFromDb.Id).ToList();
foreach (var item in allWishProducts)
{
this.context.WishProducts.Remove(item);
}
var result = await this.context.SaveChangesAsync();
return(result > 0);
}
public async Task CreateIfUserDoesNotHasCartThrowExeption()
{
//Arrange
var options = new DbContextOptionsBuilder <MarketplaceDbContext>()
.UseInMemoryDatabase("CreateIfUserDoesNotHasCartThrowExeption")
.Options;
var dbContext = new MarketplaceDbContext(options);
var profile = new MarketplaceProfile();
var configuration = new MapperConfiguration(x => x.AddProfile(profile));
var mapper = new Mapper(configuration);
var orderService = new OrderService(dbContext, mapper);
var user = new MarketplaceUser()
{
Id = "8ca6c061-52de-4f0a-8885-a7501b6dae79",
FirstName = "Ivan",
LastName = "Ivanov",
Email = "*****@*****.**"
};
dbContext.Users.Add(user);
await dbContext.SaveChangesAsync();
var phone = "0883288905";
var shippingAddress = "ul.Stara Planina 23";
//Act
//Assert
await Assert.ThrowsAsync <NullReferenceException>(() => orderService.Create(user, phone, shippingAddress));
}
public async Task InvokeAsync(HttpContext context, RoleManager <IdentityRole> roleManager, UserManager <MarketplaceUser> userManager, MarketplaceDbContext dbContext)
{
if (!await roleManager.RoleExistsAsync(Infrastructure.GlobalConstants.AdministratorRole))
{
await roleManager.CreateAsync(new IdentityRole(Infrastructure.GlobalConstants.AdministratorRole));
}
if (!await roleManager.RoleExistsAsync(Infrastructure.GlobalConstants.UserRole))
{
await roleManager.CreateAsync(new IdentityRole(Infrastructure.GlobalConstants.UserRole));
}
if (!userManager.Users.Any())
{
var user = new MarketplaceUser()
{
UserName = ADMIN_EMAIL,
Email = ADMIN_EMAIL,
FirstName = ADMIN_FIRST_NAME,
LastName = ADMIN_LAST_NAME,
ShoppingCart = new ShoppingCart()
};
user.ShoppingCart.UserId = user.Id;
await userManager.CreateAsync(user, ADMIN_PASSWORD);
await userManager.AddToRoleAsync(user, Infrastructure.GlobalConstants.AdministratorRole);
await dbContext.SaveChangesAsync();
}
// Call the next delegate/middleware in the pipeline
await _next(context);
}
public async Task <ActionResult> Register(RegisterViewModel model)
{
if (ModelState.IsValid)
{
var user = new MarketplaceUser {
UserName = model.Username, Email = model.Email, FullName = model.FullName, Country = model.Country, City = model.City, Address = model.Address
};
var result = await UserManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
await UserManager.AddToRoleAsync(user.Id, "User");
await SignInManager.SignInAsync(user, isPersistent : false, rememberBrowser : false);
// For more information on how to enable account confirmation and password reset please visit https://go.microsoft.com/fwlink/?LinkID=320771
// Send an email with this link
// string code = await UserManager.GenerateEmailConfirmationTokenAsync(user.Id);
// var callbackUrl = Url.Action("ConfirmEmail", "Account", new { userId = user.Id, code = code }, protocol: Request.Url.Scheme);
// await UserManager.SendEmailAsync(user.Id, "Confirm your account", "Please confirm your account by clicking <a href=\"" + callbackUrl + "\">here</a>");
return(RedirectToAction("Index", "Home"));
}
AddErrors(result);
}
// If we got this far, something failed, redisplay form
return(View(model));
}
public async Task GetAllWishProductsCountReturnsZero()
{
//Arrange
var options = new DbContextOptionsBuilder <MarketplaceDbContext>()
.UseInMemoryDatabase("GetAllWishProductsCountReturnsZero")
.Options;
var dbContext = new MarketplaceDbContext(options);
var profile = new MarketplaceProfile();
var configuration = new MapperConfiguration(x => x.AddProfile(profile));
var mapper = new Mapper(configuration);
var userStoreMock = new Mock <IUserStore <MarketplaceUser> >();
var userManagerMock = new Mock <UserManager <MarketplaceUser> >(userStoreMock.Object, null, null, null, null, null, null, null, null);
var userService = new UserService(dbContext, mapper, userManagerMock.Object);
var user = new MarketplaceUser()
{
Id = "eb243391-a7ee-42f6-bb4e-f28c74a68d84"
};
dbContext.Users.Add(user);
await dbContext.SaveChangesAsync();
//Act
var actual = userService.GetAllWishProductsCount(user);
var expected = 0;
//Assert
Assert.Equal(expected, actual);
}
public async Task <bool> Add(MarketplaceUser user, string id)
{
if (user == null || id == null)
{
return(false);
}
var userFromDb = await this.userService.GetUserById(user.Id);
var isExist = userFromDb.WishProducts.Select(x => x.ProductId).Contains(id);
if (isExist)
{
return(true);
}
var wishProduct = new WishProduct()
{
MarketplaceUserId = userFromDb.Id,
ProductId = id
};
this.context.WishProducts.Add(wishProduct);
userFromDb.WishProducts.Add(wishProduct);
var result = await this.context.SaveChangesAsync();
return(result > 0);
}
public async Task <bool> IsCartAny(MarketplaceUser user)
{
var cart = await this.context
.ShoppingCarts
.Where(x => x.UserId == user.Id)
.Include(x => x.Products)
.SingleOrDefaultAsync();
return(cart.Products.Count > 0);
}
public int GetAllWishProductsCount(MarketplaceUser user)
{
if (user == null)
{
return(0);
}
var count = user.WishProducts.Count();
return(count);
}
public int GetAllProductsCount(MarketplaceUser user)
{
if (user != null)
{
var productCount = user.WishProducts.Count;
return(productCount);
}
return(0);
}
public async Task CreateWithInCorrectInputIdReturnFalse()
{
//Arrange
var options = new DbContextOptionsBuilder <MarketplaceDbContext>()
.UseInMemoryDatabase("CreateWithInCorrectInputIdReturnFalse")
.Options;
var dbContext = new MarketplaceDbContext(options);
var profile = new MarketplaceProfile();
var configuration = new MapperConfiguration(x => x.AddProfile(profile));
var mapper = new Mapper(configuration);
var user = new MarketplaceUser()
{
Id = "cd89dcbc-bb80-4246-b9b8-ad21753111cc", Email = "*****@*****.**"
};
var user1 = new MarketplaceUser()
{
Id = "cd89dcbc-bb80-4246-b9b8-ad2175311111", Email = "*****@*****.**"
};
var listUsers = new List <MarketplaceUser>();
listUsers.Add(user);
listUsers.Add(user1);
dbContext.Users.Add(user);
dbContext.Users.Add(user1);
await dbContext.SaveChangesAsync();
var role = "Administrator";
var userStoreMock = new Mock <IUserStore <MarketplaceUser> >();
var userManagerMock = new Mock <UserManager <MarketplaceUser> >(userStoreMock.Object, null, null, null, null, null, null, null, null);
userManagerMock.Setup(x => x.GetUsersInRoleAsync(role))
.Returns(Task.FromResult <IList <MarketplaceUser> >(listUsers.ToList()));
userManagerMock.Setup(x => x.IsInRoleAsync(user, role))
.Returns(Task.FromResult(true));
var messageService = new MessageService(dbContext, mapper, userManagerMock.Object);
var userId = "";
var name = "Ivan";
var email = "*****@*****.**";
var phone = "0883477980";
var message = "This is test message!";
//Act
var actual = await messageService.Create(userId, name, email, phone, message);
var expected = false;
//Assert
Assert.Equal(expected, actual);
}
public async Task DeleteMessageByIdWithInCorrectMessageIdInputReturnFalse()
{
//Arrange
var options = new DbContextOptionsBuilder <MarketplaceDbContext>()
.UseInMemoryDatabase("DeleteMessageByIdWithInCorrectMessageIdInputReturnFalse")
.Options;
var dbContext = new MarketplaceDbContext(options);
var profile = new MarketplaceProfile();
var configuration = new MapperConfiguration(x => x.AddProfile(profile));
var mapper = new Mapper(configuration);
var userStoreMock = new Mock <IUserStore <MarketplaceUser> >();
var userManagerMock = new Mock <UserManager <MarketplaceUser> >(userStoreMock.Object, null, null, null, null, null, null, null, null);
var messageService = new MessageService(dbContext, mapper, userManagerMock.Object);
var user = new MarketplaceUser()
{
Id = "cd89dcbc-bb80-4246-b9b8-ad21753111cc", Email = "*****@*****.**"
};
var user1 = new MarketplaceUser()
{
Id = "cd89dcbc-bb80-4246-b9b8-ad2175311123", Email = "*****@*****.**"
};
dbContext.Users.Add(user);
await dbContext.SaveChangesAsync();
var message = new Message()
{
MarketplaceUserId = user1.Id,
Phone = "0883377905",
Name = "Ivan",
IssuedOn = DateTime.UtcNow,
MessageContent = "This is test message!",
Email = "*****@*****.**",
MarkAsRead = false,
};
dbContext.Messages.Add(message);
await dbContext.SaveChangesAsync();
user.Messages.Add(message);
await dbContext.SaveChangesAsync();
var userId = "cd89dcbc-bb80-4246-b9b8-ad21753111cc";
var messageId = "1"; //incorect messageId
//Act
var actual = await messageService.DeleteMessageById(userId, messageId);
var expected = false;
//Assert
Assert.Equal(expected, actual);
}
public IQueryable <TModel> GetAllWishProducts <TModel>(MarketplaceUser user)
{
var products = this.context
.WishProducts
.Include(x => x.Product)
.Include(x => x.MarketplaceUser)
.Where(x => x.MarketplaceUserId == user.Id)
.Select(x => x.Product)
.ProjectTo <TModel>(mapper.ConfigurationProvider);
return(products);
}
public IQueryable <TModel> GetAllShoppingCartProducts <TModel>(MarketplaceUser user)
{
var products = this.context
.ShoppingCartProduct
.Where(x => x.ShoppingCartId == user.ShoppingCartId)
.Include(x => x.Product);
var result = products.ProjectTo <TModel>(mapper.ConfigurationProvider);
return(result);
}
public async Task GetUserMessagesCorrectIdMarkAsReadSetToTrueReturnZeroMessages()
{
//Arrange
var options = new DbContextOptionsBuilder <MarketplaceDbContext>()
.UseInMemoryDatabase("GetUserMessagesCorrectIdMarkAsReadSetToTrueReturnZeroMessages")
.Options;
var dbContext = new MarketplaceDbContext(options);
var profile = new MarketplaceProfile();
var configuration = new MapperConfiguration(x => x.AddProfile(profile));
var mapper = new Mapper(configuration);
var userStoreMock = new Mock <IUserStore <MarketplaceUser> >();
var userManagerMock = new Mock <UserManager <MarketplaceUser> >(userStoreMock.Object, null, null, null, null, null, null, null, null);
var messageService = new MessageService(dbContext, mapper, userManagerMock.Object);
var user = new MarketplaceUser()
{
Id = "cd89dcbc-bb80-4246-b9b8-ad21753111cc", Email = "*****@*****.**"
};
var user1 = new MarketplaceUser()
{
Id = "cd89dcbc-bb80-4246-b9b8-ad2175311123", Email = "*****@*****.**"
};
dbContext.Users.Add(user);
await dbContext.SaveChangesAsync();
var message = new Message()
{
MarketplaceUserId = user1.Id,
Phone = "0883377905",
Name = "Ivan",
IssuedOn = DateTime.UtcNow,
MessageContent = "This is test message!",
Email = "*****@*****.**",
MarkAsRead = true,
};
dbContext.Messages.Add(message);
await dbContext.SaveChangesAsync();
user.Messages.Add(message);
await dbContext.SaveChangesAsync();
var userId = "cd89dcbc-bb80-4246-b9b8-ad21753111cc";
//Act
var result = messageService.GetUserMessages <AdminMessageViewModel>(userId);
var actual = result.Count();
var expected = 0;
//Assert
Assert.Equal(expected, actual);
}
public async Task <bool> Create(MarketplaceUser user, string phone, string shippingAddress)
{
if (user == null)
{
return(false);
}
var cart = await this.context
.ShoppingCarts
.Where(x => x.UserId == user.Id)
.Include(x => x.Products)
.SingleOrDefaultAsync();
foreach (var product in cart.Products)
{
var order = new Order()
{
IssuedOn = DateTime.UtcNow,
MarketplaceUserId = user.Id,
Quantity = product.Quantity,
Phone = phone,
ShippingAddress = shippingAddress,
};
this.context.Orders.Add(order);
await this.context.SaveChangesAsync();
var productOrder = new ProductOrder()
{
OrderId = order.Id,
ProductId = product.ProductId
};
this.context.ProductOrder.Add(productOrder);
await this.context.SaveChangesAsync();
var productFromDb = await this.context
.Products
.Where(x => x.Id == product.ProductId)
.SingleOrDefaultAsync();
productFromDb.Quantity -= product.Quantity;
this.context.Products.Update(productFromDb);
await this.context.SaveChangesAsync();
}
cart.Products.Clear();
this.context.ShoppingCarts.Update(cart);
await this.context.SaveChangesAsync();
return(true);
}
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 MarketplaceUser
{
UserName = Input.Email,
Email = Input.Email,
ShoppingCart = new ShoppingCart()
};
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 <bool> Detele(MarketplaceUser user, string id)
{
if (user == null || id == null)
{
return(false);
}
var userFromDb = await this.userService.GetUserById(user.Id);
var wishProduct = await this.context
.WishProducts
.Where(x => x.MarketplaceUserId == userFromDb.Id && x.ProductId == id)
.SingleOrDefaultAsync();
userFromDb.WishProducts.Remove(wishProduct);
this.context.WishProducts.Remove(wishProduct);
var result = await this.context.SaveChangesAsync();
return(result > 0);
}
public async Task <bool> ClearCart(MarketplaceUser user)
{
if (user == null)
{
return(false);
}
var cart = await this.context
.ShoppingCarts
.Where(x => x.User == user)
.Include(x => x.Products)
.SingleOrDefaultAsync();
cart.Products.Clear();
this.context.ShoppingCarts.Update(cart);
this.context.Users.Update(user);
var result = await this.context.SaveChangesAsync();
return(result > 0);
}
public async Task <ActionResult> ExternalLoginConfirmation(ExternalLoginConfirmationViewModel model, string returnUrl)
{
if (User.Identity.IsAuthenticated)
{
return(RedirectToAction("Index", "Manage"));
}
if (ModelState.IsValid)
{
// Get the information about the user from the external login provider
var info = await AuthenticationManager.GetExternalLoginInfoAsync();
if (info == null)
{
return(View("ExternalLoginFailure"));
}
var user = new MarketplaceUser {
UserName = model.Email, Email = model.Email
};
var result = await UserManager.CreateAsync(user);
if (result.Succeeded)
{
result = await UserManager.AddLoginAsync(user.Id, info.Login);
if (result.Succeeded)
{
await SignInManager.SignInAsync(user, isPersistent : false, rememberBrowser : false);
return(RedirectToLocal(returnUrl));
}
}
AddErrors(result);
}
ViewBag.ReturnUrl = returnUrl;
return(View(model));
}
public async Task CreateWithInputUserEqualTonullOrderShouldReturnFalse()
{
//Arrange
var options = new DbContextOptionsBuilder <MarketplaceDbContext>()
.UseInMemoryDatabase("CreateWithInputUserEqualTonullOrderShouldThrollExeption")
.Options;
var dbContext = new MarketplaceDbContext(options);
var profile = new MarketplaceProfile();
var configuration = new MapperConfiguration(x => x.AddProfile(profile));
var mapper = new Mapper(configuration);
var orderService = new OrderService(dbContext, mapper);
MarketplaceUser user = null;
var phone = "0883288905";
var shippingAddress = "ul.Stara Planina 23";
//Act
var actual = await orderService.Create(user, phone, shippingAddress);
var expected = false;
//Assert
Assert.True(actual.Equals(expected));
}
public void SeedUsers(MarketplaceContext context)
{
var usersStore = new UserStore <MarketplaceUser>(context);
var usersManager = new UserManager <MarketplaceUser>(usersStore);
MarketplaceUser admin = new MarketplaceUser();
admin.Email = "*****@*****.**";
admin.UserName = "******";
var password = "******";
if (usersManager.FindByEmail(admin.Email) == null)
{
var result = usersManager.Create(admin, password);
if (result.Succeeded)
{
//add necessary roles to admin
usersManager.AddToRole(admin.Id, "Administrator");
usersManager.AddToRole(admin.Id, "Moderator");
usersManager.AddToRole(admin.Id, "User");
}
}
}
public async Task DeleteByIdWithInCorrectInputReturnsFalse()
{
//Arrange
var options = new DbContextOptionsBuilder <MarketplaceDbContext>()
.UseInMemoryDatabase("DeleteByIdWithInCorrectInputReturnsFalse")
.Options;
var dbContext = new MarketplaceDbContext(options);
var profile = new MarketplaceProfile();
var configuration = new MapperConfiguration(x => x.AddProfile(profile));
var mapper = new Mapper(configuration);
var user = new MarketplaceUser()
{
Id = "eb243391-a7ee-42f6-bb4e-f28c74a68d84", FirstName = "Georgi", LastName = "Horozov", Email = "*****@*****.**"
};
dbContext.Users.Add(user);
await dbContext.SaveChangesAsync();
var userStoreMock = new Mock <IUserStore <MarketplaceUser> >();
var userManagerMock = new Mock <UserManager <MarketplaceUser> >(userStoreMock.Object, null, null, null, null, null, null, null, null);
userManagerMock.Setup(m => m.FindByIdAsync(user.Id))
.Returns(Task.FromResult <MarketplaceUser>(null));
var userService = new UserService(dbContext, mapper, userManagerMock.Object);
var userId = "eb243391-a7ee-42f6-bb4e-f28c74a68d84";
//Act
var actual = await userService.DeleteById(userId);
var expected = false;
//Assert
Assert.Equal(expected, actual);
}
public async Task <IActionResult> OnPostAsync(string returnUrl = null)
{
returnUrl = returnUrl ?? Url.Content("~/");
if (ModelState.IsValid)
{
var isAnyUsers = !_userManager.Users.Any();
var user = new MarketplaceUser
{
UserName = Input.Email,
Email = Input.Email,
FirstName = Input.FirstName,
LastName = Input.LastName,
ShoppingCart = new ShoppingCart()
};
user.ShoppingCart.UserId = user.Id;
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 = 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>.");
if (isAnyUsers)
{
await _userManager.AddToRoleAsync(user, GlobalConstants.AdministratorRole);
}
else
{
await _userManager.AddToRoleAsync(user, GlobalConstants.UserRole);
}
await _signInManager.SignInAsync(user, isPersistent : false);
var shoppingCart = this.HttpContext.Session
.GetObjectFromJson <ShoppingCartViewModel[]>(GlobalConstants.ShoppingCartKey) ??
new List <ShoppingCartViewModel>().ToArray();
if (shoppingCart != null)
{
foreach (var product in shoppingCart)
{
await this.shoppingCartService.AddProductToShoppingCartAsync(product.Id, this.Input.Email, product.Quantity);
}
this.HttpContext.Session.Remove(GlobalConstants.ShoppingCartKey);
}
return(LocalRedirect(returnUrl));
}
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 CreateWithCorrectInputOrderShouldReturnTrue()
{
//Arrange
var options = new DbContextOptionsBuilder <MarketplaceDbContext>()
.UseInMemoryDatabase("AddProductShouldReturnTrue")
.Options;
var dbContext = new MarketplaceDbContext(options);
var profile = new MarketplaceProfile();
var configuration = new MapperConfiguration(x => x.AddProfile(profile));
var mapper = new Mapper(configuration);
var orderService = new OrderService(dbContext, mapper);
var user = new MarketplaceUser()
{
Id = "8ca6c061-52de-4f0a-8885-a7501b6dae79",
FirstName = "Ivan",
LastName = "Ivanov",
Email = "*****@*****.**"
};
dbContext.Users.Add(user);
await dbContext.SaveChangesAsync();
var cart = new ShoppingCart()
{
Id = "86f81ed7-312e-4760-a594-1c40389440bd",
UserId = user.Id
};
dbContext.ShoppingCarts.Add(cart);
await dbContext.SaveChangesAsync();
var product = new Product()
{
Id = "532b377e-83f1-43db-a697-1e623107ae60",
Name = "TestProduct",
Price = 5.45m,
Quantity = 1
};
dbContext.Products.Add(product);
await dbContext.SaveChangesAsync();
var shoppingCartProduct = new ShoppingCartProduct()
{
ProductId = product.Id,
Quantity = product.Quantity,
ShoppingCartId = cart.Id
};
cart.Products.Add(shoppingCartProduct);
dbContext.ShoppingCarts.Update(cart);
await dbContext.SaveChangesAsync();
var phone = "0883288905";
var shippingAddress = "ul.Stara Planina 23";
//Act
var actual = await orderService.Create(user, phone, shippingAddress);
var expected = true;
//Assert
Assert.True(actual.Equals(expected));
}
