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();
}
}
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();
}
private void SetupMultiHost()
{
var workerApplication = new VostokMultiHostApplicationSettings(
new TestApplication(),
("nevermind", "blabla"),
MultiHostApplicationBuilder);
vostokMultiHost = new VostokMultiHost(new VostokMultiHostSettings(MultiHostBuilder), workerApplication);
}
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 async Task Should_run_in_parallel()
{
await SetupAndStartMultiHost();
var appList = new List <VostokMultiHostApplicationSettings>();
for (var i = 1; i < 11; i++)
{
appList.Add(
new VostokMultiHostApplicationSettings(
new DelayApplication(),
("test", i.ToString()),
SetupMultiHostApplication)
);
}
Action runInParallel = () => vostokMultiHost.RunInParallelAsync(appList).GetAwaiter().GetResult();
runInParallel.ShouldPassIn((150 * 2).Milliseconds());
}
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 Run_should_not_throw()
{
await SetupAndStartMultiHost();
var identifier = ("test", "test");
var badApplication = new VostokMultiHostApplicationSettings(new BadApplication(false), identifier, SetupMultiHostApplication);
Action checkStart = () => vostokMultiHost.RunApplicationAsync(badApplication).GetAwaiter().GetResult();
checkStart.Should().NotThrow <Exception>();
}
public async Task Should_throw_on_add_if_VostokMultiHost_is_stopped()
{
await SetupAndStartMultiHost();
await vostokMultiHost.StopAsync();
var identifier = ("test", "test");
var badApplication = new VostokMultiHostApplicationSettings(new BadApplication(false), identifier, SetupMultiHostApplication);
Action checkStart = () => vostokMultiHost.RunApplicationAsync(badApplication).GetAwaiter().GetResult();
checkStart.Should().Throw <InvalidOperationException>();
}
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_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 async Task Should_run_sequentially()
{
var currentIndex = 0;
int GetIndex() => currentIndex;
void SetIndex(int newIndex) => currentIndex = newIndex;
await SetupAndStartMultiHost();
var appList = new List <VostokMultiHostApplicationSettings>();
for (var i = 1; i < 11; i++)
{
appList.Add(
new VostokMultiHostApplicationSettings(
new SequentialCheckerApplication(GetIndex, SetIndex, i),
("test", i.ToString()),
SetupMultiHostApplication)
);
}
await vostokMultiHost.RunSequentiallyAsync(appList);
}
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();
}
public async Task Start_and_stop_should_throw_on_initialize_failed()
{
await SetupAndStartMultiHost();
var identifier = ("test", "test");
var badApplication = new VostokMultiHostApplicationSettings(new BadApplication(true), identifier, SetupMultiHostApplication);
Action checkStart = () => vostokMultiHost.StartApplicationAsync(badApplication).GetAwaiter().GetResult();
checkStart.Should().Throw <Exception>().WithMessage("initialize");
Action checkStop = () => vostokMultiHost.StopApplicationAsync(identifier).GetAwaiter().GetResult();
checkStop.Should().Throw <Exception>().WithMessage("initialize");
}
public async Task Should_not_throw_on_second_start()
{
await SetupAndStartMultiHost();
var workerIdentifier = ("nevermind", "delay");
var workerApplication = new VostokMultiHostApplicationSettings(
new DelayApplication(),
workerIdentifier,
SetupMultiHostApplication);
await vostokMultiHost.StartApplicationAsync(workerApplication);
Action secondStart = () => vostokMultiHost.GetApplication(workerIdentifier).StartAsync().GetAwaiter().GetResult();
secondStart.Should().NotThrow();
}
public async Task Should_return_same_result_on_second_run()
{
await SetupAndStartMultiHost();
var workerIdentifier = ("nevermind", "delay");
var workerApplication = new VostokMultiHostApplicationSettings(
new DelayApplication(),
workerIdentifier,
SetupMultiHostApplication);
var result = await vostokMultiHost.RunApplicationAsync(workerApplication);
var result2 = await vostokMultiHost.GetApplication(workerIdentifier).RunAsync();
result.Should().BeSameAs(result2);
}
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 Start_should_not_throw_on_run_failed()
{
await SetupAndStartMultiHost();
var identifier = ("test", "test");
var badApplication = new VostokMultiHostApplicationSettings(new BadApplication(false), identifier, SetupMultiHostApplication);
Action checkStart = () => vostokMultiHost.StartApplicationAsync(badApplication).GetAwaiter().GetResult();
checkStart.Should().NotThrow <Exception>();
var application = vostokMultiHost.GetApplication(identifier);
AssertionAssertions.ShouldPassIn(() => { application.ApplicationState.IsTerminal().Should().BeTrue(); }, 10.Seconds());
Action checkStop = () => vostokMultiHost.StopApplicationAsync(identifier).GetAwaiter().GetResult();
checkStop.Should().Throw <Exception>().WithMessage("run");
}
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);
}
