public async Task CreateSaleShouldCreateSale()
{
var release = new Release();
var seller = new VinylExchangeUser();
var address = new Address();
this.releasesEntityRetrieverMock.Setup(x => x.GetRelease(It.IsAny <Guid?>())).ReturnsAsync(release);
this.usersEntityRetrieverMock.Setup(x => x.GetUser(It.IsAny <Guid?>())).ReturnsAsync(seller);
this.addressesEntityRetrieverMock.Setup(x => x.GetAddress(It.IsAny <Guid?>())).ReturnsAsync(address);
var createdSaleModel = await this.salesService.CreateSale <CreateSaleResourceModel>(
Condition.Fair,
Condition.Mint,
"ewewe",
30,
address.Id,
release.Id,
seller.Id);
await this.dbContext.SaveChangesAsync();
var createdSale = await this.dbContext.Sales.FirstOrDefaultAsync(s => s.Id == createdSaleModel.Id);
Assert.NotNull(createdSale);
}
public async Task AddToCollectionShouldAddCollectionItemWithCorrectData()
{
var release = new Release();
var user = new VinylExchangeUser();
this.releasesEntityRetrieverMock.Setup(x => x.GetRelease(It.IsAny <Guid?>())).ReturnsAsync(release);
this.usersEntityRetrieverMock.Setup(x => x.GetUser(It.IsAny <Guid?>())).ReturnsAsync(user);
var createdCollectionItemModel =
await this.collectionsService.AddToCollection <AddToCollectionResourceModel>(
Condition.Poor,
Condition.Mint,
"Description",
release.Id,
user.Id);
var createdCollectionItem =
await this.dbContext.Collections.FirstOrDefaultAsync(ci => ci.Id == createdCollectionItemModel.Id);
Assert.Equal(Condition.Poor, createdCollectionItem.VinylGrade);
Assert.Equal(Condition.Mint, createdCollectionItem.SleeveGrade);
Assert.Equal("Description", createdCollectionItem.Description);
Assert.Equal(release.Id, createdCollectionItem.ReleaseId);
Assert.Equal(user.Id, createdCollectionItem.UserId);
}
public async Task GetUserCollectionShouldGetUserCollection()
{
var user = new VinylExchangeUser();
var userTwo = new VinylExchangeUser();
for (var i = 0; i < 6; i++)
{
var collectionItem = new CollectionItem {
UserId = user.Id
};
await this.dbContext.Collections.AddAsync(collectionItem);
}
for (var i = 0; i < 6; i++)
{
var collectionItem = new CollectionItem {
UserId = userTwo.Id
};
await this.dbContext.Collections.AddAsync(collectionItem);
}
await this.dbContext.SaveChangesAsync();
var userCollectionModels =
await this.collectionsService.GetUserCollection <GetCollectionItemUserIdResourceModel>(user.Id);
Assert.True(userCollectionModels.Count == 6);
Assert.True(userCollectionModels.All(ucm => ucm.UserId == user.Id));
}
public async Task PlaceOrderShouldSetShipsToAddress()
{
var sale = new Sale {
Status = Status.Open
};
await this.dbContext.Sales.AddAsync(sale);
await this.dbContext.SaveChangesAsync();
var address = new Address();
var user = new VinylExchangeUser();
this.usersEntityRetrieverMock.Setup(x => x.GetUser(It.IsAny <Guid?>())).ReturnsAsync(user);
this.addressesEntityRetrieverMock.Setup(x => x.GetAddress(It.IsAny <Guid?>())).ReturnsAsync(address);
await this.salesService.PlaceOrder <SaleStatusResourceModel>(sale.Id, address.Id, user.Id);
var changedSale = await this.dbContext.Sales.FirstOrDefaultAsync(s => s.Id == sale.Id);
Assert.True(
changedSale.ShipsTo
== $"{address.Country} - {address.Town} - {address.PostalCode} - {address.FullAddress}");
}
public async Task PlaceOrderShouldThrowNullReferenceExceptionIfUserIsNull()
{
var sale = new Sale {
Status = Status.Open
};
await this.dbContext.Sales.AddAsync(sale);
await this.dbContext.SaveChangesAsync();
var address = new Address();
var user = new VinylExchangeUser();
this.usersEntityRetrieverMock.Setup(x => x.GetUser(It.IsAny <Guid?>()))
.ReturnsAsync((VinylExchangeUser)null);
this.addressesEntityRetrieverMock.Setup(x => x.GetAddress(It.IsAny <Guid?>())).ReturnsAsync(address);
var exception = await Assert.ThrowsAsync <NullReferenceException>(
async() => await this.salesService.PlaceOrder <SaleStatusResourceModel>(
sale.Id,
address.Id,
Guid.NewGuid()));
Assert.Equal(UserNotFound, exception.Message);
}
public async Task GetUserSalesShouldGetUserSales()
{
var user = new VinylExchangeUser();
for (var i = 0; i < 5; i++)
{
var sale = new Sale {
SellerId = user.Id
};
await this.dbContext.Sales.AddAsync(sale);
}
for (var i = 0; i < 5; i++)
{
var sale = new Sale {
SellerId = Guid.NewGuid()
};
await this.dbContext.Sales.AddAsync(sale);
}
await this.dbContext.SaveChangesAsync();
var saleModels = await this.salesService.GetUserSales <GetSaleResourceModel>(user.Id);
Assert.True(saleModels.All(sm => sm.SellerId == user.Id));
}
private async Task <string> ConstructChangePasswordEmailContent(VinylExchangeUser user)
{
var changePasswordConfirmationToken = await this.userManager.GeneratePasswordResetTokenAsync(user);
var changePasswordHtmlContent =
$@"<h1>Change Your Vinyl Exchange Password</h1><h3>Your password change/reset token is: {changePasswordConfirmationToken}<h3>";
return(changePasswordHtmlContent);
}
public async Task GetUserShouldGetUser()
{
var user = new VinylExchangeUser();
this.userManagerMock.Setup(x => x.FindByIdAsync(It.IsAny <string>())).ReturnsAsync(user);
var returnedUser = await this.usersService.GetUser(user.Id);
Assert.NotNull(returnedUser);
}
public async Task CancelOrderShouldThrowNullReferenceExceptionIfSSaleIsNull()
{
var user = new VinylExchangeUser();
this.usersEntityRetrieverMock.Setup(x => x.GetUser(It.IsAny <Guid?>())).ReturnsAsync(user);
var exception = await Assert.ThrowsAsync <NullReferenceException>(
async() => await this.salesService.CancelOrder <SaleStatusResourceModel>(
Guid.NewGuid(),
user.Id));
Assert.Equal(SaleNotFound, exception.Message);
}
public async Task ConfirmEmailShouldReturnIdentityResultSuccess()
{
var user = new VinylExchangeUser();
this.userManagerMock.Setup(x => x.FindByIdAsync(It.IsAny <string>())).ReturnsAsync(user);
this.userManagerMock.Setup(x => x.ConfirmEmailAsync(It.IsAny <VinylExchangeUser>(), It.IsAny <string>()))
.ReturnsAsync(IdentityResult.Success);
var result = await this.usersService.ConfirmEmail("ewew", Guid.NewGuid());
Assert.True(result.Succeeded);
}
public async Task EditSaleShouldEditSaleWithCorrectData()
{
var release = new Release();
var user = new VinylExchangeUser();
var updatedAddress = this.testAddress;
this.releasesEntityRetrieverMock.Setup(x => x.GetRelease(It.IsAny <Guid?>())).ReturnsAsync(release);
this.usersEntityRetrieverMock.Setup(x => x.GetUser(It.IsAny <Guid?>())).ReturnsAsync(user);
this.addressesEntityRetrieverMock.Setup(x => x.GetAddress(It.IsAny <Guid?>())).ReturnsAsync(updatedAddress);
var addressProperties = new List <string> {
updatedAddress.Country, updatedAddress.Town
};
var sale = new Sale
{
VinylGrade = Condition.Poor,
SleeveGrade = Condition.NearMint,
Description = "blbbebe",
Price = 50,
ShipsFrom = "Paris France"
};
await this.dbContext.Sales.AddAsync(sale);
await this.dbContext.SaveChangesAsync();
var editSaleInputModel = new EditSaleInputModel
{
VinylGrade = Condition.Mint,
SleeveGrade = Condition.Mint,
Description = "updated description",
Price = 100,
SaleId = sale.Id
};
await this.salesService.EditSale <EditSaleResourceModel>(editSaleInputModel);
var updatedSale = await this.dbContext.Sales.FirstOrDefaultAsync(s => s.Id == sale.Id);
Assert.Equal(editSaleInputModel.SaleId, updatedSale.Id);
Assert.Equal(editSaleInputModel.VinylGrade, updatedSale.VinylGrade);
Assert.Equal(editSaleInputModel.SleeveGrade, updatedSale.SleeveGrade);
Assert.Equal(editSaleInputModel.Description, updatedSale.Description);
Assert.Equal(editSaleInputModel.Price, updatedSale.Price);
Assert.True(addressProperties.Select(ap => updatedSale.ShipsFrom.Contains(ap)).All(x => x));
}
public async Task SendConfirmEmailShouldNotThrowAnyException()
{
var user = new VinylExchangeUser();
this.userManagerMock.Setup(x => x.FindByIdAsync(It.IsAny <string>())).ReturnsAsync(user);
this.emailSenderMock
.Setup(x => x.SendEmailAsync(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <string>()))
.Verifiable();
var exception = await Record.ExceptionAsync(async() => await this.usersService.SendConfirmEmail(user.Id));
Assert.Null(exception);
}
public async Task RegisterUserShouldReturnIdentityResultSuccess()
{
var user = new VinylExchangeUser();
this.userManagerMock.Setup(x => x.CreateAsync(It.IsAny <VinylExchangeUser>()))
.ReturnsAsync(IdentityResult.Success);
this.userManagerMock.Setup(x => x.AddToRoleAsync(It.IsAny <VinylExchangeUser>(), It.IsAny <string>()))
.Verifiable();
var result = await this.usersService.RegisterUser("ewew", "3232", "eweqw");
Assert.True(result.Succeeded);
}
private async Task <string> ConstructChangeEmailEmailContent(VinylExchangeUser user, string newEmail)
{
var changeEmailConfirmationToken = await this.userManager.GenerateChangeEmailTokenAsync(user, newEmail);
var request = this.contextAccessor.HttpContext.Request;
var emailChangeUrl = request.Scheme + "://" + request.Host
+ $"/Authentication/ChangeEmail?cofirmToken={changeEmailConfirmationToken}";
var changeEmailHtmlContent =
$@"<h1>Change Your Vinyl Exchange Email</h1>.Follow This <a href=""{emailChangeUrl}"">Link</a>";
return(changeEmailHtmlContent);
}
public async Task <IdentityResult> RegisterUser(string username, string email, string password)
{
var user = new VinylExchangeUser {
UserName = username, Email = email
};
user.PasswordHash = this.userManager.PasswordHasher.HashPassword(user, password);
var identityResult = await this.userManager.CreateAsync(user);
await this.userManager.AddToRoleAsync(user, Roles.User);
return(identityResult);
}
public async Task LoginUserShouldReturnSignInResultSuccess()
{
var user = new VinylExchangeUser();
this.signInManagerMock.Setup(x => x.GetExternalAuthenticationSchemesAsync())
.ReturnsAsync(new List <AuthenticationScheme>());
this.signInManagerMock
.Setup(x => x.PasswordSignInAsync(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <bool>(),
It.IsAny <bool>())).ReturnsAsync(SignInResult.Success);
var result = await this.usersService.LoginUser("ewew", "3232", false);
Assert.True(result.Succeeded);
}
public async Task GetUserAvatarShouldGetUserAvatar()
{
var user = new VinylExchangeUser
{
Avatar = new byte[] { 188, 65, 69, 67, 44, 187, 37, 66, 2, 17, 210, 249, 100 }
};
await this.dbContext.Users.AddAsync(user);
await this.dbContext.SaveChangesAsync();
var userAvatar = (await this.dbContext.Users.FirstOrDefaultAsync(u => u.Id == user.Id)).Avatar;
Assert.Equal(string.Join(",", user.Avatar), string.Join(",", userAvatar));
}
DoesUserCollectionContainReleaseShouldReturnTrueIfUserHasCollectionItemInCollectionWithTheProvidedReleaseId()
{
var release = new Release();
var user = new VinylExchangeUser();
var collectionItem = new CollectionItem {
ReleaseId = release.Id, UserId = user.Id
};
await this.dbContext.Collections.AddAsync(collectionItem);
await this.dbContext.SaveChangesAsync();
Assert.True(await this.collectionsService.DoesUserCollectionContainRelease(release.Id, user.Id));
}
public async Task CancelShouldThrowInvalidSaleStatusExceptionIfStatusIsAfterPaymentPendingOrOpen(Status status)
{
var sale = new Sale {
Status = status
};
await this.dbContext.Sales.AddAsync(sale);
await this.dbContext.SaveChangesAsync();
var user = new VinylExchangeUser();
this.usersEntityRetrieverMock.Setup(x => x.GetUser(It.IsAny <Guid?>())).ReturnsAsync(user);
await Assert.ThrowsAsync <InvalidSaleActionException>(
async() => await this.salesService.CancelOrder <SaleStatusResourceModel>(sale.Id, user.Id));
}
public async Task AddMessageToSaleShouldThrowNullReferenceExceptionIfSaleIsNotInDb()
{
var user = new VinylExchangeUser();
this.usersEntityRetrieverMock.Setup(x => x.GetUser(It.IsAny <Guid?>())).ReturnsAsync(user);
this.salesEntityRetrieverMock.Setup(x => x.GetSale(It.IsAny <Guid?>())).ReturnsAsync((Sale)null);
var exception = await Assert.ThrowsAsync <NullReferenceException>(
async() => await this.saleMessagesService
.AddMessageToSale <AddMessageToSaleResourceModel>(
Guid.NewGuid(),
user.Id,
"Test Message"));
Assert.Equal(SaleNotFound, exception.Message);
}
public async Task AddToCollectionShouldThrowNullRefferenceExceptionIfProvidedReleaseIdIsNotInDb()
{
var user = new VinylExchangeUser();
this.releasesEntityRetrieverMock.Setup(x => x.GetRelease(It.IsAny <Guid?>())).ReturnsAsync((Release)null);
this.usersEntityRetrieverMock.Setup(x => x.GetUser(It.IsAny <Guid?>())).ReturnsAsync(user);
var exception = await Assert.ThrowsAsync <NullReferenceException>(
async() => await this.collectionsService.AddToCollection <AddToCollectionResourceModel>(
Condition.Poor,
Condition.Mint,
"Description",
Guid.NewGuid(),
user.Id));
Assert.Equal(ReleaseNotFound, exception.Message);
}
public async Task GetUserSalesShouldReturnEmptyListIfUserHasNoSales()
{
var user = new VinylExchangeUser();
for (var i = 0; i < 10; i++)
{
var sale = new Sale {
SellerId = Guid.NewGuid()
};
await this.dbContext.Sales.AddAsync(sale);
}
await this.dbContext.SaveChangesAsync();
var salesModels = await this.salesService.GetUserPurchases <GetSaleResourceModel>(user.Id);
Assert.True(salesModels.Count == 0);
}
public async Task AddMessageToSaleShouldAddMessageToSale()
{
var sale = new Sale();
var user = new VinylExchangeUser();
this.usersEntityRetrieverMock.Setup(x => x.GetUser(It.IsAny <Guid?>())).ReturnsAsync(user);
this.salesEntityRetrieverMock.Setup(x => x.GetSale(It.IsAny <Guid?>())).ReturnsAsync(sale);
await this.saleMessagesService.AddMessageToSale <AddMessageToSaleResourceModel>(
sale.Id,
user.Id,
"Test Message");
var message = await this.dbContext.SaleMessages.FirstOrDefaultAsync(sl => sl.SaleId == sale.Id);
Assert.NotNull(message);
}
public async Task GetUserCollectionShouldReturnEmptyListIfUserHasEmptyCollection()
{
var user = new VinylExchangeUser();
for (var i = 0; i < 6; i++)
{
var collectionItem = new CollectionItem {
UserId = user.Id
};
await this.dbContext.Collections.AddAsync(collectionItem);
}
await this.dbContext.SaveChangesAsync();
var userCollectionModels =
await this.collectionsService.GetUserCollection <GetCollectionItemUserIdResourceModel>(Guid.NewGuid());
Assert.True(userCollectionModels.Count == 0);
}
public async Task CancelOrderShouldSetSaleStatusToOpen()
{
var user = new VinylExchangeUser();
var sale = new Sale {
Status = Status.PaymentPending, BuyerId = user.Id
};
await this.dbContext.Sales.AddAsync(sale);
await this.dbContext.SaveChangesAsync();
this.usersEntityRetrieverMock.Setup(x => x.GetUser(It.IsAny <Guid?>())).ReturnsAsync(user);
await this.salesService.CancelOrder <SaleStatusResourceModel>(sale.Id, Guid.NewGuid());
var saleFromDb = await this.dbContext.Sales.FirstOrDefaultAsync(s => s.Id == sale.Id);
Assert.Equal(Status.Open, saleFromDb.Status);
}
public async Task PlaceOrderShouldThrowInvalidSaleStatusExceptionIfStatusIsNotOpen(Status status)
{
var sale = new Sale {
Status = status
};
await this.dbContext.Sales.AddAsync(sale);
await this.dbContext.SaveChangesAsync();
var address = new Address();
var user = new VinylExchangeUser();
this.usersEntityRetrieverMock.Setup(x => x.GetUser(It.IsAny <Guid?>())).ReturnsAsync(user);
this.addressesEntityRetrieverMock.Setup(x => x.GetAddress(It.IsAny <Guid?>())).ReturnsAsync(address);
await Assert.ThrowsAsync <InvalidSaleActionException>(
async() => await this.salesService.PlaceOrder <SaleStatusResourceModel>(sale.Id, address.Id, user.Id));
}
private static async Task <VinylExchangeUser> CreateUserAsync(
UserManager <VinylExchangeUser> userManager,
string username,
string password,
string email)
{
var user = new VinylExchangeUser {
UserName = username, Email = email
};
user.PasswordHash = userManager.PasswordHasher.HashPassword(user, password);
var createUserResult = await userManager.CreateAsync(user);
if (!createUserResult.Succeeded)
{
throw new Exception(
string.Join(Environment.NewLine, createUserResult.Errors.Select(e => e.Description)));
}
return(user);
}
public async Task AddToCollectionShouldAddToCollection()
{
var release = new Release();
var user = new VinylExchangeUser();
this.releasesEntityRetrieverMock.Setup(x => x.GetRelease(It.IsAny <Guid?>())).ReturnsAsync(release);
this.usersEntityRetrieverMock.Setup(x => x.GetUser(It.IsAny <Guid?>())).ReturnsAsync(user);
var createdCollectionItemModel =
await this.collectionsService.AddToCollection <AddToCollectionResourceModel>(
Condition.Poor,
Condition.Mint,
"Description",
release.Id,
Guid.NewGuid());
var createdCollectionItem =
await this.dbContext.Collections.FirstOrDefaultAsync(ci => ci.Id == createdCollectionItemModel.Id);
Assert.NotNull(createdCollectionItem);
}
public async Task CreateSaleShouldCreateSaleWithCorrectData()
{
var release = new Release();
var seller = new VinylExchangeUser();
var address = this.testAddress;
this.releasesEntityRetrieverMock.Setup(x => x.GetRelease(It.IsAny <Guid?>())).ReturnsAsync(release);
this.usersEntityRetrieverMock.Setup(x => x.GetUser(It.IsAny <Guid?>())).ReturnsAsync(seller);
this.addressesEntityRetrieverMock.Setup(x => x.GetAddress(It.IsAny <Guid?>())).ReturnsAsync(address);
var addressProperties = new List <string> {
address.Country, address.Town
};
var createdSaleModel = await this.salesService.CreateSale <CreateSaleResourceModel>(
VinylGrade,
SleeveGrade,
Description,
Price,
address.Id,
release.Id,
seller.Id);
await this.dbContext.SaveChangesAsync();
var createdSale = await this.dbContext.Sales.FirstOrDefaultAsync(s => s.Id == createdSaleModel.Id);
Assert.Equal(VinylGrade, createdSale.VinylGrade);
Assert.Equal(SleeveGrade, createdSale.SleeveGrade);
Assert.Equal(release.Id, createdSale.ReleaseId);
Assert.Equal(Price, createdSale.Price);
Assert.True(addressProperties.Select(ap => createdSale.ShipsFrom.Contains(ap)).All(x => x));
}
public async Task PlaceOrderShouldChangeSaleStatusToShippingNegotiation()
{
var sale = new Sale {
Status = Status.Open
};
await this.dbContext.Sales.AddAsync(sale);
await this.dbContext.SaveChangesAsync();
var address = new Address();
var user = new VinylExchangeUser();
this.usersEntityRetrieverMock.Setup(x => x.GetUser(It.IsAny <Guid?>())).ReturnsAsync(user);
this.addressesEntityRetrieverMock.Setup(x => x.GetAddress(It.IsAny <Guid?>())).ReturnsAsync(address);
await this.salesService.PlaceOrder <SaleStatusResourceModel>(sale.Id, address.Id, user.Id);
var changedSale = await this.dbContext.Sales.FirstOrDefaultAsync(s => s.Id == sale.Id);
Assert.True(Status.ShippingNegotiation == changedSale.Status);
}
