public void WhenInstantiated_ThenShouldBeOfCorrectType()
{
var handler = new CreateOrderHandler(_repositoryMoq.Object);
Assert.NotNull(handler);
Assert.IsType <CreateOrderHandler>(handler);
}
public void SaveAndLoadWithEntityRepository()
{
Converts.Repository
.AddJsonKey()
.AddJsonEnumSearchHandler()
.AddJsonPrimitivesSearchHandler()
.AddJsonObjectSearchHandler();
ICompositeTypeProvider compositeTypeProvider = new ReflectionCompositeTypeProvider(new ReflectionCompositeDelegateFactory());
IFactory <ICompositeStorage> storageFactory = new GetterFactory <ICompositeStorage>(() => new JsonCompositeStorage());
EventSourcingContext context = new EventSourcingContext(@"Data Source=.\sqlexpress; Initial Catalog=EventStore;Integrated Security=SSPI");
EntityEventStore eventStore = new EntityEventStore(context);
PersistentEventDispatcher eventDispatcher = new PersistentEventDispatcher(eventStore);
AggregateRootRepository <Order> repository = new AggregateRootRepository <Order>(
eventStore,
new CompositeEventFormatter(compositeTypeProvider, storageFactory),
new ReflectionAggregateRootFactory <Order>(),
eventDispatcher,
new NoSnapshotProvider(),
new EmptySnapshotStore()
);
PersistentCommandDispatcher commandDispatcher = new PersistentCommandDispatcher(
new SerialCommandDistributor(),
new EntityCommandStore(context),
new CompositeCommandFormatter(compositeTypeProvider, storageFactory)
);
CreateOrderHandler createHandler = new CreateOrderHandler(repository);
AddOrderItemHandler addItemHandler = new AddOrderItemHandler(repository);
commandDispatcher.Handlers
.Add <CreateOrder>(createHandler)
.Add <AddOrderItem>(addItemHandler);
CreateOrder create = new CreateOrder();
commandDispatcher.HandleAsync(create);
eventDispatcher.Handlers.Await <OrderPlaced>().Wait();
IEnumerable <EventModel> serializedEvents = eventStore.Get(create.OrderKey).ToList();
Assert.AreEqual(1, serializedEvents.Count());
AddOrderItem addItem = new AddOrderItem(create.OrderKey, GuidKey.Create(Guid.NewGuid(), "Product"), 5);
commandDispatcher.HandleAsync(Envelope.Create(addItem).AddDelay(TimeSpan.FromMinutes(1)));
Task <OrderTotalRecalculated> task = eventDispatcher.Handlers.Await <OrderTotalRecalculated>();
task.Wait();
Console.WriteLine(task.Result);
serializedEvents = eventStore.Get(create.OrderKey).ToList();
Assert.AreEqual(4, serializedEvents.Count());
}
public async Task WhenOrderDoesNotSaveCorrectly_ThenShouldReturnInvalidCommand()
{
_repositoryMoq.Setup(x => x.AddAsync(It.IsAny <Order>()))
.ReturnsAsync((Order)null !);
var handler = new CreateOrderHandler(_repositoryMoq.Object);
var result = await handler.Handle(new CreateOrder(_mapper.Map <Order>(Orders.Order1)), default);
Assert.NotNull(result);
Assert.Equal(CommandOutcome.InvalidCommand, result.Outcome);
}
public async Task WhenOrderIsCreated_ThenShouldReturnEntity()
{
var order = _mapper.Map <Order>(Orders.Order1);
_repositoryMoq.Setup(x => x.AddAsync(It.IsAny <Order>()))
.ReturnsAsync(order);
var handler = new CreateOrderHandler(_repositoryMoq.Object);
var result = await handler.Handle(new CreateOrder(order), default);
Assert.NotNull(result);
Assert.Equal(CommandOutcome.Accepted, result.Outcome);
Assert.Equal(order.Id, result.Entity !.Id);
}
public void CreateOrderHandlerData_ShouldbeTrue_WhenCreated()
{
IRepository <Order> repository = new Mock <IRepository <Order> >().Object;
ILogger <CreateOrderHandler> logger = new Mock <ILogger <CreateOrderHandler> >().Object;
IMediator mediator = new Mock <IMediator>().Object;
CreateOrderHandler campaignHandler = new CreateOrderHandler(repository, logger, mediator);
var result = campaignHandler.Handle(new Dtos.Requests.CreateOrderRequest {
ProductCode = "P1", Price = 10, Quantity = 5
}, new System.Threading.CancellationToken()).Result;
Assert.True(result.Data);
}
public async Task Test_Create_Order_OrderIsCorrect_Returns_OrderId()
{
var productId = Guid.NewGuid();
var defaultOrder = CreateDefaultOrder(productId);
var orderid = Guid.NewGuid();
MockSetUp(orderid, productId);
var handler = new CreateOrderHandler(Dependencies.Object);
var result = await handler.Handle(defaultOrder);
Assert.True(result.Success);
Assert.Equal(orderid, result.Value.OrderId);
VerifyDependencies();
}
public async Task Test_Create_Order_ProductIsInvalid_ReturnsFailure()
{
var productId = Guid.NewGuid();
var defaultOrder = CreateDefaultOrder(productId);
var orderid = Guid.NewGuid();
MockSetUp(orderid, productId);
Dependencies
.Setup(a => a.GetProductByIds(It.IsAny <List <Guid> >()))
.Returns(Task.FromResult(new List <ProductEntity>().AsEnumerable()));
var handler = new CreateOrderHandler(Dependencies.Object);
var result = await handler.Handle(defaultOrder);
Assert.False(result.Success);
Assert.Single(result.Errors);
}
public async Task CreateOrder_Success()
{
//arrange
const decimal amount = 5;
var command = new CreateOrder()
{
Name = "New order for product 1",
CustomerId = CustomerDoorsBuyer.Id,
Items = new List <(Guid, decimal)> {
(Product1InteriorDoor.Id, amount)
},
ShipmentDeadline = DateTimeOffset.Parse("2022-01-01"),
InitiatorId = GlobalAdmin.Id
};
var handler = new CreateOrderHandler(EntityRepository, InventoryService, EventTransmitter);
//act
await handler.HandleAsync(command);
//assert
Assert.That(CallsTo(EntityRepository, nameof(EntityRepository.AddAsync)), Is.EqualTo(1));
var entity = GetRecordedEntities <Order>(EntityRepository, nameof(EntityRepository.AddAsync)).Single();
Assert.That(entity.Name, Is.EqualTo(command.Name));
Assert.That(entity.ItemsOrdered.Count, Is.EqualTo(1));
Assert.That(entity.ItemsProduced.Count, Is.EqualTo(1));
Assert.That(entity.ItemsOrdered.Of(Product1InteriorDoor).Amount, Is.EqualTo(amount));
Assert.That(entity.ItemsProduced.Of(Product1InteriorDoor).Amount, Is.Zero);
Assert.That(entity.Customer, Is.EqualTo(CustomerDoorsBuyer));
Assert.That(entity.ParentOrder, Is.Null);
Assert.That(entity.ShipmentDeadline, Is.EqualTo(command.ShipmentDeadline));
Assert.That(entity.ShippedAt, Is.Null);
Assert.That(entity.Status, Is.EqualTo(OrderStatus.New));
Assert.That(entity.Type, Is.EqualTo(command.OrderType));
Assert.That(entity.Shop, Is.Null);
Assert.That(entity.WorkStartedAt, Is.Null);
Assert.That(entity.SubOrders, Is.Empty);
Assert.That(CustomerDoorsBuyer.Orders.Contains(entity), Is.True);
Assert.That(GetRecordedEvents <DomainEvent <Order> >().Count, Is.EqualTo(1));
//annul
CustomerDoorsBuyer.Orders.Remove(entity);
}
public CreateOrderCommandTests()
{
_campaignRepositoryMock = new Mock <IRepository <CampaignEntity> >();
_productRepositoryMock = new Mock <IRepository <ProductEntity> >();
_orderRepositoryMock = new Mock <IRepository <OrderEntity> >();
var timeServiceMock = new Mock <ITimeService>();
_createOrderServiceMock = new Mock <ICreateOrderService>();
_createOrderFaker = new Faker <CreateOrderCommand>()
.RuleFor(x => x.ProductCode, f => f.Random.AlphaNumeric(3))
.RuleFor(x => x.Quantity, f => f.Random.Int(1, 10));
_handler = new(
_orderRepositoryMock.Object,
_productRepositoryMock.Object,
_campaignRepositoryMock.Object,
_createOrderServiceMock.Object,
timeServiceMock.Object);
}
public void CreateOrder_FailFor_LackOfMaterials()
{
//arrange
var command = new CreateOrder
{
CustomerId = CustomerDoorsBuyer.Id,
Items = new List <(Guid, decimal)> {
(Product1InteriorDoor.Id, 100)
},
ShipmentDeadline = DateTimeOffset.Parse("2022-01-01"),
InitiatorId = GlobalAdmin.Id
};
var handler = new CreateOrderHandler(EntityRepository, InventoryService, EventTransmitter);
//assert () => act
var ex = Assert.ThrowsAsync <DomainException>(async() => await handler.HandleAsync(command));
Assert.That(ex.Message.StartsWith($"Required {100} {Product1InteriorDoor.UoM} of {Product1InteriorDoor}"),
Is.True);
Assert.That(GetRecordedEvents <DomainEvent <Order> >(), Is.Empty);
}
public void CreateOrder_FailFor_LackOfTime()
{
//arrange
var now = DateTimeOffset.Now; //ToDo:4 get rid of real time dependency
var command = new CreateOrder()
{
Name = "New order",
CustomerId = CustomerDoorsBuyer.Id,
Items = new List <(Guid, decimal)> {
(Product1InteriorDoor.Id, 5)
},
ShipmentDeadline = now,
InitiatorId = GlobalAdmin.Id
};
var handler = new CreateOrderHandler(EntityRepository, InventoryService, EventTransmitter);
//assert () => act
var ex = Assert.ThrowsAsync <DomainException>(async() => await handler.HandleAsync(command));
Assert.That(ex.Message.StartsWith("Not enough time to fulfill the order"), Is.True);
Assert.That(GetRecordedEvents <DomainEvent <Order> >(), Is.Empty);
}
public string[] parseInput(String input)
{
CommandHandler commandHandler;
List <string> list = input.Split(' ').ToList();
if (list.Contains(createProduct))
{
commandHandler = new CreateProductHandler();
}
else if (list.Contains(getProduct))
{
commandHandler = new GetProductHandler();
}
else if (list.Contains(createOrder))
{
commandHandler = new CreateOrderHandler();
}
else if (list.Contains(createCampaign))
{
commandHandler = new CreateCampaignHandler();
}
else if (list.Contains(getCampaign))
{
commandHandler = new GetCampaignHandler();
}
else if (list.Contains(increaseTime))
{
commandHandler = new IncreaseTimeHandler();
}
else
{
return(null);
}
Console.WriteLine(commandHandler.Execute(list));
return(null);
}
public void SetUp()
{
_orderService = new Mock <IOrderService>();
_createOrderHandler = new CreateOrderHandler(_orderService.Object);
}
public CreateOrderTest()
{
_createOrderHandler = new CreateOrderHandler();
_createProductHandler = new CreateProductHandler();
}
public OrderCreationConsumer(RabbitMQSettings settings, ISerializer serializer, CreateOrderHandler handler)
: base(settings, serializer, QueueName.CreateOrder)
{
_handler = handler;
}
