Example #1
0
        public void RequestingAnInexistantSeatType_Throws()
        {
            // Arrange
            var sut = new SeatsAvailability(_reservationId);

            // Act & Assert
            Assert.Throws <ArgumentOutOfRangeException>(() =>
                                                        sut.MakeReservation(_reservationId, new[] { new SeatQuantity(Guid.NewGuid(), 7) }));
        }
Example #2
0
        public void AddSeats_ForNonExistingSeatType_ChangesSeatsAvailability()
        {
            // Arrange
            var sut = new SeatsAvailability(_reservationId);

            // Act
            sut.AddSeats(_seatTypeId, AvailableSeats);

            // Assert
            Assert.Equal(_seatTypeId, ((AvailableSeatsChanged)sut.Events.Single()).Seats.ElementAt(0).SeatType);
            Assert.Equal(AvailableSeats, ((AvailableSeatsChanged)sut.Events.Single()).Seats.ElementAt(0).Quantity);
        }
Example #3
0
        public void CancelReservation_ForNonExistingReservation_DoNothing()
        {
            // Arrange
            var sut = new SeatsAvailability(_reservationId);

            // Act
            sut.AddSeats(_seatTypeId, AvailableSeats);
            sut.MakeReservation(_reservationId, new[] { new SeatQuantity(_seatTypeId, 4) });
            sut.CancelReservation(Guid.NewGuid());

            // Assert
            Assert.DoesNotContain(sut.Events, e => (e is SeatsReservationCancelled));
        }
Example #4
0
        public void CommittingNonExistingReservation_DoNothing()
        {
            // Arrange
            var sut = new SeatsAvailability(_reservationId);

            // Act
            sut.AddSeats(_seatTypeId, AvailableSeats);
            sut.MakeReservation(_reservationId, new[] { new SeatQuantity(_seatTypeId, 3) });
            sut.CommitReservation(Guid.NewGuid());

            // Assert
            Assert.DoesNotContain(sut.Events, e => e.GetType() == typeof(SeatsReservationCommitted));
        }
Example #5
0
        public void CanCommitReservation()
        {
            // Arrange
            var sut = new SeatsAvailability(_reservationId);

            // Act
            sut.AddSeats(_seatTypeId, AvailableSeats);
            sut.MakeReservation(_reservationId, new[] { new SeatQuantity(_seatTypeId, 3) });
            sut.CommitReservation(_reservationId);

            // Assert
            Assert.Equal(_reservationId, ((SeatsReservationCommitted)sut.Events.LastOrDefault()).ReservationId);
        }
Example #6
0
        public void RemoveSeats_ForNonExistingSeatType_DoNothing()
        {
            // Arrange
            var unknownSeatType = Guid.NewGuid();
            var sut             = new SeatsAvailability(_reservationId);

            // Act
            sut.AddSeats(_seatTypeId, AvailableSeats);
            sut.RemoveSeats(unknownSeatType, 5);

            // Assert
            Assert.DoesNotContain(sut.Events,
                                  @event => (@event is AvailableSeatsChanged e && e.Seats.ElementAt(0).SeatType == unknownSeatType));
        }
Example #7
0
        public void RemoveSeats_ForExistingSeatType_ChangesSeatsAvailability()
        {
            // Arrange
            var quantity = 5;
            var sut      = new SeatsAvailability(_reservationId);

            // Act
            sut.AddSeats(_seatTypeId, AvailableSeats);
            sut.RemoveSeats(_seatTypeId, quantity);

            // Assert
            Assert.Equal(_seatTypeId, ((AvailableSeatsChanged)sut.Events.LastOrDefault()).Seats.ElementAt(0).SeatType);
            Assert.Equal(-quantity, ((AvailableSeatsChanged)sut.Events.LastOrDefault()).Seats.ElementAt(0).Quantity);
        }
Example #8
0
        public void RequestingMoreSeatsThanTotal_ReducesAllAvailableSeats()
        {
            // Arrange
            var wantedSeats = 12;
            var sut         = new SeatsAvailability(_reservationId);

            // Act
            sut.AddSeats(_seatTypeId, AvailableSeats);
            sut.MakeReservation(_reservationId, new[] { new SeatQuantity(_seatTypeId, wantedSeats) });

            // Assert
            Assert.Equal(_seatTypeId, ((SeatsReserved)sut.Events.LastOrDefault()).AvailableSeatsChanged.ElementAt(0).SeatType);
            Assert.Equal((-1) * AvailableSeats, ((SeatsReserved)sut.Events.LastOrDefault()).AvailableSeatsChanged.ElementAt(0).Quantity);
        }
Example #9
0
        public void UpdateReservationWithMoreSeatsThanRemaining_DecreasesAllAvailableSeats()
        {
            // Arrange
            var seatsChanged = -6;
            var sut          = new SeatsAvailability(_reservationId);

            // Act
            sut.AddSeats(_seatTypeId, AvailableSeats);
            sut.MakeReservation(_reservationId, new[] { new SeatQuantity(_seatTypeId, 4) });
            sut.MakeReservation(_reservationId, new[] { new SeatQuantity(_seatTypeId, 12) });

            // Assert
            Assert.Equal(_reservationId, ((SeatsReserved)sut.Events.LastOrDefault()).ReservationId);
            Assert.Equal(seatsChanged, ((SeatsReserved)sut.Events.LastOrDefault()).AvailableSeatsChanged.Single().Quantity);
        }
Example #10
0
        public void CancelReservationChangesSeatsAvailability()
        {
            // Arrange
            var wantedSeats = 5;
            var sut         = new SeatsAvailability(_reservationId);

            // Act
            sut.AddSeats(_seatTypeId, AvailableSeats);
            sut.MakeReservation(_reservationId, new[] { new SeatQuantity(_seatTypeId, wantedSeats) });
            sut.CancelReservation(_reservationId);

            // Assert
            Assert.Equal(_reservationId, ((SeatsReservationCancelled)sut.Events.LastOrDefault()).ReservationId);
            Assert.Equal(_seatTypeId, ((SeatsReservationCancelled)sut.Events.LastOrDefault()).AvailableSeatsChanged.ElementAt(0).SeatType);
            Assert.Equal(wantedSeats, ((SeatsReservationCancelled)sut.Events.LastOrDefault()).AvailableSeatsChanged.ElementAt(0).Quantity);
        }