public async Task IgnoresStartMessageWhereComponentDoesntAffectStatus()
{
var hiddenChild = new TestComponent("child");
var root = new TestComponent("hi", new[] { hiddenChild }, false);
var change = new MessageChangeEvent(
DefaultTimestamp,
root.GetByNames <IComponent>(root.Name, hiddenChild.Name).Path,
ComponentStatus.Degraded,
MessageType.Start);
var context = new ExistingStartMessageContext(
DefaultTimestamp,
new TestComponent("name"),
ComponentStatus.Down);
var result = await Processor.ProcessAsync(change, EventEntity, root, context);
Assert.Equal(context, result);
Factory
.Verify(
x => x.CreateMessageAsync(
It.IsAny <EventEntity>(),
It.IsAny <DateTime>(),
It.IsAny <MessageType>(),
It.IsAny <IComponent>()),
Times.Never());
}
public async Task CreatesEndMessageWithContext(ComponentStatus changeStatus, ComponentStatus existingStatus)
{
var child = new TestComponent("child");
child.Status = changeStatus;
var root = new PrimarySecondaryComponent("hi", "", new[] { child });
var affectedComponent = root.GetByNames <IComponent>(root.Name, child.Name);
var change = new MessageChangeEvent(
DefaultTimestamp + TimeSpan.FromDays(1),
affectedComponent.Path,
changeStatus,
MessageType.End);
var context = new ExistingStartMessageContext(
DefaultTimestamp,
root,
existingStatus);
var result = await Processor.ProcessAsync(change, EventEntity, root, context);
Assert.Null(result);
Factory
.Verify(
x => x.CreateMessageAsync(
EventEntity,
change.Timestamp,
MessageType.End,
context.AffectedComponent,
context.AffectedComponentStatus),
Times.Once());
}
public async Task UpdatesExistingStartMessageFromContext(ComponentStatus changeStatus, ComponentStatus existingStatus)
{
var changedChild = new TestComponent("child");
var existingChild = new TestComponent("existing");
var root = new TreeComponent("hi", "", new[] { changedChild, existingChild });
var affectedComponent = root.GetByNames <IComponent>(root.Name, changedChild.Name);
var change = new MessageChangeEvent(
DefaultTimestamp,
affectedComponent.Path,
changeStatus,
MessageType.Start);
var existingAffectedComponent = root.GetByNames <IComponent>(root.Name, existingChild.Name);
var context = new ExistingStartMessageContext(
new DateTime(2018, 10, 9),
existingAffectedComponent,
existingStatus);
var result = await Processor.ProcessAsync(change, EventEntity, root, context);
Assert.Equal(context.Timestamp, result.Timestamp);
Assert.Equal(root, result.AffectedComponent);
Assert.Equal(root.Status, result.AffectedComponentStatus);
Factory
.Verify(
x => x.UpdateMessageAsync(
EventEntity,
context.Timestamp,
MessageType.Start,
root),
Times.Once());
}
public async Task ThrowsWhenUpdatingStartMessageFromContextIfLeastCommonAncestorUnaffected(ComponentStatus changeStatus, ComponentStatus existingStatus)
{
var changedChild = new TestComponent("child");
var existingChild = new TestComponent("existing");
var root = new AlwaysSameValueTestComponent(
ComponentStatus.Up,
"hi",
"",
new[] { changedChild, existingChild });
var affectedComponent = root.GetByNames <IComponent>(root.Name, changedChild.Name);
var change = new MessageChangeEvent(
DefaultTimestamp,
affectedComponent.Path,
changeStatus,
MessageType.Start);
var existingAffectedComponent = root.GetByNames <IComponent>(root.Name, existingChild.Name);
var context = new ExistingStartMessageContext(
new DateTime(2018, 10, 9),
existingAffectedComponent,
existingStatus);
await Assert.ThrowsAsync <ArgumentException>(() => Processor.ProcessAsync(change, EventEntity, root, context));
Factory
.Verify(
x => x.UpdateMessageAsync(
It.IsAny <EventEntity>(),
It.IsAny <DateTime>(),
It.IsAny <MessageType>(),
It.IsAny <IComponent>()),
Times.Never());
}
public async Task CreatesStartMessageFromNullContext(ComponentStatus status)
{
var child = new TestComponent("child");
var root = new TreeComponent("hi", "", new[] { child });
var affectedComponent = root.GetByNames <IComponent>(root.Name, child.Name);
var change = new MessageChangeEvent(
DefaultTimestamp,
affectedComponent.Path,
status,
MessageType.Start);
var result = await Processor.ProcessAsync(change, EventEntity, root, null);
Assert.Equal(change.Timestamp, result.Timestamp);
Assert.Equal(affectedComponent, result.AffectedComponent);
Assert.Equal(affectedComponent.Status, result.AffectedComponentStatus);
Factory
.Verify(
x => x.CreateMessageAsync(
EventEntity,
DefaultTimestamp,
MessageType.Start,
affectedComponent),
Times.Once());
}
public async Task ThrowsWithUnexpectedType()
{
var root = new TestComponent("root");
var change = new MessageChangeEvent(
DefaultTimestamp,
root.Path,
ComponentStatus.Degraded,
MessageType.Manual);
var context = new ExistingStartMessageContext(
DefaultTimestamp,
new TestComponent("name"),
ComponentStatus.Down);
await Assert.ThrowsAsync <ArgumentException>(() => Processor.ProcessAsync(change, EventEntity, root, context));
}
public async Task ThrowsIfUnexpectedPath(MessageType type)
{
var change = new MessageChangeEvent(
DefaultTimestamp,
"missingPath",
ComponentStatus.Degraded,
type);
var root = new TestComponent("hi");
var context = new ExistingStartMessageContext(
DefaultTimestamp,
new TestComponent("name"),
ComponentStatus.Down);
await Assert.ThrowsAsync <ArgumentException>(() => Processor.ProcessAsync(change, EventEntity, root, context));
}
public async Task ReturnsExistingIfUnexpectedPath(MessageType type)
{
// Arrange
var change = new MessageChangeEvent(
DefaultTimestamp,
"missingPath",
ComponentStatus.Degraded,
type);
var root = new TestComponent("hi");
var context = new ExistingStartMessageContext(
DefaultTimestamp,
new TestComponent("name"),
ComponentStatus.Down);
// Act
var result = await Processor.ProcessAsync(change, EventEntity, root, context);
// Assert
Assert.Equal(context, result);
}
public async Task IgnoresEndMessageWithNullContext(ComponentStatus changeStatus)
{
var root = new TestComponent("root");
var change = new MessageChangeEvent(
DefaultTimestamp,
root.Path,
changeStatus,
MessageType.End);
var result = await Processor.ProcessAsync(change, EventEntity, root, null);
Assert.Null(result);
Factory
.Verify(
x => x.CreateMessageAsync(
It.IsAny <EventEntity>(),
It.IsAny <DateTime>(),
It.IsAny <MessageType>(),
It.IsAny <IComponent>()),
Times.Never());
}
private void AssertChange(IncidentGroupEntity group, MessageType type, MessageChangeEvent change)
{
DateTime expectedTimestamp;
switch (type)
{
case MessageType.Start:
expectedTimestamp = group.StartTime;
break;
case MessageType.End:
expectedTimestamp = group.EndTime.Value;
break;
default:
throw new ArgumentException(nameof(type));
}
Assert.Equal(expectedTimestamp, change.Timestamp);
Assert.Equal(group.AffectedComponentPath, change.AffectedComponentPath);
Assert.Equal(group.AffectedComponentStatus, (int)change.AffectedComponentStatus);
Assert.Equal(type, change.Type);
}
public void GetsAndIteratesChanges()
{
var eventEntity = new EventEntity();
var cursor = new DateTime(2018, 10, 9);
var changes = new MessageChangeEvent[] {
new MessageChangeEvent(new DateTime(2018, 10, 9), "path", ComponentStatus.Degraded, MessageType.Start)
};
Provider
.Setup(x => x.Get(eventEntity, cursor))
.Returns(changes);
var iteratorTask = Task.FromResult("something to make this task unique");
Iterator
.Setup(x => x.IterateAsync(changes, eventEntity))
.Returns(iteratorTask);
var result = Updater.UpdateAsync(eventEntity, cursor);
Assert.Equal(iteratorTask, result);
}
public async Task IgnoresEndMessageWithContextIfStillAffected(ComponentStatus changeStatus, ComponentStatus existingStatus)
{
var child = new TestComponent("child");
child.Status = changeStatus;
var root = new AlwaysSameValueTestComponent(
ComponentStatus.Degraded,
"hi",
"",
new[] { child },
false);
var affectedComponent = root.GetByNames <IComponent>(root.Name, child.Name);
var change = new MessageChangeEvent(
DefaultTimestamp + TimeSpan.FromDays(1),
affectedComponent.Path,
changeStatus,
MessageType.End);
var context = new ExistingStartMessageContext(
DefaultTimestamp,
root,
existingStatus);
var result = await Processor.ProcessAsync(change, EventEntity, root, context);
Assert.Equal(context, result);
Factory
.Verify(
x => x.CreateMessageAsync(
It.IsAny <EventEntity>(),
It.IsAny <DateTime>(),
It.IsAny <MessageType>(),
It.IsAny <IComponent>()),
Times.Never());
}
