public async Task GetAllUserIdsInPublisherAsync_WithNoUsers_ReturnsEmptyCollection()
{
// Arrange
var context = this.NewInMemoryDatabase();
var testPublisherId = Guid.NewGuid().ToString();
var otherPublisherId = Guid.NewGuid().ToString();
var user1 = new KnigaUser
{
UserName = "******",
PublisherId = otherPublisherId
};
var user2 = new KnigaUser
{
UserName = "******",
PublisherId = otherPublisherId
};
await context.Users.AddRangeAsync(user1, user2);
await context.SaveChangesAsync();
var publishersService = new PublishersService(context);
// Act
var result = await publishersService.GetAllUserIdsInPublisherAsync(testPublisherId);
// Assert
Assert.NotNull(result);
Assert.Empty(result);
}
public async Task RemoveUserFromPublisherAsync_WithIncorrectId_ReturnsFalse()
{
// Arrange
var context = this.NewInMemoryDatabase();
var testPublisher = new Publisher {
Name = "TestPublisher"
};
await context.Publishers.AddAsync(testPublisher);
var testUser = new KnigaUser {
UserName = "******", PublisherId = testPublisher.Id
};
await context.Users.AddAsync(testUser);
await context.SaveChangesAsync();
var publishersService = new PublishersService(context);
// Act
var result = await publishersService.RemoveUserFromPublisherAsync(Guid.NewGuid().ToString());
// Assert
Assert.False(result);
var dbUser = await context.Users.SingleOrDefaultAsync();
Assert.Equal(testPublisher.Id, dbUser.PublisherId);
}
public async Task AssignUserToPublisherAsync_WithNullUserId_WorksCorrectly()
{
// Arrange
var context = this.NewInMemoryDatabase();
var testUser = new KnigaUser {
UserName = "******"
};
var testPublisher = new Publisher {
Name = "TestPublisher"
};
await context.Users.AddAsync(testUser);
await context.Publishers.AddAsync(testPublisher);
await context.SaveChangesAsync();
var publishersService = new PublishersService(context);
// Act
var result = await publishersService.AssignUserToPublisherAsync(null, testPublisher.Id);
// Assert
Assert.False(result);
var dbUser = await context.Users.SingleOrDefaultAsync();
Assert.Null(dbUser.PublisherId);
}
public async Task RemoveUserFromPublisherAsync_WithCorrectData_WorksCorrectly()
{
// Arrange
var context = this.NewInMemoryDatabase();
var testPublisher = new Publisher {
Name = "TestPublisher"
};
await context.Publishers.AddAsync(testPublisher);
var testUser = new KnigaUser {
UserName = "******", PublisherId = testPublisher.Id
};
await context.Users.AddAsync(testUser);
await context.SaveChangesAsync();
var publishersService = new PublishersService(context);
// Act
var result = await publishersService.RemoveUserFromPublisherAsync(testUser.Id);
// Assert
Assert.True(result);
var dbUser = await context.Users.SingleOrDefaultAsync();
Assert.Null(dbUser.PublisherId);
}
public async Task UserHasPurchasedBookAsync_WithNullBookId_ReturnsFalse()
{
// Arrange
var context = this.NewInMemoryDatabase();
var testUser = new KnigaUser {
UserName = "******"
};
var testBook = new Book();
await context.Books.AddAsync(testBook);
await context.Users.AddAsync(testUser);
var purchase = new Purchase
{
UserId = testUser.Id,
BookId = testBook.Id,
PurchaseDate = DateTime.UtcNow
};
await context.Purchases.AddAsync(purchase);
await context.SaveChangesAsync();
var purchasesService = new PurchasesService(context);
// Act
var result = await purchasesService.UserHasPurchasedBookAsync(null, testUser.UserName);
// Assert
Assert.False(result);
}
public async Task CreateAsync_WithIncorrectModel_ReturnsFalse()
{
// Arrange
var context = this.NewInMemoryDatabase();
var testUser = new KnigaUser {
UserName = "******"
};
var testBook = new Book();
await context.Books.AddAsync(testBook);
await context.Users.AddAsync(testUser);
await context.SaveChangesAsync();
var serviceModel = new PurchaseCreateServiceModel
{
UserName = null,
BookId = testBook.Id,
PurchaseDate = DateTime.UtcNow
};
var purchasesService = new PurchasesService(context);
// Act
var result = await purchasesService.CreateAsync(serviceModel);
// Assert
Assert.False(result);
Assert.False(await context.Purchases.AnyAsync());
}
public async Task CreateAsync_WithNonexistentBook_ReturnsFalse()
{
// Arrange
var context = this.NewInMemoryDatabase();
var testUser = new KnigaUser {
UserName = "******"
};
await context.Users.AddAsync(testUser);
await context.SaveChangesAsync();
var serviceModel = new PurchaseCreateServiceModel
{
UserName = testUser.UserName,
BookId = Guid.NewGuid().ToString(),
PurchaseDate = DateTime.UtcNow
};
var purchasesService = new PurchasesService(context);
// Act
var result = await purchasesService.CreateAsync(serviceModel);
// Assert
Assert.False(result);
Assert.False(await context.Purchases.AnyAsync());
}
public async Task GetPurchasesForUserAsync_WithCorrectUserName_WorksCorrectly()
{
// Arrange
var context = this.NewInMemoryDatabase();
var expectedResult = new[] { "Book1", "Book0" };
var testUser = new KnigaUser {
UserName = "******"
};
var otherUser = new KnigaUser {
UserName = "******"
};
await context.Users.AddRangeAsync(
testUser,
otherUser
);
await context.Purchases.AddRangeAsync(
new Purchase
{
UserId = testUser.Id,
PurchaseDate = DateTime.UtcNow,
Book = new Book {
Title = "Book0"
}
},
new Purchase
{
UserId = testUser.Id,
PurchaseDate = DateTime.UtcNow.AddDays(1),
Book = new Book {
Title = "Book1"
}
},
new Purchase
{
UserId = otherUser.Id,
PurchaseDate = DateTime.UtcNow,
Book = new Book {
Title = "Book2"
}
}
);
await context.SaveChangesAsync();
var purchasesService = new PurchasesService(context);
// Act
var actualResult = (await purchasesService.GetPurchasesForUserAsync("TestUser"))
.Select(p => p.Book.Title)
.ToArray();
// Assert
Assert.Equal(2, actualResult.Length);
Assert.Equal(expectedResult, actualResult);
}
public async Task GetAllUserIdsInPublisherAsync_WithCorrectId_WorksCorrectly()
{
// Arrange
var context = this.NewInMemoryDatabase();
var testPublisherId = Guid.NewGuid().ToString();
var user1 = new KnigaUser
{
UserName = "******",
PublisherId = testPublisherId
};
var user2 = new KnigaUser
{
UserName = "******",
PublisherId = testPublisherId
};
await context.Users.AddRangeAsync(
user1, user2,
new KnigaUser
{
UserName = "******",
PublisherId = Guid.NewGuid().ToString()
}
);
await context.SaveChangesAsync();
var expectedIds = new[] { user1.Id, user2.Id }.OrderBy(i => i).ToArray();
var publishersService = new PublishersService(context);
// Act
var actualIds = (await publishersService.GetAllUserIdsInPublisherAsync(testPublisherId))
.OrderBy(i => i)
.ToArray();
// Assert
Assert.NotNull(actualIds);
Assert.Equal(expectedIds, actualIds);
}
// Migrate database and create administrator role
private static async Task InitializeDatabaseAsync(IApplicationBuilder app)
{
using (var serviceScope = app.ApplicationServices.CreateScope())
{
var dbContext = serviceScope.ServiceProvider.GetRequiredService <MyKnigaDbContext>();
await dbContext.Database.MigrateAsync();
// Create administrator and publisher roles
var roleManager = serviceScope.ServiceProvider.GetService <RoleManager <IdentityRole> >();
if (!await roleManager.RoleExistsAsync(GlobalConstants.AdministratorRoleName))
{
await roleManager.CreateAsync(new IdentityRole(GlobalConstants.AdministratorRoleName));
}
if (!await roleManager.RoleExistsAsync(GlobalConstants.PublisherRoleName))
{
await roleManager.CreateAsync(new IdentityRole(GlobalConstants.PublisherRoleName));
}
// Create initial administrator
var userManager = serviceScope.ServiceProvider.GetService <UserManager <KnigaUser> >();
if (!dbContext.Users.Any())
{
var admin = new KnigaUser
{
Email = "*****@*****.**",
UserName = "******"
};
await userManager.CreateAsync(admin, "admin123");
await userManager.AddToRoleAsync(admin, GlobalConstants.AdministratorRoleName);
}
}
}
public async Task CreateAsync_WithExistingPurchase_ReturnsFalse()
{
// Arrange
var context = this.NewInMemoryDatabase();
var testUser = new KnigaUser {
UserName = "******"
};
var testBook = new Book();
await context.Books.AddAsync(testBook);
await context.Users.AddAsync(testUser);
var purchase = new Purchase
{
UserId = testUser.Id,
BookId = testBook.Id,
PurchaseDate = DateTime.UtcNow
};
await context.Purchases.AddAsync(purchase);
await context.SaveChangesAsync();
var serviceModel = new PurchaseCreateServiceModel
{
UserName = testUser.UserName,
BookId = testBook.Id,
PurchaseDate = DateTime.UtcNow
};
var purchasesService = new PurchasesService(context);
// Act
var result = await purchasesService.CreateAsync(serviceModel);
// Assert
Assert.False(result);
Assert.True(await context.Purchases.AnyAsync(p => p.User.UserName == testUser.UserName));
Assert.Equal(1, await context.Purchases.CountAsync());
}
public async Task GetPurchasesForUserAsync_WithNoPurchasesForUser_ReturnsEmptyCollection()
{
// Arrange
var context = this.NewInMemoryDatabase();
var testUser = new KnigaUser {
UserName = "******"
};
await context.Users.AddAsync(testUser);
await context.Purchases.AddRangeAsync(new Purchase
{
UserId = testUser.Id,
PurchaseDate = DateTime.UtcNow.AddDays(1),
Book = new Book {
Title = "Book2"
}
},
new Purchase
{
UserId = testUser.Id,
PurchaseDate = DateTime.UtcNow,
Book = new Book {
Title = "Book1"
}
}
);
await context.SaveChangesAsync();
var purchasesService = new PurchasesService(context);
// Act
var actualResult = (await purchasesService.GetPurchasesForUserAsync("OtherUser"));
// Assert
Assert.Empty(actualResult);
}
public async Task CreateAsync_WithCorrectModel_WorksCorrectly()
{
// Arrange
var context = this.NewInMemoryDatabase();
var testUser = new KnigaUser {
UserName = "******"
};
var testBook = new Book();
await context.Books.AddAsync(testBook);
await context.Users.AddAsync(testUser);
await context.SaveChangesAsync();
var serviceModel = new PurchaseCreateServiceModel
{
UserName = testUser.UserName,
BookId = testBook.Id,
PurchaseDate = DateTime.UtcNow
};
var purchasesService = new PurchasesService(context);
// Act
var result = await purchasesService.CreateAsync(serviceModel);
// Assert
Assert.True(result);
var purchase = await context.Purchases.SingleOrDefaultAsync();
Assert.NotNull(purchase);
Assert.Equal(testUser.Id, purchase.UserId);
Assert.Equal(testBook.Id, purchase.BookId);
Assert.Equal(serviceModel.PurchaseDate, purchase.PurchaseDate);
}
