public void DirectoryIsCorrect(
[Frozen]DirectoryInfo expected,
AtomEventsInFiles sut)
{
DirectoryInfo actual = sut.Directory;
Assert.Equal(expected, actual);
}
public void DirectoryIsCorrect(
[Frozen] DirectoryInfo expected,
AtomEventsInFiles sut)
{
DirectoryInfo actual = sut.Directory;
Assert.Equal(expected, actual);
}
static FeedController()
{
s_storage = new AtomEventsInFiles(new DirectoryInfo(Globals.StoragePath));
s_serializer = new DataContractContentSerializer(
DataContractContentSerializer
.CreateTypeResolver(typeof(ProductEntry).Assembly)
);
}
static FeedController()
{
s_storage = new AtomEventsInFiles(new DirectoryInfo(Globals.StoragePath));
s_serializer = new DataContractContentSerializer(
DataContractContentSerializer
.CreateTypeResolver(typeof (ProductEntry).Assembly)
);
}
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 ProductAddedEventHandler(ILog logger) : base(logger)
{
var storage = new AtomEventsInFiles(new DirectoryInfo(Globals.StoragePath));
var serializer = new DataContractContentSerializer(
DataContractContentSerializer
.CreateTypeResolver(typeof(ProductEntry).Assembly)
);
_observer = new AtomEventObserver <ProductEntry>(
Globals.EventStreamId,
25,
storage,
serializer
);
}
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 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 SutIsAtomEventStorage(AtomEventsInFiles sut)
{
Assert.IsAssignableFrom <IAtomEventStorage>(sut);
}
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 SutIsAtomEventStorage(AtomEventsInFiles sut)
{
Assert.IsAssignableFrom<IAtomEventStorage>(sut);
}
