示例#1
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();
        }
示例#2
0
 protected InPortCargo(InPortCargo previousState, IItinerary newItinerary)
     : base(previousState, newItinerary)
 {
     _lastKnownLocation = previousState._lastKnownLocation;
     _date          = previousState._date;
     _customCleared = previousState._customCleared;
 }
        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();
            }
        }
示例#4
0
		public IItinerary ReplaceSegment (IItinerary legs)
		{
			if(null == legs)
				throw new ArgumentNullException("legs");
			
			IItinerary newItinerary = null;
			int i = 0;
			while(i < _legs.Length)
			{
				if(null != newItinerary && newItinerary.FinalArrivalLocation.Equals(_legs[i].LoadLocation))
				{
					newItinerary = newItinerary.Append(_legs[i]);
				}
				else if(_legs[i].UnloadLocation.Equals(legs.InitialDepartureLocation))
				{
					ILeg[] newLegs = new ILeg[i + 1];
					Array.Copy(_legs, newLegs, i + 1);
					newItinerary = new Itinerary(newLegs);
					foreach(ILeg l in legs)
					{
						newItinerary = newItinerary.Append(l);
					}
				}
				
				++i;
			}
			if(null == newItinerary)
			{
				string message = string.Format("The legs departure location ({0}) is not in the itinerary.", legs.InitialDepartureLocation);
				throw new ArgumentOutOfRangeException("legs", message);
			}
			
			return newItinerary;
		}
示例#5
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();
        }
示例#6
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();
        }
示例#7
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();
        }
        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();
        }
示例#9
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);
        }
示例#10
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();
        }
示例#11
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));
        }
示例#12
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));
        }
示例#13
0
        public void Append_01()
        {
            // arrange:
            UnLocode loc1        = new UnLocode("CODLD");
            UnLocode loc2        = new UnLocode("CODUN");
            DateTime arrivalDate = DateTime.UtcNow + TimeSpan.FromDays(10);
            ILeg     leg         = MockRepository.GenerateStrictMock <ILeg>();

            leg.Expect(l => l.LoadLocation).Return(loc1).Repeat.Once();
            leg.Expect(l => l.UnloadLocation).Return(loc2).Repeat.Once();
            leg.Expect(l => l.UnloadTime).Return(arrivalDate).Repeat.Once();
            Itinerary empty = new Itinerary();

            // act:
            IItinerary tested = empty.Append(leg);

            // assert:
            Assert.IsNotNull(tested);
            Assert.AreEqual(1, tested.Count());
            Assert.AreSame(leg, tested.First());
            Assert.AreSame(leg, tested.Last());
            Assert.AreEqual(loc1, tested.InitialDepartureLocation);
            Assert.AreEqual(loc2, tested.FinalArrivalLocation);
            Assert.AreEqual(arrivalDate, tested.FinalArrivalDate);
            leg.VerifyAllExpectations();
        }
示例#14
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();
        }
示例#15
0
		public override CargoState AssignToRoute (IItinerary itinerary)
		{
			if(null == itinerary)
				throw new ArgumentNullException("itinerary");
			if(itinerary.Equals(this.Itinerary))
				return this;
			return new NewCargo(this, itinerary);
		}
示例#16
0
 public bool is_satisfied_by(IItinerary the_itinerary)
 {
     return the_itinerary != null &&
            underlying_origin_location.has_the_same_identity_as(
                the_itinerary.initial_departure_load_location()) &&
            underlying_destination_location.has_the_same_identity_as(
                the_itinerary.final_arrival_unload_location()) &&
            underlying_arrival_deadline.is_posterior_to(
                the_itinerary.final_arrival_date());
 }
示例#17
0
 public override CargoState AssignToRoute(IItinerary itinerary)
 {
     if (null == itinerary)
     {
         throw new ArgumentNullException("itinerary");
     }
     if (itinerary.Equals(this.Itinerary))
     {
         return(this);
     }
     return(new NewCargo(this, itinerary));
 }
示例#18
0
		public virtual bool IsSatisfiedBy (IItinerary candidate)
		{
			if(null == candidate)
				return false;
			if(!_origin.Equals(candidate.InitialDepartureLocation))
				return false;
			if(!_destination.Equals(candidate.FinalArrivalLocation))
				return false;
			if(_arrivalDeadline < candidate.FinalArrivalDate)
				return false;
			return true;
		}
示例#19
0
        public void ReplaceSegment_04()
        {
            // arrange:
            ILeg       leg    = MockRepository.GenerateStrictMock <ILeg>();
            Itinerary  empty  = new Itinerary();
            IItinerary tested = empty.Append(leg);

            // act:
            Assert.Throws <ArgumentNullException>(delegate { tested.ReplaceSegment(null); });

            // assert:
            leg.VerifyAllExpectations();
        }
示例#20
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();
            }
        }
示例#21
0
 protected CargoState(CargoState previousState, IItinerary newItinerary)
     : this(previousState)
 {
     if (null == newItinerary)
     {
         throw new ArgumentNullException("newItinerary");
     }
     if (!previousState.RouteSpecification.IsSatisfiedBy(newItinerary))
     {
         string message = string.Format("The itinerary provided do not satisfy the route of {0}.", Identifier);
         throw new ArgumentException(message, "itinerary");
     }
     Itinerary               = newItinerary;
     _routingStatus          = RoutingStatus.Routed;
     _estimatedTimeOfArrival = this.Itinerary.FinalArrivalDate;
 }
示例#22
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();
        }
        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();
            }
        }
示例#24
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();
        }
        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();
            }
        }
示例#26
0
        public bool Equals(IItinerary other)
        {
            if (object.ReferenceEquals(other, null))
            {
                return(false);
            }
            if (object.ReferenceEquals(this, other))
            {
                return(true);
            }

            if (_legs.Length != other.Count())
            {
                return(false);
            }

            if (_legs.Length == 0)
            {
                return(true);
            }

            if (!InitialDepartureLocation.Equals(other.InitialDepartureLocation))
            {
                return(false);
            }
            if (!FinalArrivalLocation.Equals(other.FinalArrivalLocation))
            {
                return(false);
            }
            int i = 0;

            foreach (ILeg l in other)
            {
                if (!_legs[i].Equals(l))
                {
                    return(false);
                }

                ++i;
            }
            return(true);
        }
示例#27
0
 public virtual bool IsSatisfiedBy(IItinerary candidate)
 {
     if (null == candidate)
     {
         return(false);
     }
     if (!_origin.Equals(candidate.InitialDepartureLocation))
     {
         return(false);
     }
     if (!_destination.Equals(candidate.FinalArrivalLocation))
     {
         return(false);
     }
     if (_arrivalDeadline < candidate.FinalArrivalDate)
     {
         return(false);
     }
     return(true);
 }
        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();
            }
        }
        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();
            }
        }
        /// <summary>
        /// Send request message back to caller as response
        /// </summary>
        /// <param name="pipelineContext">Pipeline context</param>
        /// <param name="inputMessage">Input message</param>
        /// <returns>Original input message</returns>
        protected override IBaseMessage Execute(IPipelineContext pipelineContext, IBaseMessage inputMessage)
        {
            var callToken = TraceProvider.Logger.TraceIn(this.Name);

            try
            {
                // delegate work to the BizTalk Xml Dissassembler
                TraceProvider.Logger.TraceInfo("Checking if itinerary should be terminated");
                var IsTerminateItinerary = inputMessage.Context.Read("IsTerminateItinerary", "https://DE.DAXFSA.Framework.Properties.ESBGlobalProperties");

                if (IsTerminateItinerary != null && (bool)IsTerminateItinerary)
                {
                    IItinerary itinerary = ItineraryOMFactory.Create(inputMessage);
                    if (itinerary != null)
                    {
                        MethodInfo CompleteItinerary_MI = itinerary.GetType().GetMethod("CompleteItinerary", BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance);
                        if (CompleteItinerary_MI != null)
                        {
                            CompleteItinerary_MI.Invoke(itinerary, new object[] { null });
                        }
                    }
                    return(null);
                }
                return(inputMessage);
            }
            catch (Exception ex)
            {
                // put component name as a source information in this exception,
                // so the event log in message could reflect this
                ex.Source = this.Name;
                TraceProvider.Logger.TraceError(ex);
                throw ex;
            }
            finally
            {
                TraceProvider.Logger.TraceOut(callToken);
            }
        }
示例#31
0
        public IItinerary ReplaceSegment(IItinerary legs)
        {
            if (null == legs)
            {
                throw new ArgumentNullException("legs");
            }

            IItinerary newItinerary = null;
            int        i            = 0;

            while (i < _legs.Length)
            {
                if (null != newItinerary && newItinerary.FinalArrivalLocation.Equals(_legs[i].LoadLocation))
                {
                    newItinerary = newItinerary.Append(_legs[i]);
                }
                else if (_legs[i].UnloadLocation.Equals(legs.InitialDepartureLocation))
                {
                    ILeg[] newLegs = new ILeg[i + 1];
                    Array.Copy(_legs, newLegs, i + 1);
                    newItinerary = new Itinerary(newLegs);
                    foreach (ILeg l in legs)
                    {
                        newItinerary = newItinerary.Append(l);
                    }
                }

                ++i;
            }
            if (null == newItinerary)
            {
                string message = string.Format("The legs departure location ({0}) is not in the itinerary.", legs.InitialDepartureLocation);
                throw new ArgumentOutOfRangeException("legs", message);
            }

            return(newItinerary);
        }
示例#32
0
        public void AssignToRoute(IItinerary itinerary)
        {
            // Thread safe, lock free sincronization
            CargoState stateBeforeTransition;
            CargoState previousState = CurrentState;

            do
            {
                stateBeforeTransition = previousState;
                CargoState newValue = stateBeforeTransition.AssignToRoute(itinerary);
                previousState = Interlocked.CompareExchange <CargoState>(ref this.CurrentState, newValue, stateBeforeTransition);
            }while (previousState != stateBeforeTransition);

            if (!previousState.Equals(this.CurrentState))
            {
                ChangeEventArgs <IItinerary> args = new ChangeEventArgs <IItinerary>(previousState.Itinerary, CurrentState.Itinerary);

                EventHandler <ChangeEventArgs <IItinerary> > handler = ItineraryChanged;
                if (null != handler)
                {
                    handler(this, args);
                }
            }
        }
示例#33
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();
            }
        }
示例#34
0
 protected NewCargo(CargoState previousState, IItinerary newItinerary)
     : base(previousState, newItinerary)
 {
 }
示例#35
0
文件: Itinerary.cs 项目: 3j/dddsample
 public bool has_the_same_value_as(IItinerary the_other_itinerary)
 {
     return the_other_itinerary != null &&
            underlying_leg_collection.Equals(the_other_itinerary.associated_legs());
 }
示例#36
0
		public override CargoState AssignToRoute (IItinerary itinerary)
		{
			string message = string.Format("The cargo {0} has been loaded on the {1} voyage.", Identifier, _voyage);
			throw new InvalidOperationException(message);
		}
示例#37
0
		protected NewCargo(CargoState previousState, IItinerary newItinerary)
			: base(previousState, newItinerary)
		{
		}
示例#38
0
		public bool Equals(IItinerary other)
		{
			if(object.ReferenceEquals(other, null))
				return false;
			if(object.ReferenceEquals(this, other))
				return true;
			
			if(_legs.Length != other.Count())
				return false;
			
			if(_legs.Length == 0)
				return true;
			
			if(! InitialDepartureLocation.Equals(other.InitialDepartureLocation))
				return false;
			if(! FinalArrivalLocation.Equals(other.FinalArrivalLocation))
				return false;
			int i = 0;
			foreach(ILeg l in other)
			{
				if(! _legs[i].Equals(l))
					return false;
				
				++i;
			}
			return true;
		}
示例#39
0
		public FakeState2(CargoState previousState, IItinerary itinerary)
			: base(previousState, itinerary)
		{
		}
示例#40
0
		public override CargoState AssignToRoute (IItinerary itinerary)
		{
			throw new System.NotImplementedException();
		}