public void SutIsInitiallyEmpty(
[Frozen(As = typeof(IAtomEventStorage))] AtomEventsInMemory dummyInjectedIntoSut,
LifoEvents <XmlAttributedTestEventX> sut)
{
Assert.False(sut.Any(), "Intial event stream should be empty.");
Assert.Empty(sut);
}
public void EnumerationStartsFromMostRecentEventEvenIfLastLinkIsStale(
int pageCount,
int staleCount,
[Frozen(As = typeof(ITypeResolver))] TestEventTypeResolver dummyResolver,
[Frozen(As = typeof(IContentSerializer))] XmlContentSerializer dummySerializer,
[Frozen(As = typeof(IAtomEventStorage))] AtomEventsInMemory storage,
[Frozen] UuidIri id,
LifoEvents <IXmlAttributedTestEvent> sut,
AtomEventObserver <XmlAttributedTestEventX> writer,
Generator <XmlAttributedTestEventX> eventGenerator)
{
// Fixture setup
var events =
eventGenerator.Take(writer.PageSize * pageCount + 1).ToList();
events.ForEach(writer.OnNext);
/* Point the 'last' link to an older page, instead of to the last
* page. This simulates that when the true last page was created,
* the index wasn't correctly updated. This could for example
* happen due to a network failure. */
var writtenFeeds = storage.Feeds.Select(ParseAtomFeed);
var lastPage = FindLastPage(writtenFeeds, id);
var olderPage =
FindPreviousPage(lastPage, writtenFeeds, staleCount);
var staleLastLink =
olderPage.Links.Single(l => l.IsSelfLink).ToLastLink();
var index = FindIndex(writtenFeeds, id);
index = index.WithLinks(index.Links
.Where(l => !l.IsLastLink)
.Concat(new[] { staleLastLink }));
using (var w = storage.CreateFeedWriterFor(index))
index.WriteTo(w, sut.Serializer);
// Exercise system
/* (The method being exercised is actual GetEnumerator and the
* returned implementation of IEnumerator<T>, but ToList or ToArray
* or similar methods triggers that.) */
var actual = sut.ToList();
// Verify outcome
var expected = events.AsEnumerable().Reverse();
Assert.True(
expected.SequenceEqual(actual),
"All written events should be enumerated in correct order.");
}
public void SutCanAppendAndYieldPolymorphicEvents(
[Frozen(As = typeof(ITypeResolver))] TestEventTypeResolver dummyResolver,
[Frozen(As = typeof(IContentSerializer))] XmlContentSerializer dummySerializer,
[Frozen(As = typeof(IAtomEventStorage))] AtomEventsInMemory dummyInjectedIntoSut,
[Frozen] UuidIri dummyId,
AtomEventObserver <IXmlAttributedTestEvent> writer,
LifoEvents <IXmlAttributedTestEvent> sut,
XmlAttributedTestEventX tex,
XmlAttributedTestEventY tey)
{
writer.AppendAsync(tex).Wait();
writer.AppendAsync(tey).Wait();
var expected = new IXmlAttributedTestEvent[] { tey, tex };
Assert.True(expected.SequenceEqual(sut));
}
public void ReverseReturnsCorrectResult(
UuidIri id,
AtomEventsInMemory storage,
XmlContentSerializer serializer)
{
var sut =
new LifoEvents <XmlAttributedTestEventX>(id, storage, serializer);
var expected =
new FifoEvents <XmlAttributedTestEventX>(id, storage, serializer);
var actual = sut.Reverse();
var fifo = Assert.IsType <FifoEvents <XmlAttributedTestEventX> >(actual);
Assert.Equal(expected.Id, fifo.Id);
Assert.Equal(expected.Storage, fifo.Storage);
Assert.Equal(expected.Serializer, fifo.Serializer);
}
public void ReverseYieldsCorrectEvents(
[Frozen(As = typeof(ITypeResolver))] TestEventTypeResolver dummyResolver,
[Frozen(As = typeof(IContentSerializer))] XmlContentSerializer dummySerializer,
[Frozen(As = typeof(IAtomEventStorage))] AtomEventsInMemory dummyInjectedIntoSut,
[Frozen] UuidIri dummyId,
AtomEventObserver <XmlAttributedTestEventX> writer,
LifoEvents <XmlAttributedTestEventX> sut,
List <XmlAttributedTestEventX> expected)
{
expected.ForEach(e => writer.AppendAsync(e).Wait());
var actual = sut.Reverse();
Assert.True(
expected.SequenceEqual(actual),
"Events should be yielded in a FIFO order");
Assert.True(
expected.Cast <object>().SequenceEqual(actual.OfType <object>()),
"Events should be yielded in a FIFO order");
}
public void SutYieldsPagedEvents(
[Frozen(As = typeof(ITypeResolver))] TestEventTypeResolver dummyResolver,
[Frozen(As = typeof(IContentSerializer))] XmlContentSerializer dummySerializer,
[Frozen(As = typeof(IAtomEventStorage))] AtomEventsInMemory dummyInjectedIntoSut,
[Frozen] UuidIri dummyId,
AtomEventObserver <XmlAttributedTestEventX> writer,
LifoEvents <XmlAttributedTestEventX> sut,
Generator <XmlAttributedTestEventX> eventGenerator)
{
var expected = eventGenerator.Take(writer.PageSize * 2 + 1).ToList();
Enumerable
.Reverse(expected)
.ToList()
.ForEach(e => writer.AppendAsync(e).Wait());
Assert.True(
expected.SequenceEqual(sut),
"Events should be yielded in a LIFO order");
Assert.True(
expected.Cast <object>().SequenceEqual(sut.OfType <object>()),
"Events should be yielded in a LIFO order");
}
public void SutIsEnumerable(LifoEvents <XmlAttributedTestEventX> sut)
{
Assert.IsAssignableFrom <IEnumerable <XmlAttributedTestEventX> >(sut);
}
