public async Task RemoveCommentShouldReduceCount() { var options = new DbContextOptionsBuilder <ApplicationDbContext>() .UseInMemoryDatabase(databaseName: "MyTestDb5") .Options; var dbContext = new ApplicationDbContext(options); var comment1 = new Comment { Id = 1 }; var comment2 = new Comment { Id = 2 }; dbContext.Comments.Add(comment1); dbContext.Comments.Add(comment2); await dbContext.SaveChangesAsync(); var repository = new EfDeletableEntityRepository <Comment>(dbContext); var service = new CommentService(repository); int existingId = 2; await service.RemoveComment(existingId); Assert.Equal(1, repository.All().Count()); }
public async Task Handle_GivenInvalidRequest_ShouldThrowPlayerCannotBeAMemeberOfMultipleTeamsWithTheSameFormatException() { // Arrange var command = new InvitePlayerCommand { TeamId = 1, UserName = "******" }; this.dbContext.PlayerTeams.Add(new PlayerTeam { PlayerId = "Foo5", TeamId = 2 }); this.dbContext.SaveChanges(); var playersRepository = new EfDeletableEntityRepository <Player>(this.dbContext); var sut = new InvitePlayerCommandHandler( this.deletableEntityRepository, playersRepository, It.IsAny <IDeletableEntityRepository <TeamInvite> >(), It.IsAny <IMediator>(), It.IsAny <IUserAccessor>()); // Act & Assert await Should.ThrowAsync <PlayerCannotBeAMemeberOfMultipleTeamsWithTheSameFormatException>(sut.Handle(command, It.IsAny <CancellationToken>())); }
public async void DeleteProductAsync() { var options = new DbContextOptionsBuilder <ApplicationDbContext>() .UseInMemoryDatabase(databaseName: "Product_Database") .Options; var dbContext = new ApplicationDbContext(options); await dbContext.AddAsync(new Product { Name = "TestProduct", Details = "TestDetails" }); await dbContext.SaveChangesAsync(); var product = new EfDeletableEntityRepository <Product>(dbContext); var productLang = new EfDeletableEntityRepository <ProductLang>(dbContext); var userStore = new UserStore <ApplicationUser>(dbContext); var sanitizer = new HtmlSanitizer(); var service = new ProductService(product, productLang, userStore, sanitizer); var productToDelete = service.GetAll().FirstOrDefault(x => x.Details == "TestDetails"); await service.Delete(productToDelete); var count = service.GetAll().Count(); Assert.Equal(0, count); }
public async void GetNotificationTemplateShouldRetunrProperType() { var options = new DbContextOptionsBuilder <ApplicationDbContext>() .UseInMemoryDatabase(Guid.NewGuid().ToString()); var notificationRepository = new EfDeletableEntityRepository <Notification>(new ApplicationDbContext(options.Options)); var userRepository = new EfDeletableEntityRepository <ApplicationUser>(new ApplicationDbContext(options.Options)); AutoMapperConfig.RegisterMappings(typeof(ErrorViewModel).GetTypeInfo().Assembly); var notificationsService = new NotificationsService(notificationRepository, userRepository); var notification = new Notification { DogsitterId = Guid.NewGuid().ToString(), OwnerId = Guid.NewGuid().ToString(), Content = "True", }; await notificationsService.SendNotification(notification); var notificationBase = notificationsService.GetNotificationById <NotificationViewModel>(notification.Id); Assert.IsType <NotificationViewModel>(notificationBase); }
public async Task Handle_GivenInvalidRequest_ShouldThrowNotFoundExceptionForTeam() { // Arrange var command = new EnrollATeamCommand { TableId = 2, TeamId = 55 }; var userAccessorMock = new Mock <IUserAccessor>(); userAccessorMock.Setup(x => x.UserId).Returns("Foo3"); var playersRepository = new EfDeletableEntityRepository <Player>(this.dbContext); var teamsRepository = new EfDeletableEntityRepository <Team>(this.dbContext); var tournamentTablesRepository = new EfDeletableEntityRepository <TournamentTable>(this.dbContext); var sut = new EnrollATeamCommandHandler( teamsRepository, playersRepository, tournamentTablesRepository, userAccessorMock.Object); // Act & Assert await Should.ThrowAsync <NotFoundException>(sut.Handle(command, It.IsAny <CancellationToken>())); }
public async Task DeleteRequestAsync_WithValidReqesterUsername_ShouldRemoveFromDatabase() { // Arrange var context = InMemoryDbContext.Initiliaze(); var userRepository = new EfDeletableEntityRepository <ApplicationUser>(context); var userFollowerRepository = new EfRepository <UserFollower>(context); var profileService = new ProfilesService(userRepository, userFollowerRepository); await this.SeedUsers(context); await userFollowerRepository.AddAsync(new UserFollower { UserId = "userOneId", FollowerId = "userTwoId", IsApproved = false }); await userFollowerRepository.SaveChangesAsync(); // Act int expectedCount = userFollowerRepository.All().Count() - 1; await profileService.DeleteRequestAsync("userTwoUsername"); int actualCount = userFollowerRepository.All().Count(); // Assert Assert.Equal(expectedCount, actualCount); }
public async Task GetDetailsForNewByIdAsync_WithData_ShouldReturnNew() { var context = SteuDbContextInMemoryFactory.InitializeContext(); NewsService service = this.IntializeNewsService(context); var repository = new EfDeletableEntityRepository <News>(context); var tempNews = new News() { Id = "newsId", Content = "content", Title = "title", IsDeleted = false, SteuUserId = "userId", }; await repository.AddAsync(tempNews); await repository.SaveChangesAsync(); var actualResult = await service.GetDetailsForNewByIdAsync <NewsDetailsViewModel>("newsId"); Assert.Equal("content", actualResult.Content); }
public async Task EditLoadAsync_WithIncorectOrderId_ShouldReturnArgumentNullException() { var context = SteuDbContextInMemoryFactory.InitializeContext(); LoadsService service = IntializeLoadService(context); var repository = new EfDeletableEntityRepository <Order>(context); await repository.AddAsync(new Order() { Id = "asdasd", Load = new Load(), }); await context.SaveChangesAsync(); EditLoadViewModel model = new EditLoadViewModel() { Id = "asd", CountryFrom = "Bulgaria", TownFrom = "Sofia", CountryTo = "Croatia", TownTo = "Zagreb", TruckTypeName = "Normal", Priority = "Normal", Circle = false, ExpireTime = DateTime.UtcNow, LoadDeliveryTime = DateTime.UtcNow, LoadTime = DateTime.UtcNow, LoadVolume = 100, LoadWeight = 20000, Price = 12312231, Referer = "dasada", InputModel = new LoadEditViewModel(), }; await Assert.ThrowsAsync <ArgumentNullException>(() => service.EditLoadAsync(model)); }
public async Task GetAllAvaibleLoadsBySearchAsync_WhithNonExistingLoad_ShoulRetunEmptyList() { var context = SteuDbContextInMemoryFactory.InitializeContext(); LoadsService service = IntializeLoadService(context); var repository = new EfDeletableEntityRepository <Order>(context); await repository.AddAsync(new Order() { AddressFrom = new Address() { Country = new Country() { Name = "Bulgaria" }, Town = new Town() { Name = "Sofia" }, }, ExpireTime = DateTime.UtcNow.AddDays(7), IsDeleted = false, Load = new Load(), }); await context.SaveChangesAsync(); SearchLoadInputModel model = new SearchLoadInputModel() { CountryTo = "Bulgaria", }; var actualResult = await service.GetAllAvaibleLoadsBySearchAsync <AllAvaibleLoadsBySearchViewModel>(model); Assert.Empty(actualResult); }
public async Task DeleteAsyncWorksCorrectly() { var options = new DbContextOptionsBuilder <ApplicationDbContext>() .UseInMemoryDatabase(databaseName: Guid.NewGuid().ToString()).Options; var dbContext = new ApplicationDbContext(options); var repository = new EfDeletableEntityRepository <Category>(dbContext); var service = new CategoriesService(repository); var category = new Category() { Id = 1, }; var childCategoryOne = new Category() { Id = 2, ParentCategoryId = 1, }; var childCategoryTwo = new Category() { Id = 3, ParentCategoryId = 1, }; dbContext.Add(category); dbContext.Add(childCategoryOne); dbContext.Add(childCategoryTwo); await dbContext.SaveChangesAsync(); await service.DeleteAsync(1); var categoriesInDbCount = dbContext.Categories.ToList().Count(); Assert.Equal(0, categoriesInDbCount); }
public async Task EditAsync_WithCorrectData_ShouldSuccessfullyEdit() { var errorMessagePrefix = "SpecialOffersService EditAsync() method does not work properly."; // Arrange MapperInitializer.InitializeMapper(); var context = HotelDbContextInMemoryFactory.InitializeContext(); var seeder = new SpecialOffersServiceTestsSeeder(); await seeder.SeedSpecialOfferAsync(context); var specialOfferRepository = new EfDeletableEntityRepository <SpecialOffer>(context); var specialOffersService = this.GetSpecialOffersService(specialOfferRepository, context); var specialOffer = context.SpecialOffers.First(); var model = new EditSpecialOfferViewModel { Id = specialOffer.Id, Title = "Title1-Edited", Content = "Content1-Edited", ShortContent = "ShortContenr1-Edited", HotelDataId = context.Hotels.FirstOrDefault().Id, }; // Act await specialOffersService.EditAsync(model); var actualResult = specialOfferRepository.All().First(); var expectedResult = model; // Assert Assert.True(expectedResult.Title == actualResult.Title, errorMessagePrefix + " " + "Title is not returned properly."); Assert.True(expectedResult.Content == actualResult.Content, errorMessagePrefix + " " + "Content is not returned properly."); Assert.True(expectedResult.ShortContent == actualResult.ShortContent, errorMessagePrefix + " " + "Short content is not returned properly."); Assert.True(expectedResult.HotelDataId == actualResult.HotelDataId, errorMessagePrefix + " " + "Hotel is not returned properly."); }
public async Task UpdateProfileCorrectlyUpdatesProfilePictureUrlWhenItIsNotNull() { AutoMapperInitializer.InitializeMapper(); var context = InMemoryDbContextInitializer.InitializeContext(); await context.Candidates.AddRangeAsync(this.SeedTestData()); await context.SaveChangesAsync(); var candidatesRepository = new EfDeletableEntityRepository <Candidate>(context); var languagesRepository = new EfDeletableEntityRepository <CandidateLanguage>(context); var skillsRepository = new EfDeletableEntityRepository <CandidateSkill>(context); var cloudinary = new Cloudinary(new Account(CloudinaryConfig.CloudName, CloudinaryConfig.ApiKey, CloudinaryConfig.ApiSecret)); var candidatesService = this.GetMockedService(candidatesRepository, languagesRepository, skillsRepository, cloudinary); var profilePicture = this.PrepareImage(); var candidateId = await candidatesService.UpdateProfileAsync("Second", new UpdateCandidateProfileViewModel { ProfilePicture = profilePicture }); Assert.NotNull(candidateId); var profilePictureUrl = context.Candidates.Find(candidateId).ProfilePictureUrl; Assert.NotEqual("someUrl", profilePictureUrl); }
public async Task EditAsync_WithIncorrectProperty_ShouldThrowArgumentNullException() { // Arrange MapperInitializer.InitializeMapper(); var context = HotelDbContextInMemoryFactory.InitializeContext(); var reservationRepository = new EfDeletableEntityRepository <Reservation>(context); var reservationsService = this.GetReservationService(reservationRepository, context); var seeder = new ReservationsServiceTestsSeeder(); await seeder.SeedReservationAsync(context); var reservation = context.Reservations.First(); var model = new EditReservationViewModel { Id = reservation.Id, UserId = null, StartDate = new DateTime(2020, 4, 4), EndDate = new DateTime(2020, 4, 8), Adults = 2, Kids = 1, ReservationStatusId = null, PaymentTypeId = null, TotalAmount = 1000, TotalDays = 4, AdvancedPayment = 300, RoomId = null, }; // Act // Assert await Assert.ThrowsAsync <ArgumentNullException>(async() => { await reservationsService.EditAsync(model); }); }
public async Task EditAsync_WithCorrectData_ShouldReturnCorrectResult() { var errorMessage = "ReservationsService EditAsync() method does not work properly."; // Arrange MapperInitializer.InitializeMapper(); var context = HotelDbContextInMemoryFactory.InitializeContext(); var reservationRepository = new EfDeletableEntityRepository <Reservation>(context); var reservationsService = this.GetReservationService(reservationRepository, context); var seeder = new ReservationsServiceTestsSeeder(); await seeder.SeedReservationAsync(context); var reservation = context.Reservations.First(); var model = new EditReservationViewModel { Id = reservation.Id, UserId = context.Users.First().Id, StartDate = new DateTime(2020, 4, 4), EndDate = new DateTime(2020, 4, 8), Adults = 2, Kids = 1, ReservationStatusId = context.ReservationStatuses.First().Id, PaymentTypeId = context.PaymentTypes.First().Id, TotalAmount = 1000, TotalDays = 4, AdvancedPayment = 300, RoomId = context.Rooms.First().Id, }; // Act var result = await reservationsService.EditAsync(model); // Assert Assert.True(result, errorMessage + " " + "Returns false."); }
public async Task GetAllCoverPicturesAsyncShouldReturnCorrectCount() { var options = new DbContextOptionsBuilder <ApplicationDbContext>() .UseInMemoryDatabase(databaseName: Guid.NewGuid().ToString()).Options; var dbContext = new ApplicationDbContext(options); var repositoryNewsFeedPost = new EfDeletableEntityRepository <NewsFeedPost>(dbContext); var applicationUser = new EfDeletableEntityRepository <ApplicationUser>(dbContext); var pictureRepository = new EfRepository <UserProfilePicture>(dbContext); var repositoryComment = new EfDeletableEntityRepository <NewsFeedComment>(dbContext); var coverPictureRepository = new EfRepository <UserCoverPicture>(dbContext); var friendRepository = new EfDeletableEntityRepository <Friend>(dbContext); var userPicture = new UserCoverPicture { PictureURL = "mountain.jpg", ApplicationUserId = "1", }; var secondUserPicture = new UserCoverPicture { PictureURL = "mountainTwo.jpg", ApplicationUserId = "1", }; var service = new NewsFeedService(repositoryNewsFeedPost, applicationUser, pictureRepository, repositoryComment, coverPictureRepository, friendRepository); var firstPictureResult = service.CreateCoverPictureAsync(userPicture.ApplicationUserId, userPicture.PictureURL); var secondPictureResult = service.CreateCoverPictureAsync(secondUserPicture.ApplicationUserId, secondUserPicture.PictureURL); AutoMapperConfig.RegisterMappings(typeof(GetAllCoverPictureForUserViewModel).GetTypeInfo().Assembly); var resultCount = await service.GetAllCoverPicturesAsync <GetAllCoverPictureForUserViewModel>(userPicture.ApplicationUserId); Assert.Equal(2, resultCount.Count()); }
public async Task GetAllLoadsByUserIdAsync_WithNullUser_ShouldReturnArgumentNullException() { var context = SteuDbContextInMemoryFactory.InitializeContext(); LoadsService service = IntializeLoadService(context); var repository = new EfDeletableEntityRepository <Order>(context); var order = new Order() { Id = "orderId", IsDeleted = false, ExpireTime = DateTime.UtcNow.AddDays(7), Load = new Load(), SteuUser = new SteuUser() { Id = "userId", }, }; await repository.AddAsync(order); await repository.SaveChangesAsync(); await Assert.ThrowsAsync <ArgumentNullException>(() => service.GetAllLoadsByUserIdAsync(1, 10, null)); }
public async Task GetUserFollowingsAsync_WithValidData_ShouldReturnUserFollowings() { // Arrange this.InitilaizeMapper(); var context = InMemoryDbContext.Initiliaze(); var userRepository = new EfDeletableEntityRepository <ApplicationUser>(context); var userFollowerRepository = new EfRepository <UserFollower>(context); var profileService = new ProfilesService(userRepository, userFollowerRepository); await this.SeedUsers(context); await userFollowerRepository.AddAsync(new UserFollower { UserId = "userOneId", FollowerId = "userTwoId", IsApproved = true }); await userFollowerRepository.SaveChangesAsync(); // Act var followings = await profileService.GetUserFollowingsAsync("userTwoUsername"); string expectedUsername = userRepository.All().FirstOrDefault(u => u.Id == "userOneId").UserName; string actualUsername = followings.FirstOrDefault().UserUserName; // Assert Assert.Equal(expectedUsername, actualUsername); }
public async void ListAllUserFeedbackCorrectly() { var dbContext = new DbContextOptionsBuilder <ApplicationDbContext>() .UseInMemoryDatabase(Guid.NewGuid().ToString()); var feedbackRepository = new EfDeletableEntityRepository <Feedback>(new ApplicationDbContext(dbContext.Options)); feedbackRepository.SaveChangesAsync().GetAwaiter().GetResult(); var service = new FeedbacksService(feedbackRepository); var user = new ApplicationUser { Id = Guid.NewGuid().ToString(), }; var meeting = new Meeting { Id = Guid.NewGuid().ToString(), Title = "Test 1", }; var secondMeeting = new Meeting { Id = Guid.NewGuid().ToString(), Title = "Test 2", }; await service.AddAsync(user.Id, user, 6, "Awesome", meeting.Id, meeting); await service.AddAsync("Not user id", new ApplicationUser { }, 1, "Poor", secondMeeting.Id, secondMeeting); var list = service.GetUserFeedbacks(user.Id).ToList(); Assert.Single(list); }
public async Task DeleteByIdAsync_WithExistentId_ShouldSuccessfullyDelete() { var errorMessagePrefix = "NutritionalValueService DeleteByIdAsync() method does not work properly."; // Arrange MapperInitializer.InitializeMapper(); var context = ApplicationDbContextInMemoryFactory.InitializeContext(); await this.SeedDataAsync(context); var nutritionalValueRepository = new EfDeletableEntityRepository <NutritionalValue>(context); var nutritionalValueService = new NutritionalValueService(nutritionalValueRepository); var existentId = nutritionalValueRepository.All().First().Id; // Act var nutritionalValuesCount = nutritionalValueRepository.All().Count(); await nutritionalValueService.DeleteByIdAsync(existentId); var actualResult = nutritionalValueRepository.All().Count(); var expectedResult = nutritionalValuesCount - 1; // Assert Assert.True(actualResult == expectedResult, errorMessagePrefix + " " + "NutritionalValues count is not reduced."); }
public async Task FindProduct_WithExistingId_ShouldSuccessfullyFind() { // Arrange var context = ApplicationDbContextInMemoryFactory.InitializeContext(); var groupRepository = new EfDeletableEntityRepository <Product_Group>(context); var productRepository = new EfDeletableEntityRepository <Product>(context); var groupService = new GroupService(groupRepository); var productService = new ProductService(productRepository, groupService); var seeder = new DbContextTestsSeeder(); await seeder.SeedGroupAsync(context); await seeder.SeedProdcutAsync(context); // Act var result = productService.GetById("abc").Name; var actual = context.Products.SingleOrDefault(p => p.Id == "abc").Name; // Assert AssertExtension.EqualsWithMessage(actual, result, string.Format(ErrorMessage, "ProductGetIdByNameAndGroup")); }
public async Task TestGetExercisesByCategoryAsync_WithValidData_ShouldReturnCorrectExercises() { MapperInitializer.InitializeMapper(); var context = ApplicationDbContextInMemoryFactory.InitializeContext(); var repository = new EfDeletableEntityRepository <Exercise>(context); await repository.AddAsync(new Exercise { Name = "first", MuscleGroup = MuscleGroup.Abs }); await repository.AddAsync(new Exercise { Name = "second", MuscleGroup = MuscleGroup.Abs }); await repository.AddAsync(new Exercise { Name = "third", MuscleGroup = MuscleGroup.Shoulders }); await repository.AddAsync(new Exercise { Name = "fourth", MuscleGroup = MuscleGroup.Upper_Legs }); await repository.SaveChangesAsync(); var service = new ExercisesService(repository); var exercises = await service.GetExercisesByCategoryAsync(false, null, MuscleGroup.Abs.ToString(), null); Assert.Equal(2, exercises.Count); Assert.Equal("first", exercises[0].Name); Assert.Equal("second", exercises[1].Name); }
public async Task AddVisitsToUserShouldWorkCorrectly() { var options = new DbContextOptionsBuilder <ApplicationDbContext>() .UseInMemoryDatabase(Guid.NewGuid().ToString()).Options; var db = new ApplicationDbContext(options); var repository = new EfDeletableEntityRepository <Card>(db); var user = new ApplicationUser(); await repository.AddAsync(new Card() { User = user, UserId = user.Id, }); await repository.SaveChangesAsync(); var service = new CardsService(repository, this.qrcodeService.Object, this.notificationsService.Object); var result = await service.AddVisitsToUser(user.Id, 12); var result2 = await service.AddVisitsToUser(user.Id, 12); Assert.Equal(12, result.Visits); Assert.Equal(12, result2.Visits); }
public async void SendNotificationShouldHaveTheSameValuesAsTheSentOne() { var options = new DbContextOptionsBuilder <ApplicationDbContext>() .UseInMemoryDatabase(Guid.NewGuid().ToString()); var notificationRepository = new EfDeletableEntityRepository <Notification>(new ApplicationDbContext(options.Options)); var userRepository = new EfDeletableEntityRepository <ApplicationUser>(new ApplicationDbContext(options.Options)); var notificationsService = new NotificationsService(notificationRepository, userRepository); var notification = new Notification { DogsitterId = Guid.NewGuid().ToString(), OwnerId = Guid.NewGuid().ToString(), Content = "True", }; await notificationRepository.SaveChangesAsync(); await notificationsService.SendNotification(notification); var notifFromDb = await notificationRepository.All().FirstAsync(); Assert.Equal(notification.Content, notifFromDb.Content); }
public async Task EditAsync_WithNonExistentId_ShouldThrowArgumentNullException() { // Arrange MapperInitializer.InitializeMapper(); var context = HotelDbContextInMemoryFactory.InitializeContext(); var reservationStatusRepository = new EfDeletableEntityRepository <ReservationStatus>(context); var reservationStatusesService = this.GetReservationStatusesService(reservationStatusRepository, context); var nonExistentId = Guid.NewGuid().ToString(); var model = new EditReservationStatusViewModel { Id = nonExistentId, Name = "Test-1-Edited", }; // Act // Assert await Assert.ThrowsAsync <ArgumentNullException>(async() => { await reservationStatusesService.EditAsync(model); }); }
public async Task Handle_GivenInvalidRequest_ShouldThrowTeamFormatDoesNotMatchTournamentFormatException() { // Arrange var command = new EnrollATeamCommand { TableId = 2, TeamId = 123 }; var userAccessorMock = new Mock <IUserAccessor>(); userAccessorMock.Setup(x => x.UserId).Returns("Foo2"); var playersRepository = new EfDeletableEntityRepository <Player>(this.dbContext); var tournamentTablesRepository = new EfDeletableEntityRepository <TournamentTable>(this.dbContext); var dataSet = new List <Team>(1) { new Team { Id = 123, OwnerId = "Foo2", TournamentFormatId = 6969, Name = "MockTeam" } } .AsQueryable() .BuildMock(); var teamsMockRepository = new Mock <IDeletableEntityRepository <Team> >(); teamsMockRepository.Setup(x => x.AllAsNoTracking()).Returns(dataSet.Object); var sut = new EnrollATeamCommandHandler( teamsMockRepository.Object, playersRepository, tournamentTablesRepository, userAccessorMock.Object); // Act & Assert await Should.ThrowAsync <TeamFormatDoesNotMatchTournamentFormatException>(sut.Handle(command, It.IsAny <CancellationToken>())); }
public async Task DeleteByIdAsync_WithExistentId_ShouldSuccessfullyDelete() { var errorMessagePrefix = "ReservationStatusesService DeleteByIdAsync() method does not work properly."; // Arrange MapperInitializer.InitializeMapper(); var context = HotelDbContextInMemoryFactory.InitializeContext(); var reservationStatusRepository = new EfDeletableEntityRepository <ReservationStatus>(context); var reservationStatusesService = this.GetReservationStatusesService(reservationStatusRepository, context); var seeder = new ReservationStatusesServiceTestsSeeder(); await seeder.SeedReservationStatusesAsync(context); var reservationStatusId = reservationStatusRepository.All().First().Id; // Act var reservationStatusCount = reservationStatusRepository.All().Count(); await reservationStatusesService.DeleteByIdAsync(reservationStatusId); var actualResult = reservationStatusRepository.All().Count(); var expectedResult = reservationStatusCount - 1; // Assert Assert.True(actualResult == expectedResult, errorMessagePrefix + " " + "Reservation ststuses count is not reduced."); }
public async Task UnBanShouldUnBanUserAsync() { var options = new DbContextOptionsBuilder <ApplicationDbContext>() .UseInMemoryDatabase(databaseName: Guid.NewGuid().ToString()).Options; AutoMapperConfig.RegisterMappings(Assembly.Load("CookingBook.Web.ViewModels")); var dbContext = new ApplicationDbContext(options); var userRepo = new EfDeletableEntityRepository <ApplicationUser>(dbContext); await userRepo.AddAsync(new ApplicationUser { Name = "Trayan Keranov", Id = "trk", UserName = "******", NormalizedUserName = "******", Email = "*****@*****.**", NormalizedEmail = "*****@*****.**", PasswordHash = "AQAAAAEAACcQAAAAEKDTOW0hiJThqFCz2cTS+wMBN2HthJkHT1jCsqVhgYwc0XikiVo0ESJYcqs8yrZkgg==", SecurityStamp = "5ZMAFTFQEDOZPXC573KIOV5B56KVMHKS", ConcurrencyStamp = "5ed4afbd-318e-456b-8d1b-19a36f2d82f1", CreatedOn = DateTime.Parse("1993-03-21 08:10:00.2228617"), EmailConfirmed = true, Roles = new List <IdentityUserRole <string> >(), LockoutEnabled = true, LockoutEnd = DateTimeOffset.MaxValue, }); await userRepo.SaveChangesAsync(); var rolesRepo = new EfDeletableEntityRepository <ApplicationRole>(dbContext); var service = new UsersService(userRepo, rolesRepo); await service.Unban("trk"); Assert.Null(dbContext.Users.Find("trk").LockoutEnd); Assert.False(dbContext.Users.Find("trk").LockoutEnabled); }
public async Task GetReservationStatusByNamec_WithExistentName_ShouldReturnCorrectResult() { var errorMessagePrefix = "ReservationStatusesService GetReservationStatusByName() method does not work properly."; // Arrange MapperInitializer.InitializeMapper(); var context = HotelDbContextInMemoryFactory.InitializeContext(); var reservationStatusRepository = new EfDeletableEntityRepository <ReservationStatus>(context); var reservationStatusesService = this.GetReservationStatusesService(reservationStatusRepository, context); var seeder = new ReservationStatusesServiceTestsSeeder(); await seeder.SeedReservationStatusesAsync(context); var reservationStatusName = reservationStatusRepository.All().First().Name; // Act var actualResult = reservationStatusesService.GetReserVationStatusByName(reservationStatusName); var expectedResult = await reservationStatusRepository .All() .SingleOrDefaultAsync(x => x.Name == reservationStatusName); // Assert Assert.True(expectedResult.Id == actualResult.Id, errorMessagePrefix + " " + "Id is not returned properly."); Assert.True(expectedResult.Name == actualResult.Name, errorMessagePrefix + " " + "Name is not returned properly."); }
public async Task ChangeStatusToPendingShouldChangeStatusOnExistingId() { var options = new DbContextOptionsBuilder <ApplicationDbContext>() .UseInMemoryDatabase(databaseName: "MyTestDb2") .Options; var dbContext = new ApplicationDbContext(options); dbContext.Claims.Add(new InsuranceClaim { Id = 1, Status = ClaimStatus.Open }); dbContext.Claims.Add(new InsuranceClaim { Id = 2, Status = ClaimStatus.Settled }); await dbContext.SaveChangesAsync(); var repository = new EfDeletableEntityRepository <InsuranceClaim>(dbContext); var service = new ClaimService(repository); await service.ChangeStatusToPending(1); Assert.True((await repository.GetByIdAsync(1)).Status == ClaimStatus.Pending); await service.ChangeStatusToPending(2); Assert.True((await repository.GetByIdAsync(2)).Status == ClaimStatus.Pending); }
public async Task DeleteUserShouldRemoveUserFromService() { AutoMapperConfig.RegisterMappings(typeof(UserTestModel).Assembly); var options = new DbContextOptionsBuilder <ApplicationDbContext>() .UseInMemoryDatabase(Guid.NewGuid().ToString()); var repository = new EfDeletableEntityRepository <ApplicationUser>(new ApplicationDbContext(options.Options)); await repository.AddAsync(new ApplicationUser { Id = "test1", UserName = "******" }); await repository.AddAsync(new ApplicationUser { Id = "test2", UserName = "******" }); await repository.AddAsync(new ApplicationUser { Id = "test3", UserName = "******" }); await repository.SaveChangesAsync(); var mockedUserManager = MockUserManager <ApplicationUser>(repository.All().ToList()); var service = new UsersService(repository, null, null, null, mockedUserManager.Object); var outputMessage = await service.DeleteUserAsync("TestUser2"); Assert.Equal($"User 'TestUser2' successfully deleted.", outputMessage); Assert.Equal(2, repository.All().Count()); }