public async Task GetAuthorsCountAsyncShouldReturnCorrectCount()
{
var db = DbInfrastructure.GetDatabase();
for (var i = 0; i < 100; i++)
{
var user = new User
{
UserName = $"Username {i}"
};
await db.AddAsync(user);
if (i % 10 == 0)
{
await db.SaveChangesAsync();
await db.AddAsync(new Book
{
Title = $"Book Title {i + 1000}",
AuthorId = user.Id
});
}
}
await db.SaveChangesAsync();
var userSerivce = new UserService(db, this.GetUserManagerMock().Object);
var authorsCount = await userSerivce.GetAuthorsCountAsync();
authorsCount.Should().Be(10);
}
public async Task GetBorrowedCountAsyncShouldReturnCorrectCount()
{
var db = DbInfrastructure.GetDatabase();
for (var i = 0; i < 50; i++)
{
await db.AddAsync(new Book
{
Title = $"Title {i}"
});
}
const int BorrowedBooks = 25;
for (var i = 0; i < BorrowedBooks; i++)
{
await db.AddAsync(new Book
{
Title = $"Title {i + 50}",
BorrowerId = Guid.NewGuid().ToString()
});
}
await db.SaveChangesAsync();
var bookService = new BookService(db);
var borrowedBooks = await bookService.GetBorrowedCountAsync();
borrowedBooks.Should().Be(BorrowedBooks);
}
public async Task EditAsyncShouldEditBook()
{
var db = DbInfrastructure.GetDatabase();
var bookService = new BookService(db);
var book = new Book
{
Title = "Title",
Description = "Description"
};
await db.AddAsync(book);
await db.SaveChangesAsync();
const string EditedTitle = "Edited Title";
const string EditedDescription = "Edited Description";
await bookService.EditAsync(book.Id, EditedTitle, EditedDescription);
book
.Title
.Should()
.Be(EditedTitle);
book
.Description
.Should()
.Be(EditedDescription);
}
public async Task CreateAsyncShouldNotCreateOrderIfEventIsNull()
{
using (var db = DbInfrastructure.GetDatabase())
{
var events = new EventService(db);
var allEvents = await events.AllAsync();
var orders = new OrderService(db);
var user = new User
{
Id = Guid.NewGuid().ToString(),
Email = FirstUserEmail,
FirstName = "Pesho",
LastName = "Ivanov",
UniqueCitizenNumber = "UNIQUE",
UserName = Username
};
await orders.CreateAsync(user, null, 550);
var allOrders = await orders.AllAsync();
Assert.Empty(allOrders);
}
}
public async Task ByIdAsyncShouldReturnBookById()
{
var db = DbInfrastructure.GetDatabase();
var books = new List <Book>();
for (var i = 0; i < 10; i++)
{
var currentBook = new Book
{
Title = $"title {i + 1}",
};
books.Add(currentBook);
}
await db.AddRangeAsync(books);
await db.SaveChangesAsync();
var expectedBook = books.First();
var bookService = new BookService(db);
var book = await bookService.ByIdAsync(expectedBook.Id);
book.Title.Should().Be("title 1");
}
public async Task DeliverAsyncShouldMarkGivenPackageAsDelivered()
{
var db = DbInfrastructure.GetDatabase();
var mockUserManager = this.GetUserManagerMock();
mockUserManager
.Setup(m => m.FindByIdAsync(It.IsAny <string>()))
.Returns((string id) => db.Users.SingleOrDefaultAsync(u => u.Id == id));
var receiptService = new Mock <IReceiptService>().Object;
var packageService = new PackageService(db, receiptService, mockUserManager.Object);
await AddPackagesToDb(db);
var packages = await db
.Packages
.Where(p => p.Status == Status.Pending)
.OrderBy(p => Guid.NewGuid())
.ToListAsync();
var expectedPackage = packages.First();
await packageService.DeliverAsync(expectedPackage.Id);
var package = await db.Packages.FindAsync(expectedPackage.Id);
package
.Status
.Should()
.Be(Status.Delivered);
}
public async Task PendingForUserAsyncShouldReturnAllPendingPackagesForGivenUser()
{
var db = DbInfrastructure.GetDatabase();
var mockUserManager = this.GetUserManagerMock();
mockUserManager
.Setup(m => m.FindByIdAsync(It.IsAny <string>()))
.Returns((string id) => db.Users.SingleOrDefaultAsync(u => u.Id == id));
var receiptService = new Mock <IReceiptService>().Object;
var packageService = new PackageService(db, receiptService, mockUserManager.Object);
var firstUser = new User
{
UserName = "******"
};
var secondUser = new User
{
UserName = "******"
};
await db.AddRangeAsync(firstUser, secondUser);
await db.SaveChangesAsync();
for (var i = 0; i < 50; i++)
{
var package = new Package
{
RecipientId = firstUser.Id,
Status = Status.Delivered
};
await db.AddAsync(package);
}
const int PackagesCount = 25;
for (var i = 0; i < PackagesCount; i++)
{
var package = new Package
{
RecipientId = secondUser.Id,
Status = Status.Pending
};
await db.AddAsync(package);
}
await db.SaveChangesAsync();
var actualPendingPackages = await packageService.PendingForUserAsync(secondUser);
actualPendingPackages
.Should()
.HaveCount(PackagesCount);
}
public async Task PreferredAsyncShoulReturnOnlyPrefferedDrinks()
{
var db = DbInfrastructure.GetDatabase();
var drinkService = new DrinkService(db);
const int Drinks = 90;
// 90 preffered drinks with 3 categories
await this.SeedData(db, Drinks, 3, true);
var drinks = await drinkService.PreferredAsync();
drinks
.Should()
.HaveCount(Drinks);
drinks
.Should()
.BeInAscendingOrder(d => d.Name);
foreach (var drink in drinks)
{
var drinkFromDb = await db
.Drinks
.FindAsync(drink.Id);
drinkFromDb.IsPreferred.Should().BeTrue();
}
}
public async Task NonAlcoholicCountAsyncShouldReturnCorrectCount()
{
var db = DbInfrastructure.GetDatabase();
const int NonAlcoholicDrinks = 150;
var alcoholicCategory = new Category
{
Name = "Alcoholic"
};
var nonAlcoholicCategory = new Category
{
Name = "Non-Alcoholic"
};
await db.AddRangeAsync(alcoholicCategory, nonAlcoholicCategory);
await db.SaveChangesAsync();
await this.SeedDataByCategory(db, 1234, alcoholicCategory.Id);
await this.SeedDataByCategory(db, NonAlcoholicDrinks, nonAlcoholicCategory.Id);
var drinkService = new DrinkService(db);
var count = await drinkService.NonAlcoholicCountAsync();
count.Should().Be(NonAlcoholicDrinks);
}
public async Task TotalAsyncShouldReturnCorrectCount()
{
using (var db = DbInfrastructure.GetDatabase())
{
var events = new EventService(db);
for (var i = 0; i < 45; i++)
{
var newEvent = new Event
{
Name = Name,
Place = Place,
Start = this.startDate,
End = this.endDate,
Tickets = TicketsCount,
TicketPrice = TicketPrice
};
await db.AddAsync(newEvent);
}
await db.SaveChangesAsync();
Assert.Equal(45, await events.TotalAsync());
}
}
public async Task AllAsyncShouldReturnOnlyEventsThatHaveMoreThan1Ticket()
{
using (var db = DbInfrastructure.GetDatabase())
{
var events = new EventService(db);
for (var i = 0; i < 10; i++)
{
var newEvent = new Event
{
Name = $"Name {i + 1}",
TicketPrice = i * 123.321M,
Tickets = i - 1,
Place = $"Place {i * 15}",
Start = new DateTime(2018 - i, this.rnd.Next(1, 13), this.rnd.Next(1, 10) + i),
End = new DateTime(2018 - i + 2, this.rnd.Next(1, 13), this.rnd.Next(1, 10) + i)
};
await db.AddAsync(newEvent);
}
await db.SaveChangesAsync();
var eventsFromPageOne = await events.AllAsync();
Assert.Equal(8, eventsFromPageOne.Count());
}
}
public async Task CreateAsyncShouldCreateSuccessfullyEventAndAddItToDb()
{
using (var db = DbInfrastructure.GetDatabase())
{
var events = new EventService(db);
await events.CreateAsync(Name, Place, this.startDate, this.endDate, TicketsCount, TicketPrice);
var allEvents = await events.AllAsync();
var actualEvent = allEvents.FirstOrDefault();
var expectedEvent = new Event
{
Name = Name,
Place = Place,
Start = this.startDate,
End = this.endDate,
Tickets = TicketsCount,
TicketPrice = TicketPrice
};
Assert.True(expectedEvent.Name == actualEvent.Name);
Assert.True(expectedEvent.Start == actualEvent.Start);
Assert.True(expectedEvent.End == actualEvent.End);
Assert.True(expectedEvent.Place == actualEvent.Place);
Assert.True(expectedEvent.Tickets == actualEvent.Tickets);
}
}
public async Task ByIdAsyncShoulReturnCorrectEvent()
{
using (var db = DbInfrastructure.GetDatabase())
{
var events = new EventService(db);
for (var i = 0; i < 30; i++)
{
var newEvent = new Event
{
Name = $"Name {i + 1}",
TicketPrice = i * 123.321M,
Tickets = i * 123,
Place = $"Place {i * 15}",
};
await db.AddAsync(newEvent);
}
await db.SaveChangesAsync();
var actualEvent = await events.ByIdAsync(10);
Assert.Equal(10, actualEvent.Id);
Assert.Equal("Name 10", actualEvent.Name);
Assert.Equal(9 * 123.321M, actualEvent.TicketPrice);
Assert.Equal($"Place {9 * 15}", actualEvent.Place);
}
}
public async Task AllAsyncShouldReturnOnlyTheEventsLocatedAtTheGivenPage()
{
using (var db = DbInfrastructure.GetDatabase())
{
var events = new EventService(db);
for (var i = 0; i < 22; i++)
{
var newEvent = new Event
{
Name = $"Name {i}"
};
await db.AddAsync(newEvent);
}
await db.SaveChangesAsync();
var eventsFromPageTwo = await events.AllAsync();
var expectedEvents = new List <EventServiceModel>();
for (var i = 10; i < eventsFromPageTwo.Count() + 10; i++)
{
expectedEvents.Add(new EventServiceModel
{
Name = $"Name {i}"
});
}
Assert.Equal(expectedEvents, eventsFromPageTwo);
}
}
public async Task ByIdAsyncShouldReturnContactById()
{
var db = DbInfrastructure.GetDatabase();
const string Title = "Title";
const string Message = "Message";
var contact = new Contact
{
Title = Title,
Message = Message
};
await db.AddAsync(contact);
await db.SaveChangesAsync();
var contactAdminService = new ContactAdminService(db);
var actualContact = await contactAdminService.ByIdAsync(contact.Id);
actualContact.Title.Should().Be(Title);
actualContact.Message.Should().Be(Message);
}
public async Task AllAsyncShouldReturnCorrectDrinksByPageWithoutCategory()
{
var db = DbInfrastructure.GetDatabase();
// 270 drinks with 1 categories
await this.SeedData(db, 270, 1);
var drinkService = new DrinkService(db);
const string Search = "0";
for (var i = 0; i < 3; i++)
{
var drinks = await drinkService.AllAsync(i + 1, null, Search);
drinks
.Should()
.HaveCount(WebConstants.DrinksPerPage);
drinks
.Should()
.BeInAscendingOrder(d => d.Name);
foreach (var drink in drinks)
{
drink
.Name
.ToLower()
.Should()
.Contain(Search.ToLower());
}
}
}
public async Task EditAsyncShouldEditContact()
{
var db = DbInfrastructure.GetDatabase();
var contact = new Contact
{
Title = "Title",
Message = "Message",
ContactType = ContactType.Bug,
IsAnswered = false
};
await db.AddAsync(contact);
await db.SaveChangesAsync();
var contactAdminService = new ContactAdminService(db);
const string Title = "Edited Title";
const string Message = "Edited Message";
await contactAdminService.EditAsync(contact.Id, Title, Message, ContactType.Question, true);
var actualContact = await contactAdminService.ByIdAsync(contact.Id);
actualContact.Title.Should().Be(Title);
actualContact.Message.Should().Be(Message);
actualContact.ContactType.Should().Be(ContactType.Question);
actualContact.IsAnswered.Should().BeTrue();
}
public async Task AllAsyncShouldReturnCorrectCustomersWithoutSort()
{
var db = DbInfrastructure.GetDatabase();
await DbInfrastructure.SeedCustomers(100, 10, db);
var serviceProviderMock = new Mock <IServiceProvider>();
var customerService = new CustomerService(db, new SortStrategyParser(serviceProviderMock.Object));
IEnumerable <CustomerViewModel> customers;
for (var i = 1; i <= 8; i++)
{
customers = await customerService.AllAsync <CustomerViewModel>(i, string.Empty);
customers
.Should()
.HaveCount(WebConstants.CustomersPerPage);
customers
.Should()
.BeInDescendingOrder(c => c.CreatedOn);
customers
.Should()
.NotContain(c => c.Status == Status.Deleted);
}
customers = await customerService.AllAsync <CustomerViewModel>(9, string.Empty);
customers
.Should()
.HaveCount(4);
}
public async Task DetailsByUserAsyncShouldThrowInvalidOperationExceptionIfPackageIsNotFound()
{
var db = DbInfrastructure.GetDatabase();
var mockUserManager = this.GetUserManagerMock();
mockUserManager
.Setup(m => m.FindByIdAsync(It.IsAny <string>()))
.Returns((string id) => db.Users.SingleOrDefaultAsync(u => u.Id == id));
var receiptService = new Mock <IReceiptService>().Object;
var packageService = new PackageService(db, receiptService, mockUserManager.Object);
var user = new User
{
UserName = "******"
};
await db.AddAsync(user);
await db.SaveChangesAsync();
Func <Task> func = async() => await packageService.DetailsByUserAsync(user, 5);
func.Should().Throw <InvalidOperationException>();
}
public async Task DeleteAsyncShouldMarkCustomerAsDeleted()
{
var db = DbInfrastructure.GetDatabase();
var customer = new Customer
{
FirstName = "Tedd",
LastName = "Ivanov",
Status = Status.Active,
PhoneNumber = "089 456 231",
IsMale = true,
CreatedOn = DateTime.UtcNow,
};
await db.AddAsync(customer);
await db.SaveChangesAsync();
var serviceProviderMock = new Mock <IServiceProvider>();
var customerService = new CustomerService(db, new SortStrategyParser(serviceProviderMock.Object));
await customerService.DeleteAsync(customer.Id);
var actualCustomer = await db.Customers.FirstOrDefaultAsync();
actualCustomer
.Status
.Should()
.Be(Status.Deleted);
}
public async Task CreateAsyncShouldNotCreateOrderIfUserIsNull()
{
using (var db = DbInfrastructure.GetDatabase())
{
var events = new EventService(db);
var allEvents = await events.AllAsync();
var orders = new OrderService(db);
var newEvent = new Event
{
Name = Event,
Place = Place,
Start = new DateTime(),
End = new DateTime(),
Tickets = 1000,
TicketPrice = 100
};
await orders.CreateAsync(null, newEvent, 550);
var allOrders = await orders.AllAsync();
Assert.Empty(allOrders);
}
}
public async Task UpdateAsyncShouldUpdateCustomer()
{
var db = DbInfrastructure.GetDatabase();
var customer = await DbInfrastructure.SeedCustomer(db);
var serviceProviderMock = new Mock <IServiceProvider>();
var customerService = new CustomerService(db, new SortStrategyParser(serviceProviderMock.Object));
const string UpdatedFirstName = "Teodora";
const string UpdatedLastName = "Ivanova";
const string UpdatedPhoneNumer = "08 888 555";
await customerService.UpdateAsync(customer.Id, UpdatedFirstName, UpdatedLastName, UpdatedPhoneNumer, Status.Inactive);
var actualCustomer = await db.Customers.FirstOrDefaultAsync();
actualCustomer
.Should()
.Match <Customer>(c => c.FirstName == UpdatedFirstName)
.And
.Match <Customer>(c => c.LastName == UpdatedLastName)
.And
.Match <Customer>(c => c.PhoneNumber == UpdatedPhoneNumer)
.And
.Match <Customer>(c => c.Status == Status.Inactive);
}
public async Task AddAsyncShouldAddBook()
{
var db = DbInfrastructure.GetDatabase();
var bookService = new BookService(db);
var author1 = new User
{
UserName = "******"
};
var author2 = new User
{
UserName = "******"
};
await db.AddRangeAsync(author1, author2);
const string Title = "Some title";
const string Description = "Description of the book";
await bookService.AddAsync(Title, Description, author1.Id);
var book = await db.Books.FirstOrDefaultAsync();
book.Title.Should().Be(Title);
book.Description.Should().Be(Description);
book.AuthorId.Should().Be(author1.Id);
}
public async Task ByIdAsyncShouldReturnAnimalById()
{
var db = DbInfrastructure.GetDatabase();
const string Name = "Animal Name";
await db.AddAsync(new Animal
{
Name = Name
});
for (var i = 0; i < 50; i++)
{
await db.AddAsync(new Animal
{
Name = $"Name {i}"
});
}
await db.SaveChangesAsync();
var animalService = new AnimalService(db);
const int Id = 1;
var animal = await animalService.ByIdAsync(Id);
animal.Should().NotBeNull();
animal.Name.Should().Be(Name);
}
public async Task BorrowAsyncShouldThrowInvalidOperationExceptionIfBookIsAlreadyBorrowed()
{
var db = DbInfrastructure.GetDatabase();
var user = new User
{
UserName = "******"
};
var book = new Book
{
Title = "Title test",
BorrowerId = Guid.NewGuid().ToString()
};
await db.AddAsync(book);
await db.AddAsync(user);
await db.SaveChangesAsync();
var bookService = new BookService(db);
Func <Task> func = async() => await bookService.BorrowAsync(book.Id, user.UserName);
func
.Should()
.Throw <InvalidOperationException>()
.WithMessage(ExceptionMessages.BookAlreadyBorrowed);
}
public async Task AllAsyncShouldReturnCorrectAnimalsByPages()
{
var db = DbInfrastructure.GetDatabase();
for (var i = 0; i < 50; i++)
{
await db.AddAsync(new Animal
{
Name = $"Some random name {i}"
});
}
await db.SaveChangesAsync();
var animalService = new AnimalService(db);
for (var i = 0; i < 10; i++)
{
var animals = await animalService.AllAsync(i + 1);
animals
.Should()
.HaveCount(WebConstants.AnimalsPerPage);
animals
.Should()
.BeInAscendingOrder(a => a.AnimalClass);
}
var animalsFromNonExistingPage = await animalService.AllAsync(11);
animalsFromNonExistingPage.Should().HaveCount(0);
}
public async Task ReturnAsyncShouldMarkBookAsReturned()
{
var db = DbInfrastructure.GetDatabase();
for (var i = 0; i < 200; i++)
{
await db.AddAsync(new Book
{
Title = $"book title {i}"
});
}
var user = new User
{
UserName = "******"
};
await db.AddAsync(user);
await db.SaveChangesAsync();
var bookService = new BookService(db);
var book = await db.Books.FirstOrDefaultAsync(b => b.Title.Contains("5"));
book.BorrowerId.Should().BeNull();
await bookService.BorrowAsync(book.Id, user.UserName);
book.BorrowerId.Should().Be(user.Id);
await bookService.ReturnAsync(book.Id, user.UserName);
book.BorrowerId.Should().BeNull();
}
public async Task GetUserByNameAsyncShouldReturnUserByName()
{
var db = DbInfrastructure.GetDatabase();
const string UserName = "******";
var user = new User
{
UserName = UserName,
Email = "*****@*****.**"
};
await db.AddAsync(user);
await db.SaveChangesAsync();
for (var i = 0; i < 10; i++)
{
await db.AddAsync(new User
{
UserName = $"Gosho {i}"
});
}
await db.SaveChangesAsync();
var userAdminService = new UserAdminService(db);
var actualUser = await userAdminService.GetUserByNameAsync(UserName);
user.Should().BeSameAs(actualUser);
}
public async Task GetCountBySearchAsyncShouldReturnCorrectCount()
{
var db = DbInfrastructure.GetDatabase();
const int SearchedTitlesCount = 50;
for (var i = 0; i < SearchedTitlesCount; i++)
{
await db.AddAsync(new Book
{
Title = $"Title {i}"
});
}
for (var i = 0; i < 150; i++)
{
await db.AddAsync(new Book
{
Title = $"asdf {i}"
});
}
await db.SaveChangesAsync();
var bookService = new BookService(db);
const string SearchedText = "ti";
var count = await bookService.GetCountBySearchAsync(SearchedText);
count.Should().Be(SearchedTitlesCount);
}
public async Task GetCountBySearchAsyncShouldReturnCorrectCount()
{
var db = DbInfrastructure.GetDatabase();
const int UsersCount = 45;
for (var i = 0; i < UsersCount; i++)
{
var user = new User
{
UserName = $"Some User {i}"
};
await db.AddAsync(user);
}
await db.SaveChangesAsync();
var userSerivce = new UserService(db, this.GetUserManagerMock().Object);
const string UserSearchText = "user";
var count = await userSerivce.GetCountBySearchAsync(UserSearchText);
count.Should().Be(UsersCount);
}
