Example #1
0
        public void ShouldCancelRequest()
        {
            // given

            // when
            var task = ZeebeClient
                       .NewResolveIncidentCommand(1201321)
                       .Send(new CancellationTokenSource(TimeSpan.Zero).Token);
            var aggregateException = Assert.Throws <AggregateException>(() => task.Wait());
            var rpcException       = (RpcException)aggregateException.InnerExceptions[0];

            // then
            Assert.AreEqual(StatusCode.Cancelled, rpcException.Status.StatusCode);
        }
Example #2
0
        public void ShouldTimeoutRequest()
        {
            // given

            // when
            var task = ZeebeClient
                       .NewResolveIncidentCommand(1201321)
                       .Send(TimeSpan.Zero);
            var aggregateException = Assert.Throws <AggregateException>(() => task.Wait());
            var rpcException       = (RpcException)aggregateException.InnerExceptions[0];

            // then
            Assert.AreEqual(StatusCode.DeadlineExceeded, rpcException.Status.StatusCode);
        }
        public void ShouldSendRequestReceiveResponseAsExpected()
        {
            // given
            var expectedRequest = new ActivateJobsRequest
            {
                Timeout           = 123_000L,
                MaxJobsToActivate = 3,
                Type           = "foo",
                Worker         = "jobWorker",
                RequestTimeout = 5_000L
            };

            TestService.AddRequestHandler(typeof(ActivateJobsRequest), request => CreateExpectedResponse());

            // when
            var signal       = new EventWaitHandle(false, EventResetMode.AutoReset);
            var receivedJobs = new List <IJob>();

            using (var jobWorker = ZeebeClient.NewWorker()
                                   .JobType("foo")
                                   .Handler((jobClient, job) =>
            {
                receivedJobs.Add(job);
                if (receivedJobs.Count == 3)
                {
                    signal.Set();
                }
            })
                                   .MaxJobsActive(3)
                                   .Name("jobWorker")
                                   .Timeout(TimeSpan.FromSeconds(123L))
                                   .PollInterval(TimeSpan.FromMilliseconds(100))
                                   .PollingTimeout(TimeSpan.FromSeconds(5L))
                                   .Open())
            {
                Assert.True(jobWorker.IsOpen());
                signal.WaitOne();
            }

            // then
            var actualRequest = TestService.Requests[0];

            Assert.AreEqual(expectedRequest, actualRequest);

            Assert.AreEqual(receivedJobs.Count, 3);

            AssertJob(receivedJobs[0], 1);
            AssertJob(receivedJobs[1], 2);
            AssertJob(receivedJobs[2], 3);
        }
Example #4
0
        public void ShouldTimeoutRequest()
        {
            // given
            const string variables = "{\"foo\":23}";
            const int    jobKey    = 255;

            // when
            var task = ZeebeClient.NewCompleteJobCommand(jobKey).Variables(variables).Send(TimeSpan.Zero);
            var aggregateException = Assert.Throws <AggregateException>(() => task.Wait());
            var rpcException       = (RpcException)aggregateException.InnerExceptions[0];

            // then
            Assert.AreEqual(StatusCode.DeadlineExceeded, rpcException.Status.StatusCode);
        }
Example #5
0
        public void ShouldFailWithZeroThreadCount()
        {
            // expected
            var aggregateException = Assert.Throws <ArgumentOutOfRangeException>(
                () =>
            {
                ZeebeClient.NewWorker()
                .JobType("foo")
                .Handler((jobClient, job) => { })
                .HandlerThreads(0);
            });

            StringAssert.Contains("Expected an handler thread count larger then zero, but got 0.", aggregateException.Message);
        }
Example #6
0
        public void ShouldUseAutoCompleteWithWorker()
        {
            // given
            var expectedRequest = new ActivateJobsRequest
            {
                Timeout           = 5_000L,
                MaxJobsToActivate = 3,
                Type           = "foo",
                Worker         = "jobWorker",
                RequestTimeout = 5_000L
            };

            TestService.AddRequestHandler(
                typeof(ActivateJobsRequest),
                request => CreateExpectedResponse());

            // when
            using (var jobWorker = ZeebeClient.NewWorker()
                                   .JobType("foo")
                                   .Handler((jobClient, job) =>
            {
                Logger.Info("Handler has seen job '{0}'", job);
            })
                                   .AutoCompletion()
                                   .MaxJobsActive(3)
                                   .Name("jobWorker")
                                   .Timeout(TimeSpan.FromMilliseconds(5_000L))
                                   .PollInterval(TimeSpan.FromSeconds(5))
                                   .PollingTimeout(TimeSpan.FromMilliseconds(5_000L))
                                   .Open())
            {
                Assert.True(jobWorker.IsOpen());
                while (TestService.Requests[typeof(CompleteJobRequest)].Count < 3)
                {
                }
            }

            // then
            var actualRequest = TestService.Requests[typeof(ActivateJobsRequest)][0];

            Assert.AreEqual(expectedRequest, actualRequest);

            var completeJobRequests = TestService.Requests[typeof(CompleteJobRequest)].OfType <CompleteJobRequest>().Select(j => j.JobKey).ToList();

            Assert.AreEqual(3, completeJobRequests.Count);

            Assert.Contains(1, completeJobRequests);
            Assert.Contains(2, completeJobRequests);
            Assert.Contains(3, completeJobRequests);
        }
 /// <summary>
 /// Adds the Zeebe builders to the IServiceCollection
 /// </summary>
 /// <param name="services">the collection where the zeebe services are appended</param>
 /// <returns>the service collection</returns>
 public static IServiceCollection AddZeebeBuilders(this IServiceCollection services)
 {
     services.AddTransient(serviceProvider =>
     {
         var loggerFactory = serviceProvider.GetService <ILoggerFactory>();
         return(ZeebeClient.Builder().UseLoggerFactory(loggerFactory));
     });
     services.AddTransient(serviceProvider =>
     {
         var loggerFactory = serviceProvider.GetService <ILoggerFactory>();
         return(CamundaCloudTokenProvider.Builder().UseLoggerFactory(loggerFactory));
     });
     return(services);
 }
        public void ShouldNotThrowExceptionWhenDisposingMultipleTimes()
        {
            // given
            var zeebeClient = ZeebeClient.Builder()
                              .UseGatewayAddress("localhost:26500")
                              .UsePlainText()
                              .Build();

            // when
            zeebeClient.Dispose();

            // then
            Assert.DoesNotThrow(() => zeebeClient.Dispose());
        }
Example #9
0
        public async Task ShouldSendMultipleDeployResourceAndGetResponseAsExpected()
        {
            // given
            var expectedResponse = new DeployWorkflowResponse {
                Key = 1
            };

            expectedResponse.Workflows.Add(new WorkflowMetadata
            {
                BpmnProcessId = "process",
                ResourceName  = _demoProcessPath,
                Version       = 1,
                WorkflowKey   = 2
            });
            expectedResponse.Workflows.Add(new WorkflowMetadata
            {
                BpmnProcessId = "process2",
                ResourceName  = _demoProcessPath,
                Version       = 1,
                WorkflowKey   = 3
            });

            TestService.AddRequestHandler(typeof(DeployWorkflowRequest), request => expectedResponse);

            // when
            var fileContent            = File.ReadAllText(_demoProcessPath);
            var deployWorkflowResponse = await ZeebeClient.NewDeployCommand()
                                         .AddResourceFile(_demoProcessPath)
                                         .AddResourceString(fileContent, Encoding.UTF8, _demoProcessPath)
                                         .Send();

            // then
            Assert.AreEqual(1, deployWorkflowResponse.Key);
            Assert.AreEqual(2, deployWorkflowResponse.Workflows.Count);

            var workflowMetadata = deployWorkflowResponse.Workflows[0];

            Assert.AreEqual("process", workflowMetadata.BpmnProcessId);
            Assert.AreEqual(1, workflowMetadata.Version);
            Assert.AreEqual(_demoProcessPath, workflowMetadata.ResourceName);
            Assert.AreEqual(2, workflowMetadata.WorkflowKey);

            var workflowMetadata2 = deployWorkflowResponse.Workflows[1];

            Assert.AreEqual("process2", workflowMetadata2.BpmnProcessId);
            Assert.AreEqual(1, workflowMetadata2.Version);
            Assert.AreEqual(_demoProcessPath, workflowMetadata2.ResourceName);
            Assert.AreEqual(3, workflowMetadata2.WorkflowKey);
        }
Example #10
0
        public void ShouldTimeoutRequest()
        {
            // given

            // when
            var task = ZeebeClient
                       .NewUpdateRetriesCommand(1024)
                       .Retries(223)
                       .Send(TimeSpan.Zero);
            var aggregateException = Assert.Throws <AggregateException>(() => task.Wait());
            var rpcException       = (RpcException)aggregateException.InnerExceptions[0];

            // then
            Assert.AreEqual(Grpc.Core.StatusCode.DeadlineExceeded, rpcException.Status.StatusCode);
        }
        public void ShouldCancelRequest()
        {
            // given

            // when
            var task = ZeebeClient.NewCreateProcessInstanceCommand()
                       .BpmnProcessId("process")
                       .LatestVersion()
                       .Send(new CancellationTokenSource(TimeSpan.Zero).Token);
            var aggregateException = Assert.Throws <AggregateException>(() => task.Wait());
            var rpcException       = (RpcException)aggregateException.InnerExceptions[0];

            // then
            Assert.AreEqual(Grpc.Core.StatusCode.Cancelled, rpcException.Status.StatusCode);
        }
Example #12
0
        public void ShouldTimeoutRequest()
        {
            // given

            // when
            var task = ZeebeClient.NewCreateWorkflowInstanceCommand()
                       .BpmnProcessId("process")
                       .LatestVersion()
                       .Send(TimeSpan.Zero);
            var aggregateException = Assert.Throws <AggregateException>(() => task.Wait());
            var rpcException       = (RpcException)aggregateException.InnerExceptions[0];

            // then
            Assert.AreEqual(Grpc.Core.StatusCode.DeadlineExceeded, rpcException.Status.StatusCode);
        }
Example #13
0
        public void ShouldTimeoutRequest()
        {
            // given

            // when
            var task = ZeebeClient
                       .NewSetVariablesCommand(2123)
                       .Variables("{\"foo\":\"bar\"}")
                       .Send(TimeSpan.Zero);
            var aggregateException = Assert.Throws <AggregateException>(() => task.Wait());
            var rpcException       = (RpcException)aggregateException.InnerExceptions[0];

            // then
            Assert.AreEqual(Grpc.Core.StatusCode.DeadlineExceeded, rpcException.Status.StatusCode);
        }
        public void ShouldTimeoutRequest()
        {
            // given

            // when
            var task = ZeebeClient
                       .NewDeployCommand()
                       .AddResourceFile(_demoProcessPath)
                       .Send(TimeSpan.Zero);
            var aggregateException = Assert.Throws <AggregateException>(() => task.Wait());
            var rpcException       = (RpcException)aggregateException.InnerExceptions[0];

            // then
            Assert.AreEqual(Grpc.Core.StatusCode.DeadlineExceeded, rpcException.Status.StatusCode);
        }
Example #15
0
        public void ShouldCancelRequest()
        {
            // given

            // when
            var task = ZeebeClient
                       .NewDeployCommand()
                       .AddResourceFile(_demoProcessPath)
                       .Send(new CancellationTokenSource(TimeSpan.Zero).Token);
            var aggregateException = Assert.Throws <AggregateException>(() => task.Wait());
            var rpcException       = (RpcException)aggregateException.InnerExceptions[0];

            // then
            Assert.AreEqual(StatusCode.Cancelled, rpcException.Status.StatusCode);
        }
        public void ShouldCancelRequest()
        {
            // given

            // when
            var task = ZeebeClient
                       .NewSetVariablesCommand(2123)
                       .Variables("{\"foo\":\"bar\"}")
                       .Send(new CancellationTokenSource(TimeSpan.Zero).Token);
            var aggregateException = Assert.Throws <AggregateException>(() => task.Wait());
            var rpcException       = (RpcException)aggregateException.InnerExceptions[0];

            // then
            Assert.AreEqual(StatusCode.Cancelled, rpcException.Status.StatusCode);
        }
        public void ShouldCancelRequest()
        {
            // given

            // when
            var task = ZeebeClient
                       .NewPublishMessageCommand()
                       .MessageName("messageName")
                       .CorrelationKey("p-1")
                       .Send(new CancellationTokenSource(TimeSpan.Zero).Token);
            var aggregateException = Assert.Throws <AggregateException>(() => task.Wait());
            var rpcException       = (RpcException)aggregateException.InnerExceptions[0];

            // then
            Assert.AreEqual(StatusCode.Cancelled, rpcException.Status.StatusCode);
        }
Example #18
0
        public async Task ShouldSendRequestAsExpected()
        {
            // given
            var expected = new ResolveIncidentRequest
            {
                IncidentKey = 1201321
            };

            // when
            await ZeebeClient.NewResolveIncidentCommand(1201321).Send();

            // then
            var request = TestService.Requests[typeof(ResolveIncidentRequest)][0];

            Assert.AreEqual(expected, request);
        }
Example #19
0
        public void ShouldTimeoutRequest()
        {
            // given

            // when
            var task = ZeebeClient
                       .NewPublishMessageCommand()
                       .MessageName("messageName")
                       .CorrelationKey("p-1")
                       .Send(TimeSpan.Zero);
            var aggregateException = Assert.Throws <AggregateException>(() => task.Wait());
            var rpcException       = (RpcException)aggregateException.InnerExceptions[0];

            // then
            Assert.AreEqual(Grpc.Core.StatusCode.DeadlineExceeded, rpcException.Status.StatusCode);
        }
        public void ShouldCancelRequest()
        {
            // given
            const int jobKey = 255;

            // when
            var task = ZeebeClient.NewThrowErrorCommand(jobKey)
                       .ErrorCode("code 13")
                       .ErrorMessage("This is a business error!")
                       .Send(new CancellationTokenSource(TimeSpan.Zero).Token);
            var aggregateException = Assert.Throws <AggregateException>(() => task.Wait());
            var rpcException       = (RpcException)aggregateException.InnerExceptions[0];

            // then
            Assert.AreEqual(StatusCode.Cancelled, rpcException.Status.StatusCode);
        }
Example #21
0
        public async Task shouldSendRequestWithFilterAsExpected()
        {
            // given
            var expected = new ListWorkflowsRequest
            {
                BpmnProcessId = "process"
            };

            // when
            await ZeebeClient.NewListWorkflowRequest().BpmnProcessId("process").Send();

            // then
            var request = TestService.Requests[0];

            Assert.AreEqual(expected, request);
        }
Example #22
0
        public async Task ShouldReceiveResponseAsExpected()
        {
            // given
            var expectedResponse = new SetVariablesResponse
            {
                Key = 12
            };

            TestService.AddRequestHandler(typeof(SetVariablesRequest), request => expectedResponse);

            // when
            var response = await ZeebeClient.NewSetVariablesCommand(2123).Variables("{\"foo\":\"bar\"}").Local().Send();

            // then
            Assert.AreEqual(12, response.Key);
        }
        public void ShouldTimeoutRequest()
        {
            // given
            const int JobKey = 255;

            // when
            var task = ZeebeClient.NewThrowErrorCommand(JobKey)
                       .ErrorCode("code 13")
                       .ErrorMessage("This is a business error!")
                       .Send(TimeSpan.Zero);
            var aggregateException = Assert.Throws <AggregateException>(() => task.Wait());
            var rpcException       = (RpcException)aggregateException.InnerExceptions[0];

            // then
            Assert.AreEqual(Grpc.Core.StatusCode.DeadlineExceeded, rpcException.Status.StatusCode);
        }
Example #24
0
        public async Task ShouldSendRequestAsExpected()
        {
            // given
            var expected = new CancelWorkflowInstanceRequest
            {
                WorkflowInstanceKey = 12113
            };

            // when
            await ZeebeClient.NewCancelInstanceCommand(12113).Send();

            // then
            var request = TestService.Requests[typeof(CancelWorkflowInstanceRequest)][0];

            Assert.AreEqual(expected, request);
        }
        public void ShouldTimeoutRequest()
        {
            // given
            const int jobKey = 255;

            // when
            var task = ZeebeClient
                       .NewFailCommand(jobKey)
                       .Retries(2)
                       .ErrorMessage("This job failed!")
                       .Send(TimeSpan.Zero);
            var aggregateException = Assert.Throws <AggregateException>(() => task.Wait());
            var rpcException       = (RpcException)aggregateException.InnerExceptions[0];

            // then
            Assert.AreEqual(StatusCode.DeadlineExceeded, rpcException.Status.StatusCode);
        }
Example #26
0
        public async Task ShouldSendRequestAsExpected()
        {
            // given
            var expectedRequest = new SetVariablesRequest
            {
                ElementInstanceKey = 2123,
                Variables          = "{\"foo\":\"bar\"}"
            };

            // when
            await ZeebeClient.NewSetVariablesCommand(2123).Variables("{\"foo\":\"bar\"}").Send();

            // then
            var request = TestService.Requests[typeof(SetVariablesRequest)][0];

            Assert.AreEqual(expectedRequest, request);
        }
Example #27
0
        public async Task shouldSendRequestAsExpected()
        {
            // given
            var expectedRequest = new UpdateWorkflowInstancePayloadRequest
            {
                ElementInstanceKey = 2123,
                Payload            = "{\"foo\":\"bar\"}"
            };

            // when
            await ZeebeClient.NewUpdatePayloadCommand(2123).Payload("{\"foo\":\"bar\"}").Send();

            // then
            var request = TestService.Requests[0];

            Assert.AreEqual(expectedRequest, request);
        }
Example #28
0
        public async Task ShouldFailOnWrongCert()
        {
            // given
            GrpcEnvironment.SetLogger(new ConsoleLogger());

            var keyCertificatePairs = new List <KeyCertificatePair>();
            var serverCert          = File.ReadAllText(ServerCertPath);

            keyCertificatePairs.Add(new KeyCertificatePair(serverCert, File.ReadAllText(ServerKeyPath)));
            var channelCredentials = new SslServerCredentials(keyCertificatePairs);

            var server = new Server();

            server.Ports.Add(new ServerPort("0.0.0.0", 26505, channelCredentials));

            var testService       = new GatewayTestService();
            var serviceDefinition = Gateway.BindService(testService);

            server.Services.Add(serviceDefinition);
            server.Start();


            // client
            var zeebeClient = ZeebeClient.Builder()
                              .UseGatewayAddress("0.0.0.0:26505")
                              .UseTransportEncryption(WrongCertPath)
                              .Build();

            // when
            try
            {
                await zeebeClient
                .NewPublishMessageCommand()
                .MessageName("messageName")
                .CorrelationKey("p-1")
                .Send();

                Assert.Fail();
            }
            catch (RpcException rpcException)
            {
                // expected
                Assert.AreEqual(rpcException.Status.StatusCode, StatusCode.Unavailable);
            }
        }
Example #29
0
        public async Task ShouldSendRequestWithWorkflowKeyAsExpected()
        {
            // given
            var expectedRequest = new CreateWorkflowInstanceRequest
            {
                WorkflowKey = 1
            };

            // when
            await ZeebeClient.NewCreateWorkflowInstanceCommand()
            .WorkflowKey(1)
            .Send();

            // then
            var request = TestService.Requests[typeof(CreateWorkflowInstanceRequest)][0];

            Assert.AreEqual(expectedRequest, request);
        }
Example #30
0
        public async Task ShouldUseUserAgentHeader()
        {
            // given
            Metadata sendMetadata = null;

            TestService.ConsumeRequestHeaders(metadata => { sendMetadata = metadata; });

            // when
            await ZeebeClient.TopologyRequest().Send();

            // then
            Assert.NotNull(sendMetadata);

            var entry = sendMetadata[0];

            Assert.AreEqual("user-agent", entry.Key);
            Assert.IsTrue(entry.Value.StartsWith("zeebe-client-csharp/" + typeof(ZeebeClient).Assembly.GetName().Version));
        }