public Test_FixtureNoConnect(CadenceFixture fixture) { var settings = new CadenceSettings() { DefaultDomain = CadenceFixture.DefaultDomain, LogLevel = CadenceTestHelper.LogLevel, CreateDomain = true, Debug = CadenceTestHelper.Debug, DebugPrelaunched = CadenceTestHelper.DebugPrelaunched, DebugDisableHeartbeats = CadenceTestHelper.DebugDisableHeartbeats }; if (fixture.Start(settings, keepConnection: true, keepOpen: CadenceTestHelper.KeepCadenceServerOpen, noClient: true) == TestFixtureStatus.Started) { this.fixture = fixture; this.client = fixture.Client = CadenceClient.ConnectAsync(fixture.Settings).Result; // Auto register the test workflow and activity implementations. client.RegisterAssemblyAsync(Assembly.GetExecutingAssembly()).Wait(); // Start the worker. client.StartWorkerAsync(CadenceTestHelper.TaskList).Wait(); } else { this.fixture = fixture; this.client = fixture.Client; } }
public Test_Replay(CadenceFixture fixture) { TestHelper.ResetDocker(this.GetType()); var settings = new CadenceSettings() { DefaultDomain = CadenceFixture.DefaultDomain, LogLevel = CadenceTestHelper.LogLevel, CreateDomain = true, Debug = CadenceTestHelper.Debug, DebugPrelaunched = CadenceTestHelper.DebugPrelaunched, DebugDisableHeartbeats = CadenceTestHelper.DebugDisableHeartbeats, ClientIdentity = CadenceTestHelper.ClientIdentity }; if (fixture.Start(settings, reconnect: true, keepRunning: CadenceTestHelper.KeepCadenceServerOpen) == TestFixtureStatus.Started) { this.fixture = fixture; this.client = fixture.Client; // Auto register the test workflow and activity implementations. client.RegisterAssemblyAsync(Assembly.GetExecutingAssembly()).WaitWithoutAggregate(); // Start the worker. client.StartWorkerAsync(CadenceTestHelper.TaskList).WaitWithoutAggregate(); } else { this.fixture = fixture; this.client = fixture.Client; } }
public Test_EndToEnd(CadenceFixture fixture, ITestOutputHelper outputHelper) { TestHelper.ResetDocker(this.GetType()); testWriter = new TestOutputWriter(outputHelper); // Initialize the Cadence fixture. var settings = new CadenceSettings() { DefaultDomain = CadenceFixture.DefaultDomain, LogLevel = CadenceTestHelper.LogLevel, CreateDomain = true, Debug = CadenceTestHelper.Debug, DebugPrelaunched = CadenceTestHelper.DebugPrelaunched, DebugDisableHeartbeats = CadenceTestHelper.DebugDisableHeartbeats, ClientIdentity = CadenceTestHelper.ClientIdentity }; if (fixture.Start(settings, reconnect: true, keepRunning: CadenceTestHelper.KeepCadenceServerOpen) == TestFixtureStatus.Started) { this.fixture = fixture; this.client = fixture.Client; this.proxyClient = new HttpClient() { BaseAddress = client.ProxyUri }; // Setup a service for activity dependency injection testing if it doesn't // already exist. if (NeonHelper.ServiceContainer.GetService <ActivityDependency>() == null) { NeonHelper.ServiceContainer.AddSingleton(typeof(ActivityDependency), new ActivityDependency() { Hello = "World!" }); } // Auto register the test workflow and activity implementations. client.RegisterAssemblyAsync(Assembly.GetExecutingAssembly()).WaitWithoutAggregate(); // Start the worker. client.StartWorkerAsync(CadenceTestHelper.TaskList).WaitWithoutAggregate(); } else { this.fixture = fixture; this.client = fixture.Client; this.proxyClient = new HttpClient() { BaseAddress = client.ProxyUri }; } }
public CadenceTests(CadenceFixture fixture) { TestHelper.ResetDocker(this.GetType()); var settings = new CadenceSettings() { DefaultDomain = "test-domain", LogLevel = LogLevel.Info, CreateDomain = true // <-- this ensures that the default domain exists }; // This starts/restarts the [nforgeio/cadence-dev] container for the first test // run in this class. Subsequent tests run from the class will use the existing // container instance, saving time by not having to wait for Cadence and Cassandra // to spin up and be ready for business. // // The [keepOpen=true] parameter tells the fixture to let the container continue running // after all of the tests have completed. This is useful for examining workflow histories // via the Cadence UX after the tests have completed. You can view the Cadence portal at // // http://localhost:8088 // // You can pass [keepOpen=false] to have the fixture remove the container after the // test run if you wish. if (fixture.Start(settings, reconnect: true, keepRunning: true) == TestFixtureStatus.Started) { this.fixture = fixture; this.client = fixture.Client; // Register the test workflow and activity implementations // from this assembly and start the worker. client.RegisterAssemblyAsync(Assembly.GetExecutingAssembly()).WaitWithoutAggregate(); client.StartWorkerAsync("test-tasks").WaitWithoutAggregate(); } else { this.fixture = fixture; this.client = fixture.Client; } }
public async Task Multiple_TaskLists() { await SyncContext.Clear; // Test the scenario where there multiple clients without // workers that will be used to simulate apps that make calls // on workflows and then create multiple clients that register // different workflows and activities and then verify that // each of the workerless clients are able to execute workflows // and activities and that these end up being executed on the // correct clients. var clients = new List <CadenceClient>(); try { // Initialize the non-worker clients. CadenceClient client1; CadenceClient client2; CadenceClient client3; clients.Add(client1 = await CadenceClient.ConnectAsync(fixture.Settings)); clients.Add(client2 = await CadenceClient.ConnectAsync(fixture.Settings)); clients.Add(client3 = await CadenceClient.ConnectAsync(fixture.Settings)); // Initialize the worker clients. clients.Add(workerClient1 = await CadenceClient.ConnectAsync(fixture.Settings)); clients.Add(workerClient2 = await CadenceClient.ConnectAsync(fixture.Settings)); clients.Add(workerClient3 = await CadenceClient.ConnectAsync(fixture.Settings)); // Start the workers. await workerClient1.RegisterActivityAsync <ActivityWorker1>(); await workerClient1.RegisterWorkflowAsync <WorkflowWorker1>(); await workerClient1.StartWorkerAsync("tasklist-1"); await workerClient2.RegisterActivityAsync <ActivityWorker2>(); await workerClient2.RegisterWorkflowAsync <WorkflowWorker2>(); await workerClient2.StartWorkerAsync("tasklist-2"); await workerClient3.RegisterActivityAsync <ActivityWorker3>(); await workerClient3.RegisterWorkflowAsync <WorkflowWorker3>(); await workerClient3.StartWorkerAsync("tasklist-3"); // Execute each of the worker workflows WITHOUT the associated activities // from each client (both the worker and non-worker clients). foreach (var client in clients) { var stub = client.NewWorkflowStub <IWorkflowWorker1>(); Assert.True(await stub.RunAsync(testActivity: false)); } foreach (var client in clients) { var stub = client.NewWorkflowStub <IWorkflowWorker2>(); Assert.True(await stub.RunAsync(testActivity: false)); } foreach (var client in clients) { var stub = client.NewWorkflowStub <IWorkflowWorker3>(); Assert.True(await stub.RunAsync(testActivity: false)); } // Re-run the workflows calling the activities this time. foreach (var client in clients) { var stub = client.NewWorkflowStub <IWorkflowWorker1>(); Assert.True(await stub.RunAsync(testActivity: true)); } foreach (var client in clients) { var stub = client.NewWorkflowStub <IWorkflowWorker2>(); Assert.True(await stub.RunAsync(testActivity: true)); } foreach (var client in clients) { var stub = client.NewWorkflowStub <IWorkflowWorker3>(); Assert.True(await stub.RunAsync(testActivity: true)); } } finally { foreach (var client in clients) { client.Dispose(); } workerClient1 = null; workerClient2 = null; workerClient3 = null; } }
public async Task Worker() { await SyncContext.Clear; await client.RegisterDomainAsync("test-domain", ignoreDuplicates : true); // Verify that the stub builder methods don't barf. CadenceClient.BuildActivityStub <ITestActivity>(); CadenceClient.BuildWorkflowStub <ITestWorkflow>(); CadenceClient.BuildAssemblyStubs(Assembly.GetExecutingAssembly()); // Verify that creating workers with the same attributes actually // return the pre-existing instance with an incremented reference // count. var activityWorker1 = await client.StartWorkerAsync("tasks1", new WorkerOptions() { DisableWorkflowWorker = true }); Assert.Equal(0, activityWorker1.RefCount); var activityWorker2 = await client.StartWorkerAsync("tasks1", new WorkerOptions() { DisableWorkflowWorker = true }); Assert.Same(activityWorker1, activityWorker2); Assert.Equal(1, activityWorker2.RefCount); var workflowWorker1 = await client.StartWorkerAsync("tasks1", new WorkerOptions() { DisableActivityWorker = true }); Assert.Equal(0, workflowWorker1.RefCount); var workflowWorker2 = await client.StartWorkerAsync("tasks1", new WorkerOptions() { DisableActivityWorker = true }); Assert.Same(workflowWorker1, workflowWorker2); Assert.Equal(1, workflowWorker2.RefCount); Assert.Same(workflowWorker1, workflowWorker2); Assert.Equal(1, workflowWorker2.RefCount); var worker1 = await client.StartWorkerAsync("tasks2"); Assert.Equal(0, worker1.RefCount); var worker2 = await client.StartWorkerAsync("tasks2"); Assert.Same(worker1, worker2); Assert.Equal(1, worker2.RefCount); // Verify the dispose/refcount behavior. activityWorker2.Dispose(); Assert.False(activityWorker2.IsDisposed); Assert.Equal(0, activityWorker2.RefCount); activityWorker2.Dispose(); Assert.True(activityWorker2.IsDisposed); Assert.Equal(-1, activityWorker2.RefCount); workflowWorker2.Dispose(); Assert.False(workflowWorker2.IsDisposed); Assert.Equal(0, workflowWorker2.RefCount); workflowWorker2.Dispose(); Assert.True(workflowWorker2.IsDisposed); Assert.Equal(-1, workflowWorker2.RefCount); // Verify that we're not allowed to restart workers. await Assert.ThrowsAsync <InvalidOperationException>(async() => await client.StartWorkerAsync("tasks1", new WorkerOptions() { DisableWorkflowWorker = true })); await Assert.ThrowsAsync <InvalidOperationException>(async() => await client.StartWorkerAsync("tasks1", new WorkerOptions() { DisableActivityWorker = true })); }