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();
}
}
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));
}
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 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));
}
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);
}
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();
}
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();
}
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();
}
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();
}
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();
}
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();
}
}
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();
}
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();
}
}
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();
}
}
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();
}
}
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 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 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();
}
}
public void ReplaceSegment_05()
{
// arrange:
UnLocode loc1 = new UnLocode("CODAA");
UnLocode loc2 = new UnLocode("CODAB");
UnLocode loc3 = new UnLocode("CODAC");
UnLocode loc4 = new UnLocode("CODAD");
UnLocode loc5 = new UnLocode("CODAE");
UnLocode loc6 = new UnLocode("CODAF");
List <ILeg> newLegs = new List <ILeg>();
ILeg newLeg1 = MockRepository.GenerateStrictMock <ILeg>();
newLeg1.Expect(l => l.LoadLocation).Return(new UnLocode("OTHER")).Repeat.Any();
newLeg1.Expect(l => l.LoadTime).Return(DateTime.UtcNow + TimeSpan.FromDays(1)).Repeat.Any();
newLeg1.Expect(l => l.UnloadTime).Return(DateTime.UtcNow + TimeSpan.FromDays(3)).Repeat.Any();
newLeg1.Expect(l => l.UnloadLocation).Return(loc5).Repeat.Any();
newLegs.Add(newLeg1);
ILeg newLeg2 = MockRepository.GenerateStrictMock <ILeg>();
newLeg2.Expect(l => l.LoadLocation).Return(loc5).Repeat.Any();
newLeg2.Expect(l => l.LoadTime).Return(DateTime.UtcNow + TimeSpan.FromDays(4)).Repeat.Any();
newLeg2.Expect(l => l.UnloadTime).Return(DateTime.UtcNow + TimeSpan.FromDays(6)).Repeat.Any();
newLeg2.Expect(l => l.UnloadLocation).Return(loc6).Repeat.Any();
newLegs.Add(newLeg2);
ILeg newLeg3 = MockRepository.GenerateStrictMock <ILeg>();
newLeg3.Expect(l => l.LoadLocation).Return(loc6).Repeat.Any();
newLeg3.Expect(l => l.LoadTime).Return(DateTime.UtcNow + TimeSpan.FromDays(10)).Repeat.Any();
newLeg3.Expect(l => l.UnloadLocation).Return(loc3).Repeat.Any();
newLeg3.Expect(l => l.UnloadTime).Return(DateTime.UtcNow + TimeSpan.FromDays(13)).Repeat.Any();
newLegs.Add(newLeg3);
IItinerary newSegment = MockRepository.GenerateStrictMock <IItinerary>();
newSegment.Expect(s => s.GetEnumerator()).Return(newLegs.GetEnumerator()).Repeat.Any();
newSegment.Expect(s => s.InitialDepartureLocation).Return(new UnLocode("OTHER")).Repeat.Any();
newSegment.Expect(s => s.FinalArrivalLocation).Return(loc3).Repeat.Any();
ILeg leg = MockRepository.GenerateStrictMock <ILeg>();
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.LoadLocation).Return(loc2).Repeat.Any();
leg2.Expect(l => l.UnloadLocation).Return(loc3).Repeat.Any();
leg2.Expect(l => l.LoadTime).Return(DateTime.UtcNow + TimeSpan.FromHours(5)).Repeat.Any();
leg2.Expect(l => l.UnloadTime).Return(DateTime.UtcNow + TimeSpan.FromHours(20)).Repeat.Any();
ILeg leg3 = MockRepository.GenerateStrictMock <ILeg>();
leg3.Expect(l => l.LoadLocation).Return(loc3).Repeat.Any();
leg3.Expect(l => l.UnloadLocation).Return(loc4).Repeat.Any();
leg3.Expect(l => l.LoadTime).Return(DateTime.UtcNow + TimeSpan.FromDays(30)).Repeat.Any();
leg3.Expect(l => l.UnloadTime).Return(DateTime.UtcNow + TimeSpan.FromHours(32)).Repeat.Any();
IItinerary tested = new Itinerary();
tested = tested.Append(leg);
tested = tested.Append(leg2);
tested = tested.Append(leg3);
// act:
Assert.Throws <ArgumentOutOfRangeException>(delegate { tested.ReplaceSegment(newSegment); });
// assert:
leg.VerifyAllExpectations();
leg2.VerifyAllExpectations();
leg3.VerifyAllExpectations();
foreach (ILeg l in newLegs)
{
l.VerifyAllExpectations();
}
}
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();
}
}
public void ReplaceSegment_02()
{
// arrange:
UnLocode loc1 = new UnLocode("CODAA");
UnLocode loc2 = new UnLocode("CODAB");
UnLocode loc3 = new UnLocode("CODAC");
UnLocode loc4 = new UnLocode("CODAD");
UnLocode loc5 = new UnLocode("CODAE");
UnLocode loc6 = new UnLocode("CODAF");
List <ILeg> newLegs = new List <ILeg>();
ILeg newLeg1 = MockRepository.GenerateStrictMock <ILeg>();
newLeg1.Expect(l => l.LoadLocation).Return(loc3).Repeat.AtLeastOnce();
newLeg1.Expect(l => l.LoadTime).Return(DateTime.UtcNow + TimeSpan.FromDays(1)).Repeat.AtLeastOnce();
newLeg1.Expect(l => l.UnloadTime).Return(DateTime.UtcNow + TimeSpan.FromDays(3)).Repeat.Any();
newLeg1.Expect(l => l.UnloadLocation).Return(loc4).Repeat.AtLeastOnce();
newLegs.Add(newLeg1);
ILeg newLeg2 = MockRepository.GenerateStrictMock <ILeg>();
newLeg2.Expect(l => l.LoadLocation).Return(loc4).Repeat.AtLeastOnce();
newLeg2.Expect(l => l.LoadTime).Return(DateTime.UtcNow + TimeSpan.FromDays(4)).Repeat.Any();
newLeg2.Expect(l => l.UnloadTime).Return(DateTime.UtcNow + TimeSpan.FromDays(6)).Repeat.Any();
newLeg2.Expect(l => l.UnloadLocation).Return(loc5).Repeat.AtLeastOnce();
newLegs.Add(newLeg2);
ILeg newLeg3 = MockRepository.GenerateStrictMock <ILeg>();
newLeg3.Expect(l => l.LoadLocation).Return(loc5).Repeat.AtLeastOnce();
newLeg3.Expect(l => l.LoadTime).Return(DateTime.UtcNow + TimeSpan.FromDays(10)).Repeat.Any();
newLeg3.Expect(l => l.UnloadLocation).Return(loc6).Repeat.AtLeastOnce();
newLeg3.Expect(l => l.UnloadTime).Return(DateTime.UtcNow + TimeSpan.FromDays(13)).Repeat.Any();
newLegs.Add(newLeg3);
IItinerary newSegment = MockRepository.GenerateStrictMock <IItinerary>();
newSegment.Expect(s => s.GetEnumerator()).Return(newLegs.GetEnumerator()).Repeat.AtLeastOnce();
newSegment.Expect(s => s.InitialDepartureLocation).Return(loc3).Repeat.AtLeastOnce();
newSegment.Expect(s => s.FinalArrivalLocation).Return(loc6).Repeat.Any();
ILeg leg = MockRepository.GenerateStrictMock <ILeg>();
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.LoadLocation).Return(loc2).Repeat.Any();
leg2.Expect(l => l.UnloadLocation).Return(loc3).Repeat.Any();
leg2.Expect(l => l.LoadTime).Return(DateTime.UtcNow + TimeSpan.FromHours(5)).Repeat.Any();
leg2.Expect(l => l.UnloadTime).Return(DateTime.UtcNow + TimeSpan.FromHours(20)).Repeat.Any();
IItinerary tested = new Itinerary();
tested = tested.Append(leg);
tested = tested.Append(leg2);
// act:
IItinerary replaced = tested.ReplaceSegment(newSegment);
// assert:
Assert.IsNotNull(replaced);
Assert.AreEqual(5, replaced.Count());
Assert.AreEqual(loc1, replaced.InitialDepartureLocation);
Assert.AreEqual(loc6, replaced.FinalArrivalLocation);
leg.VerifyAllExpectations();
leg2.VerifyAllExpectations();
foreach (ILeg l in newLegs)
{
l.VerifyAllExpectations();
}
}
