public TestBase()
{
var services = new ServiceCollection();
var configuration = ConfigurationRootCreator.Create(services);
var elasticsearchUrl = configuration["ElasticsearchUrl"];
var connection = new ConnectionSettings(new Uri(elasticsearchUrl));
connection.DisableDirectStreaming(true);
Resolver = EventFlowOptions.New
.UseServiceCollection(services)
.RegisterModule <BookingDomainModule>()
.RegisterModule <CommandModule>()
.RegisterModule <CommandHandlersModule>()
.RegisterModule <ElasticsearchReadModelModule>()
.RegisterModule <ElasticsearchQueryHandlersModule>()
.ConfigureElasticsearch(connection)
.CreateResolver();
CommandBus = Resolver.Resolve <ICommandBus>();
QueryProcessor = Resolver.Resolve <IQueryProcessor>();
var indexer = Resolver.Resolve <BookingReadModelIndexer>();
indexer.PrepareIndex();
}
public Task LogException(string message)
{
var log = _resolver.Resolve <ILog>();
log.Debug(message);
return(Task.FromResult(0));
}
public void SetUp()
{
_resolver = EventFlowOptions.New
.ConfigureShippingDomain()
.ConfigureShippingQueriesInMemory()
.CreateResolver();
_eventStore = _resolver.Resolve <IEventStore>();
_commandBus = _resolver.Resolve <ICommandBus>();
}
public SelectJourneysCommandHandlerTests()
{
_bookingId = BookingId.New;
_resolver = EventFlowOptions.New
.ConfigureBookingDomain()
.ConfigureBookingCommands()
.ConfigureBookingCommandHandlers()
.CreateResolver();
_commandBus = _resolver.Resolve <ICommandBus>();
_aggregateStore = _resolver.Resolve <IAggregateStore>();
}
public void Assert_Decorator()
{
// The order should be like this (like unwrapping a present with the order of
// wrapping paper applied)
//
// Call MagicClassDecorator2
// Call MagicClassDecorator1
// Call MagicClass
// Return to MagicClassDecorator1
// Return to MagicClassDecorator2
_sut.Decorate <IMagicInterface>((r, inner) => new MagicClassDecorator1(inner));
_sut.Decorate <IMagicInterface>((r, inner) => new MagicClassDecorator2(inner));
IRootResolver resolver = _sut.CreateResolver();
var magic = resolver.Resolve <IMagicInterface>();
magic.ShouldBeAssignableTo <MagicClassDecorator2>();
var magicClassDecorator2 = (MagicClassDecorator2)magic;
magicClassDecorator2.Inner.ShouldBeAssignableTo <MagicClassDecorator1>();
var magicClassDecorator1 = (MagicClassDecorator1)magicClassDecorator2.Inner;
magicClassDecorator1.Inner.ShouldBeAssignableTo <MagicClass>();
}
public static async Task <CompetitionReadModel> Query(IRootResolver resolver, CompetitionId exampleId)
{
// Resolve the query handler and use the built-in query for fetching
// read models by identity to get our read model representing the
// state of our aggregate root
return(await resolver.Resolve <IQueryProcessor>().ProcessAsync(new ReadModelByIdQuery <CompetitionReadModel>(exampleId), CancellationToken.None));
}
public void if_any_exception_appears_on_disposing_events_root_container_should_be_dispose_finally()
{
ISomeManager manager = null;
IRootResolver rootResolver = IocBuilder.New
.UseAutofacContainerBuilder()
.RegisterServices(r =>
{
r.Register <ISomeManager, SomeManager>();
r.OnDisposing += (sender, args) =>
{
manager = args.Context.Resolver.Resolve <ISomeManager>();
manager.Shutdown();
throw new HandlerException();
};
})
.CreateResolver();
Action act = () => rootResolver.Dispose();
act.ShouldThrow <HandlerException>();
Action containerDisposedAction = () => rootResolver.Container.Resolve <ISomeManager>();
containerDisposedAction.ShouldThrow <ObjectDisposedException>();
Action rootResolverDisposedAction = () => rootResolver.Resolve <ISomeManager>();
rootResolverDisposedAction.ShouldThrow <ObjectDisposedException>();
manager.ShutdownCount.ShouldBe(1);
}
public static void Main(string[] args)
{
NHibernateProfiler.Initialize();
IRootResolver rootResolver = IocBuilder.New
.UseAutofacContainerBuilder()
.UseStove <StoveDemoBootstrapper>()
.UseStoveNullLogger()
.UseStoveNHibernate(nhCfg =>
{
nhCfg.FluentConfiguration
.Database(MsSqlConfiguration.MsSql2012.ConnectionString(nhCfg.Configuration.DefaultNameOrConnectionString))
.Mappings(m => m.FluentMappings.AddFromAssembly(Assembly.GetExecutingAssembly()));
return(nhCfg);
})
.UseStoveDefaultConnectionStringResolver()
.UseStoveDapper()
.UseStoveEventBus()
.RegisterServices(r => r.RegisterAssemblyByConvention(Assembly.GetExecutingAssembly()))
.CreateResolver();
using (rootResolver)
{
rootResolver.Resolve <ProductDomainService>().DoSomeCoolStuff();
}
NHibernateProfiler.Shutdown();
Console.ReadLine();
}
public void Assert_Service()
{
IRootResolver resolver = _sut.CreateResolver();
var magicInterface = resolver.Resolve <IMagicInterface>();
magicInterface.ShouldNotBeNull();
magicInterface.ShouldBeAssignableTo <MagicClass>();
}
public TestBase()
{
var services = new ServiceCollection();
ConfigurationRootCreator.Create(services);
Resolver = EventFlowOptions.New
.UseServiceCollection(services)
.RegisterModule <BookingDomainModule>()
.RegisterModule <CommandModule>()
.RegisterModule <CommandHandlersModule>()
.RegisterServices(r => r.Register <IDbContextProvider <EventStoreContext>, FakedEventStoreContextProvider>())
.CreateResolver();
CommandBus = Resolver.Resolve <ICommandBus>();
AggregateStore = Resolver.Resolve <IAggregateStore>();
}
public TestBase()
{
BookingId = BookingId.New;
Resolver = EventFlowOptions.New
.ConfigureBookingDomain()
.CreateResolver();
AggregateStore = Resolver.Resolve <IAggregateStore>();
}
public TestBase()
{
var services = new ServiceCollection();
var runner = MongoDbRunner.Start();
Resolver = EventFlowOptions.New
.UseServiceCollection(services)
.RegisterModule <BookingDomainModule>()
.RegisterModule <CommandModule>()
.RegisterModule <CommandHandlersModule>()
.RegisterModule <MongoDbReadModelModule>()
.RegisterModule <MongoDbQueryHandlersModule>()
.ConfigureMongoDb(runner.ConnectionString, "restairline")
.CreateResolver();
CommandBus = Resolver.Resolve <ICommandBus>();
QueryProcessor = Resolver.Resolve <IQueryProcessor>();
}
public Bootstrap()
{
var mquri = new Uri("amqp://*****:*****@127.0.0.1");
var mqconf = RabbitMqConfiguration.With(
mquri, true, 5, "loxnet"
);
_resolver = EventFlowOptions.New
.ConfigureTransportDomain()
.UseConsoleLog()
.PublishToRabbitMq(mqconf)
.CreateResolver();
_aggregateStore = _resolver
.Resolve <IAggregateStore>();
_commandBus = _resolver
.Resolve <ICommandBus>();
}
public TestBase()
{
Resolver = EventFlowOptions.New.ConfigureBookingDomain()
.ConfigureBookingCommands()
.ConfigureBookingCommandHandlers()
.ConfigureReadModel()
.CreateResolver();
CommandBus = Resolver.Resolve <ICommandBus>();
}
public void Initialize(ExtensionConfigContext context)
{
_resolver = IocBuilder.New
.UseAutofacContainerBuilder()
.RegisterServices(r => r.RegisterAssemblyByConvention(Assembly.GetExecutingAssembly()))
.CreateResolver();
context.AddBindingRule <InjectAttribute>()
.BindToInput <dynamic>(inject => _resolver.Resolve(inject.Type));
}
private EntryId[] RegisterCompetitionWithEntries(IRootResolver resolver, int amount, CompetitionId competitionId = null)
{
var domainId = PrepareCompetition(resolver, "test-competition", "test-user", competitionId);
// Resolve the command bus and use it to publish a command
var commandBus = resolver.Resolve <ICommandBus>();
// Resolve the query handler and use the built-in query for fetching
// read models by identity to get our read model representing the
// state of our aggregate root
var queryProcessor = resolver.Resolve <IQueryProcessor>();
const string discipline = "Discipline";
EntryId[] ids = new EntryId[amount];
for (int x = 0; x < amount; x++)
{
var entryId = EntryId.New;
ids[x] = entryId;
string competitor = string.Format("Competitor {0}", x + 1);
int time = 12300 + x;
// Add
var executionResult = commandBus.PublishAsync(new RecordEntryCommand(domainId, entryId, discipline, competitor, time + 1), CancellationToken.None).Result;
executionResult.IsSuccess.Should().BeTrue();
// Change time
executionResult = commandBus.PublishAsync(new CorrectEntryTimeCommand(domainId, entryId, time), CancellationToken.None).Result;
executionResult.IsSuccess.Should().BeTrue();
// Verify that the read model has the expected value
var readModel2 = queryProcessor.ProcessAsync(new ReadModelByIdQuery <EntryReadModel>(entryId), CancellationToken.None).Result;
readModel2.Should().NotBeNull();
readModel2.AggregateId.Should().Be(entryId.Value);
readModel2.Discipline.Should().Be(discipline);
readModel2.Competitor.Should().Be(competitor);
readModel2.TimeInMillis.Should().Be(time);
}
return(ids);
}
public TestBase()
{
var services = new ServiceCollection();
var configuration = ConfigurationRootCreator.Create(services);
services.Configure <RabbitMqOption>(configuration);
services.ConfigureBus();
services.AddSingleton <ISubscribeSynchronousToAll, RabbitMqEventPublisher>();
Resolver = EventFlowOptions.New
.UseServiceCollection(services)
.RegisterModule <BookingDomainModule>()
.RegisterModule <CommandModule>()
.RegisterModule <CommandHandlersModule>()
.RegisterServices(r => r.Register <IDbContextProvider <EventStoreContext>, FakedEventStoreContextProvider>())
.CreateResolver(false);
CommandBus = Resolver.Resolve <ICommandBus>();
HostedService = Resolver.Resolve <IHostedService>();
}
public async Task Simple()
{
await CreateLocationAggregatesAsync().ConfigureAwait(false);
await CreateVoyageAggregatesAsync().ConfigureAwait(false);
var route = new Route(
Locations.Tokyo,
Locations.Helsinki,
1.October(2008).At(11, 00),
6.November(2008).At(12, 00));
var booking = _resolver.Resolve <IBookingApplicationService>();
await booking.BookCargoAsync(route, CancellationToken.None).ConfigureAwait(false);
var voyage = _resolver.Resolve <IScheduleApplicationService>();
await voyage.DelayScheduleAsync(
Voyages.DallasToHelsinkiId,
TimeSpan.FromDays(7),
CancellationToken.None)
.ConfigureAwait(false);
}
public void SetUp()
{
_resolver = EventFlowOptions.New
.AddSagas(typeof(AlternativeSagaStoreTestClasses.TestSaga))
.AddCommandHandlers(
typeof(AlternativeSagaStoreTestClasses.SagaTestACommandHandler),
typeof(AlternativeSagaStoreTestClasses.SagaTestBCommandHandler),
typeof(AlternativeSagaStoreTestClasses.SagaTestCCommandHandler))
.AddEvents(
typeof(AlternativeSagaStoreTestClasses.SagaTestEventA),
typeof(AlternativeSagaStoreTestClasses.SagaTestEventB),
typeof(AlternativeSagaStoreTestClasses.SagaTestEventC))
.RegisterServices(sr =>
{
sr.RegisterType(typeof(AlternativeSagaStoreTestClasses.TestSagaLocator));
sr.Register <ISagaStore, AlternativeSagaStoreTestClasses.InMemorySagaStore>(Lifetime.Singleton);
})
.CreateResolver(false);
_commandBus = _resolver.Resolve <ICommandBus>();
_aggregateStore = _resolver.Resolve <IAggregateStore>();
}
public override IRootResolver CreateRootResolver(IEventFlowOptions eventFlowOptions)
{
// Disable SSL certificate validation
ServicePointManager.ServerCertificateValidationCallback = delegate { return true; };
var url = Environment.GetEnvironmentVariable("ELASTICSEARCH_URL");
if (string.IsNullOrEmpty(url))
{
Assert.Inconclusive("The environment variabel named 'ELASTICSEARCH_URL' isn't set. Set it to e.g. 'http://localhost:9200'");
}
_resolver = eventFlowOptions
.ConfigureElasticsearch(new Uri(url))
.UseElasticsearchReadModel<ElasticsearchTestAggregateReadModel>()
.CreateResolver();
_elasticClient = _resolver.Resolve<IElasticClient>();
_readModelPopulator = _resolver.Resolve<IReadModelPopulator>();
_readModelDescriptionProvider = _resolver.Resolve<IReadModelDescriptionProvider>();
_readModelStore = _resolver.Resolve<IElasticsearchReadModelStore<ElasticsearchTestAggregateReadModel>>();
return _resolver;
}
private void PrepareIndexes(IRootResolver resolver)
{
_elasticClient = resolver.Resolve <IElasticClient>();
var readModelTypes =
GetLoadableTypes <ElasticsearchTypeAttribute>(typeof(ElasticsearchThingyReadModel).Assembly);
foreach (var readModelType in readModelTypes)
{
var esType = readModelType.GetTypeInfo()
.GetCustomAttribute <ElasticsearchTypeAttribute>();
//var indexName = GetIndexName(esType.RelationName);
var aliasResponse = _elasticClient.Indices.GetAlias(esType.RelationName);
var alias2Response = _elasticClient.GetAliasesPointingToIndex(esType.RelationName);
var indexResponse = _elasticClient.Indices.Get(esType.RelationName);
if (aliasResponse.ApiCall.Success)
{
if (aliasResponse.Indices != null)
{
foreach (var indice in aliasResponse?.Indices)
{
_elasticClient.Indices.DeleteAlias(
indice.Key,
esType.RelationName
);
_elasticClient.Indices.Delete(
indice.Key,
d => d.RequestConfiguration(c => c.AllowedStatusCodes((int)HttpStatusCode.NotFound))
);
}
_elasticClient.Indices.Delete(
esType.RelationName,
d => d.RequestConfiguration(c => c.AllowedStatusCodes((int)HttpStatusCode.NotFound))
);
}
}
var indexName = GetIndexName(esType.RelationName);
_indexes.Add(indexName);
_elasticClient.Indices.Create(indexName, c => c
.Settings(s => s
.NumberOfShards(1)
.NumberOfReplicas(0))
.Aliases(a => a.Alias(esType.RelationName)));
}
}
public override IRootResolver CreateRootResolver(IEventFlowOptions eventFlowOptions)
{
// Disable SSL certificate validation
ServicePointManager.ServerCertificateValidationCallback = delegate { return(true); };
var url = Environment.GetEnvironmentVariable("ELASTICSEARCH_URL");
if (string.IsNullOrEmpty(url))
{
Assert.Inconclusive("The environment variabel named 'ELASTICSEARCH_URL' isn't set. Set it to e.g. 'http://localhost:9200'");
}
_resolver = eventFlowOptions
.ConfigureElasticsearch(new Uri(url))
.UseElasticsearchReadModel <ElasticsearchTestAggregateReadModel>()
.CreateResolver();
_elasticClient = _resolver.Resolve <IElasticClient>();
_readModelPopulator = _resolver.Resolve <IReadModelPopulator>();
_readModelDescriptionProvider = _resolver.Resolve <IReadModelDescriptionProvider>();
_readModelStore = _resolver.Resolve <IElasticsearchReadModelStore <ElasticsearchTestAggregateReadModel> >();
return(_resolver);
}
public static void Main(string[] args)
{
EntityFrameworkProfiler.Initialize();
Database.SetInitializer(new NullDatabaseInitializer <AnimalStoveDbContext>());
Database.SetInitializer(new NullDatabaseInitializer <PersonStoveDbContext>());
IRootResolver resolver = IocBuilder.New
.UseAutofacContainerBuilder()
.UseStove <StoveDemoBootstrapper>(false)
.UseStoveEntityFramework()
.UseStoveDapper()
.UseStoveMapster()
.UseStoveEventBus()
.UseStoveDbContextEfTransactionStrategy()
.UseStoveTypedConnectionStringResolver()
.UseStoveNLog()
.UseStoveBackgroundJobs()
.UseStoveRedisCaching()
.UseStoveRabbitMQ(configuration =>
{
configuration.HostAddress = "rabbitmq://localhost/";
configuration.Username = "******";
configuration.Password = "******";
configuration.QueueName = "Default";
return(configuration);
})
.UseStoveHangfire(configuration =>
{
configuration.GlobalConfiguration
.UseSqlServerStorage("Default")
.UseNLogLogProvider();
return(configuration);
})
.RegisterServices(r => r.RegisterAssemblyByConvention(Assembly.GetExecutingAssembly()))
.CreateResolver();
//var someDomainService = resolver.Resolve<SomeDomainService>();
//someDomainService.DoSomeStuff();
var productDomainService = resolver.Resolve <ProductDomainService>();
productDomainService.DoSomeStuff();
resolver.Dispose();
EntityFrameworkProfiler.Shutdown();
Console.ReadKey();
}
public TestBase()
{
var services = new ServiceCollection();
ConfigurationRootCreator.Create(services);
Resolver = EventFlowOptions.New
.UseServiceCollection(services)
.RegisterModule <BookingDomainModule>()
.RegisterModule <EntityFrameworkEventStoreModule>()
.RegisterModule <CommandModule>()
.RegisterModule <CommandHandlersModule>()
.RegisterModule <EntityFrameworkReadModelModule>()
.RegisterModule <EntityFrameworkQueryHandlersModule>()
.RegisterServices(register =>
{
register.Register <IDbContextProvider <RestAirlineReadModelContext>, FakedEntityFramewokReadModelDbContextProvider>();
register.Register <IDbContextProvider <EventStoreContext>, FakedEventStoreContextProvider>();
})
.CreateResolver();
CommandBus = Resolver.Resolve <ICommandBus>();
QueryProcessor = Resolver.Resolve <IQueryProcessor>();
}
public TestBase()
{
var services = new ServiceCollection();
ConfigurationRootCreatorForTesting.Create(services);
FlightAvailabilityId = FlightAvailabilityId.New;
Resolver = EventFlowOptions.New
.UseServiceCollection(services)
.RegisterModule <FlightAvailabilityDomainModule>()
.RegisterServices(r => r.Register <IDbContextProvider <EventStoreContext>, FakedEventStoreContextProvider>())
.CreateResolver();
AggregateStore = Resolver.Resolve <IAggregateStore>();
}
public void Test()
{
IEventFlowOptions eventFlow = EventFlowOptions.New
.AddDefaults(typeof(CustomerTests).Assembly);
CustomerDefinition.Define(eventFlow);
IRootResolver resolver = eventFlow.CreateResolver();
ICommandBus bus = resolver.Resolve <ICommandBus>();
CustomerId aggregateId = CustomerId.New;
bus.PublishAsync(new CreateCustomer(aggregateId), CancellationToken.None);
bus.PublishAsync(new DeleteCustomer(aggregateId), CancellationToken.None);
}
public static void Main(string[] args)
{
IRootResolver resolver = IocBuilder.New
.UseAutofacContainerBuilder()
.UseStoveWithNullables <StoveRavenDBDemoBootstrapper>()
.UseStoveRavenDB(cfg =>
{
cfg.DefaultDatabase = "Stove";
cfg.Urls = new string[] { "http://localhost:8080/" };
return(cfg);
})
.RegisterServices(r => r.RegisterAssemblyByConvention(Assembly.GetExecutingAssembly()))
.CreateResolver();
using (resolver)
{
var service = resolver.Resolve <RavenDomainService>();
service.DoSomeStuff();
}
}
public static void Main(string[] args)
{
// EntityFrameworkProfiler.Initialize();
IIocBuilder builder = IocBuilder.New
.UseAutofacContainerBuilder()
.UseStoveWithNullables(typeof(StoveMigratorBootstrapper))
.UseStoveNLog()
.UseStoveEntityFramework()
.UseStoveMigrationParticipant()
.UseStoveMigrator()
.UseStoveMigratorDefaults();
var options = new MigrationOptions();
Parser.Default.ParseArguments(args, options);
if (Parser.Default.ParseArguments(args, options))
{
if (options.Is(MigrationType.DbUp))
{
Console.WriteLine("Selected Migration is only DbUp...");
builder.UseStoveDbUpMigrationStrategy();
}
else if (options.Is(MigrationType.DbContext))
{
Console.WriteLine("Selected Migration is only DbContext...");
builder.UseStoveDbContextMigrationStrategy();
}
else if (options.Is(MigrationType.DbContextSeed))
{
Console.WriteLine("Selected Migration is only DbContextSeed...");
builder.UseStoveDbContextSeedMigrationStrategy(configuration =>
{
configuration.Schema = options.Schema;
configuration.Table = options.Table;
configuration.TransactionTimeout = options.TransactionTimeout;
configuration.Enviroment = options.Enviroment;
return(configuration);
});
}
else
{
Console.WriteLine("Selected Migration is DbContext, DbUp and DbContextSeed...");
builder.UseStoveAllMigrationStrategies(configuration =>
{
configuration.Schema = options.Schema;
configuration.Table = options.Table;
configuration.TransactionTimeout = options.TransactionTimeout;
configuration.Enviroment = options.Enviroment;
return(configuration);
});
}
}
builder.RegisterServices(r => r.OnDisposing += (sender, eventArgs) => { Console.WriteLine("Stove.Migrator.Executer successfully executed and disposed."); });
IRootResolver rootResolver = builder.CreateResolver();
using (rootResolver)
{
var migrator = rootResolver.Resolve <MigrateExecuter>();
migrator.Run();
}
Console.WriteLine("Press ENTER to exit...");
Console.ReadLine();
}
protected T The <T>()
{
return(LocalResolver.Resolve <T>());
}