public FeedController()
{
_events = new FifoEvents <ProductEntry>(
Globals.EventStreamId,
s_storage,
s_serializer);
}
public void SutIsInitiallyEmpty(
[Frozen(As = typeof(IAtomEventStorage))] AtomEventsInMemory dummyInjectedIntoSut,
FifoEvents <XmlAttributedTestEventX> sut)
{
Assert.False(sut.Any(), "Intial event stream should be empty.");
Assert.Empty(sut);
}
public FeedController()
{
_events = new FifoEvents<ProductEntry>(
Globals.EventStreamId,
s_storage,
s_serializer);
}
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 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 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 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 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,
FifoEvents <IXmlAttributedTestEvent> sut,
XmlAttributedTestEventX tex,
XmlAttributedTestEventY tey)
{
writer.AppendAsync(tex).Wait();
writer.AppendAsync(tey).Wait();
var expected = new IXmlAttributedTestEvent[] { tex, tey };
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 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 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 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 static void Run(UnityContainer container)
{
container.RegisterType <FeedController>();
container.RegisterType <ProductsController>();
container.RegisterInstance(typeof(ILog), LogProvider.For <ProductService>(), new ContainerControlledLifetimeManager());
container.RegisterType <IProductsDAO, ProductsDAO>();
container.RegisterType <AddProductCommandHandler>();
container.RegisterType <ChangeProductCommandHandler>();
container.RegisterType <ProductAddedEventHandler>();
container.RegisterType <ProductChangedEventHandler>();
container.RegisterType <ProductRemovedEventHandler>();
container.RegisterType <RemoveProductCommandHandler>();
var storage = new AtomEventsInFiles(new DirectoryInfo(Globals.StoragePath));
var serializer = new DataContractContentSerializer(
DataContractContentSerializer
.CreateTypeResolver(typeof(ProductEntry).Assembly)
);
var events = new FifoEvents <ProductEntry>(
Globals.EventStreamId,
storage,
serializer);
container.RegisterInstance(typeof(IObserver <ProductEntry>), events, new TransientLifetimeManager());
var handlerFactory = new UnityHandlerFactory(container);
var subscriberRegistry = new SubscriberRegistry
{
{ typeof(AddProductCommand), typeof(AddProductCommandHandler) },
{ typeof(ChangeProductCommand), typeof(ChangeProductCommandHandler) },
{ typeof(RemoveProductCommand), typeof(RemoveProductCommandHandler) },
{ typeof(ProductAddedEvent), typeof(ProductAddedEventHandler) },
{ typeof(ProductRemovedEvent), typeof(ProductRemovedEventHandler) },
};
//create policies
var retryPolicy = Policy
.Handle <Exception>()
.WaitAndRetry(new[]
{
TimeSpan.FromMilliseconds(50),
TimeSpan.FromMilliseconds(100),
TimeSpan.FromMilliseconds(150)
});
var circuitBreakerPolicy = Policy
.Handle <Exception>()
.CircuitBreaker(1, TimeSpan.FromMilliseconds(500));
var policyRegistry = new PolicyRegistry()
{
{ CommandProcessor.RETRYPOLICY, retryPolicy },
{ CommandProcessor.CIRCUITBREAKER, circuitBreakerPolicy }
};
var commandProcessor = CommandProcessorBuilder.With()
.Handlers(new HandlerConfiguration(subscriberRegistry, handlerFactory))
.Policies(policyRegistry)
.Logger(container.Resolve <ILog>())
.NoTaskQueues()
.RequestContextFactory(new InMemoryRequestContextFactory())
.Build();
container.RegisterInstance(typeof(IAmACommandProcessor), commandProcessor);
}
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 SutIsEnumerable(FifoEvents <XmlAttributedTestEventX> sut)
{
Assert.IsAssignableFrom <IEnumerable <XmlAttributedTestEventX> >(sut);
}
