public void ByAllProperties_FalseOnUnMatchedObjectInstances()
{
A a = new A(5, "Foo"),
b = new A(3, "Bar");
Assert.NotEqual(a, b, GenericEqualityComparer <A> .ByAllMembers());
}
public void Constructor_StoresException()
{
var exception = new ArgumentNullException("foo");
var poison = new Poison <int>(42, exception);
Assert.Equal(new ExceptionDetails(exception), poison.Exception, GenericEqualityComparer <ExceptionDetails> .ByAllMembers());
}
public void ByAllProperties_TrueOnMatchedObjectInstancesWithCustomComparer()
{
B b = new B(6, new A(5, "Foo")),
b2 = new B(6, new A(5, "Bar"));
Assert.Equal(b, b2, GenericEqualityComparer <B> .ByAllMembers(new[] { A.IntegerOnlyComparer }));
}
public void Queue_GeneratesExpectedOnQueueAction()
{
var actionType = DurableJobQueueActionType.Queued;
var observation = SubscribeForAction(actionType, (store, item, poison) =>
{
store.Queue(item);
});
Assert.True(observation.Action.ActionType == actionType && GenericEqualityComparer <TQueue> .ByAllMembers().Equals(observation.Action.Input, observation.Input));
}
public void Subscribe_ResumesInProperQueuePositionAfterReadingMaximumDuringInterval()
{
int maxToSlurp = 3;
var jobStorage = A.Fake <IDurableJobQueue <Incoming, Incoming> >();
var scheduler = new HistoricalScheduler();
var monitor = new DurableJobQueueMonitor <Incoming, Incoming>(jobStorage, maxToSlurp, DurableJobQueueMonitor.DefaultPollingInterval,
scheduler);
List <Incoming> incomingItems = new List <Incoming>();
var queuedItems = Enumerable.Repeat(Item.From(new Incoming()
{
Id = 1
}), 3)
.Concat(new []
{
Item.From(new Incoming()
{
Id = 456
}),
Item.From(new Incoming()
{
Id = 222
}),
Item.From(new Incoming()
{
Id = 8714
})
})
.Concat(Enumerable.Repeat(Item.From(new Incoming()
{
Id = 5
}), 2))
.Concat(Enumerable.Repeat(Item.From(new Incoming()
{
Id = 2
}), 4))
.Concat(Enumerable.Repeat(Item.From(new Incoming()
{
Id = 3
}), 3))
.ToArray();
A.CallTo(() => jobStorage.NextQueuedItem()).ReturnsNextFromSequence(queuedItems);
using (var subscription = monitor.Subscribe(publishedItem => { incomingItems.Add(publishedItem); }))
{
scheduler.AdvanceBy(monitor.PollingInterval);
scheduler.AdvanceBy(monitor.PollingInterval);
Assert.True(queuedItems.Take(maxToSlurp * 2)
.Select(item => item.Value)
.SequenceEqual(incomingItems, GenericEqualityComparer <Incoming> .ByAllMembers()));
}
}
public void GetQueued_PreservesOrdering()
{
var storage = JobStorageFactory();
var queueItems = Fixture.CreateMany <TQueue>(15).ToList();
foreach (var item in queueItems)
{
storage.Queue(item);
}
Assert.True(queueItems.SequenceEqual(storage.GetQueued(), GenericEqualityComparer <TQueue> .ByAllMembers()));
}
public void Deleted_GeneratesExpectedOnQueueAction()
{
var actionType = DurableJobQueueActionType.Deleted;
var observation = SubscribeForAction(actionType, (store, item, poison) =>
{
store.Queue(item);
store.NextQueuedItem();
store.Poison(item, poison);
store.Delete(poison);
});
Assert.True(observation.Action.ActionType == actionType &&
GenericEqualityComparer <TQueuePoison> .ByAllMembers().Equals(observation.Action.Poison, observation.Poison));
}
public void Poison_GetPoisoned_QueuesMatch()
{
var storage = JobStorageFactory();
var item = Fixture.CreateAnonymous <TQueue>();
storage.Queue(item);
storage.NextQueuedItem();
var poison = _poisonConverter(item);
storage.Poison(item, poison);
Assert.True(storage.GetPoisoned().SequenceEqual(new [] { poison }, GenericEqualityComparer <TQueuePoison> .
ByAllMembers()));
}
public void ResetAllPendingToQueued_PreservesOriginalOrder()
{
var storage = JobStorageFactory();
var queueItems = Fixture.CreateMany <TQueue>(15).ToList();
foreach (var item in queueItems)
{
storage.Queue(item);
}
storage.ResetAllPendingToQueued();
List <TQueue> items = SlideItemsToPending(storage).ToList();
Assert.True(queueItems.SequenceEqual(items, GenericEqualityComparer <TQueue> .ByAllMembers()));
}
public void GetPoisoned_PreservesOrdering()
{
var storage = JobStorageFactory();
List <TQueuePoison> poisonedItems = new List <TQueuePoison>();
foreach (var item in Fixture.CreateMany <TQueue>(15))
{
storage.Queue(item);
storage.NextQueuedItem();
var poisoned = _poisonConverter(item);
poisonedItems.Add(poisoned);
storage.Poison(item, poisoned);
}
Assert.True(poisonedItems.SequenceEqual(storage.GetPoisoned(), GenericEqualityComparer <TQueuePoison> .ByAllMembers())
);
}
public static void Subscribe_PublishesExactSequenceOfItemsOverMultipleElapsedIntervals()
{
var jobStorage = A.Fake <IDurableJobQueue <Incoming, Incoming> >();
var scheduler = new HistoricalScheduler();
var monitor = new DurableJobQueueMonitor <Incoming, Incoming>(jobStorage, 20, DurableJobQueueMonitor.DefaultPollingInterval, scheduler);
List <Incoming> incomingItems = new List <Incoming>();
var queuedItems = Enumerable.Repeat(Item.From(new Incoming()
{
Id = 1
}), 5)
.Concat(new [] { Item.None <Incoming>() })
.Concat(Enumerable.Repeat(Item.From(new Incoming()
{
Id = 2
}), 5))
.Concat(new [] { Item.None <Incoming>() })
.Concat(Enumerable.Repeat(Item.From(new Incoming()
{
Id = 1
}), 2))
.Concat(new [] { Item.None <Incoming>() }).ToArray();
using (var subscription = monitor.Subscribe(publishedItem => { incomingItems.Add(publishedItem); }))
{
A.CallTo(() => jobStorage.NextQueuedItem()).ReturnsNextFromSequence(queuedItems);
scheduler.AdvanceBy(monitor.PollingInterval);
scheduler.AdvanceBy(monitor.PollingInterval);
scheduler.AdvanceBy(monitor.PollingInterval);
Assert.True(queuedItems.Where(item => item.Success)
.Select(item => item.Value)
.SequenceEqual(incomingItems, GenericEqualityComparer <Incoming> .ByAllMembers()));
}
}
public IDurableJobQueue <TQueueInput, TQueuePoison> CreateDurableJobQueue <TQueueInput, TQueuePoison>()
{
return(new TransientJobQueue <TQueueInput, TQueuePoison>(GenericEqualityComparer <TQueueInput> .ByAllMembers(), GenericEqualityComparer <TQueuePoison> .ByAllMembers()));
}
private static IDurableJobQueue <TQueue, TQueuePoison> GetTransient()
{
return(new TransientJobQueue <TQueue, TQueuePoison>(GenericEqualityComparer <TQueue> .ByAllMembers(),
GenericEqualityComparer <TQueuePoison> .ByAllMembers()));
}
protected TransientJobQueueTest(Func <TQueue, TQueuePoison> poisonConverter)
: base(() => new TransientJobQueue <TQueue, TQueuePoison>(GenericEqualityComparer <TQueue> .ByAllMembers(), GenericEqualityComparer <TQueuePoison> .ByAllMembers()), poisonConverter)
{
}
public void Constructor_Throws_OnNullPoisonComparer()
{
Assert.Throws <ArgumentNullException>(() => new TransientJobQueue <TQueue, TQueuePoison>(GenericEqualityComparer <TQueue> .ByAllMembers(), null));
}
public void Equal_ThrowsOnMoreThanOneComparerForATypeInList()
{
Assert.Throws <ArgumentException>(() => MemberComparer.Equal(4, 4, new[] { GenericEqualityComparer <int> .ByAllMembers(), GenericEqualityComparer <int> .ByAllMembers() }));
}
public void FromJobSpecification_Inspect_ReturnsExpectedQueuePoison_OnFailedJobResult()
{
int input = 2;
var exception = new ArgumentException();
var inspectionResult = GetFailedInspectionResult(input, exception);
Assert.Equal(new Poison <int>(input, exception), inspectionResult.QueuePoison, GenericEqualityComparer <Poison <int> > .ByAllMembers());
}
