public void TestInitialize()
        {
            _seat = new Seat
            {
                Id           = Guid.NewGuid(),
                AuditoriumId = 1,
                Row          = 2,
                Number       = 2
            };

            _seatDomainModel = new SeatDomainModel
            {
                Id           = _seat.Id,
                AuditoriumId = 1,
                Row          = 2,
                Number       = 2
            };

            _reservationDomainModel = new ReservationDomainModel
            {
                ProjectionId = Guid.NewGuid(),
                SeatId       = _seat.Id,
                UserId       = Guid.NewGuid()
            };

            _numberOfSeatsModel = new NumberOfSeatsModel
            {
                MaxNumber = 2,
                MaxRow    = 2
            };


            List <Seat> seatsModelsList = new List <Seat>();

            seatsModelsList.Add(_seat);
            IEnumerable <Seat>         seats        = seatsModelsList;
            Task <IEnumerable <Seat> > responseTask = Task.FromResult(seats);

            _mockSeatsRepository = new Mock <ISeatsRepository>();

            List <ReservationDomainModel> reservationDomainModelsList = new List <ReservationDomainModel>();

            reservationDomainModelsList.Add(_reservationDomainModel);
            IEnumerable <ReservationDomainModel>         reservations            = reservationDomainModelsList;
            Task <IEnumerable <ReservationDomainModel> > reservationResponseTask = Task.FromResult(reservations);

            _mockReservationService = new Mock <IReservationService>();
        }
Beispiel #2
0
        public async Task <NumberOfSeatsModel> GetNumberOfSeats(int id)
        {
            var data = _seatsRepository.GetMaxValuesByAuditoriumId(id);

            if (data == null)
            {
                return(null);
            }

            NumberOfSeatsModel domainModel = new NumberOfSeatsModel
            {
                MaxNumber = data[0],
                MaxRow    = data[1]
            };

            return(domainModel);
        }
        public void SeatsController_GetNumberOfSeats_SeatServiceReturnsNull_404()
        {
            //Arrange
            NumberOfSeatsModel        nullNum         = null;
            Task <NumberOfSeatsModel> numberOfSeats   = Task.FromResult(nullNum);
            SeatsController           seatsController = new SeatsController(_mockSeatService.Object);
            int    expectedStatusCode = 404;
            string expectedMessage    = Messages.AUDITORIUM_DOES_NOT_EXIST;

            _mockSeatService.Setup(x => x.GetNumberOfSeats(It.IsAny <int>())).Returns(numberOfSeats);

            //Act
            var result          = seatsController.GetNumberOfSeats(_seatDomainModel.AuditoriumId).ConfigureAwait(false).GetAwaiter().GetResult().Result;
            var resultResponse  = ((NotFoundObjectResult)result);
            var badObjectResult = ((NotFoundObjectResult)result).Value;

            //Assert
            Assert.IsNotNull(resultResponse);
            Assert.AreEqual(expectedMessage, badObjectResult);
            Assert.IsInstanceOfType(result, typeof(NotFoundObjectResult));
            Assert.AreEqual(expectedStatusCode, resultResponse.StatusCode);
        }
        public void TestIni()
        {
            _seatDomainModel = new SeatDomainModel
            {
                Id           = Guid.NewGuid(),
                AuditoriumId = 1,
                Number       = 1,
                Row          = 1
            };

            _numberOfSeats = new NumberOfSeatsModel
            {
                MaxNumber = 1,
                MaxRow    = 1
            };

            List <SeatDomainModel> seatList = new List <SeatDomainModel>();

            seatList.Add(_seatDomainModel);
            IEnumerable <SeatDomainModel>         seats        = seatList;
            Task <IEnumerable <SeatDomainModel> > responseTask = Task.FromResult(seats);

            _mockSeatService = new Mock <ISeatService>();
        }