public void IsEventDataEquivalentDetectsDifferentBodies()
{
var trackOneEvent = new TrackOne.EventData(new byte[] { 0x22, 0x44 });
var trackTwoEvent = new EventData(new byte[] { 0x11, 0x33 });
Assert.That(TrackOneComparer.IsEventDataEquivalent(trackOneEvent, trackTwoEvent), Is.False);
}
public void IsEventDataEquivalentDetectsEqualEvents()
{
var body = new byte[] { 0x22, 0x44, 0x88 };
var offset = 27;
var trackTwoSystemProperties = new Dictionary <string, object>();
var trackTwoEvent = new EventData(
eventBody: (byte[])body.Clone(),
offset: offset,
systemProperties: trackTwoSystemProperties,
lastPartitionSequenceNumber: 9765551212,
lastPartitionOffset: 54321,
lastPartitionEnqueuedTime: DateTimeOffset.Parse("2015-10-27T00:00:00Z"));
trackTwoEvent.Properties["test"] = "same";
var trackOneEvent = new TrackOne.EventData((byte[])body.Clone());
trackOneEvent.Properties["test"] = trackTwoEvent.Properties["test"];
trackOneEvent.SystemProperties = new TrackOne.EventData.SystemPropertiesCollection();
trackOneEvent.SystemProperties[TrackOne.ClientConstants.OffsetName] = offset.ToString();
trackOneEvent.LastEnqueuedOffset = trackTwoEvent.LastPartitionOffset.ToString();
trackOneEvent.LastSequenceNumber = trackTwoEvent.LastPartitionSequenceNumber.Value;
trackOneEvent.LastEnqueuedTime = trackTwoEvent.LastPartitionEnqueuedTime.Value.UtcDateTime;
Assert.That(TrackOneComparer.IsEventDataEquivalent(trackOneEvent, trackTwoEvent), Is.True);
}
static EventData TransformEvent(TrackOne.EventData eventData) =>
new EventData(eventData.Body,
eventData.Properties,
eventData.SystemProperties.WithoutTypedMembers(),
eventData.SystemProperties.SequenceNumber,
Int64.Parse(eventData.SystemProperties.Offset),
new DateTimeOffset(eventData.SystemProperties.EnqueuedTimeUtc),
eventData.SystemProperties.PartitionKey);
public void IsEventDataEquivalentDetectsWhenOnePropertySetIsNull()
{
var body = new byte[] { 0x22, 0x44, 0x88 };
var trackOneEvent = new TrackOne.EventData((byte[])body.Clone());
var trackTwoEvent = new EventData((byte[])body.Clone());
trackOneEvent.Properties = null;
trackTwoEvent.Properties["test"] = "trackTwo";
Assert.That(TrackOneComparer.IsEventDataEquivalent(trackOneEvent, trackTwoEvent), Is.False);
}
static EventData TransformEvent(TrackOne.EventData eventData) =>
new EventData(eventData.Body)
{
Properties = eventData.Properties,
SystemProperties = new EventData.SystemEventProperties
{
SequenceNumber = eventData.SystemProperties.SequenceNumber,
EnqueuedTime = new DateTimeOffset(eventData.SystemProperties.EnqueuedTimeUtc),
Offset = Int64.Parse(eventData.SystemProperties.Offset),
PartitionKey = eventData.SystemProperties.PartitionKey
}
};
static EventData TransformEvent(TrackOne.EventData eventData) =>
new EventData(eventData.Body)
{
Properties = eventData.Properties,
SystemProperties = new EventData.SystemEventProperties
(
eventData.SystemProperties.SequenceNumber,
eventData.SystemProperties.EnqueuedTimeUtc,
eventData.SystemProperties.Offset,
eventData.SystemProperties.PartitionKey
)
};
public void IsEventDataEquivalentDetectsWhenOneSystemPropertySetIsNull()
{
var body = new byte[] { 0x22, 0x44, 0x88 };
var trackOneEvent = new TrackOne.EventData((byte[])body.Clone());
var trackTwoEvent = new EventData((byte[])body.Clone());
trackOneEvent.SystemProperties = new TrackOne.EventData.SystemPropertiesCollection();
trackOneEvent.SystemProperties["something"] = "trackOne";
trackTwoEvent.SystemProperties = null;
Assert.That(TrackOneComparer.IsEventDataEquivalent(trackOneEvent, trackTwoEvent), Is.False);
}
public void IsEventDataEquivalentDetectsDifferentSystemProperties()
{
var body = new byte[] { 0x22, 0x44, 0x88 };
var trackOneEvent = new TrackOne.EventData((byte[])body.Clone());
var trackTwoEvent = new EventData((byte[])body.Clone());
trackOneEvent.SystemProperties = new TrackOne.EventData.SystemPropertiesCollection();
trackOneEvent.SystemProperties[TrackOne.ClientConstants.OffsetName] = "4";
trackTwoEvent.SystemProperties = new EventData.SystemEventProperties();
trackTwoEvent.SystemProperties.Offset = 27;
Assert.That(TrackOneComparer.IsEventDataEquivalent(trackOneEvent, trackTwoEvent), Is.False);
}
public void IsEventDataEquivalentDetectsDifferentSystemPropertiesWithMissingTypedMember()
{
var body = new byte[] { 0x22, 0x44, 0x88 };
var trackTwoSystemProperties = new Dictionary <string, object>();
var trackTwoEvent = new EventData(
eventBody: (byte[])body.Clone(),
systemProperties: trackTwoSystemProperties);
var trackOneEvent = new TrackOne.EventData((byte[])body.Clone());
trackOneEvent.SystemProperties = new TrackOne.EventData.SystemPropertiesCollection();
trackOneEvent.SystemProperties[TrackOne.ClientConstants.OffsetName] = "4";
Assert.That(TrackOneComparer.IsEventDataEquivalent(trackOneEvent, trackTwoEvent), Is.False);
}
public void IsEventDataEquivalentDetectsEqualEvents()
{
var body = new byte[] { 0x22, 0x44, 0x88 };
var trackOneEvent = new TrackOne.EventData((byte[])body.Clone());
var trackTwoEvent = new EventData((byte[])body.Clone());
trackOneEvent.Properties["test"] = "same";
trackTwoEvent.Properties["test"] = "same";
trackOneEvent.SystemProperties = new TrackOne.EventData.SystemPropertiesCollection();
trackOneEvent.SystemProperties["something"] = "otherSame";
trackTwoEvent.SystemProperties = new EventData.SystemEventProperties();
trackTwoEvent.SystemProperties["something"] = "otherSame";
Assert.That(TrackOneComparer.IsEventDataEquivalent(trackOneEvent, trackTwoEvent), Is.True);
}
static EventData TransformEvent(TrackOne.EventData eventData)
{
if (!Int64.TryParse(eventData.LastEnqueuedOffset, out var parsedLastOffset))
{
parsedLastOffset = -1;
}
return(new EventData(eventData.Body,
eventData.Properties,
eventData.SystemProperties.WithoutTypedMembers(),
eventData.SystemProperties.SequenceNumber,
Int64.Parse(eventData.SystemProperties.Offset),
new DateTimeOffset(eventData.SystemProperties.EnqueuedTimeUtc),
eventData.SystemProperties.PartitionKey,
(eventData.LastSequenceNumber != default ? eventData.LastSequenceNumber : default(long?)),
(parsedLastOffset >= 0 ? parsedLastOffset : default(long?)),
(eventData.LastEnqueuedTime != default ? new DateTimeOffset(eventData.LastEnqueuedTime) : default(DateTimeOffset?))));
}
public void IsEventDataEquivalentDetectsDifferentSystemPropertiesWithMapMember()
{
var body = new byte[] { 0x22, 0x44, 0x88 };
var propertyName = "Something";
var trackTwoSystemProperties = new Dictionary <string, object>();
var trackTwoEvent = new EventData(
eventBody: (byte[])body.Clone(),
systemProperties: trackTwoSystemProperties);
trackTwoSystemProperties[propertyName] = nameof(trackTwoSystemProperties);
var trackOneEvent = new TrackOne.EventData((byte[])body.Clone());
trackOneEvent.SystemProperties = new TrackOne.EventData.SystemPropertiesCollection();
trackOneEvent.SystemProperties[propertyName] = nameof(trackOneEvent);
Assert.That(TrackOneComparer.IsEventDataEquivalent(trackOneEvent, trackTwoEvent), Is.False);
}
public void IsEventDataEquivalentDetectsDifferentSystemPropertiesMismatchedMembers()
{
var body = new byte[] { 0x22, 0x44, 0x88 };
var propertyValue = "one";
var trackTwoSystemProperties = new Dictionary <string, object>();
var trackTwoEvent = new EventData(
eventBody: (byte[])body.Clone(),
systemProperties: trackTwoSystemProperties);
trackTwoSystemProperties["two"] = propertyValue;
var trackOneEvent = new TrackOne.EventData((byte[])body.Clone());
trackOneEvent.SystemProperties = new TrackOne.EventData.SystemPropertiesCollection();
trackOneEvent.SystemProperties["one"] = propertyValue;
Assert.That(TrackOneComparer.IsEventDataEquivalent(trackOneEvent, trackTwoEvent), Is.False);
}
public void IsEventDataEquivalentDetectsEqualEvents()
{
var body = new byte[] { 0x22, 0x44, 0x88 };
var offset = 27;
var trackTwoSystemProperties = new Dictionary <string, object>();
var trackTwoEvent = new EventData(
eventBody: (byte[])body.Clone(),
offset: offset,
systemProperties: trackTwoSystemProperties);
var trackOneEvent = new TrackOne.EventData((byte[])body.Clone());
trackOneEvent.Properties["test"] = "same";
trackTwoEvent.Properties["test"] = "same";
trackOneEvent.SystemProperties = new TrackOne.EventData.SystemPropertiesCollection();
trackOneEvent.SystemProperties[TrackOne.ClientConstants.OffsetName] = offset.ToString();
Assert.That(TrackOneComparer.IsEventDataEquivalent(trackOneEvent, trackTwoEvent), Is.True);
}
/// <summary>
/// Compares event data between its representations in track one and
/// track two to determine if the instances represent the same event.
/// </summary>
///
/// <param name="trackOneEvent">The track one event to consider.</param>
/// <param name="trackTwoEvent">The track two event to consider.</param>
///
/// <returns><c>true</c>, if the two events are structurally equivilent; otherwise, <c>false</c>.</returns>
///
public static bool IsEventDataEquivalent(TrackOne.EventData trackOneEvent,
EventData trackTwoEvent)
{
// If the events are the same instance, they're equal. This should only happen
// if both are null, since the types differ.
if (Object.ReferenceEquals(trackOneEvent, trackTwoEvent))
{
return(true);
}
// If one or the other is null, then they cannot be equal, since we know that
// they are not both null.
if ((trackOneEvent == null) || (trackTwoEvent == null))
{
return(false);
}
// If the contents of each body is not equal, the events are not
// equal.
var trackOneBody = trackOneEvent.Body.ToArray();
var trackTwoBody = trackTwoEvent.Body.ToArray();
if (trackOneBody.Length != trackTwoBody.Length)
{
return(false);
}
if (!Enumerable.SequenceEqual(trackOneBody, trackTwoBody))
{
return(false);
}
// Verify the system properties are equivilent, unless they're the same reference.
if (!Object.ReferenceEquals(trackOneEvent.SystemProperties, trackTwoEvent.SystemProperties))
{
if ((trackOneEvent.SystemProperties == null) || (trackTwoEvent.SystemProperties == null))
{
return(false);
}
// Verify that the system properties contain the same elements, assuming they are non-null.
if (trackOneEvent.SystemProperties?.Count != trackTwoEvent.SystemProperties?.Count)
{
return(false);
}
if (!trackOneEvent.SystemProperties.OrderBy(kvp => kvp.Key).SequenceEqual(trackTwoEvent.SystemProperties.OrderBy(kvp => kvp.Key)))
{
return(false);
}
}
// Since we know that the event bodies and system properties are equal, if the property sets are the
// same instance, then we know that the events are equal. This should only happen if both are null.
if (Object.ReferenceEquals(trackOneEvent.Properties, trackTwoEvent.Properties))
{
return(true);
}
// If either property is null, then the events are not equal, since we know that they are
// not both null.
if ((trackOneEvent.Properties == null) || (trackTwoEvent.Properties == null))
{
return(false);
}
// The only meaningful comparison left is to ensure that the property sets are equivilent,
// the outcome of this check is the final word on equality.
if (trackOneEvent.Properties.Count != trackTwoEvent.Properties.Count)
{
return(false);
}
return(trackOneEvent.Properties.OrderBy(kvp => kvp.Key).SequenceEqual(trackTwoEvent.Properties.OrderBy(kvp => kvp.Key)));
}
/// <summary>
/// Compares event data between its representations in track one and
/// track two to determine if the instances represent the same event.
/// </summary>
///
/// <param name="trackOneEvent">The track one event to consider.</param>
/// <param name="trackTwoEvent">The track two event to consider.</param>
///
/// <returns><c>true</c>, if the two events are structurally equivalent; otherwise, <c>false</c>.</returns>
///
public static bool IsEventDataEquivalent(TrackOne.EventData trackOneEvent,
EventData trackTwoEvent)
{
// If the events are the same instance, they're equal. This should only happen
// if both are null, since the types differ.
if (Object.ReferenceEquals(trackOneEvent, trackTwoEvent))
{
return(true);
}
// If one or the other is null, then they cannot be equal, since we know that
// they are not both null.
if ((trackOneEvent == null) || (trackTwoEvent == null))
{
return(false);
}
// If the contents of each body is not equal, the events are not
// equal.
var trackOneBody = trackOneEvent.Body.ToArray();
var trackTwoBody = trackTwoEvent.Body.ToArray();
if (trackOneBody.Length != trackTwoBody.Length)
{
return(false);
}
if (!Enumerable.SequenceEqual(trackOneBody, trackTwoBody))
{
return(false);
}
// Verify the system properties are equivalent, unless they're the same reference.
if (!Object.ReferenceEquals(trackOneEvent.SystemProperties, trackTwoEvent.SystemProperties))
{
if ((trackOneEvent.SystemProperties == null) || (trackTwoEvent.SystemProperties == null))
{
return(false);
}
if (trackOneEvent.SystemProperties.WithoutTypedMembers().Count != trackTwoEvent.SystemProperties.Count)
{
return(false);
}
foreach (var property in trackOneEvent.SystemProperties)
{
if (property.Key == TrackOne.ClientConstants.EnqueuedTimeUtcName)
{
var trackOneDate = (DateTime)trackOneEvent.SystemProperties[property.Key];
var trackTwoDate = trackTwoEvent.EnqueuedTime;
if (trackOneDate != trackTwoDate.Value.UtcDateTime)
{
return(false);
}
}
else if (property.Key == TrackOne.ClientConstants.SequenceNumberName)
{
var trackOneSequence = (long)trackOneEvent.SystemProperties[property.Key];
var trackTwoSequence = trackTwoEvent.SequenceNumber;
if (trackOneSequence != trackTwoSequence)
{
return(false);
}
}
else if (property.Key == TrackOne.ClientConstants.OffsetName)
{
var trackOneOffset = (string)trackOneEvent.SystemProperties[property.Key];
var trackTwoOffset = trackTwoEvent.Offset?.ToString();
if (trackOneOffset != trackTwoOffset)
{
return(false);
}
}
else if (property.Key == TrackOne.ClientConstants.PartitionKeyName)
{
var trackOnePartitionKey = (string)trackOneEvent.SystemProperties[property.Key];
var trackTwoPartitionKey = trackTwoEvent.PartitionKey;
if (trackOnePartitionKey != trackTwoPartitionKey)
{
return(false);
}
}
else if ((!trackTwoEvent.SystemProperties.ContainsKey(property.Key)) ||
(trackOneEvent.SystemProperties[property.Key] != trackTwoEvent.SystemProperties[property.Key]))
{
return(false);
}
}
}
// Since we know that the event bodies and system properties are equal, if the property sets are the
// same instance, then we know that the events are equal. This should only happen if both are null.
if (Object.ReferenceEquals(trackOneEvent.Properties, trackTwoEvent.Properties))
{
return(true);
}
// If either property is null, then the events are not equal, since we know that they are
// not both null.
if ((trackOneEvent.Properties == null) || (trackTwoEvent.Properties == null))
{
return(false);
}
// The only meaningful comparison left is to ensure that the property sets are equivalent,
// the outcome of this check is the final word on equality.
if (trackOneEvent.Properties.Count != trackTwoEvent.Properties.Count)
{
return(false);
}
if (!trackOneEvent.Properties.OrderBy(kvp => kvp.Key).SequenceEqual(trackTwoEvent.Properties.OrderBy(kvp => kvp.Key)))
{
return(false);
}
// Validate the runtime metrics properties.
return(((trackOneEvent.LastSequenceNumber != default ? trackOneEvent.LastSequenceNumber : default(long?)) == trackTwoEvent.LastPartitionSequenceNumber) &&
((trackOneEvent.LastEnqueuedTime != default ? new DateTimeOffset(trackOneEvent.LastEnqueuedTime) : default(DateTimeOffset?)) == trackTwoEvent.LastPartitionEnqueuedTime) &&
((trackOneEvent.LastEnqueuedOffset == trackTwoEvent.LastPartitionOffset?.ToString())));
}
/// <summary>
/// Compares event data between its representations in track one and
/// track two to determine if the instances represent the same event.
/// </summary>
///
/// <param name="trackOneEvent">The track one event to consider.</param>
/// <param name="trackTwoEvent">The track two event to consider.</param>
///
/// <returns><c>true</c>, if the two events are structurally equivalent; otherwise, <c>false</c>.</returns>
///
public static bool IsEventDataEquivalent(TrackOne.EventData trackOneEvent,
EventData trackTwoEvent)
{
// If the events are the same instance, they're equal. This should only happen
// if both are null, since the types differ.
if (Object.ReferenceEquals(trackOneEvent, trackTwoEvent))
{
return(true);
}
// If one or the other is null, then they cannot be equal, since we know that
// they are not both null.
if ((trackOneEvent == null) || (trackTwoEvent == null))
{
return(false);
}
// If the contents of each body is not equal, the events are not
// equal.
var trackOneBody = trackOneEvent.Body.ToArray();
var trackTwoBody = trackTwoEvent.Body.ToArray();
if (trackOneBody.Length != trackTwoBody.Length)
{
return(false);
}
if (!Enumerable.SequenceEqual(trackOneBody, trackTwoBody))
{
return(false);
}
// Verify the system properties are equivalent, unless they're the same reference.
if (!Object.ReferenceEquals(trackOneEvent.SystemProperties, trackTwoEvent.SystemProperties))
{
if ((trackOneEvent.SystemProperties == null) || (trackTwoEvent.SystemProperties == null))
{
return(false);
}
// Verify that the system properties contain the same elements, assuming they are non-null.
if (trackOneEvent.SystemProperties?.Count != trackTwoEvent.SystemProperties?.Count)
{
return(false);
}
foreach (var property in trackOneEvent.SystemProperties)
{
if (property.Key == TrackOne.ClientConstants.EnqueuedTimeUtcName)
{
// It's necessary to be extra careful with EnqueuedTime property because its type
// differs between Track One and Track Two.
var trackOneDate = (DateTime)trackOneEvent.SystemProperties[property.Key];
var trackTwoDate = (DateTimeOffset)trackTwoEvent.SystemProperties[property.Key];
if (trackOneDate != trackTwoDate.UtcDateTime)
{
return(false);
}
}
else
{
// Other properties have the same type in Track One and Track Two.
if (!trackTwoEvent.SystemProperties.ContainsKey(property.Key))
{
return(false);
}
if (!Equals(trackTwoEvent.SystemProperties[property.Key], property.Value))
{
return(false);
}
}
}
}
// Since we know that the event bodies and system properties are equal, if the property sets are the
// same instance, then we know that the events are equal. This should only happen if both are null.
if (Object.ReferenceEquals(trackOneEvent.Properties, trackTwoEvent.Properties))
{
return(true);
}
// If either property is null, then the events are not equal, since we know that they are
// not both null.
if ((trackOneEvent.Properties == null) || (trackTwoEvent.Properties == null))
{
return(false);
}
// The only meaningful comparison left is to ensure that the property sets are equivalent,
// the outcome of this check is the final word on equality.
if (trackOneEvent.Properties.Count != trackTwoEvent.Properties.Count)
{
return(false);
}
return(trackOneEvent.Properties.OrderBy(kvp => kvp.Key).SequenceEqual(trackTwoEvent.Properties.OrderBy(kvp => kvp.Key)));
}
