Exemplo n.º 1
0
        public void ShouldReturnInvoicePositionFromMinuteService()
        {
            //Arrange
            var minuteServiceToReservation = new MinuteServiceToReservation()
            {
                MinuteService = new MinuteService()
                {
                    Name = "Cycling"
                },
                Cost     = 120,
                Duration = 60
            };
            var converter = new InvoicePositionConverter();

            //Act
            var actualInvoicePosition   = converter.MinuteServiceToGetInvoicePositionDto(minuteServiceToReservation);
            var expectedInvoicePosition = new GetInvoicePositionDto()
            {
                Name        = "Cycling / 60 minutes",
                PriceBrutto = 120,
                VatRate     = 23,
                PriceNetto  = 92.40M,
                Amount      = 1,
                VatValue    = 27.60M
            };

            //Assert
            actualInvoicePosition.Should().BeEquivalentTo(expectedInvoicePosition);
        }
 public GetMinuteServiceToReservationDto MinuteServiceToReservationToGetMinuteServiceToReservationDto(
     MinuteServiceToReservation minuteServiceToReservation)
 {
     return(new GetMinuteServiceToReservationDto()
     {
         ReservationId = minuteServiceToReservation.ReservationId,
         MinuteServiceId = minuteServiceToReservation.MinuteServiceId,
         Duration = minuteServiceToReservation.Duration,
         Cost = minuteServiceToReservation.Cost
     });
 }
        public async Task <int> AddAsync(MinuteServiceToReservation minuteServiceToReservation)
        {
            if (minuteServiceToReservation.MinuteServiceId == 0)
            {
                return(minuteServiceToReservation.ReservationId);
            }
            var minuteService = await _minuteServiceRepository.GetAsync(minuteServiceToReservation.MinuteServiceId);

            minuteServiceToReservation.Cost = minuteServiceToReservation.Duration * minuteService.PricePerMinute;

            await _db.MinuteServicesToReservation.AddAsync(minuteServiceToReservation);

            await _db.SaveChangesAsync();

            return(minuteServiceToReservation.MinuteServiceId);
        }
        public GetInvoicePositionDto MinuteServiceToGetInvoicePositionDto(MinuteServiceToReservation minuteServiceToReservation)
        {
            var name        = $"{minuteServiceToReservation.MinuteService.Name} / {minuteServiceToReservation.Duration} minutes";
            var priceBrutto = minuteServiceToReservation.Cost;
            var priceNetto  = priceBrutto * 0.77M;
            var vatValue    = priceBrutto - priceNetto;

            return(new GetInvoicePositionDto()
            {
                Name = name,
                PriceBrutto = priceBrutto,
                PriceNetto = priceNetto,
                VatRate = 23,
                Amount = 1,
                VatValue = vatValue
            });
        }
Exemplo n.º 5
0
        public async Task ShouldAssignNothingAndReturnReservationId()
        {
            //Arrange
            var context    = new iReceptionDbContext(DbOptions);
            var repository = new MinuteServiceToReservationRepository(context, null);
            var convertedMinuteServiceToReservation = new MinuteServiceToReservation
            {
                ReservationId   = 1,
                MinuteServiceId = 0,
                Duration        = 30
            };

            //Act
            var actual = await repository.AddAsync(convertedMinuteServiceToReservation);

            var expected = convertedMinuteServiceToReservation.ReservationId;

            //Assert
            Assert.Equal(expected, actual);
        }
Exemplo n.º 6
0
        public async Task ShouldRemoveGivenConnection()
        {
            //Arrange
            var context            = new iReceptionDbContext(DbOptions);
            var repository         = new MinuteServiceToReservationRepository(context, null);
            var connectionToDelete = new MinuteServiceToReservation
            {
                ReservationId   = 1,
                MinuteServiceId = 2
            };
            await context.MinuteServicesToReservation.AddAsync(connectionToDelete);

            await context.SaveChangesAsync();

            //Act
            var actual = await repository.DeleteAsync(connectionToDelete.ReservationId,
                                                      connectionToDelete.MinuteServiceId);

            var expected = connectionToDelete.MinuteServiceId;

            //Assert
            Assert.Equal(expected, actual);
        }
Exemplo n.º 7
0
        public async Task ShouldAssignServiceToReservation()
        {
            //Arrange
            var context = new iReceptionDbContext(DbOptions);
            var returnedMinuteService = new MinuteService
            {
                Id             = 1,
                PricePerMinute = 10
            };
            var msRepository = new Mock <IMinuteServiceRepository>();

            msRepository
            .Setup(r => r.GetAsync(It.IsAny <int>()))
            .ReturnsAsync(returnedMinuteService);
            var repository = new MinuteServiceToReservationRepository(context, msRepository.Object);


            var convertedMinuteServiceToReservation = new MinuteServiceToReservation
            {
                ReservationId   = 1,
                MinuteServiceId = 12,
                Duration        = 30
            };

            //Act
            var actual = await repository.AddAsync(convertedMinuteServiceToReservation);

            var expected   = convertedMinuteServiceToReservation.MinuteServiceId;
            var actualCost = (await context.MinuteServicesToReservation.FirstAsync(
                                  mstr => mstr.MinuteServiceId == 12)).Cost;
            var expectedCost = convertedMinuteServiceToReservation.Duration * returnedMinuteService.PricePerMinute;

            //Assert
            Assert.Equal(expected, actual);
            Assert.Equal(expectedCost, actualCost);
        }