public void Route_Start_End_Destinations_Should_Differ(IDestination start, IDestination end, bool throws)
{
if (throws)
{
Assert.Throws <ArgumentException>(() => _routeFactory.Create(start, end, TransportKind.Truck, 1));
}
else
{
var route = _routeFactory.Create(start, end, TransportKind.Truck, 1);
}
}
public void Create_Route_Factory(
[Frozen] IRouteFactory routeFactory,
Route route)
{
//Information
var _route = routeFactory.Create(route);
//Act
A.CallTo(() => routeFactory.Create(A <Route> .Ignored)).Returns(route);
//Test
Assert.AreNotEqual(_route.RouteID, route.RouteID);
}
public void CreateRoute_CallRouteFactory(
[Frozen] IRouteFactory routeFactory,
CreateRouteCommand message,
Route route,
CreateRouteCommandHandler createRouteCommandHandler)
{
//Information
A.CallTo(() => routeFactory.Create(message.Route)).Returns(route);
//Act
createRouteCommandHandler.ExecuteAsync(message);
//Test
A.CallTo(() => routeFactory.Create(message.Route)).MustHaveHappened();
}
public Route GetRoute()
{
Console.Write("Please enter the route: ");
var stringRoute = Console.ReadLine();
return(routeFactory.Create(stringRoute));
}
public Task ExecuteAsync(CreateRouteCommand message)
{
var route = _routeFactory.Create(message.Route);
_routeRepository.Add(route);
_createAddressCommandHandler.ExecuteAsync(new CreateAddressCommand(message.Route.Addresses));
return(Task.CompletedTask);
}
public IEnumerable <Route> GetDeliveryRoutes(IDestination end)
{
if (end == Destination.B)
{
yield return(_routeFactory.Create(Destination.Factory, Destination.B, TransportKind.Truck, 5));
}
else if (end == Destination.A)
{
yield return(_routeFactory.Create(Destination.Factory, Destination.Port, TransportKind.Truck, 1));
yield return(_routeFactory.Create(Destination.Port, Destination.A, TransportKind.Ship, 4));
}
else
{
throw new ArgumentException($"Doesn't have routes to deliver to {end.Name}");
}
}
public void SetUp()
{
expectedRoute = new Route("GRU", "ASD");
routeFactory = Substitute.For <IRouteFactory>();
routeFactory.Create("GRU-ASD").Returns(expectedRoute);
userInterfaceConsole = new UserInterfaceConsole(routeFactory);
}
private Route BuildRoute(string route)
{
var routes = route.Split(new[] { '-' }, StringSplitOptions.RemoveEmptyEntries);
var dto = new CreateRouteDto
{
Start = routes[0].ToUpper(),
End = routes[1].ToUpper()
};
return(_routeFactory.Create(dto));
}
public void Add(MethodInfo method, string basePath)
{
foreach (RestRouteAttribute routeAttr in method.GetRouteAttributes())
{
string path = CreatePath(basePath, routeAttr.Path);
_logger.Information("Registering Route {0} {1}", routeAttr.HttpMethod, path);
IRoute route = _routeFactory.Create(method, routeAttr.HttpMethod, path);
if (!Routes.Add(route))
{
throw new DuplicateRouteException("Duplicate Route {0}", route);
}
}
}
private void GivenRouteFactory()
{
foreach (var deliveryRoute in _deliveryRoutes)
{
var(start, end) = (deliveryRoute.Key, deliveryRoute.Value.First().End);
var deliveryRouteStub = Substitute.For <DeliveryRoute>();
deliveryRouteStub.Start.Returns(start);
deliveryRouteStub.End.Returns(end);
_routeFactory
.Create(Arg.Is <CreateRouteDto>(route => route.Start == start && route.End == end))
.Returns(deliveryRouteStub);
}
}
private Route[] BuildRoutes(string route)
{
var result = new List <Route>();
var routes = route.Split(new[] { '-' }, StringSplitOptions.RemoveEmptyEntries);
for (int i = 0; i < routes.Length - 1; i++)
{
var dto = new CreateRouteDto
{
Start = routes[i].ToUpper(),
End = routes[i + 1].ToUpper()
};
result.Add(_routeFactory.Create(dto));
}
return(result.ToArray());
}
public void SetRoute <TRouteDefinition>(params object[] routeArguments) where TRouteDefinition : IRouteDefinition
{
_isSetToDefaultRoute = typeof(TRouteDefinition) == typeof(RecordReplayRoute);
_currentRoute = _routeFactory.Create <TRouteDefinition>(routeArguments);
}
private void WhenRouteIsCreated()
{
_func = (() => _factory.Create(_dto));
}