public void Should_override_default_host_settings()
{
void Assertion(IVostokHostingEnvironment environment)
{
environment.ApplicationIdentity.Project.Should().Be("testProject");
environment.ApplicationIdentity.Environment.Should().Be("testEnvironment");
environment.ApplicationIdentity.Application.Should().Be("testApplication");
environment.ApplicationIdentity.Instance.Should().Be("testInstance");
}
var vostokMultiHost = new VostokMultiHost(
new VostokMultiHostSettings(
builder =>
{
builder.SetupApplicationIdentity(
identityBuilder => { identityBuilder.SetProject("testProject").SetEnvironment("testEnvironment").SetApplication("default"); });
builder.SetupLog(logBuilder => logBuilder.SetupConsoleLog());
}));
var application = new VostokMultiHostApplicationSettings(
new TesterApplication(Assertion),
("testApplication", "testInstance"),
SetupMultiHostApplication);
vostokMultiHost.AddApplication(application);
Action run = () => vostokMultiHost.RunAsync().GetAwaiter().GetResult().EnsureSuccess();
run.Should().NotThrow();
}
public async Task Should_stop_all_applications()
{
vostokMultiHost = new VostokMultiHost(new VostokMultiHostSettings(SetupMultiHost));
var applications = new List <VostokMultiHostApplicationSettings>();
for (var i = 0; i < 10; i++)
{
applications.Add(
new VostokMultiHostApplicationSettings(
new NeverEndingApplication(),
("test", i.ToString()),
SetupMultiHostApplication));
}
foreach (var app in applications)
{
vostokMultiHost.AddApplication(app);
}
await vostokMultiHost.StartAsync();
await Task.Delay(1000);
await vostokMultiHost.StopAsync();
foreach (var app in applications)
{
// ReSharper disable once PossibleNullReferenceException
vostokMultiHost.GetApplication(app.Identifier).ApplicationState.IsTerminal().Should().BeTrue();
}
}
private void SetupMultiHost()
{
var workerApplication = new VostokMultiHostApplicationSettings(
new TestApplication(),
("nevermind", "blabla"),
MultiHostApplicationBuilder);
vostokMultiHost = new VostokMultiHost(new VostokMultiHostSettings(MultiHostBuilder), workerApplication);
}
public void Should_throw_on_add_if_VostokMultiHost_not_launched()
{
var identifier = ("test", "test");
var badApplication = new VostokMultiHostApplicationSettings(new BadApplication(false), identifier, SetupMultiHostApplication);
vostokMultiHost = new VostokMultiHost(new VostokMultiHostSettings(SetupMultiHost));
Action checkStart = () => vostokMultiHost.StartApplicationAsync(badApplication).GetAwaiter().GetResult();
checkStart.Should().Throw <InvalidOperationException>();
}
public async Task Should_not_stop_if_didnt_start_any_application()
{
var vostokMultiHost = new VostokMultiHost(new VostokMultiHostSettings(SetupMultiHost));
await vostokMultiHost.StartAsync();
await Task.Delay(500);
vostokMultiHost.MultiHostState.Should().Be(VostokMultiHostState.Running);
Action stop = () => vostokMultiHost.StopAsync().GetAwaiter().GetResult();
stop.ShouldPassIn(1.Seconds());
}
public async Task Should_be_able_to_override_common_components()
{
IHerculesSink extractedSink = null;
void Assert(IVostokHostingEnvironment environment)
{
environment.HerculesSink.Should().BeSameAs(extractedSink);
}
void Extract(IVostokHostingEnvironment environment)
{
extractedSink = environment.HerculesSink;
}
var initialSink = new DevNullHerculesSink();
var vostokMultiHost = new VostokMultiHost(
new VostokMultiHostSettings(
builder =>
{
builder.SetupApplicationIdentity(identityBuilder => identityBuilder.SetProject("testProject").SetEnvironment("testEnvironment"));
builder.SetupHerculesSink(sinkBuilder => sinkBuilder.UseInstance(initialSink));
builder.SetupLog(logBuilder => logBuilder.SetupConsoleLog());
}));
var extractIdentifier = ("testApplication", "testInstance");
var extractApplication = new VostokMultiHostApplicationSettings(
new TesterApplication(Extract),
extractIdentifier,
SetupMultiHostApplication);
var assertIdentifier = ("testApplication", "testInstance2");
var assertApplication = new VostokMultiHostApplicationSettings(
new TesterApplication(Assert),
assertIdentifier,
SetupMultiHostApplication);
await vostokMultiHost.StartAsync();
await vostokMultiHost.RunSequentiallyAsync(extractApplication, assertApplication);
var results = await vostokMultiHost.StopAsync();
// ReSharper disable once PossibleNullReferenceException
results.ApplicationRunResults[assertIdentifier].EnsureSuccess();
extractedSink.Should().BeSameAs(initialSink);
}
public void Should_stop_after_applications_finished()
{
var application = new VostokMultiHostApplicationSettings(
new DelayApplication(),
("test", "test"),
SetupMultiHostApplication);
var vostokMultiHost = new VostokMultiHost(new VostokMultiHostSettings(SetupMultiHost), application);
Action run = () => vostokMultiHost.RunAsync().GetAwaiter().GetResult();
run.ShouldPassIn(1.Seconds());
vostokMultiHost.MultiHostState.Should().Be(VostokMultiHostState.Exited);
}
public void Should_return_CrashedDuringEnvironmentSetup()
{
vostokMultiHost = new VostokMultiHost(
new VostokMultiHostSettings(
builder =>
{
builder.SetupApplicationIdentity(identityBuilder => throw new Exception("Failed!"));
builder.SetupLog(logBuilder => logBuilder.SetupConsoleLog());
})
);
Action error = () => vostokMultiHost.RunAsync().GetAwaiter().GetResult();
error.Should().Throw <Exception>().WithMessage("Failed!");
vostokMultiHost.MultiHostState.Should().Be(VostokMultiHostState.CrashedDuringEnvironmentSetup);
}
public async Task Start_should_wait_until_given_state_occurs(VostokApplicationState stateToAwait)
{
var identifier = ("test", "test");
var workerApplication = new VostokMultiHostApplicationSettings(new NeverEndingApplication(), identifier, SetupMultiHostApplication);
vostokMultiHost = new VostokMultiHost(new VostokMultiHostSettings(SetupMultiHost), workerApplication);
await vostokMultiHost.StartAsync();
await vostokMultiHost.GetApplication(identifier).StartAsync(stateToAwait);
vostokMultiHost.GetApplication(identifier).ApplicationState.Should().Match <VostokApplicationState>(state => state >= stateToAwait);
await vostokMultiHost.StopApplicationAsync(identifier);
vostokMultiHost.GetApplication(identifier).ApplicationState.IsTerminal().Should().BeTrue();
await vostokMultiHost.StopAsync();
}
public async Task Should_allow_to_subscribe_to_state_changes_prior_to_start()
{
vostokMultiHost = new VostokMultiHost(new VostokMultiHostSettings(SetupMultiHost));
var workerIdentifier = ("nevermind", "delay");
var workerApplication = new VostokMultiHostApplicationSettings(
new DelayApplication(),
workerIdentifier,
SetupMultiHostApplication);
var stateChangesCount = 0;
VostokApplicationState?lastState = null;
var observable = vostokMultiHost.AddApplication(workerApplication).OnApplicationStateChanged;
using (observable.Subscribe(state => stateChangesCount++))
using (observable.Subscribe(state => lastState = state))
await vostokMultiHost.RunAsync();
stateChangesCount.Should().Be(7);
lastState.Should().Be(VostokApplicationState.Exited);
}
public void Should_interpret_MultiHost_builder_settings_as_default_in_applications()
{
void Assertion(IVostokHostingEnvironment environment) => environment.HostExtensions.Get <TestHostExtension>().A.Should().Be(10);
var vostokMultiHost = new VostokMultiHost(
new VostokMultiHostSettings(
builder =>
{
builder.SetupLog(logBuilder => logBuilder.SetupConsoleLog());
builder.SetupHostExtensions(extensionsBuilder => extensionsBuilder.Add(new TestHostExtension(10)));
}));
var application = new VostokMultiHostApplicationSettings(
new TesterApplication(Assertion),
("test", "test"),
SetupMultiHostApplication);
vostokMultiHost.AddApplication(application);
Action run = () => vostokMultiHost.RunAsync().GetAwaiter().GetResult().EnsureSuccess();
run.Should().NotThrow();
}
public async Task Should_not_stop_if_contains_not_finished_application()
{
var application = new VostokMultiHostApplicationSettings(
new DelayApplication(),
("test", "test"),
SetupMultiHostApplication);
var newApplication = new VostokMultiHostApplicationSettings(
new NeverEndingApplication(),
("nevermind", "delay"),
SetupMultiHostApplication);
var vostokMultiHost = new VostokMultiHost(new VostokMultiHostSettings(SetupMultiHost), application);
await vostokMultiHost.StartAsync();
vostokMultiHost.AddApplication(newApplication);
await Task.Delay(500);
vostokMultiHost.MultiHostState.Should().Be(VostokMultiHostState.Running);
await vostokMultiHost.StopAsync();
}
private async Task SetupAndStartMultiHost()
{
vostokMultiHost = new VostokMultiHost(new VostokMultiHostSettings(SetupMultiHost));
await vostokMultiHost.StartAsync();
}
