public void AppendAsyncTwicePageSizeEventDoesNotAddPreviousLinkToPreviousPage( [Frozen(As = typeof(IAtomEventStorage))] AtomEventsInMemory storage, AtomFeedParser <XmlContentSerializer> parser, AtomEventStream <XmlAttributedTestEventX> sut, Generator <XmlAttributedTestEventX> eventGenerator) { var before = DateTimeOffset.Now; var events = eventGenerator.Take(sut.PageSize * 2).ToList(); events.ForEach(e => sut.AppendAsync(e).Wait()); var writtenIndex = storage.Feeds .Select(parser.Parse) .Single(f => f.Id == sut.Id); UuidIri previousPageId = Guid.Parse( writtenIndex.Links .Single(AtomEventStream.IsPreviousFeedLink) .Href.ToString()); var previousPage = storage.Feeds .Select(parser.Parse) .Single(f => f.Id == previousPageId); Assert.Equal( 0, previousPage.Links.Count(AtomEventStream.IsPreviousFeedLink)); }
public void AppendAsyncMoreThanPageSizeEventsStoresPreviousPage( [Frozen(As = typeof(IAtomEventStorage))] AtomEventsInMemory storage, AtomFeedParser <XmlContentSerializer> parser, AtomEventStream <XmlAttributedTestEventX> sut, Generator <XmlAttributedTestEventX> eventGenerator) { var before = DateTimeOffset.Now; var events = eventGenerator.Take(sut.PageSize + 1).ToList(); events.ForEach(e => sut.AppendAsync(e).Wait()); var writtenIndex = storage.Feeds .Select(parser.Parse) .Single(f => f.Id == sut.Id); UuidIri previousPageId = Guid.Parse( writtenIndex.Links .Single(AtomEventStream.IsPreviousFeedLink) .Href.ToString()); Assert.True( storage.Feeds .Select(parser.Parse) .Any(f => f.Id == previousPageId), "The previous feed should have been stored."); }
public void NewIdReturnsUniqueId() { var x = UuidIri.NewId(); var y = UuidIri.NewId(); Assert.NotEqual(x, y); }
public void ReadNonPersistedFeedReturnsCorrectFeed( AtomEventsInMemory sut, UuidIri id, IContentSerializer dummySerializer) { var expectedSelfLink = AtomLink.CreateSelfLink( new Uri( ((Guid)id).ToString(), UriKind.Relative)); var before = DateTimeOffset.Now; using (var r = sut.CreateFeedReaderFor(expectedSelfLink.Href)) { var actual = AtomFeed.ReadFrom(r, dummySerializer); Assert.Equal(id, actual.Id); Assert.Equal("Index of event stream " + (Guid)id, actual.Title); Assert.True(before <= actual.Updated, "Updated should be very recent."); Assert.True(actual.Updated <= DateTimeOffset.Now, "Updated should not be in the future."); Assert.Empty(actual.Entries); Assert.Contains( expectedSelfLink, actual.Links); } }
private static AtomFeed FindIndex(IEnumerable <AtomFeed> pages, UuidIri id) { var index = pages.SingleOrDefault(f => f.Id == id); Assert.NotNull(index); return(index); }
public void AppendAsyncMoreThanPageSizeEventsStoresOldestEventsInPreviousPage( [Frozen(As = typeof(IAtomEventStorage))] AtomEventsInMemory storage, AtomFeedParser <XmlContentSerializer> parser, AtomEventStream <XmlAttributedTestEventX> sut, Generator <XmlAttributedTestEventX> eventGenerator) { var before = DateTimeOffset.Now; var events = eventGenerator.Take(sut.PageSize + 1).ToList(); events.ForEach(e => sut.AppendAsync(e).Wait()); var writtenIndex = storage.Feeds .Select(parser.Parse) .Single(f => f.Id == sut.Id); UuidIri previousPageId = Guid.Parse( writtenIndex.Links .Single(AtomEventStream.IsPreviousFeedLink) .Href.ToString()); var actualPreviousPage = storage.Feeds .Select(parser.Parse) .Single(f => f.Id == previousPageId); var expectedPreviousPage = new AtomFeedLikeness( before, previousPageId, events.AsEnumerable().Reverse().Skip(1).ToArray()); Assert.True( expectedPreviousPage.Equals(actualPreviousPage), "Expected feed must match actual feed."); }
public void IdIsCorrect( [Frozen] UuidIri expected, AtomEventStream <DataContractTestEventX> sut) { UuidIri actual = sut.Id; Assert.Equal(expected, actual); }
public void GuidCorrectlyConvertsToSut( UuidIri sut) { Guid expected = sut; UuidIri actual = expected; Assert.Equal <Guid>(expected, actual); }
public void SutCorrectlyConvertsToGuid( [Frozen] Guid expected, UuidIri sut) { Guid actual = sut; Assert.Equal(expected, actual); }
public void IsPreviousFeedLinkReturnsTrueForPreviousFeedLink( UuidIri id) { var link = AtomEventStream.CreatePreviousLinkFrom(id); bool actual = AtomEventStream.IsPreviousFeedLink(link); Assert.True(actual); }
public void IsPreviousFeedLinkReturnsFalsForLinkWithIncorrectRel( UuidIri id) { var link = AtomEventStream.CreateSelfLinkFrom(id); var actual = AtomEventStream.IsPreviousFeedLink(link); Assert.False(actual); }
public void GetHashCodeReturnsCorrectResult( UuidIri sut) { var actual = sut.GetHashCode(); var expected = ((Guid)sut).GetHashCode(); Assert.Equal(expected, actual); }
public AtomFeedLikeness( DateTimeOffset minimumTime, UuidIri expectedId, params object[] expectedEvents) { this.minimumTime = minimumTime; this.expectedId = expectedId; this.expectedEvents = expectedEvents; }
public AtomFeedLikeness( DateTimeOffset minimumTime, UuidIri expectedId, params object[] expectedEvents) { this.minimumTime = minimumTime; this.expectedId = expectedId; this.expectedEvents = expectedEvents; }
public void ParseNullReturnsCorrectResult() { UuidIri actualFromTry; bool couldParse = UuidIri.TryParse(null, out actualFromTry); Assert.Throws <ArgumentNullException>(() => UuidIri.Parse(null)); Assert.False(couldParse, "TryParse should fail."); Assert.Equal(default(UuidIri), actualFromTry); }
private static AtomFeed FindLastPage(IEnumerable <AtomFeed> pages, UuidIri id) { var page = FindFirstPage(pages, id); while (page.Links.Any(l => l.IsNextLink)) { page = FindNextPage(page, pages); } return(page); }
private static AtomFeed FindFirstPage(IEnumerable <AtomFeed> pages, UuidIri id) { var index = FindIndex(pages, id); var firstLink = index.Links.SingleOrDefault(l => l.IsFirstLink); Assert.NotNull(firstLink); var firstPage = pages.SingleOrDefault(f => f.Links.Single(l => l.IsSelfLink).Href == firstLink.Href); Assert.NotNull(firstPage); return(firstPage); }
public void CreatePreviousLinkFromReturnsCorrectResult( UuidIri id) { AtomLink actual = AtomEventStream.CreatePreviousLinkFrom(id); var expected = AtomLink.CreatePreviousLink( new Uri( ((Guid)id).ToString(), UriKind.Relative)); Assert.Equal(expected, actual); }
public void ParseStringWithIncorrectIdReturnsCorrectResult( DateTimeOffset notAGuid) { var incorrectlyIdd = "urn:uuid:" + notAGuid.ToString(); UuidIri actualFromTry; bool couldParse = UuidIri.TryParse(incorrectlyIdd, out actualFromTry); Assert.Throws <ArgumentException>(() => UuidIri.Parse(incorrectlyIdd)); Assert.False(couldParse, "TryParse should fail."); Assert.Equal(default(UuidIri), actualFromTry); }
public void ParseCorrectlyFormattedStringReturnsCorrectResult( UuidIri expected) { var correctlyFormatted = expected.ToString(); UuidIri actualFromTry; bool couldParse = UuidIri.TryParse(correctlyFormatted, out actualFromTry); UuidIri actual = UuidIri.Parse(correctlyFormatted); Assert.True(couldParse, "TryParse should succeed."); Assert.Equal(expected, actualFromTry); Assert.Equal(expected, actual); }
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 ParseIncorrectlyPrefixedStringReturnsCorrectResult( string incorrectPrefix, Guid guid) { Assert.NotEqual("urn:uuid:", incorrectPrefix); var inccorectlyPrefixed = incorrectPrefix + guid; UuidIri actualFromTry; bool couldParse = UuidIri.TryParse(inccorectlyPrefixed, out actualFromTry); Assert.Throws <ArgumentException>(() => UuidIri.Parse(inccorectlyPrefixed)); Assert.False(couldParse, "TryParse should fail."); Assert.Equal(default(UuidIri), actualFromTry); }
public void TwoSutsWithIdenticalIdAreEqual(Guid guid) { UuidIri sut = guid; UuidIri other = guid; var actual1 = sut.Equals((object)other); var actual2 = sut.Equals(other); var actual3 = sut == other; var actual4 = sut != other; Assert.True(actual1, "Equals(object)"); Assert.True(actual2, "Equals(UuidIri)"); Assert.True(actual3, "=="); Assert.False(actual4, "!="); }
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 SutYieldsCorrectEvents( [Frozen(As = typeof(ITypeResolver))] TestEventTypeResolver dummyResolver, [Frozen(As = typeof(IContentSerializer))] XmlContentSerializer dummySerializer, [Frozen(As = typeof(IAtomEventStorage))] AtomEventsInMemory dummyInjectedIntoSut, [Frozen] UuidIri dummyId, AtomEventObserver <XmlAttributedTestEventX> writer, FifoEvents <XmlAttributedTestEventX> sut, List <XmlAttributedTestEventX> expected) { expected.ForEach(e => writer.AppendAsync(e).Wait()); Assert.True( expected.SequenceEqual(sut), "Events should be yielded in a FIFO order"); Assert.True( expected.Cast <object>().SequenceEqual(sut.OfType <object>()), "Events should be yielded in a FIFO order"); }
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 TwoSutsWithDifferentIdsAreNotEquals( Guid x, Guid y) { Assert.NotEqual(x, y); UuidIri sut = x; UuidIri other = y; var actual1 = sut.Equals((object)other); var actual2 = sut.Equals(other); var actual3 = sut == other; var actual4 = sut != other; Assert.False(actual1, "Equals(object)"); Assert.False(actual2, "Equals(UuidIri)"); Assert.False(actual3, "=="); Assert.True(actual4, "!="); }
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"); }
/// <summary> /// Initializes a new instance of the <see cref="AtomFeed"/> class. /// </summary> /// <param name="id">The ID of the Atom Feed.</param> /// <param name="title">The title of the Atom Feed.</param> /// <param name="updated"> /// The date and time the Atom Feed was last updated. /// </param> /// <param name="author">The author of the Atom Feed.</param> /// <param name="entries">The entries of the Atom Feed.</param> /// <param name="links">The links of the Atom Feed itself.</param> /// <remarks> /// <para> /// All values passed into this constructor are subsequently available /// as properties on the instance. /// </para> /// </remarks> /// <exception cref="System.ArgumentNullException"> /// <paramref name="title" /> /// or /// <paramref name="author" /> /// or /// <paramref name="entries" /> /// or /// <paramref name="links" /> /// is <see langword="null" />. /// </exception> public AtomFeed( UuidIri id, string title, DateTimeOffset updated, AtomAuthor author, IEnumerable<AtomEntry> entries, IEnumerable<AtomLink> links) { if (title == null) throw new ArgumentNullException("title"); if (author == null) throw new ArgumentNullException("author"); if (entries == null) throw new ArgumentNullException("entries"); if (links == null) throw new ArgumentNullException("links"); this.id = id; this.title = title; this.updated = updated; this.author = author; this.entries = entries; this.links = links; }
public void ReadNonPersistedFeedReturnsCorrectFeed( AtomEventsInMemory sut, UuidIri id, IContentSerializer dummySerializer) { var expectedSelfLink = AtomLink.CreateSelfLink( new Uri( ((Guid)id).ToString(), UriKind.Relative)); var before = DateTimeOffset.Now; using (var r = sut.CreateFeedReaderFor(expectedSelfLink.Href)) { var actual = AtomFeed.ReadFrom(r, dummySerializer); Assert.Equal(id, actual.Id); Assert.Equal("Index of event stream " + (Guid)id, actual.Title); Assert.True(before <= actual.Updated, "Updated should be very recent."); Assert.True(actual.Updated <= DateTimeOffset.Now, "Updated should not be in the future."); Assert.Empty(actual.Entries); Assert.Contains( expectedSelfLink, actual.Links); } }
public void ToStringReturnsCorrectResult([Frozen] Guid g, UuidIri sut) { var actual = sut.ToString(); Assert.Equal("urn:uuid:" + g, actual); }
public void SutIsEquatable(UuidIri sut) { Assert.IsAssignableFrom <IEquatable <UuidIri> >(sut); }
public void IdIsCorrect([Frozen] UuidIri expected, AtomEntry sut) { UuidIri actual = sut.Id; Assert.Equal(expected, actual); }