예제 #1
0
        public void IsSatisfiedBy_06()
        {
            // arrange:
            UnLocode  first  = new UnLocode("CDFST");
            UnLocode  second = new UnLocode("CDSND");
            UnLocode  third  = new UnLocode("CDTRD");
            ILocation origin = MockRepository.GenerateStrictMock <ILocation>();

            origin.Expect(l => l.UnLocode).Return(first).Repeat.AtLeastOnce();
            ILocation destination = MockRepository.GenerateStrictMock <ILocation>();

            destination.Expect(l => l.UnLocode).Return(second).Repeat.AtLeastOnce();
            DateTime arrivalDeadline = DateTime.UtcNow + TimeSpan.FromDays(5);

            IItinerary candidate = MockRepository.GenerateStrictMock <IItinerary>();

            candidate.Expect(i => i.InitialDepartureLocation).Return(first).Repeat.Once();
            candidate.Expect(i => i.FinalArrivalLocation).Return(third).Repeat.Once();
            candidate.Expect(i => i.FinalArrivalDate).Return(arrivalDeadline - TimeSpan.FromHours(1)).Repeat.Any();

            IRouteSpecification specification = new RouteSpecification(origin, destination, arrivalDeadline);

            // act:
            bool satisfied = specification.IsSatisfiedBy(candidate);

            // assert:
            Assert.IsFalse(satisfied);
            origin.VerifyAllExpectations();
            destination.VerifyAllExpectations();
            candidate.VerifyAllExpectations();
        }
예제 #2
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();
        }
예제 #3
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();
        }
예제 #4
0
        public void AssignToRoute_01()
        {
            // arrange:
            TrackingId id        = new TrackingId("CRG01");
            IItinerary itinerary = MockRepository.GenerateStrictMock <IItinerary>();

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

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

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

            // assert:
            Assert.IsNotNull(newState);
            Assert.IsTrue(state.CalculationDate <= newState.CalculationDate);
            Assert.AreEqual(RoutingStatus.Routed, newState.RoutingStatus);
            Assert.AreSame(itinerary, newState.Itinerary);
            Assert.AreNotSame(state, newState);
            Assert.IsFalse(state.Equals(newState));
            Assert.IsFalse(newState.Equals(state));
            itinerary.VerifyAllExpectations();
            specification.VerifyAllExpectations();
        }
예제 #5
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();
        }
예제 #6
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();
        }
예제 #7
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();
        }
예제 #8
0
        public void Equals_06()
        {
            // arrange:
            UnLocode    loc1    = new UnLocode("CODAA");
            UnLocode    loc2    = new UnLocode("CODAB");
            UnLocode    loc3    = new UnLocode("CODAC");
            UnLocode    loc4    = new UnLocode("CODAD");
            List <ILeg> legs    = new List <ILeg>();
            ILeg        legCopy = MockRepository.GenerateStrictMock <ILeg>();

            legs.Add(legCopy);
            ILeg leg2Copy = MockRepository.GenerateStrictMock <ILeg>();

            legs.Add(leg2Copy);
            ILeg leg = MockRepository.GenerateStrictMock <ILeg>();

            leg.Expect(l => l.Equals(legCopy)).Return(true).Repeat.Any();
            leg.Expect(l => l.LoadLocation).Return(loc1).Repeat.Any();
            leg.Expect(l => l.UnloadLocation).Return(loc2).Repeat.Any();
            leg.Expect(l => l.UnloadTime).Return(DateTime.UtcNow).Repeat.Any();
            ILeg leg2 = MockRepository.GenerateStrictMock <ILeg>();

            leg2.Expect(l => l.Equals(leg2Copy)).Return(true).Repeat.Any();
            leg2.Expect(l => l.LoadLocation).Return(loc2).Repeat.Any();
            leg2.Expect(l => l.UnloadLocation).Return(loc3).Repeat.Any();
            leg2.Expect(l => l.LoadTime).Return(DateTime.UtcNow + TimeSpan.FromDays(1)).Repeat.Any();
            IItinerary candidate = MockRepository.GenerateStrictMock <IItinerary>();

            candidate.Expect(c => c.InitialDepartureLocation).Return(loc4).Repeat.Once();
            candidate.Expect(c => c.FinalArrivalLocation).Return(loc3).Repeat.Any();
            candidate.Expect(c => c.GetEnumerator()).Return(legs.GetEnumerator()).Repeat.Any();

            // act:
            IItinerary tested = new Itinerary();

            tested = tested.Append(leg);
            tested = tested.Append(leg2);

            // assert:
            Assert.IsFalse(tested.Equals(candidate));
            candidate.VerifyAllExpectations();
            leg.VerifyAllExpectations();
            leg2.VerifyAllExpectations();
            foreach (ILeg l in legs)
            {
                l.VerifyAllExpectations();
            }
        }
예제 #9
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();
        }
예제 #10
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();
        }
예제 #11
0
        public void Equals_02()
        {
            // arrange:
            UnLocode    loc1    = new UnLocode("CODAA");
            UnLocode    loc2    = new UnLocode("CODAB");
            UnLocode    loc3    = new UnLocode("CODAC");
            List <ILeg> legs    = new List <ILeg>();
            ILeg        legCopy = MockRepository.GenerateStrictMock <ILeg>();

            legs.Add(legCopy);
            ILeg leg2Copy = MockRepository.GenerateStrictMock <ILeg>();

            legs.Add(leg2Copy);
            ILeg leg = MockRepository.GenerateStrictMock <ILeg, IObject>();

            leg.Expect(l => l.Equals(leg)).Return(true).Repeat.AtLeastOnce();
            leg.Expect(l => l.Equals(legCopy)).Return(true).Repeat.AtLeastOnce();
            leg.Expect(l => l.LoadLocation).Return(loc1).Repeat.AtLeastOnce();
            leg.Expect(l => l.UnloadLocation).Return(loc2).Repeat.AtLeastOnce();
            leg.Expect(l => l.UnloadTime).Return(DateTime.UtcNow).Repeat.AtLeastOnce();
            leg.Expect(l => l.GetHashCode()).Return(543210).Repeat.AtLeastOnce();
            ILeg leg2 = MockRepository.GenerateStrictMock <ILeg, IObject>();

            leg2.Expect(l => l.Equals(leg2)).Return(true).Repeat.AtLeastOnce();
            leg2.Expect(l => l.Equals(leg2Copy)).Return(true).Repeat.AtLeastOnce();
            leg2.Expect(l => l.LoadLocation).Return(loc2).Repeat.AtLeastOnce();
            leg2.Expect(l => l.UnloadLocation).Return(loc3).Repeat.AtLeastOnce();
            leg2.Expect(l => l.LoadTime).Return(DateTime.UtcNow + TimeSpan.FromDays(1)).Repeat.AtLeastOnce();
            IItinerary candidate = MockRepository.GenerateStrictMock <IItinerary>();

            candidate.Expect(c => c.InitialDepartureLocation).Return(loc1).Repeat.AtLeastOnce();
            candidate.Expect(c => c.FinalArrivalLocation).Return(loc3).Repeat.AtLeastOnce();
            candidate.Expect(c => c.GetEnumerator()).Return(legs.GetEnumerator()).Repeat.Once();
            candidate.Expect(c => c.GetEnumerator()).Return(legs.GetEnumerator()).Repeat.Once();
            candidate.Expect(c => c.GetEnumerator()).Return(legs.GetEnumerator()).Repeat.Once();
            candidate.Expect(c => c.GetEnumerator()).Return(legs.GetEnumerator()).Repeat.Once();

            // act:
            IItinerary tested = new Itinerary();

            tested = tested.Append(leg);
            tested = tested.Append(leg2);
            IItinerary tested2 = new Itinerary();

            tested2 = tested2.Append(leg);
            tested2 = tested2.Append(leg2);

            // assert:
            Assert.IsTrue(tested.Equals(candidate));
            Assert.IsTrue(tested.Equals((object)candidate));
            Assert.IsTrue(tested.Equals(tested2));
            Assert.IsTrue(tested.Equals((object)tested2));
            Assert.IsTrue(tested2.Equals(tested));
            Assert.IsTrue(tested2.Equals((object)tested));
            Assert.AreEqual(tested.GetHashCode(), tested2.GetHashCode());
            CollectionAssert.AreEqual(tested, tested.AsWeakEnumerable());
            CollectionAssert.AreEqual(tested, tested2);
            candidate.VerifyAllExpectations();
            leg.VerifyAllExpectations();
            leg2.VerifyAllExpectations();
            foreach (ILeg l in legs)
            {
                l.VerifyAllExpectations();
            }
        }