public void ParseToRaw_ValidRawEvent_ShouldSucceed()
{
// Arrange
const string eventId = "2d1781af-3a4c-4d7c-bd0c-e34b19da4e66";
const string licensePlate = "1-TOM-337";
var originalEvent = new NewCarRegistered(eventId, licensePlate);
var rawEventBody = JsonConvert.SerializeObject(originalEvent.Data, Formatting.Indented);
var rawEvent = new RawEvent(eventId, originalEvent.EventType, rawEventBody, originalEvent.Subject, originalEvent.DataVersion, originalEvent.EventTime);
IEnumerable <RawEvent> events = new List <RawEvent>
{
rawEvent
};
var serializedRawEvents = JsonConvert.SerializeObject(events);
// Act
var eventGridMessage = EventGridParser.Parse <RawEvent>(serializedRawEvents);
// Assert
Assert.NotNull(eventGridMessage);
Assert.NotNull(eventGridMessage.Events);
Assert.Single(eventGridMessage.Events);
var eventPayload = eventGridMessage.Events.Single();
Assert.Equal(eventId, eventPayload.Id);
Assert.Equal(originalEvent.Subject, eventPayload.Subject);
Assert.Equal(originalEvent.EventType, eventPayload.EventType);
Assert.Equal(originalEvent.EventTime, eventPayload.EventTime);
Assert.Equal(originalEvent.DataVersion, eventPayload.DataVersion);
Assert.NotNull(eventPayload.Data);
Assert.Equal(rawEventBody, eventPayload.Data.ToString());
}
public async Task PublishSingleRawEvent_WithBuilder_ValidParameters_Succeeds()
{
// Arrange
var topicEndpoint = Configuration.GetValue <string>("Arcus:EventGrid:TopicEndpoint");
var endpointKey = Configuration.GetValue <string>("Arcus:EventGrid:EndpointKey");
const string licensePlate = "1-TOM-337";
const string expectedSubject = "/";
var eventId = Guid.NewGuid().ToString();
var @event = new NewCarRegistered(eventId, licensePlate);
var rawEventBody = JsonConvert.SerializeObject(@event.Data);
// Act
await EventGridPublisherBuilder
.ForTopic(topicEndpoint)
.UsingAuthenticationKey(endpointKey)
.Build()
.PublishRaw(@event.Id, @event.EventType, rawEventBody);
TracePublishedEvent(eventId, @event);
// Assert
var receivedEvent = _serviceBusEventConsumerHost.GetReceivedEvent(eventId);
AssertReceivedEvent(eventId, @event.EventType, expectedSubject, licensePlate, receivedEvent);
}
public void Parse_ValidNewCarRegisteredEvent_ShouldSucceed()
{
// Arrange
string eventId = Guid.NewGuid().ToString();
const string licensePlate = "1-TOM-337";
const string subject = licensePlate;
var @event = new NewCarRegistered(eventId, subject, licensePlate);
var rawEvent = JsonConvert.SerializeObject(new[] { @event });
// Act
var eventGridBatch = EventGridParser.Parse <NewCarRegistered>(rawEvent);
// Assert
Assert.NotNull(eventGridBatch);
Assert.NotNull(eventGridBatch.Events);
var eventPayload = Assert.Single(eventGridBatch.Events);
Assert.Equal(eventId, eventPayload.Id);
Assert.Equal(subject, eventPayload.Subject);
Assert.Equal(@event.EventType, eventPayload.EventType);
Assert.Equal(@event.EventTime, eventPayload.EventTime);
Assert.NotNull(eventPayload.Data);
var eventInformation = eventPayload.GetPayload();
Assert.NotNull(eventInformation);
Assert.Equal(licensePlate, eventInformation.LicensePlate);
}
public void SerializedCustomEventGridEvent_AsJObject_IsNotCloudEvent()
{
// Arrange
var newCarRegisteredEvent =
new NewCarRegistered($"event-id-{Guid.NewGuid()}", $"license-plate-{Guid.NewGuid()}");
JObject jObject = JObject.FromObject(newCarRegisteredEvent);
// Act
bool isCloudEvent = jObject.IsCloudEvent();
// Assert
Assert.False(isCloudEvent, "Serialized custom EventGridEvent should not be evaluated as CloudEvent schema");
}
public void Parse_ValidRawEvent_ShouldSucceed()
{
// Arrange
const string eventId = "2d1781af-3a4c-4d7c-bd0c-e34b19da4e66";
const string licensePlate = "1-TOM-337";
var originalEvent = new NewCarRegistered(eventId, licensePlate);
var rawEventBody = JsonConvert.SerializeObject(originalEvent.Data);
var rawEvent = new RawEvent(eventId, originalEvent.EventType, rawEventBody, originalEvent.Subject, originalEvent.DataVersion, originalEvent.EventTime);
// Act
var serializedOriginalEvent = JsonConvert.SerializeObject(originalEvent);
var serializedRawEvent = JsonConvert.SerializeObject(rawEvent);
// Assert
Assert.Equal(serializedRawEvent, serializedOriginalEvent);
}
public void Event_CreateWithId_ShouldSucceed()
{
// Arrange
string eventId = Guid.NewGuid().ToString();
const string licensePlate = "1-TOM-337";
// Act
var createdEvent = new NewCarRegistered(eventId, licensePlate);
// Assert
Assert.NotNull(createdEvent);
Assert.Equal(eventId, createdEvent.Id);
Assert.Null(createdEvent.Subject);
Assert.NotNull(createdEvent.Data);
Assert.Equal(licensePlate, createdEvent.Data.LicensePlate);
Assert.NotEqual(default(DateTimeOffset), createdEvent.EventTime);
}
public async Task Publish_NoEventSpecified_ShouldFailWithArgumentNullException()
{
// Arrange
const string topicEndpoint = "http://myTopic";
const string authenticationKey = "myKey";
NewCarRegistered @event = null;
// Act
var eventGridPublisher =
EventGridPublisherBuilder
.ForTopic(topicEndpoint)
.UsingAuthenticationKey(authenticationKey)
.Build();
// Assert
await Assert.ThrowsAsync <ArgumentNullException>(() => eventGridPublisher.PublishAsync(@event));
}
private static void AssertReceivedEvent(string eventId, string eventType, string eventSubject, string licensePlate, string receivedEvent)
{
Assert.NotEqual(string.Empty, receivedEvent);
EventGridMessage <NewCarRegistered> deserializedEventGridMessage = EventGridParser.Parse <NewCarRegistered>(receivedEvent);
Assert.NotNull(deserializedEventGridMessage);
Assert.NotEmpty(deserializedEventGridMessage.SessionId);
Assert.NotNull(deserializedEventGridMessage.Events);
NewCarRegistered deserializedEvent = Assert.Single(deserializedEventGridMessage.Events);
Assert.NotNull(deserializedEvent);
Assert.Equal(eventId, deserializedEvent.Id);
Assert.Equal(eventSubject, deserializedEvent.Subject);
Assert.Equal(eventType, deserializedEvent.EventType);
Assert.NotNull(deserializedEvent.Data);
Assert.Equal(licensePlate, deserializedEvent.Data.LicensePlate);
}
public async Task PublishSingleEventGridEvent_WithBuilder_ValidParameters_Succeeds()
{
// Arrange
const string eventSubject = "integration-test";
const string licensePlate = "1-TOM-337";
var eventId = Guid.NewGuid().ToString();
var @event = new NewCarRegistered(eventId, eventSubject, licensePlate);
IEventGridPublisher publisher = EventPublisherFactory.CreateEventGridEventPublisher(_config);
// Act
await publisher.PublishAsync(@event);
TracePublishedEvent(eventId, @event);
// Assert
var receivedEvent = _endpoint.ServiceBusEventConsumerHost.GetReceivedEvent(eventId);
ArcusAssert.ReceivedNewCarRegisteredEvent(eventId, @event.EventType, eventSubject, licensePlate, receivedEvent);
}
private static void AssertReceivedNewCarRegisteredEvent(string eventId, string eventType, string eventSubject, string licensePlate, string receivedEvent)
{
Assert.NotEqual(String.Empty, receivedEvent);
EventBatch <NewCarRegistered> deserializedEventGridMessage = EventGridParser.Parse <NewCarRegistered>(receivedEvent);
Assert.NotNull(deserializedEventGridMessage);
Assert.NotEmpty(deserializedEventGridMessage.SessionId);
Assert.NotNull(deserializedEventGridMessage.Events);
NewCarRegistered deserializedEvent = Assert.Single(deserializedEventGridMessage.Events);
Assert.NotNull(deserializedEvent);
Assert.Equal(eventId, deserializedEvent.Id);
Assert.Equal(eventSubject, deserializedEvent.Subject);
Assert.Equal(eventType, deserializedEvent.EventType);
Assert.NotNull(deserializedEvent.Data);
CarEventData eventData = deserializedEvent.GetPayload();
Assert.NotNull(eventData);
Assert.Equal(JsonConvert.DeserializeObject <CarEventData>(deserializedEvent.Data.ToString()), eventData);
Assert.Equal(licensePlate, eventData.LicensePlate);
}
