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); }