public ManagementTests()
{
_client = new MessageBrokerClient(TestAssembly.ClientConfiguration, TestAssembly.GetRestClientConfiguration());
ResetDatabase()
.GetAwaiter()
.GetResult();
}
private void UnregisterStudent(StudentDto dto)
{
ApiClient.Unregister(dto.Id).ConfigureAwait(false).GetAwaiter().GetResult();
using (var mbClient = new MessageBrokerClient())
{
mbClient.Send($"Student was unregistered: {dto.Name}");
}
Search();
}
public QueuePerformanceTest()
{
_client = new MessageBrokerClient(TestAssembly.ClientConfiguration, TestAssembly.GetRestClientConfiguration());
_utility = new Utility(_client);
ResetDatabase()
.GetAwaiter()
.GetResult();
}
private void EditPersonalInfo(StudentDto dto)
{
var viewModel = new EditPersonalInfoViewModel(dto.Id, dto.Name, dto.Email);
_dialogService.ShowDialog(viewModel);
using (var mbClient = new MessageBrokerClient())
{
mbClient.Send($"Student was edited: {dto.Name}");
}
Search();
}
public MessageBrokerClientTests()
{
_client = new MessageBrokerClient <Payload>(
TestAssembly.ClientConfiguration.BaseUri,
_agentName,
_queueName,
TestAssembly.GetRestClientConfiguration());
_utility = new Utility(_client.Client);
ResetDatabase()
.GetAwaiter()
.GetResult();
}
public async Task Given_PutOrderPlacedCommand_Which_Should_Publish_A_PutOrderPlacedEvent_Expect_OrderResponse_With_OrderPlacedEvent_Published()
{
// Arrange
const string topic = "OrderPlacedUpdated";
const string subscriptionId = "OrderPlacedUpdated_IntegrationTest";
var command = new PutOrderPlacedCommand(1, 5, 2);
var order = new Order
{
Id = 1,
Name = "product zero one",
Quantity = 10
};
Factory.Seed <Startup, MicroserviceDbContext>(db =>
{
db.Clear();
db.Orders.Add(order);
});
// Act
var response = await Client.PutAsJsonAsync($"{GetBaseRoute()}/place", command);
Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.OK));
var result = response.Content.Deserialize <OrderResponse>().Result;
var subscriptionResponse = await MessageBrokerClient.Subscribe <OrderPlacedEvent>(
topic,
subscriptionId,
AssertCallback,
c => c.UseBasicQos());
// Assert PutOrderPlaced Response
Assert.That(result.Quantity, Is.EqualTo(8));
Assert.That(result.Id, Is.EqualTo(order.Id));
StringAssert.AreEqualIgnoringCase(order.Name, result.Name);
// Assert Messagebus OrderCreatedEvent
Task AssertCallback(OrderPlacedEvent orderPlacedEvent)
{
var tcs = new TaskCompletionSource <OrderPlacedEvent>();
Assert.That(orderPlacedEvent.QuantityBeforeReduction, Is.EqualTo(order.Quantity));
Assert.That(orderPlacedEvent.Quantity, Is.EqualTo(result.Quantity));
Assert.That(result.Id, Is.EqualTo(order.Id));
StringAssert.AreEqualIgnoringCase(order.Name, result.Name);
tcs.SetResult(orderPlacedEvent);
return(tcs.Task);
}
}
public async Task Given_PatchOrder_Which_Should_Publish_OrderUpdatedEvent_Expect_Updated_OrderResponse_With_UpdatedEvent_Published()
{
// Arrange
const string topic = "Order";
const string subscriptionId = "OrderUpdated";
var originationOrder = new Order
{
Id = 1,
Name = "product zero one"
};
var patchDoc = new JsonPatchDocument <OrderResponse>();
patchDoc.Replace(x => x.Name, "zero one");
var operations = patchDoc.Operations.ToList();
Factory.Seed <Startup, MicroserviceDbContext>(db =>
{
db.Clear();
db.Orders.Add(originationOrder);
});
// Act
var response = await Client.PatchAsJsonAsync($"{GetBaseRoute()}/update/{originationOrder.Id}/77", patchDoc);
Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.OK));
var result = response.Content.Deserialize <OrderResponse>().Result;
var subscriptionResponse = await MessageBrokerClient.Subscribe <OrderUpdatedEvent>(
topic,
subscriptionId,
AssertCallback,
c => c.UseBasicQos());
// Assert Patch Operation
StringAssert.AreEqualIgnoringCase($"PROD: zero one", result.Name);
// Assert OrderUpdatedEvent
Task AssertCallback(OrderUpdatedEvent updatedEvent)
{
var tcs = new TaskCompletionSource <OrderUpdatedEvent>();
StringAssert.AreEqualIgnoringCase($"PROD: zero one", updatedEvent.Name);
Assert.That(updatedEvent.Quantity, Is.EqualTo(result.Quantity));
Assert.That(updatedEvent.Id, Is.EqualTo(result.Id));
tcs.SetResult(updatedEvent);
return(tcs.Task);
}
}
public async Task Given_CreateOrderCommand_Which_Should_Publish_A_OrderCreatedEvent_Expect_OrderResponse_With_CreatedEvent_Published()
{
// Arrange
const string topic = "OrderCreated";
const string subscriptionId = "OrderCreated_IntegrationTest";
var createCommand = new CreateOrderCommand("Keyboard", 5);
Factory.Seed <Startup, MicroserviceDbContext>(db =>
{
db.Clear();
});
// Act
var response = await Client.PostAsJsonAsync(GetBaseRoute(), createCommand);
Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.Created));
var result = response.Content.Deserialize <OrderResponse>().Result;
var subscriptionResponse = await MessageBrokerClient.Subscribe <OrderCreatedEvent>(
topic,
subscriptionId,
AssertCallback,
c => c.UseBasicQos());
// Assert Create Response
Assert.That(result.Quantity, Is.EqualTo(createCommand.Quantity));
StringAssert.AreEqualIgnoringCase(createCommand.Name, result.Name);
// Assert Messagebus OrderCreatedEvent
Task AssertCallback(OrderCreatedEvent orderCreatedEvent)
{
var tcs = new TaskCompletionSource <OrderCreatedEvent>();
StringAssert.AreEqualIgnoringCase(orderCreatedEvent.Name, result.Name);
Assert.That(orderCreatedEvent.Quantity, Is.EqualTo(createCommand.Quantity));
Assert.That(orderCreatedEvent.Id, Is.GreaterThan(0));
tcs.SetResult(orderCreatedEvent);
return(tcs.Task);
}
}
