public static Assembly DetermineApplicationAssembly(JasperRegistry registry)
{
var assembly = registry.GetType().Assembly;
var isFeature = assembly.GetCustomAttribute <JasperFeatureAttribute>() != null;
if (!Equals(assembly, typeof(JasperRegistry).Assembly) && !isFeature)
{
return(assembly);
}
return(Find());
}
//[Fact] -- NOT RELIABLE ENOUGH. NOT SURE WHY YET
public void can_discover_modules_from_assembly_scanning_and_apply_extensions()
{
Module1.Module1Extension.Registry = null;
var registry = new JasperRegistry();
var runtime = JasperRuntime.For(registry);
runtime.ShouldNotBeNull();
Module1Extension.Registry.ShouldBe(registry);
}
private async Task <Registry> bootstrap(JasperRegistry registry)
{
var actions = await Actions.FindActions(registry.ApplicationAssembly);
foreach (var methodCall in actions)
{
Routes.AddRoute(methodCall);
}
return(new HttpServices(Routes));
}
public void configure(JasperRegistry registry)
{
registry.Include <MartenBackedSubscriptions>();
registry.MartenConnectionStringIs(ConnectionSource.ConnectionString);
registry.Settings.Alter <MartenSubscriptionSettings>(x =>
{
x.StoreOptions.Connection(ConnectionSource.ConnectionString);
});
}
public async Task find_what_is_wrong()
{
var registry = new JasperRegistry();
registry.HttpRoutes.DisableConventionalDiscovery().IncludeType <FakeThing>();
using (var system = JasperAlba.For(registry))
{
await system.Scenario(x => x.Get.Url("/chars/a/to/c"));
}
}
public override void SetUp()
{
_registry = new JasperRegistry();
_registry.Handlers.DisableConventionalDiscovery();
_registry.Handlers.IncludeType <Message1Handler>();
_registry.Handlers.IncludeType <Message2Handler>();
_registry.Handlers.IncludeType <Message3Handler>();
_registry.Handlers.IncludeType <Message4Handler>();
_registry.Handlers.IncludeType <Message5Handler>();
}
public void smoke_test_calls(string commandLine)
{
var registry = new JasperRegistry();
registry.MartenConnectionStringIs(Servers.PostgresConnectionString);
registry.Include <MartenBackedPersistence>();
var args = commandLine.Split(' ');
JasperHost.Run(registry, args).ShouldBe(0);
}
public void Configure(JasperRegistry registry)
{
registry.Handlers.IncludeType(typeof(DiagnosticsHandler));
registry.Logging.LogBusEventsWith <DiagnosticsBusLogger>();
registry.Services.AddTransient <IStartupFilter, AddJasperDiagnosticMiddleware>();
registry.Settings.Require <DiagnosticsSettings>();
registry.Generation.Assemblies.Add(GetType().GetTypeInfo().Assembly);
}
public void Configure(JasperRegistry registry)
{
// Add service registrations
registry.Services.AddTransient <IFoo, Foo>();
// Alter settings within the application
registry.Settings.Alter <JasperOptions>(_ =>
{
_.JsonSerialization.TypeNameHandling = TypeNameHandling.All;
});
}
public async Task services_registered_by_the_DI_abstraction_are_in_the_container()
{
var registry = new JasperRegistry();
registry.Services.AddTransient <IService, FooService>();
using (var runtime = JasperRuntime.For(registry))
{
runtime.Container.Model.For <IService>().Default.ImplementationType
.ShouldBe(typeof(FooService));
}
}
public void Configure(JasperRegistry registry)
{
Registry = registry;
registry.Settings.Alter <ModuleSettings>(_ =>
{
_.From = "Module1";
_.Count = 100;
});
registry.Services.For <IModuleService>().Use <ServiceFromModule>();
}
public void adds_the_core_service_provider_abstractions()
{
var registry = new JasperRegistry();
registry.Services.AddTransient <IService, FooService>();
using (var runtime = JasperRuntime.For(registry))
{
runtime.Get <IServiceProvider>().ShouldNotBeNull();
runtime.Get <IServiceScopeFactory>().ShouldNotBeNull();
}
}
public bootstrapping_end_to_end()
{
registry = new JasperRegistry();
registry.HttpRoutes.ExcludeTypes(_ => _.IsInNamespace("Jasper.Bus"));
registry.Include <EndpointExtension>();
registry.Handlers.DisableConventionalDiscovery();
registry.Services.AddTransient <IWriterRule, CustomWriterRule>();
registry.Services.AddTransient <IReaderRule, CustomReaderRule>();
}
public void Configure(JasperRegistry registry)
{
registry.Settings.Require <StoreOptions>();
registry.Services.AddSingleton <IDocumentStore>(x => new DocumentStore(x.GetService <StoreOptions>()));
registry.Services.AddScoped(c => c.GetService <IDocumentStore>().OpenSession());
registry.Services.AddScoped(c => c.GetService <IDocumentStore>().QuerySession());
registry.Generation.Sources.Add(new SessionVariableSource());
}
public void hosting_environment_uses_config_2()
{
var registry = new JasperRegistry();
registry.Handlers.DisableConventionalDiscovery();
registry.Hosting(x => x.UseEnvironment("Fake2"));
using (var runtime = JasperHost.For(registry))
{
runtime.Get <IHostingEnvironment>()
.EnvironmentName.ShouldBe("Fake2");
}
}
public void Configure(JasperRegistry registry)
{
registry.Handlers.Discovery(x => x.IncludeType(typeof(DiagnosticsHandler)));
// TODO -- how do we register for message and transport messages?
registry.Services.AddTransient <IStartupFilter, AddJasperDiagnosticMiddleware>();
registry.Settings.Require <DiagnosticsSettings>();
registry.CodeGeneration.Assemblies.Add(GetType().GetTypeInfo().Assembly);
}
public void hosting_environment_uses_config()
{
var registry = new JasperRegistry();
registry.Handlers.DisableConventionalDiscovery(true);
registry.EnvironmentName = "Fake";
using (var runtime = JasperRuntime.For(registry))
{
runtime.Get <IHostingEnvironment>()
.EnvironmentName.ShouldBe("Fake");
}
}
public void sets_up_the_container_with_services()
{
var registry = new JasperRegistry();
registry.Handlers.DisableConventionalDiscovery();
registry.Services.For <IFoo>().Use <Foo>();
registry.Services.AddTransient <IFakeStore, FakeStore>();
using (var runtime = JasperHost.For(registry))
{
runtime.Container.DefaultRegistrationIs <IFoo, Foo>();
}
}
public void Configure(JasperRegistry registry)
{
registry.Publish
.MessagesMatching(x => x.CanBeCastTo <ClientMessage>())
.To("ws://default");
registry.Http.Configure(app => app.UseWebSockets());
registry.Services.AddSingleton <WebSocketTransport>();
registry.Services.AddSingleton <ITransport>(x => x.GetService <WebSocketTransport>());
registry.Services.AddSingleton <IWebSocketSender, WebSocketSender>();
}
public void use_the_extension()
{
var registry = new JasperRegistry();
registry.Include <ConsulBackedSubscriptions>();
using (var runtime = JasperRuntime.For(registry))
{
runtime.Get <INodeDiscovery>().ShouldBeOfType <ConsulNodeDiscovery>();
runtime.Get <ISubscriptionsRepository>()
.ShouldBeOfType <ConsulSubscriptionRepository>();
}
}
public void will_apply_an_extension()
{
var registry = new JasperRegistry();
registry.Include <OptionalExtension>();
registry.Handlers.DisableConventionalDiscovery(true);
using (var runtime = JasperRuntime.For(registry))
{
runtime.Get <IColorService>()
.ShouldBeOfType <RedService>();
}
}
public async Task hosting_environment_uses_config_2()
{
var registry = new JasperRegistry();
registry.Handlers.DisableConventionalDiscovery(true);
registry.Hosting.UseEnvironment("Fake2");
using (var runtime = await JasperRuntime.ForAsync(registry))
{
runtime.Get <IHostingEnvironment>()
.EnvironmentName.ShouldBe("Fake2");
}
}
public void Configure(JasperRegistry registry)
{
registry.HttpRoutes.IncludeTypes(x => x.CanBeCastTo <ControllerBase>());
registry.HttpRoutes.IncludeMethods(x => x.HasAttribute <HttpMethodAttribute>());
// SAMPLE: applying-route-policy
registry.HttpRoutes.GlobalPolicy <ControllerUsagePolicy>();
// ENDSAMPLE
registry.Services.AddSingleton <IWriterRule, ActionResultWriterRule>();
RouteBuilder.PatternRules.Insert(0, new HttpAttributePatternRule());
}
protected void with(JasperRegistry registry)
{
registry.Services.Scan(_ =>
{
_.TheCallingAssembly();
_.WithDefaultConventions();
});
Runtime = JasperRuntime.For(registry);
Handlers = Runtime.Get <HandlerGraph>();
}
public IJasperHost Add(JasperRegistry registry)
{
registry.Services.For <MessageTracker>().Use(Tracker);
registry.Services.For <MessageHistory>().Use(History);
registry.Services.For <IMessageLogger>().Use <MessageTrackingLogger>().Singleton();
var runtime = JasperHost.For(registry);
_hosts.Add(runtime);
return(runtime);
}
private static CommandExecutor buildExecutor(JasperRegistry registry)
{
return(CommandExecutor.For(factory =>
{
factory.RegisterCommands(typeof(RunCommand).GetTypeInfo().Assembly);
factory.ConfigureRun = cmd =>
{
if (cmd.Input is JasperInput)
{
cmd.Input.As <JasperInput>().Registry = registry;
}
};
}));
}
public void sets_up_the_container_with_services()
{
var registry = new JasperRegistry();
registry.Services.For <IFoo>().Use <Foo>();
registry.Services.AddTransient <IFakeStore, FakeStore>();
registry.Services.For <IWidget>().Use <Widget>();
registry.Services.For <IFakeService>().Use <FakeService>();
using (var runtime = JasperRuntime.For(registry))
{
runtime.Container.DefaultRegistrationIs <IFoo, Foo>();
}
}
private void theAppIs(Action <IApplicationBuilder> configure)
{
var registry = new JasperRegistry();
registry.Handlers.DisableConventionalDiscovery(true);
_alba = SystemUnderTest.For(builder =>
{
builder
.UseServer(new NulloServer())
.Configure(configure)
.UseJasper(registry);
});
}
public override void SetUp()
{
_registry = new JasperRegistry();
_waitForSubscriptions = false;
_registry.Services.AddTransient <ITransport, StubTransport>();
_registry.Services.AddSingleton(new MessageTracker());
_registry.Services.AddSingleton(new MessageHistory());
_registry.Services.AddTransient <IMessageLogger, MessageTrackingLogger>();
_registry.Logging.LogMessageEventsWith(new StorytellerMessageLogger(Context));
}
public void the_application_still_wins()
{
var registry = new JasperRegistry();
registry.Handlers.DisableConventionalDiscovery(true);
registry.Include <OptionalExtension>();
registry.Services.For <IColorService>().Use <BlueService>();
using (var runtime = JasperRuntime.For(registry))
{
runtime.Get <IColorService>()
.ShouldBeOfType <BlueService>();
}
}
