public async Task ReservationService_CreateAsync_Conflicting_Reservation()
        {
            // Arrange
            var reservation = new InputModels.Reservation
            {
                AccountId          = Guid.NewGuid(),
                FirstName          = "Test",
                LastName           = "User",
                Notes              = "Test Note",
                ReservationTimeUtc = DateTime.UtcNow,
                RestaurantName     = "Test Restaurant",
                TotalPatrons       = 8
            };

            this._reservationProvider
            .Setup(x => x.GetWithinRange(reservation.AccountId, reservation.ReservationTimeUtc))
            .ReturnsAsync(new Collection <Reservation>()
            {
                new Reservation(Guid.NewGuid())
            });

            var reservationService = new ReservationService(this._reservationProvider.Object);

            // Act
            var result = await reservationService.CreateAsync(reservation);

            // Assert
            Assert.Fail("Expected exception was not thrown");
        }
        public async Task ReservationService_CreateAsync_Valid()
        {
            // Arrange
            var reservation = new InputModels.Reservation
            {
                AccountId          = Guid.NewGuid(),
                FirstName          = "Test",
                LastName           = "User",
                Notes              = "Test Note",
                ReservationTimeUtc = DateTime.UtcNow,
                RestaurantName     = "Test Restaurant",
                TotalPatrons       = 8
            };

            this._reservationProvider
            .Setup(x => x.GetWithinRange(reservation.AccountId, reservation.ReservationTimeUtc))
            .ReturnsAsync(new Collection <Reservation>());

            var reservationService = new ReservationService(this._reservationProvider.Object);

            // Act
            var result = await reservationService.CreateAsync(reservation);

            Assert.IsNotNull(result);
            Assert.AreEqual(reservation.AccountId, result.AccountId);
            Assert.AreEqual(reservation.FirstName, result.FirstName);
            Assert.AreEqual(reservation.LastName, result.LastName);
            Assert.AreEqual(reservation.Notes, result.Notes);
            Assert.AreEqual(reservation.ReservationTimeUtc, result.ReservationTimeUtc);
            Assert.AreEqual(reservation.RestaurantName, result.RestaurantName);
            Assert.AreEqual(reservation.TotalPatrons, result.TotalPatrons);
        }
        public async Task <Reservation> CreateAsync(InputModels.Reservation reservation)
        {
            // Confirm we have a reservation
            if (reservation == null)
            {
                throw new ArgumentNullException();
            }

            // Confirm this is not within 4 hours of another reservation
            var conflictingReservations = await this._reservationProvider.GetWithinRange(reservation.AccountId, reservation.ReservationTimeUtc);

            if (conflictingReservations.Count > 0)
            {
                throw new Exception("Existing reservation conflicts with this reservation.");
            }

            var newReservation = new Reservation(Guid.NewGuid())
            {
                AccountId          = reservation.AccountId,
                FirstName          = reservation.FirstName,
                LastName           = reservation.LastName,
                Notes              = reservation.Notes,
                ReservationTimeUtc = reservation.ReservationTimeUtc,
                RestaurantName     = reservation.RestaurantName,
                TotalPatrons       = reservation.TotalPatrons
            };

            await this._reservationProvider.CreateAsync(newReservation);

            return(newReservation);
        }