public void ReadASingleEvent() { var eventStreamId = new Guid("A0E50259-7345-48F9-84B4-BEEB5CEC662C"); using (var storage = new AtomEventsInMemory()) { var pageSize = 25; var serializer = DataContractContentSerializer.Scan( typeof(UserCreated).Assembly); var obs = new AtomEventObserver <object>( eventStreamId, pageSize, storage, serializer); var userCreated = new UserCreated { UserId = eventStreamId, UserName = "******", Password = "******", Email = "*****@*****.**" }; obs.OnNext(userCreated); IEnumerable <object> events = new FifoEvents <object>( eventStreamId, // a Guid storage, // an IAtomEventStorage object serializer); // an IContentSerializer object var firstEvent = events.First(); var uc = Assert.IsAssignableFrom <UserCreated>(firstEvent); Assert.Equal(userCreated, uc, new SemanticComparer <UserCreated>()); } }
public void WriteMoreThanPageSizeEventsWritesInCorrectOrder( AtomEventWriteUsage usage, [Frozen(As = typeof(ITypeResolver))] TestEventTypeResolver dummyResolver, [Frozen(As = typeof(IContentSerializer))] XmlContentSerializer dummySerializer, [Frozen(As = typeof(IAtomEventStorage))] SpyAtomEventStore spyStore, AtomEventWriterFactory <XmlAttributedTestEventX> writerFactory, AtomEventObserver <XmlAttributedTestEventX> sut, Generator <XmlAttributedTestEventX> eventGenerator) { var events = eventGenerator.Take(sut.PageSize + 1).ToList(); var writer = writerFactory.Create(usage); events.ForEach(e => writer.WriteTo(sut, e)); var writtenFeeds = spyStore.Feeds.Select(ParseAtomFeed); var firstPage = FindFirstPage(writtenFeeds, sut.Id); var nextPage = FindNextPage(firstPage, writtenFeeds); var expected = new[] { nextPage.Id, firstPage.Id, sut.Id }; var actual = spyStore .ObservedArguments .OfType <AtomFeed>() .Select(f => f.Id) .Reverse() .Take(3) .Reverse(); Assert.Equal(expected, actual); }
public void WriteMoreThanPageSizeEventsAddsNextPageWithPreviousLink( AtomEventWriteUsage usage, [Frozen(As = typeof(ITypeResolver))] TestEventTypeResolver dummyResolver, [Frozen(As = typeof(IContentSerializer))] XmlContentSerializer dummySerializer, [Frozen(As = typeof(IAtomEventStorage))] AtomEventsInMemory storage, AtomEventWriterFactory <XmlAttributedTestEventX> writerFactory, AtomEventObserver <XmlAttributedTestEventX> sut, Generator <XmlAttributedTestEventX> eventGenerator) { var events = eventGenerator.Take(sut.PageSize + 1).ToList(); var writer = writerFactory.Create(usage); events.ForEach(e => writer.WriteTo(sut, e)); var writtenFeeds = storage.Feeds.Select(ParseAtomFeed); var firstPage = FindFirstPage(writtenFeeds, sut.Id); var nextPage = FindNextPage(firstPage, writtenFeeds); var previousLink = nextPage.Links.SingleOrDefault(l => l.IsPreviousLink); Assert.NotNull(previousLink); Assert.Equal( firstPage.Links.Single(l => l.IsSelfLink).Href, previousLink.Href); }
public async Task WriteASingleEventAsynchronously() { var eventStreamId = new Guid("A0E50259-7345-48F9-84B4-BEEB5CEC662C"); using (var storage = new AtomEventsInMemory()) { var pageSize = 25; var serializer = DataContractContentSerializer.Scan( typeof(UserCreated).Assembly); var obs = new AtomEventObserver<object>( eventStreamId, // a Guid pageSize, // an Int32 storage, // an IAtomEventStorage object serializer); // an IContentSerializer object var userCreated = new UserCreated { UserId = eventStreamId, UserName = "******", Password = "******", Email = "*****@*****.**" }; await obs.AppendAsync(userCreated); Assert.NotEmpty(storage); } }
public void WriteMoreThanTwicePageSizeCorrectlyStoresOverflowingEvent( AtomEventWriteUsage usage, [Frozen(As = typeof(ITypeResolver))] TestEventTypeResolver dummyResolver, [Frozen(As = typeof(IContentSerializer))] XmlContentSerializer dummySerializer, [Frozen(As = typeof(IAtomEventStorage))] AtomEventsInMemory storage, AtomEventWriterFactory <XmlAttributedTestEventX> writerFactory, AtomEventObserver <XmlAttributedTestEventX> sut, Generator <XmlAttributedTestEventX> eventGenerator) { var before = DateTimeOffset.Now; var events = eventGenerator.Take(sut.PageSize * 2 + 1).ToList(); var writer = writerFactory.Create(usage); events.ForEach(e => writer.WriteTo(sut, e)); var writtenFeeds = storage.Feeds.Select(ParseAtomFeed); var firstPage = FindFirstPage(writtenFeeds, sut.Id); var nextPage = FindNextPage(firstPage, writtenFeeds); nextPage = FindNextPage(nextPage, writtenFeeds); var expectedPage = new AtomFeedLikeness( before, nextPage.Id, events.AsEnumerable().Reverse().First()); Assert.True( expectedPage.Equals(nextPage), "Expected feed must match actual feed."); }
public void ReadASingleEvent() { var eventStreamId = new Guid("A0E50259-7345-48F9-84B4-BEEB5CEC662C"); using (var storage = new AtomEventsInMemory()) { var pageSize = 25; var serializer = DataContractContentSerializer.Scan( typeof(UserCreated).Assembly); var obs = new AtomEventObserver<object>( eventStreamId, pageSize, storage, serializer); var userCreated = new UserCreated { UserId = eventStreamId, UserName = "******", Password = "******", Email = "*****@*****.**" }; obs.OnNext(userCreated); IEnumerable<object> events = new FifoEvents<object>( eventStreamId, // a Guid storage, // an IAtomEventStorage object serializer); // an IContentSerializer object var firstEvent = events.First(); var uc = Assert.IsAssignableFrom<UserCreated>(firstEvent); Assert.Equal(userCreated, uc, new SemanticComparer<UserCreated>()); } }
public async Task WriteASingleEventAsynchronously() { var eventStreamId = new Guid("A0E50259-7345-48F9-84B4-BEEB5CEC662C"); using (var storage = new AtomEventsInMemory()) { var pageSize = 25; var serializer = DataContractContentSerializer.Scan( typeof(UserCreated).Assembly); var obs = new AtomEventObserver <IUserEvent>( eventStreamId, // a Guid pageSize, // an Int32 storage, // an IAtomEventStorage object serializer); // an IContentSerializer object var userCreated = new UserCreated { UserId = eventStreamId, UserName = "******", Password = "******", Email = "*****@*****.**" }; await obs.AppendAsync(userCreated); Assert.NotEmpty(storage); } }
public void WriteMoreThanPageSizeEventsCorrectlyUpdatesLastLink( AtomEventWriteUsage usage, [Frozen(As = typeof(ITypeResolver))] TestEventTypeResolver dummyResolver, [Frozen(As = typeof(IContentSerializer))] XmlContentSerializer dummySerializer, [Frozen(As = typeof(IAtomEventStorage))] AtomEventsInMemory storage, AtomEventWriterFactory <XmlAttributedTestEventX> writerFactory, AtomEventObserver <XmlAttributedTestEventX> sut, Generator <XmlAttributedTestEventX> eventGenerator) { var before = DateTimeOffset.Now; var events = eventGenerator.Take(sut.PageSize + 1).ToList(); var writer = writerFactory.Create(usage); events.ForEach(e => writer.WriteTo(sut, e)); var writtenFeeds = storage.Feeds.Select(ParseAtomFeed); var index = FindIndex(writtenFeeds, sut.Id); var lastLink = index.Links.SingleOrDefault(l => l.IsLastLink); Assert.NotNull(lastLink); var firstPage = FindFirstPage(writtenFeeds, sut.Id); var nextPage = FindNextPage(firstPage, writtenFeeds); var expected = nextPage.Links.SingleOrDefault(l => l.IsSelfLink); Assert.NotNull(expected); Assert.Equal(expected.Href, lastLink.Href); }
public void WritePageSizeEventsStoresAllEntriesInFirstPage( AtomEventWriteUsage usage, [Frozen(As = typeof(ITypeResolver))] TestEventTypeResolver dummyResolver, [Frozen(As = typeof(IContentSerializer))] XmlContentSerializer dummySerializer, [Frozen(As = typeof(IAtomEventStorage))] AtomEventsInMemory storage, AtomEventWriterFactory <XmlAttributedTestEventX> writerFactory, AtomEventObserver <XmlAttributedTestEventX> sut, Generator <XmlAttributedTestEventX> eventGenerator) { var before = DateTimeOffset.Now; var events = eventGenerator.Take(sut.PageSize).ToList(); var writer = writerFactory.Create(usage); events.ForEach(e => writer.WriteTo(sut, e)); var writtenFeeds = storage.Feeds.Select(ParseAtomFeed); var actual = FindFirstPage(writtenFeeds, sut.Id); var expectedFeed = new AtomFeedLikeness( before, actual.Id, events.AsEnumerable().Reverse().ToArray()); Assert.True( expectedFeed.Equals(actual), "Expected feed must match actual feed."); }
public void WriteFirstEventFailsIfWritingIndexFails( AtomEventWriteUsage usage, [Frozen(As = typeof(ITypeResolver))] TestEventTypeResolver dummyResolver, [Frozen(As = typeof(IContentSerializer))] XmlContentSerializer dummySerializer, [Frozen] Mock <IAtomEventStorage> storeStub, AtomEventsInMemory innerStorage, AtomEventWriterFactory <XmlAttributedTestEventX> writerFactory, AtomEventObserver <XmlAttributedTestEventX> sut, XmlAttributedTestEventX @event) { storeStub .Setup(s => s.CreateFeedReaderFor(It.IsAny <Uri>())) .Returns((Uri u) => innerStorage.CreateFeedReaderFor(u)); storeStub .Setup(s => s.CreateFeedWriterFor( It.Is <AtomFeed>(f => f.Id != sut.Id))) .Returns((AtomFeed f) => innerStorage.CreateFeedWriterFor(f)); var expected = new Exception("On-purpose write failure."); storeStub .Setup(s => s.CreateFeedWriterFor( It.Is <AtomFeed>(f => f.Id == sut.Id))) .Throws(expected); var ae = Assert.Throws <AggregateException>(() => writerFactory.Create(usage).WriteTo(sut, @event)); Assert.True( ae.InnerExceptions.Any(expected.Equals), "Expected exception not thrown."); }
public void ReadMultipleEvents() { var eventStreamId = new Guid("A0E50259-7345-48F9-84B4-BEEB5CEC662C"); using (var storage = new AtomEventsInMemory()) { var pageSize = 25; var serializer = new DataContractContentSerializer( new TypeResolutionTable( new TypeResolutionEntry( "urn:grean:samples:user-sign-up", "user-created", typeof(UserCreated)), new TypeResolutionEntry( "urn:grean:samples:user-sign-up", "email-verified", typeof(EmailVerified)), new TypeResolutionEntry( "urn:grean:samples:user-sign-up", "email-changed", typeof(EmailChanged)))); var obs = new AtomEventObserver <IUserEvent>( eventStreamId, pageSize, storage, serializer); obs.OnNext(new UserCreated { UserId = eventStreamId, UserName = "******", Password = "******", Email = "*****@*****.**" }); obs.OnNext(new EmailVerified { UserId = eventStreamId, Email = "*****@*****.**" }); obs.OnNext(new EmailChanged { UserId = eventStreamId, NewEmail = "*****@*****.**" }); var events = new FifoEvents <IUserEvent>( eventStreamId, // a Guid storage, // an IAtomEventStorage object serializer); // an IContentSerializer object var user = User.Fold(events); Assert.Equal(eventStreamId, user.Id); Assert.Equal("ploeh", user.Name); Assert.Equal("12345", user.Password); Assert.Equal("*****@*****.**", user.Email); Assert.False(user.EmailVerified); } }
public void PublishMessage(DomainEvent thingToPublish) { var obs = new AtomEventObserver<DomainEvent>( Guid.NewGuid(), 400, new AtomEventsInMemory(), new DataContractContentSerializer(new TypeResolutionTable(new List<TypeResolutionEntry>()))); obs.AppendAsync(thingToPublish); }
public void PublishMessage(DomainEvent thingToPublish) { var obs = new AtomEventObserver <DomainEvent>( Guid.NewGuid(), 400, new AtomEventsInMemory(), new DataContractContentSerializer(new TypeResolutionTable(new List <TypeResolutionEntry>()))); obs.AppendAsync(thingToPublish); }
public void WriteASingleEventSynchronously() { var eventStreamId = new Guid("A0E50259-7345-48F9-84B4-BEEB5CEC662C"); /* Uses file storage to provide a documentation example of how to * do that. */ var directory = new DirectoryInfo( Path.Combine( Environment.CurrentDirectory, Guid.NewGuid().ToString("N"))); try { var storage = new AtomEventsInFiles(directory); var pageSize = 25; var serializer = new DataContractContentSerializer( new TypeResolutionTable( new TypeResolutionEntry( "urn:grean:samples:user-sign-up", "user-created", typeof(UserCreated)), new TypeResolutionEntry( "urn:grean:samples:user-sign-up", "email-verified", typeof(EmailVerified)), new TypeResolutionEntry( "urn:grean:samples:user-sign-up", "email-changed", typeof(EmailChanged)))); IObserver <IUserEvent> obs = new AtomEventObserver <IUserEvent>( eventStreamId, // a Guid pageSize, // an Int32 storage, // an IAtomEventStorage object serializer); // an IContentSerializer object var userCreated = new UserCreated { UserId = eventStreamId, UserName = "******", Password = "******", Email = "*****@*****.**" }; obs.OnNext(userCreated); Assert.NotEmpty(storage); } finally { directory.Delete(recursive: true); } }
public void WriteWritesEventToCorrectPageEvenIfLastLinkIsNotUpToDate( AtomEventWriteUsage usage, [Frozen(As = typeof(ITypeResolver))] TestEventTypeResolver dummyResolver, [Frozen(As = typeof(IContentSerializer))] XmlContentSerializer dummySerializer, [Frozen(As = typeof(IAtomEventStorage))] AtomEventsInMemory storage, AtomEventWriterFactory <XmlAttributedTestEventX> writerFactory, AtomEventObserver <XmlAttributedTestEventX> sut, Generator <XmlAttributedTestEventX> eventGenerator) { // Fixture setup var writer = writerFactory.Create(usage); var events = eventGenerator.Take(sut.PageSize * 2 + 1).ToList(); events.ForEach(e => writer.WriteTo(sut, e)); /* Point the 'last' link to the second 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 index = FindIndex(writtenFeeds, sut.Id); var firstPage = FindFirstPage(writtenFeeds, sut.Id); var nextPage = FindNextPage(firstPage, writtenFeeds); var incorrectLastLink = nextPage.Links.Single(l => l.IsSelfLink).ToLastLink(); index = index.WithLinks(index.Links .Where(l => !l.IsLastLink) .Concat(new[] { incorrectLastLink })); using (var w = storage.CreateFeedWriterFor(index)) index.WriteTo(w, sut.Serializer); var expected = eventGenerator.First(); // Exercise system writer.WriteTo(sut, expected); // Verify outcome writtenFeeds = storage.Feeds.Select(ParseAtomFeed); index = FindIndex(writtenFeeds, sut.Id); firstPage = FindFirstPage(writtenFeeds, sut.Id); nextPage = FindNextPage(firstPage, writtenFeeds); nextPage = FindNextPage(nextPage, writtenFeeds); Assert.Equal(expected, nextPage.Entries.First().Content.Item); Assert.Equal( nextPage.Links.Single(l => l.IsSelfLink).Href, index.Links.Single(l => l.IsLastLink).Href); // Teardown }
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 WriteASingleEventSynchronously() { var eventStreamId = new Guid("A0E50259-7345-48F9-84B4-BEEB5CEC662C"); /* Uses file storage to provide a documentation example of how to * do that. */ var directory = new DirectoryInfo( Path.Combine( Environment.CurrentDirectory, Guid.NewGuid().ToString("N"))); try { var storage = new AtomEventsInFiles(directory); var pageSize = 25; /* This is an example of using * DataContractContentSerializer.CreateTypeResolver, so it * should not be refactored to one of the terser * alternatives. */ var resolver = DataContractContentSerializer.CreateTypeResolver( typeof(UserCreated).Assembly); var serializer = new DataContractContentSerializer(resolver); IObserver <IUserEvent> obs = new AtomEventObserver <IUserEvent>( eventStreamId, // a Guid pageSize, // an Int32 storage, // an IAtomEventStorage object serializer); // an IContentSerializer object var userCreated = new UserCreated { UserId = eventStreamId, UserName = "******", Password = "******", Email = "*****@*****.**" }; obs.OnNext(userCreated); Assert.NotEmpty(storage); } finally { directory.Delete(recursive: true); } }
public void WriteFirstEventWritesPageBeforeIndex( AtomEventWriteUsage usage, [Frozen(As = typeof(ITypeResolver))] TestEventTypeResolver dummyResolver, [Frozen(As = typeof(IContentSerializer))] XmlContentSerializer dummySerializer, [Frozen(As = typeof(IAtomEventStorage))] SpyAtomEventStore spyStore, AtomEventWriterFactory <XmlAttributedTestEventX> writerFactory, AtomEventObserver <XmlAttributedTestEventX> sut, XmlAttributedTestEventX @event) { writerFactory.Create(usage).WriteTo(sut, @event); var feed = Assert.IsAssignableFrom <AtomFeed>( spyStore.ObservedArguments.Last()); Assert.Equal(sut.Id, feed.Id); }
public void ReadASingleEvent() { var eventStreamId = new Guid("A0E50259-7345-48F9-84B4-BEEB5CEC662C"); using (var storage = new AtomEventsInMemory()) { var pageSize = 25; var serializer = new DataContractContentSerializer( new TypeResolutionTable( new TypeResolutionEntry( "urn:grean:samples:user-on-boarding", "user-created", typeof(UserCreated)), new TypeResolutionEntry( "urn:grean:samples:user-on-boarding", "email-verified", typeof(EmailVerified)), new TypeResolutionEntry( "urn:grean:samples:user-on-boarding", "email-changed", typeof(EmailChanged)))); var obs = new AtomEventObserver <object>( eventStreamId, pageSize, storage, serializer); var userCreated = new UserCreated { UserId = eventStreamId, UserName = "******", Password = "******", Email = "*****@*****.**" }; obs.OnNext(userCreated); IEnumerable <object> events = new FifoEvents <object>( eventStreamId, // a Guid storage, // an IAtomEventStorage object serializer); // an IContentSerializer object var firstEvent = events.First(); var uc = Assert.IsAssignableFrom <UserCreated>(firstEvent); Assert.Equal(userCreated, uc, new SemanticComparer <UserCreated>()); } }
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 ReadMultipleEvents() { var eventStreamId = new Guid("A0E50259-7345-48F9-84B4-BEEB5CEC662C"); using (var storage = new AtomEventsInMemory()) { var pageSize = 25; var serializer = DataContractContentSerializer.Scan( typeof(UserCreated).Assembly); var obs = new AtomEventObserver <IUserEvent>( eventStreamId, pageSize, storage, serializer); obs.OnNext(new UserCreated { UserId = eventStreamId, UserName = "******", Password = "******", Email = "*****@*****.**" }); obs.OnNext(new EmailVerified { UserId = eventStreamId, Email = "*****@*****.**" }); obs.OnNext(new EmailChanged { UserId = eventStreamId, NewEmail = "*****@*****.**" }); var events = new FifoEvents <IUserEvent>( eventStreamId, // a Guid storage, // an IAtomEventStorage object serializer); // an IContentSerializer object var user = User.Fold(events); Assert.Equal(eventStreamId, user.Id); Assert.Equal("ploeh", user.Name); Assert.Equal("12345", user.Password); Assert.Equal("*****@*****.**", user.Email); Assert.False(user.EmailVerified); } }
public void WriteASingleEventSynchronously() { var eventStreamId = new Guid("A0E50259-7345-48F9-84B4-BEEB5CEC662C"); /* Uses file storage to provide a documentation example of how to * do that. */ var directory = new DirectoryInfo( Path.Combine( Environment.CurrentDirectory, Guid.NewGuid().ToString("N"))); try { var storage = new AtomEventsInFiles(directory); var pageSize = 25; /* This is an example of using * DataContractContentSerializer.CreateTypeResolver, so it * should not be refactored to one of the terser * alternatives. */ var resolver = DataContractContentSerializer.CreateTypeResolver( typeof(UserCreated).Assembly); var serializer = new DataContractContentSerializer(resolver); IObserver<IUserEvent> obs = new AtomEventObserver<IUserEvent>( eventStreamId, // a Guid pageSize, // an Int32 storage, // an IAtomEventStorage object serializer); // an IContentSerializer object var userCreated = new UserCreated { UserId = eventStreamId, UserName = "******", Password = "******", Email = "*****@*****.**" }; obs.OnNext(userCreated); Assert.NotEmpty(storage); } finally { directory.Delete(recursive: true); } }
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 WriteTwoEventsOnlyWritesIndexOnce( AtomEventWriteUsage usage, [Frozen(As = typeof(ITypeResolver))] TestEventTypeResolver dummyResolver, [Frozen(As = typeof(IContentSerializer))] XmlContentSerializer dummySerializer, [Frozen(As = typeof(IAtomEventStorage))] SpyAtomEventStore spyStore, AtomEventWriterFactory <XmlAttributedTestEventX> writerFactory, AtomEventObserver <XmlAttributedTestEventX> sut, Generator <XmlAttributedTestEventX> eventGenerator) { var events = eventGenerator.Take(2).ToList(); var writer = writerFactory.Create(usage); events.ForEach(e => writer.WriteTo(sut, e)); var writtenIds = spyStore.ObservedArguments .OfType <AtomFeed>() .Select(f => f.Id); Assert.Equal(1, writtenIds.Count(id => sut.Id == id)); }
public async Task WriteASingleEventAsynchronously() { var eventStreamId = new Guid("A0E50259-7345-48F9-84B4-BEEB5CEC662C"); using (var storage = new AtomEventsInMemory()) { var pageSize = 25; var serializer = new DataContractContentSerializer( new TypeResolutionTable( new TypeResolutionEntry( "urn:grean:samples:user-sign-up", "user-created", typeof(UserCreated)), new TypeResolutionEntry( "urn:grean:samples:user-sign-up", "email-verified", typeof(EmailVerified)), new TypeResolutionEntry( "urn:grean:samples:user-sign-up", "email-changed", typeof(EmailChanged)))); var obs = new AtomEventObserver <IUserEvent>( eventStreamId, // a Guid pageSize, // an Int32 storage, // an IAtomEventStorage object serializer); // an IContentSerializer object var userCreated = new UserCreated { UserId = eventStreamId, UserName = "******", Password = "******", Email = "*****@*****.**" }; await obs.AppendAsync(userCreated); Assert.NotEmpty(storage); } }
public void WriteCorrectlyStoresFeed( AtomEventWriteUsage usage, [Frozen(As = typeof(ITypeResolver))] TestEventTypeResolver dummyResolver, [Frozen(As = typeof(IContentSerializer))] XmlContentSerializer dummySerializer, [Frozen(As = typeof(IAtomEventStorage))] AtomEventsInMemory storage, AtomEventWriterFactory <XmlAttributedTestEventX> writerFactory, AtomEventObserver <XmlAttributedTestEventX> sut, XmlAttributedTestEventX expectedEvent) { var before = DateTimeOffset.Now; writerFactory.Create(usage).WriteTo(sut, expectedEvent); var writtenFeeds = storage.Feeds.Select(ParseAtomFeed); var actual = FindFirstPage(writtenFeeds, sut.Id); var expectedFeed = new AtomFeedLikeness(before, actual.Id, expectedEvent); Assert.True( expectedFeed.Equals(actual), "Expected feed must match actual feed."); }
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 WriteCorrectlyStoresLastLinkOnIndex( AtomEventWriteUsage usage, [Frozen(As = typeof(ITypeResolver))] TestEventTypeResolver dummyResolver, [Frozen(As = typeof(IContentSerializer))] XmlContentSerializer dummySerializer, [Frozen(As = typeof(IAtomEventStorage))] AtomEventsInMemory storage, AtomEventWriterFactory <XmlAttributedTestEventX> writerFactory, AtomEventObserver <XmlAttributedTestEventX> sut, XmlAttributedTestEventX expectedEvent) { var before = DateTimeOffset.Now; writerFactory.Create(usage).WriteTo(sut, expectedEvent); var writtenFeeds = storage.Feeds.Select(ParseAtomFeed); var index = FindIndex(writtenFeeds, sut.Id); var firstLink = index.Links.SingleOrDefault(l => l.IsFirstLink); Assert.NotNull(firstLink); var lastLink = index.Links.SingleOrDefault(l => l.IsLastLink); Assert.NotNull(lastLink); Assert.Equal(firstLink.Href, lastLink.Href); }
public void WriteTo(AtomEventObserver <T> observer, T @event) { observer.OnNext(@event); }
public void WriteTo(AtomEventObserver <T> observer, T @event) { observer.AppendAsync(@event).Wait(); }
public void OnCompletedDoesNotThrow( AtomEventObserver <DataContractTestEventX> sut) { Assert.DoesNotThrow(sut.OnCompleted); }
public void ReadMultipleEvents() { var eventStreamId = new Guid("A0E50259-7345-48F9-84B4-BEEB5CEC662C"); using (var storage = new AtomEventsInMemory()) { var pageSize = 25; /* This is an example of how to use the TypeResolutionEntry * class, so it should not be refactored to one of the terser * alternatives. */ var resolver = new TypeResolutionTable( new TypeResolutionEntry( "urn:grean:samples:user-on-boarding", "user-created", typeof(UserCreated)), new TypeResolutionEntry( "urn:grean:samples:user-on-boarding", "email-verified", typeof(EmailVerified)), new TypeResolutionEntry( "urn:grean:samples:user-on-boarding", "email-changed", typeof(EmailChanged))); var serializer = new DataContractContentSerializer(resolver); var obs = new AtomEventObserver <object>( eventStreamId, pageSize, storage, serializer); obs.OnNext(new UserCreated { UserId = eventStreamId, UserName = "******", Password = "******", Email = "*****@*****.**" }); obs.OnNext(new EmailVerified { UserId = eventStreamId, Email = "*****@*****.**" }); obs.OnNext(new EmailChanged { UserId = eventStreamId, NewEmail = "*****@*****.**" }); var events = new FifoEvents <object>( eventStreamId, // a Guid storage, // an IAtomEventStorage object serializer); // an IContentSerializer object var user = User.Fold(events); Assert.Equal(eventStreamId, user.Id); Assert.Equal("ploeh", user.Name); Assert.Equal("12345", user.Password); Assert.Equal("*****@*****.**", user.Email); Assert.False(user.EmailVerified); } }
public void OnErrorDoesNotThrow( AtomEventObserver <DataContractTestEventX> sut, Exception error) { Assert.DoesNotThrow(() => sut.OnError(error)); }
public void ReadMultipleEvents() { var eventStreamId = new Guid("A0E50259-7345-48F9-84B4-BEEB5CEC662C"); using (var storage = new AtomEventsInMemory()) { var pageSize = 25; var serializer = DataContractContentSerializer.Scan( typeof(UserCreated).Assembly); var obs = new AtomEventObserver<IUserEvent>( eventStreamId, pageSize, storage, serializer); obs.OnNext(new UserCreated { UserId = eventStreamId, UserName = "******", Password = "******", Email = "*****@*****.**" }); obs.OnNext(new EmailVerified { UserId = eventStreamId, Email = "*****@*****.**" }); obs.OnNext(new EmailChanged { UserId = eventStreamId, NewEmail = "*****@*****.**" }); var events = new FifoEvents<IUserEvent>( eventStreamId, // a Guid storage, // an IAtomEventStorage object serializer); // an IContentSerializer object var user = User.Fold(events); Assert.Equal(eventStreamId, user.Id); Assert.Equal("ploeh", user.Name); Assert.Equal("12345", user.Password); Assert.Equal("*****@*****.**", user.Email); Assert.False(user.EmailVerified); } }
public void ReadMultipleEvents() { var eventStreamId = new Guid("A0E50259-7345-48F9-84B4-BEEB5CEC662C"); using (var storage = new AtomEventsInMemory()) { var pageSize = 25; /* This is an example of how to use the TypeResolutionEntry * class, so it should not be refactored to one of the terser * alternatives. */ var resolver = new TypeResolutionTable( new TypeResolutionEntry( "urn:grean:samples:user-on-boarding", "user-created", typeof(UserCreated)), new TypeResolutionEntry( "urn:grean:samples:user-on-boarding", "email-verified", typeof(EmailVerified)), new TypeResolutionEntry( "urn:grean:samples:user-on-boarding", "email-changed", typeof(EmailChanged))); var serializer = new DataContractContentSerializer(resolver); var obs = new AtomEventObserver<object>( eventStreamId, pageSize, storage, serializer); obs.OnNext(new UserCreated { UserId = eventStreamId, UserName = "******", Password = "******", Email = "*****@*****.**" }); obs.OnNext(new EmailVerified { UserId = eventStreamId, Email = "*****@*****.**" }); obs.OnNext(new EmailChanged { UserId = eventStreamId, NewEmail = "*****@*****.**" }); var events = new FifoEvents<object>( eventStreamId, // a Guid storage, // an IAtomEventStorage object serializer); // an IContentSerializer object var user = User.Fold(events); Assert.Equal(eventStreamId, user.Id); Assert.Equal("ploeh", user.Name); Assert.Equal("12345", user.Password); Assert.Equal("*****@*****.**", user.Email); Assert.False(user.EmailVerified); } }
public void SutIsObserver(AtomEventObserver <DataContractTestEventX> sut) { Assert.IsAssignableFrom <IObserver <DataContractTestEventX> >(sut); }