Пример #1
0
        public void SpecifyNewRoute_04()
        {
            // arrange:
            TrackingId          id             = new TrackingId("CRG01");
            IRouteSpecification specification  = MockRepository.GenerateStrictMock <IRouteSpecification>();
            IRouteSpecification specification2 = MockRepository.GenerateStrictMock <IRouteSpecification>();

            specification.Expect(s => s.Equals(specification2)).Return(false).Repeat.Any();
            specification2.Expect(s => s.Equals(specification)).Return(false).Repeat.Any();
            IItinerary itinerary = MockRepository.GenerateStrictMock <IItinerary>();

            itinerary.Expect(i => i.Equals(null)).Return(false);
            itinerary.Expect(i => i.FinalArrivalDate).Return(DateTime.UtcNow + TimeSpan.FromDays(1)).Repeat.Any();
            specification.Expect(s => s.IsSatisfiedBy(itinerary)).Return(true).Repeat.Once();
            specification2.Expect(s => s.IsSatisfiedBy(itinerary)).Return(false).Repeat.Once();
            CargoState state = new NewCargo(id, specification);

            state = state.AssignToRoute(itinerary);

            // act:
            CargoState newState = state.SpecifyNewRoute(specification2);

            // assert:
            Assert.IsNotNull(newState);
            Assert.AreNotSame(state, newState);
            Assert.IsFalse(state.Equals(newState));
            Assert.IsFalse(newState.Equals(state));
            Assert.AreEqual(RoutingStatus.Misrouted, newState.RoutingStatus);
            Assert.AreSame(specification2, newState.RouteSpecification);
            Assert.IsTrue(state.CalculationDate <= newState.CalculationDate);
            specification.VerifyAllExpectations();
            specification2.VerifyAllExpectations();
            itinerary.VerifyAllExpectations();
        }
Пример #2
0
        public void Recieve_04()
        {
            // arrange:
            TrackingId id        = new TrackingId("CRG01");
            IItinerary itinerary = MockRepository.GenerateStrictMock <IItinerary>();

            itinerary.Expect(i => i.Equals(null)).Return(false).Repeat.Any();
            itinerary.Expect(i => i.FinalArrivalDate).Return(DateTime.UtcNow + TimeSpan.FromDays(1)).Repeat.Any();
            IRouteSpecification specification = MockRepository.GenerateStrictMock <IRouteSpecification>();

            specification.Expect(s => s.IsSatisfiedBy(itinerary)).Return(true).Repeat.AtLeastOnce();
            IRouteSpecification specification2 = MockRepository.GenerateStrictMock <IRouteSpecification>();

            specification2.Expect(s => s.IsSatisfiedBy(itinerary)).Return(false).Repeat.AtLeastOnce();
            specification.Expect(s => s.Equals(specification2)).Return(false).Repeat.Any();
            specification2.Expect(s => s.Equals(specification)).Return(false).Repeat.Any();
            ILocation  location       = MockRepository.GenerateMock <ILocation>();
            CargoState initialState   = new NewCargo(id, specification);
            CargoState routedState    = initialState.AssignToRoute(itinerary);
            CargoState misroutedState = routedState.SpecifyNewRoute(specification2);

            // assert:
            Assert.AreEqual(initialState.GetType(), routedState.GetType());
            Assert.AreNotSame(initialState, routedState);
            Assert.AreEqual(routedState.GetType(), misroutedState.GetType());
            Assert.AreNotSame(routedState, misroutedState);
            Assert.IsTrue(RoutingStatus.Misrouted == misroutedState.RoutingStatus);
            Assert.Throws <InvalidOperationException>(delegate { misroutedState.Recieve(location, DateTime.UtcNow); });
            location.VerifyAllExpectations();
            specification.VerifyAllExpectations();
            specification2.VerifyAllExpectations();
            itinerary.VerifyAllExpectations();
        }
Пример #3
0
        public void Equals_onDifferentVoyage_isFalse_02()
        {
            // arrange:
            DateTime   arrivalDate = DateTime.Now + TimeSpan.FromDays(30);
            TrackingId identifier  = new TrackingId("CARGO01");
            IItinerary itinerary   = MockRepository.GenerateStrictMock <IItinerary>();

            itinerary.Expect(i => i.Equals(null)).Return(false).Repeat.Any();
            itinerary.Expect(i => i.FinalArrivalDate).Return(arrivalDate).Repeat.Any();
            itinerary.Expect(i => i.Equals(itinerary)).Return(true).Repeat.Any();
            IRouteSpecification route = MockRepository.GenerateStrictMock <IRouteSpecification>();

            route.Expect(s => s.Equals(route)).Return(true).Repeat.Any();
            route.Expect(s => s.IsSatisfiedBy(itinerary)).Return(true).Repeat.Any();
            FakeState state1 = new FakeState(identifier, route);

            state1 = new FakeState(state1, itinerary);
            state1._currentVoyage = null;
            FakeState state2 = new FakeState2(identifier, route);

            state2 = new FakeState(state2, itinerary);

            // act:

            // assert:
            Assert.IsFalse(state1.Equals(state2));
        }
Пример #4
0
        public void Equals_withDifferentItineraries_isFalse()
        {
            // arrange:
            DateTime   arrivalDate = DateTime.Now + TimeSpan.FromDays(30);
            TrackingId identifier  = new TrackingId("CARGO01");
            IItinerary itinerary   = MockRepository.GenerateStrictMock <IItinerary>();

            itinerary.Expect(i => i.Equals(null)).Return(false).Repeat.Any();
            itinerary.Expect(i => i.FinalArrivalDate).Return(arrivalDate).Repeat.Any();
            IRouteSpecification route = MockRepository.GenerateStrictMock <IRouteSpecification>();

            route.Expect(s => s.Equals(route)).Return(true).Repeat.Any();
            route.Expect(s => s.IsSatisfiedBy(itinerary)).Return(true).Repeat.Any();
            FakeState state1 = new FakeState(identifier, route);

            state1 = new FakeState(state1, itinerary);
            state1._lastKnownLocation = new Challenge00.DDDSample.Location.UnLocode("TESTA");
            FakeState state2 = new FakeState2(identifier, route);

            state2._lastKnownLocation = new Challenge00.DDDSample.Location.UnLocode("TESTA");

            // act:

            // assert:
            Assert.IsFalse(state1.Equals(state2));
        }
Пример #5
0
        public void Recieve_01()
        {
            // arrange:
            TrackingId          id            = new TrackingId("CRG01");
            UnLocode            code          = new UnLocode("START");
            IRouteSpecification specification = MockRepository.GenerateStrictMock <IRouteSpecification>();
            ILocation           location      = MockRepository.GenerateMock <ILocation>();

            location.Expect(l => l.UnLocode).Return(code).Repeat.AtLeastOnce();
            IItinerary itinerary = MockRepository.GenerateStrictMock <IItinerary>();

            itinerary.Expect(i => i.InitialDepartureLocation).Return(code).Repeat.AtLeastOnce();
            itinerary.Expect(i => i.Equals(null)).Return(false).Repeat.Any();
            itinerary.Expect(i => i.FinalArrivalDate).Return(DateTime.UtcNow + TimeSpan.FromDays(1)).Repeat.Any();
            specification.Expect(s => s.IsSatisfiedBy(itinerary)).Return(true).Repeat.Once();
            CargoState state = new NewCargo(id, specification);

            state = state.AssignToRoute(itinerary);

            // act:
            CargoState newState = state.Recieve(location, DateTime.UtcNow);

            // assert:
            Assert.IsNotNull(newState);
            Assert.IsInstanceOf <InPortCargo>(newState);
            Assert.AreSame(code, newState.LastKnownLocation);
            Assert.IsTrue(newState.EstimatedTimeOfArrival.HasValue);
            Assert.IsTrue(TransportStatus.InPort == newState.TransportStatus);
            location.VerifyAllExpectations();
            itinerary.VerifyAllExpectations();
            specification.VerifyAllExpectations();
        }
Пример #6
0
        public void AssignToRoute_03()
        {
            // arrange:
            TrackingId id            = new TrackingId("CRG01");
            IItinerary itinerary     = MockRepository.GenerateStrictMock <IItinerary>();
            DateTime   finalArrival1 = DateTime.Now + TimeSpan.FromDays(30);

            itinerary.Expect(i => i.Equals(null)).Return(false).Repeat.AtLeastOnce();
            itinerary.Expect(i => i.FinalArrivalDate).Return(finalArrival1).Repeat.AtLeastOnce();
            IItinerary itinerary2 = MockRepository.GenerateStrictMock <IItinerary>();

            itinerary2.Expect(i => i.Equals(itinerary)).Return(true).Repeat.AtLeastOnce();
            IRouteSpecification specification = MockRepository.GenerateStrictMock <IRouteSpecification>();

            specification.Expect(s => s.IsSatisfiedBy(itinerary)).Return(true).Repeat.Once();
            CargoState initialState = new NewCargo(id, specification);
            CargoState state        = initialState.AssignToRoute(itinerary);

            // act:
            CargoState newState = state.AssignToRoute(itinerary2);

            // assert:
            Assert.AreEqual(finalArrival1, newState.EstimatedTimeOfArrival);
            Assert.AreEqual(initialState.GetType(), state.GetType());
            Assert.AreNotSame(initialState, state);
            Assert.IsNotNull(newState);
            Assert.AreSame(state, newState);
        }
Пример #7
0
        public void Recieve_02()
        {
            // arrange:
            TrackingId          id            = new TrackingId("CRG01");
            UnLocode            start         = new UnLocode("START");
            UnLocode            other         = new UnLocode("OTHER");
            IRouteSpecification specification = MockRepository.GenerateStrictMock <IRouteSpecification>();
            ILocation           location      = MockRepository.GenerateMock <ILocation>();

            location.Expect(l => l.UnLocode).Return(other).Repeat.AtLeastOnce();
            IItinerary itinerary = MockRepository.GenerateStrictMock <IItinerary>();

            itinerary.Expect(i => i.InitialDepartureLocation).Return(start).Repeat.AtLeastOnce();
            itinerary.Expect(i => i.Equals(null)).Return(false).Repeat.Any();
            itinerary.Expect(i => i.FinalArrivalDate).Return(DateTime.UtcNow + TimeSpan.FromDays(1)).Repeat.Any();
            specification.Expect(s => s.IsSatisfiedBy(itinerary)).Return(true).Repeat.Once();
            CargoState state = new NewCargo(id, specification);

            state = state.AssignToRoute(itinerary);

            // assert:
            Assert.Throws <ArgumentException>(delegate { state.Recieve(location, DateTime.UtcNow); });
            location.VerifyAllExpectations();
            itinerary.VerifyAllExpectations();
            specification.VerifyAllExpectations();
        }
Пример #8
0
        public void Ctor_02()
        {
            // arrange:
            GList      mocks     = new GList();
            TrackingId id        = new TrackingId("START");
            DateTime   loadTime  = DateTime.Now;
            IItinerary itinerary = MockRepository.GenerateStrictMock <IItinerary>();

            itinerary.Expect(i => i.Equals(null)).IgnoreArguments().Return(false).Repeat.Any();
            itinerary.Expect(i => i.FinalArrivalDate).Return(DateTime.UtcNow + TimeSpan.FromDays(1)).Repeat.Any();
            itinerary.Expect(i => i.FinalArrivalLocation).Return(new UnLocode("ENDLC")).Repeat.Any();
            mocks.Add(itinerary);
            IRouteSpecification specification = MockRepository.GenerateStrictMock <IRouteSpecification>();

            specification.Expect(s => s.IsSatisfiedBy(itinerary)).Return(true).Repeat.Any();
            CargoState previousState = MockRepository.GenerateStrictMock <CargoState>(id, specification);

            mocks.Add(previousState);
            previousState = MockRepository.GenerateStrictMock <CargoState>(previousState, itinerary);
            mocks.Add(previousState);

            // assert:
            Assert.Throws <ArgumentNullException>(delegate { new OnboardCarrierCargo(previousState, null, loadTime); });
            foreach (object mock in mocks)
            {
                mock.VerifyAllExpectations();
            }
        }
Пример #9
0
        public void Ctor_05()
        {
            // arrange:
            TrackingId id        = new TrackingId("CLAIM");
            IItinerary itinerary = MockRepository.GenerateStrictMock <IItinerary>();

            itinerary.Expect(i => i.FinalArrivalDate).Return(DateTime.UtcNow).Repeat.AtLeastOnce();
            IRouteSpecification specification = MockRepository.GenerateStrictMock <IRouteSpecification>();

            specification.Expect(s => s.IsSatisfiedBy(itinerary)).Return(true).Repeat.Any();
            CargoState previousState = MockRepository.GenerateStrictMock <CargoState>(id, specification);

            previousState = MockRepository.GenerateStrictMock <CargoState>(previousState, itinerary);
            previousState.Expect(s => s.IsUnloadedAtDestination).Return(false).Repeat.AtLeastOnce();
            previousState.Expect(s => s.TransportStatus).Return(TransportStatus.InPort).Repeat.AtLeastOnce();
            DateTime claimDate = DateTime.UtcNow;


            // act:
            Assert.Throws <ArgumentException>(delegate { new ClaimedCargo(previousState, claimDate); });

            // assert:
            itinerary.VerifyAllExpectations();
            specification.VerifyAllExpectations();
            previousState.VerifyAllExpectations();
        }
Пример #10
0
        public void Ctor_01()
        {
            // arrange:
            UnLocode   final     = new UnLocode("FINAL");
            TrackingId id        = new TrackingId("CLAIM");
            IItinerary itinerary = MockRepository.GenerateStrictMock <IItinerary>();

            itinerary.Expect(i => i.FinalArrivalDate).Return(DateTime.UtcNow).Repeat.AtLeastOnce();
            itinerary.Expect(i => i.FinalArrivalLocation).Return(final).Repeat.AtLeastOnce();
            IRouteSpecification specification = MockRepository.GenerateStrictMock <IRouteSpecification>();

            specification.Expect(s => s.IsSatisfiedBy(itinerary)).Return(true).Repeat.Any();
            CargoState previousState = MockRepository.GenerateStrictMock <CargoState>(id, specification);

            previousState = MockRepository.GenerateStrictMock <CargoState>(previousState, itinerary);
            previousState.Expect(s => s.IsUnloadedAtDestination).Return(true).Repeat.AtLeastOnce();
            previousState.Expect(s => s.TransportStatus).Return(TransportStatus.InPort).Repeat.AtLeastOnce();
            DateTime claimDate = DateTime.UtcNow;


            // act:
            ClaimedCargo state = new ClaimedCargo(previousState, claimDate);

            // assert:
            Assert.AreEqual(TransportStatus.Claimed, state.TransportStatus);
            Assert.AreEqual(RoutingStatus.Routed, state.RoutingStatus);
            Assert.AreSame(final, state.LastKnownLocation);
            Assert.AreSame(specification, state.RouteSpecification);
            Assert.IsNull(state.CurrentVoyage);
            Assert.IsTrue(state.IsUnloadedAtDestination);
            itinerary.VerifyAllExpectations();
            specification.VerifyAllExpectations();
            previousState.VerifyAllExpectations();
        }
Пример #11
0
        public void Unload_04()
        {
            // arrange:
            GList mocks = new GList();

            UnLocode     code         = new UnLocode("START");
            VoyageNumber voyageNumber = new VoyageNumber("ATEST");
            DateTime     arrival      = DateTime.UtcNow;
            TrackingId   id           = new TrackingId("CARGO01");
            IItinerary   itinerary    = MockRepository.GenerateStrictMock <IItinerary>();

            itinerary.Expect(i => i.Equals(null)).IgnoreArguments().Return(false).Repeat.Any();
            itinerary.Expect(i => i.FinalArrivalDate).Return(DateTime.UtcNow + TimeSpan.FromDays(1)).Repeat.Any();
            itinerary.Expect(i => i.FinalArrivalLocation).Return(code).Repeat.Any();
            mocks.Add(itinerary);
            IRouteSpecification specification = MockRepository.GenerateStrictMock <IRouteSpecification>();

            specification.Expect(s => s.IsSatisfiedBy(itinerary)).Return(true).Repeat.Any();
            mocks.Add(specification);
            IVoyage voyage = MockRepository.GenerateStrictMock <IVoyage>();

            voyage.Expect(v => v.Number).Return(voyageNumber).Repeat.Any();
            voyage.Expect(v => v.LastKnownLocation).Return(code).Repeat.AtLeastOnce();
            voyage.Expect(v => v.IsMoving).Return(false).Repeat.AtLeastOnce();
            mocks.Add(voyage);
            CargoState previousState = MockRepository.GenerateStrictMock <CargoState>(id, specification);

            mocks.Add(previousState);
            previousState = MockRepository.GenerateStrictMock <CargoState>(previousState, itinerary);
            mocks.Add(previousState);
            previousState.Expect(s => s.LastKnownLocation).Return(code).Repeat.Any();
            OnboardCarrierCargo state = new OnboardCarrierCargo(previousState, voyage, arrival);

            // act:
            CargoState newState = state.Unload(voyage, arrival + TimeSpan.FromDays(2));

            // assert:
            Assert.IsNotNull(newState);
            Assert.IsInstanceOf <InPortCargo>(newState);
            Assert.AreSame(code, newState.LastKnownLocation);
            foreach (object mock in mocks)
            {
                mock.VerifyAllExpectations();
            }
        }
Пример #12
0
        public void StateTransitions_01()
        {
            // arrange:
            UnLocode   final         = new UnLocode("FINAL");
            TrackingId id            = new TrackingId("CLAIM");
            ILocation  finalLocation = MockRepository.GenerateStrictMock <ILocation>();

            finalLocation.Expect(l => l.UnLocode).Return(final).Repeat.AtLeastOnce();
            ILocation otherLocation = MockRepository.GenerateStrictMock <ILocation>();

            otherLocation.Expect(l => l.UnLocode).Return(new UnLocode("OTHER")).Repeat.AtLeastOnce();
            IItinerary itinerary = MockRepository.GenerateStrictMock <IItinerary>();

            itinerary.Expect(i => i.FinalArrivalDate).Return(DateTime.UtcNow).Repeat.Any();
            itinerary.Expect(i => i.FinalArrivalLocation).Return(final).Repeat.Any();
            IRouteSpecification specification = MockRepository.GenerateStrictMock <IRouteSpecification>();

            specification.Expect(s => s.IsSatisfiedBy(itinerary)).Return(true).Repeat.Any();
            CargoState previousState = MockRepository.GenerateStrictMock <CargoState>(id, specification);

            previousState = MockRepository.GenerateStrictMock <CargoState>(previousState, itinerary);
            previousState.Expect(s => s.IsUnloadedAtDestination).Return(true).Repeat.Any();
            previousState.Expect(s => s.TransportStatus).Return(TransportStatus.InPort).Repeat.Any();
            IVoyage  voyage    = MockRepository.GenerateStrictMock <IVoyage>();
            DateTime claimDate = DateTime.UtcNow;

            ClaimedCargo state = new ClaimedCargo(previousState, claimDate);

            // act:
            CargoState newState = state.Claim(finalLocation, claimDate);

            // assert:
            Assert.AreSame(state, newState);
            Assert.Throws <ArgumentNullException>(delegate { state.Claim(null, DateTime.UtcNow); });
            Assert.Throws <InvalidOperationException>(delegate { state.Claim(finalLocation, DateTime.UtcNow + TimeSpan.FromSeconds(10)); });
            Assert.Throws <InvalidOperationException>(delegate { state.Claim(otherLocation, claimDate); });
            Assert.Throws <InvalidOperationException>(delegate { state.LoadOn(voyage, DateTime.UtcNow + TimeSpan.FromSeconds(10)); });
            Assert.Throws <InvalidOperationException>(delegate { state.Unload(voyage, DateTime.UtcNow + TimeSpan.FromSeconds(10)); });
            Assert.Throws <InvalidOperationException>(delegate { state.SpecifyNewRoute(MockRepository.GenerateStrictMock <IRouteSpecification>()); });
            Assert.Throws <InvalidOperationException>(delegate { state.AssignToRoute(MockRepository.GenerateStrictMock <IItinerary>()); });
            Assert.Throws <InvalidOperationException>(delegate { state.Recieve(MockRepository.GenerateStrictMock <ILocation>(), DateTime.UtcNow + TimeSpan.FromSeconds(10) + TimeSpan.FromSeconds(10)); });
            Assert.Throws <InvalidOperationException>(delegate { state.ClearCustoms(MockRepository.GenerateStrictMock <ILocation>(), DateTime.UtcNow + TimeSpan.FromSeconds(10)); });
            itinerary.VerifyAllExpectations();
            specification.VerifyAllExpectations();
        }
Пример #13
0
        public void LoadOn_02()
        {
            // arrange:
            GList mocks = new GList();

            UnLocode     code         = new UnLocode("START");
            VoyageNumber voyageNumber = new VoyageNumber("ATEST");
            DateTime     arrival      = DateTime.UtcNow;
            TrackingId   id           = new TrackingId("CARGO01");
            IItinerary   itinerary    = MockRepository.GenerateStrictMock <IItinerary>();

            itinerary.Expect(i => i.Equals(null)).IgnoreArguments().Return(false).Repeat.Any();
            itinerary.Expect(i => i.FinalArrivalDate).Return(DateTime.UtcNow + TimeSpan.FromDays(1)).Repeat.Any();
            itinerary.Expect(i => i.FinalArrivalLocation).Return(code).Repeat.Any();
            mocks.Add(itinerary);
            IRouteSpecification specification = MockRepository.GenerateStrictMock <IRouteSpecification>();

            specification.Expect(s => s.IsSatisfiedBy(itinerary)).Return(true).Repeat.Any();
            mocks.Add(specification);
            IVoyage voyage = MockRepository.GenerateStrictMock <IVoyage>();

            voyage.Expect(v => v.Number).Return(voyageNumber).Repeat.Any();
            voyage.Expect(v => v.LastKnownLocation).Return(code).Repeat.AtLeastOnce();
            mocks.Add(voyage);
            IVoyage voyage2 = MockRepository.GenerateStrictMock <IVoyage>();

            voyage2.Expect(v => v.Number).Return(new VoyageNumber("VYGOTHER")).Repeat.Any();
            mocks.Add(voyage2);
            CargoState previousState = MockRepository.GenerateStrictMock <CargoState>(id, specification);

            mocks.Add(previousState);
            previousState = MockRepository.GenerateStrictMock <CargoState>(previousState, itinerary);
            mocks.Add(previousState);
            previousState.Expect(s => s.LastKnownLocation).Return(code).Repeat.Any();
            OnboardCarrierCargo state = new OnboardCarrierCargo(previousState, voyage, arrival);

            // assert:
            Assert.Throws <InvalidOperationException>(delegate { state.LoadOn(voyage2, arrival + TimeSpan.FromDays(2)); });
            foreach (object mock in mocks)
            {
                mock.VerifyAllExpectations();
            }
        }
Пример #14
0
        public void AssignToRoute_02()
        {
            // arrange:
            TrackingId id        = new TrackingId("CRG01");
            IItinerary itinerary = MockRepository.GenerateStrictMock <IItinerary>();

            itinerary.Expect(i => i.Equals(null)).Return(false);
            IRouteSpecification specification = MockRepository.GenerateStrictMock <IRouteSpecification>();

            specification.Expect(s => s.IsSatisfiedBy(itinerary)).Return(false).Repeat.Once();
            NewCargo state = new NewCargo(id, specification);

            // act:
            Assert.Throws <ArgumentException>(delegate { state.AssignToRoute(itinerary); });

            // assert:
            itinerary.VerifyAllExpectations();
            specification.VerifyAllExpectations();
        }
Пример #15
0
        public void SpecifyNewRoute_02()
        {
            // arrange:
            TrackingId          id             = new TrackingId("CRG01");
            IRouteSpecification specification  = MockRepository.GenerateStrictMock <IRouteSpecification>();
            IRouteSpecification specification2 = MockRepository.GenerateStrictMock <IRouteSpecification>();

            specification.Expect(s => s.Equals(specification2)).Return(true).Repeat.Any();
            specification2.Expect(s => s.Equals(specification)).Return(true).Repeat.Any();
            NewCargo state = new NewCargo(id, specification);

            // act:
            CargoState newState = state.SpecifyNewRoute(specification2);

            // assert:
            Assert.IsNotNull(newState);
            Assert.AreSame(state, newState);
            specification.VerifyAllExpectations();
            specification2.VerifyAllExpectations();
        }
Пример #16
0
        public void Ctor_01()
        {
            // arrange:
            GList        mocks        = new GList();
            TrackingId   id           = new TrackingId("START");
            DateTime     loadTime     = DateTime.Now;
            VoyageNumber voyageNumber = new VoyageNumber("VYG001");
            UnLocode     location     = new UnLocode("CURLC");
            IItinerary   itinerary    = MockRepository.GenerateStrictMock <IItinerary>();

            itinerary.Expect(i => i.Equals(null)).IgnoreArguments().Return(false).Repeat.Any();
            itinerary.Expect(i => i.FinalArrivalDate).Return(DateTime.UtcNow + TimeSpan.FromDays(1)).Repeat.Any();
            itinerary.Expect(i => i.FinalArrivalLocation).Return(new UnLocode("ENDLC")).Repeat.Any();
            mocks.Add(itinerary);
            IRouteSpecification specification = MockRepository.GenerateStrictMock <IRouteSpecification>();

            specification.Expect(s => s.IsSatisfiedBy(itinerary)).Return(true).Repeat.Any();
            CargoState previousState = MockRepository.GenerateStrictMock <CargoState>(id, specification);

            mocks.Add(previousState);
            previousState = MockRepository.GenerateStrictMock <CargoState>(previousState, itinerary);
            mocks.Add(previousState);
            IVoyage voyage = MockRepository.GenerateStrictMock <IVoyage>();

            voyage.Expect(v => v.Number).Return(voyageNumber).Repeat.AtLeastOnce();
            voyage.Expect(v => v.LastKnownLocation).Return(location).Repeat.AtLeastOnce();
            mocks.Add(voyage);

            // act:
            CargoState state = new OnboardCarrierCargo(previousState, voyage, loadTime);

            // assert:
            Assert.IsNotNull(state);
            Assert.AreSame(voyageNumber, state.CurrentVoyage);
            Assert.AreEqual(TransportStatus.OnboardCarrier, state.TransportStatus);
            Assert.AreSame(location, state.LastKnownLocation);
            foreach (object mock in mocks)
            {
                mock.VerifyAllExpectations();
            }
        }
Пример #17
0
        public void ClearCustoms_01()
        {
            // arrange:
            GList        mocks        = new GList();
            TrackingId   id           = new TrackingId("START");
            DateTime     loadTime     = DateTime.Now;
            VoyageNumber voyageNumber = new VoyageNumber("VYG001");
            UnLocode     locCode      = new UnLocode("CURLC");
            ILocation    location     = MockRepository.GenerateStrictMock <ILocation>();

            location.Expect(l => l.UnLocode).Return(locCode).Repeat.Any();
            mocks.Add(location);
            IItinerary itinerary = MockRepository.GenerateStrictMock <IItinerary>();

            itinerary.Expect(i => i.Equals(null)).IgnoreArguments().Return(false).Repeat.Any();
            itinerary.Expect(i => i.FinalArrivalDate).Return(DateTime.UtcNow + TimeSpan.FromDays(1)).Repeat.Any();
            itinerary.Expect(i => i.FinalArrivalLocation).Return(new UnLocode("ENDLC")).Repeat.Any();
            mocks.Add(itinerary);
            IRouteSpecification specification = MockRepository.GenerateStrictMock <IRouteSpecification>();

            specification.Expect(s => s.IsSatisfiedBy(itinerary)).Return(true).Repeat.Any();
            mocks.Add(specification);
            CargoState previousState = MockRepository.GenerateStrictMock <CargoState>(id, specification);

            mocks.Add(previousState);
            previousState = MockRepository.GenerateStrictMock <CargoState>(previousState, itinerary);
            mocks.Add(previousState);
            IVoyage voyage = MockRepository.GenerateStrictMock <IVoyage>();

            voyage.Expect(v => v.Number).Return(voyageNumber).Repeat.AtLeastOnce();
            voyage.Expect(v => v.LastKnownLocation).Return(locCode).Repeat.AtLeastOnce();
            mocks.Add(voyage);
            CargoState state = new OnboardCarrierCargo(previousState, voyage, loadTime);

            // assert:
            Assert.Throws <InvalidOperationException>(delegate { state.ClearCustoms(location, DateTime.Now + TimeSpan.FromDays(1)); });
            foreach (object mock in mocks)
            {
                mock.VerifyAllExpectations();
            }
        }
Пример #18
0
        public void Ctor_02()
        {
            // arrange:
            System.Collections.Generic.List <object> mocks = new System.Collections.Generic.List <object>();
            TrackingId id        = new TrackingId("CLAIM");
            IItinerary itinerary = MockRepository.GenerateStrictMock <IItinerary>();

            itinerary.Expect(i => i.FinalArrivalDate).Return(DateTime.UtcNow).Repeat.AtLeastOnce();
            mocks.Add(itinerary);
            IRouteSpecification specification = MockRepository.GenerateStrictMock <IRouteSpecification>();

            specification.Expect(s => s.IsSatisfiedBy(itinerary)).Return(true).Repeat.Any();
            mocks.Add(specification);
            IRouteSpecification specification2 = MockRepository.GenerateStrictMock <IRouteSpecification>();

            specification2.Expect(s => s.IsSatisfiedBy(itinerary)).Return(false).Repeat.Any();
            mocks.Add(specification2);
            CargoState previousState = MockRepository.GenerateStrictMock <CargoState>(id, specification);

            mocks.Add(previousState);
            previousState = MockRepository.GenerateStrictMock <CargoState>(previousState, itinerary);
            mocks.Add(previousState);
            previousState = MockRepository.GenerateStrictMock <CargoState>(previousState, specification2);
            mocks.Add(previousState);
            DateTime claimDate = DateTime.UtcNow;


            // act:
            Assert.Throws <ArgumentException>(delegate { new ClaimedCargo(previousState, claimDate); });

            // assert:
            foreach (object mock in mocks)
            {
                mock.VerifyAllExpectations();
            }
        }