Example #1
0
        public async Task EditAsync_WithCorrectData_ShouldReturnCorrectResult()
        {
            var errorMessagePrefix = "PaymentTypesService EditAsync() method does not work properly.";

            // Arrange
            MapperInitializer.InitializeMapper();
            var context = HotelDbContextInMemoryFactory.InitializeContext();
            var paymentTypeRepository = new EfDeletableEntityRepository <PaymentType>(context);
            var paymentTypesService   = this.GetPaymentTypesService(paymentTypeRepository);
            var seeder = new PaymentTypesServiceTestsSeeder();
            await seeder.SeedPaymentTypeAsync(context);

            var paymentType = context.PaymentTypes.First();

            var model = new EditPaymentTypeViewModel
            {
                Id   = paymentType.Id,
                Name = "Test-1-Edited",
            };

            // Act
            var result = await paymentTypesService.EditAsync(model);

            // Assert
            Assert.True(result, errorMessagePrefix + " " + "Returns false.");
        }
Example #2
0
        public async Task GetAllPaymentTypesAsyn_ShouldReturnCorrectResult()
        {
            var errorMessagePrefix = "PaymentTypesService GetAllPaymentTypesAsyn() method does not work properly.";

            // Arrange
            MapperInitializer.InitializeMapper();
            var context = HotelDbContextInMemoryFactory.InitializeContext();
            var paymentTypeRepository = new EfDeletableEntityRepository <PaymentType>(context);
            var paymentTypesService   = this.GetPaymentTypesService(paymentTypeRepository);
            var seeder = new PaymentTypesServiceTestsSeeder();
            await seeder.SeedPaymentTypesAsync(context);

            // Act
            var actualResult   = paymentTypesService.GetAllPaymentTypes <DetailsPaymentTypeViewModel>().ToList();
            var expectedResult = new DetailsPaymentTypeViewModel[]
            {
                new DetailsPaymentTypeViewModel
                {
                    Id   = paymentTypeRepository.All().First().Id,
                    Name = paymentTypeRepository.All().First().Name,
                },
            };

            Assert.True(expectedResult[0].Id == actualResult[0].Id, errorMessagePrefix + " " + "Id is not returned properly.");
            Assert.True(expectedResult[0].Name == actualResult[0].Name, errorMessagePrefix + " " + "Name is not returned properly.");
        }
Example #3
0
        public async Task GetPaymentTypeByNamec_WithExistentName_ShouldReturnCorrectResult()
        {
            var errorMessagePrefix = "PaymentTypesService GetPaymentTypeByName() method does not work properly.";

            // Arrange
            MapperInitializer.InitializeMapper();
            var context = HotelDbContextInMemoryFactory.InitializeContext();
            var paymentTypeRepository = new EfDeletableEntityRepository <PaymentType>(context);
            var paymentTypesService   = this.GetPaymentTypesService(paymentTypeRepository);
            var seeder = new PaymentTypesServiceTestsSeeder();
            await seeder.SeedPaymentTypeAsync(context);

            var paymentTypeName = paymentTypeRepository.All().First().Name;

            // Act
            var actualResult = await paymentTypesService.GetPaymentTypeByNameAsync(paymentTypeName);

            var expectedResult = await paymentTypeRepository
                                 .All()
                                 .SingleOrDefaultAsync(x => x.Name == paymentTypeName);

            // 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.");
        }
Example #4
0
        public async Task EditAsync_WithIncorrectProperty_ShouldThrowArgumentNullException()
        {
            // Arrange
            MapperInitializer.InitializeMapper();
            var context = HotelDbContextInMemoryFactory.InitializeContext();
            var paymentTypeRepository = new EfDeletableEntityRepository <PaymentType>(context);
            var paymentTypesService   = this.GetPaymentTypesService(paymentTypeRepository);
            var seeder = new PaymentTypesServiceTestsSeeder();
            await seeder.SeedPaymentTypeAsync(context);

            var paymentType = context.PaymentTypes.First();

            var model = new EditPaymentTypeViewModel
            {
                Id   = paymentType.Id,
                Name = null,
            };

            // Act

            // Assert
            await Assert.ThrowsAsync <ArgumentNullException>(async() =>
            {
                await paymentTypesService.EditAsync(model);
            });
        }
Example #5
0
        public async Task CreateAllAsync_ShouldShouldSuccessfullyCreate()
        {
            var errorMessagePrefix = "PaymentTypesService CreateAllAsync() method does not work properly.";

            // Arrange
            MapperInitializer.InitializeMapper();
            var context = HotelDbContextInMemoryFactory.InitializeContext();
            var paymentTypeRepository = new EfDeletableEntityRepository <PaymentType>(context);
            var paymentTypesService   = this.GetPaymentTypesService(paymentTypeRepository);
            var seeder = new PaymentTypesServiceTestsSeeder();
            await seeder.SeedPaymentTypesAsync(context);

            // Act
            var result = await paymentTypesService.CreateAllAsync(new string[] { "Test-1", "Test-2", "Test-3" });

            // Assert
            Assert.True(result, errorMessagePrefix + " " + "Returns false.");
        }
Example #6
0
        public async Task GetAllPaymentTypesCountAsync_ShouldReturnCorrectResult()
        {
            var errorMessage = "PaymentTypesService GetAllPaymentTypesCountAsync() method does not work properly.";

            // Arrange
            MapperInitializer.InitializeMapper();
            var context = HotelDbContextInMemoryFactory.InitializeContext();
            var paymentTypeRepository = new EfDeletableEntityRepository <PaymentType>(context);
            var paymentTypesService   = this.GetPaymentTypesService(paymentTypeRepository);
            var seeder = new PaymentTypesServiceTestsSeeder();
            await seeder.SeedPaymentTypesAsync(context);

            // Act
            var actualResult = await paymentTypesService.GetAllPaymentTypesCountAsync();

            var expectedResult = paymentTypeRepository.All().Count();

            // Assert
            Assert.True(actualResult == expectedResult, errorMessage + " " + "PaymentTypesService GetAllRoomTypesCountAsync() method does not work properly.");
        }
Example #7
0
        public async Task DeleteByIdAsync_WithExistentId_ShouldReturnCorrectResult()
        {
            var errorMessage = "PaymentTypeService DeleteByIdAsync() method does not work properly.";

            // Arrange
            MapperInitializer.InitializeMapper();
            var context = HotelDbContextInMemoryFactory.InitializeContext();
            var paymentTypeRepository = new EfDeletableEntityRepository <PaymentType>(context);
            var paymentTypesService   = this.GetPaymentTypesService(paymentTypeRepository);
            var seeder = new PaymentTypesServiceTestsSeeder();
            await seeder.SeedPaymentTypesAsync(context);

            var paymentTypeId = paymentTypeRepository.All().First().Id;

            // Act
            var result = await paymentTypesService.DeleteByIdAsync(paymentTypeId);

            // Assert
            Assert.True(result, errorMessage + " " + "Returns false.");
        }
Example #8
0
        public async Task CreateAllAsync_ShouldReturnCorrectResult()
        {
            var errorMessage = "PaymentTypesService CreateAllAsync() method does not work properly.";

            // Arrange
            MapperInitializer.InitializeMapper();
            var context = HotelDbContextInMemoryFactory.InitializeContext();
            var paymentTypeRepository = new EfDeletableEntityRepository <PaymentType>(context);
            var paymentTypesService   = this.GetPaymentTypesService(paymentTypeRepository);
            var seeder = new PaymentTypesServiceTestsSeeder();
            await seeder.SeedPaymentTypeAsync(context);

            // Act
            await paymentTypesService.CreateAllAsync(new string[] { "Test-1" });

            var actualResult = new RoomType {
                Name = "Test-1"
            };
            var expectedResult = paymentTypeRepository.All().First();

            // Assert
            Assert.True(expectedResult.Name == actualResult.Name, errorMessage + " " + "Name is not returned properly.");
        }
Example #9
0
        public async Task GetAllPaymentTypesAsyn_ShouldReturnCorrectCount()
        {
            // Arrange
            MapperInitializer.InitializeMapper();
            var context = HotelDbContextInMemoryFactory.InitializeContext();
            var paymentTypeRepository = new EfDeletableEntityRepository <PaymentType>(context);
            var paymentTypesService   = this.GetPaymentTypesService(paymentTypeRepository);
            var seeder = new PaymentTypesServiceTestsSeeder();
            await seeder.SeedPaymentTypeAsync(context);

            // Act
            var actualResult   = paymentTypesService.GetAllPaymentTypes <DetailsPaymentTypeViewModel>().ToList();
            var expectedResult = new DetailsPaymentTypeViewModel[]
            {
                new DetailsPaymentTypeViewModel
                {
                    Id   = paymentTypeRepository.All().First().Id,
                    Name = paymentTypeRepository.All().First().Name,
                },
            };

            Assert.Equal(expectedResult.Length, actualResult.Count());
        }
Example #10
0
        public async Task DeleteByIdAsync_WithExistentId_ShouldSuccessfullyDelete()
        {
            var errorMessagePrefix = "PaymentTypesService DeleteByIdAsync() method does not work properly.";

            // Arrange
            MapperInitializer.InitializeMapper();
            var context = HotelDbContextInMemoryFactory.InitializeContext();
            var paymentTypeRepository = new EfDeletableEntityRepository <PaymentType>(context);
            var paymentTypesService   = this.GetPaymentTypesService(paymentTypeRepository);
            var seeder = new PaymentTypesServiceTestsSeeder();
            await seeder.SeedPaymentTypesAsync(context);

            var paymentTypeId = paymentTypeRepository.All().First().Id;

            // Act
            var paymentTypesCount = paymentTypeRepository.All().Count();
            await paymentTypesService.DeleteByIdAsync(paymentTypeId);

            var actualResult   = paymentTypeRepository.All().Count();
            var expectedResult = paymentTypesCount - 1;

            // Assert
            Assert.True(actualResult == expectedResult, errorMessagePrefix + " " + "Payment types count is not reduced.");
        }