public void ShouldSendFailCommandOnExceptionInJobHandler()
        {
            // given
            var expectedRequest = new ActivateJobsRequest
            {
                Timeout           = 123_000L,
                MaxJobsToActivate = 1,
                Type   = "foo",
                Worker = "jobWorker"
            };

            var expectedFailRequest = new FailJobRequest
            {
                JobKey       = 1,
                ErrorMessage = "Job worker 'jobWorker' tried to handle job of type 'foo', but exception occured 'Fail'",
                Retries      = 2
            };

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

            // when
            using (var jobWorker = ZeebeClient.NewWorker()
                                   .JobType("foo")
                                   .Handler((jobClient, job) =>
            {
                if (job.Key == 1)
                {
                    throw new Exception("Fail");
                }
            })
                                   .MaxJobsActive(1)
                                   .Name("jobWorker")
                                   .Timeout(TimeSpan.FromSeconds(123L))
                                   .PollInterval(TimeSpan.FromMilliseconds(100))
                                   .Open())
            {
                Assert.True(jobWorker.IsOpen());
                while (TestService.Requests.Count < 2)
                {
                }
            }

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

            Assert.AreEqual(expectedRequest, actualRequest);

            var actualFailRequest = TestService.Requests[1];

            Assert.AreEqual(expectedFailRequest, actualFailRequest);
        }
        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);
        }
        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[typeof(ActivateJobsRequest)][0];

            Assert.AreEqual(expectedRequest, actualRequest);

            Assert.AreEqual(receivedJobs.Count, 3);

            AssertJob(receivedJobs[0], 1);
            AssertJob(receivedJobs[1], 2);
            AssertJob(receivedJobs[2], 3);
        }
        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);
        }
        public void ShouldCompleteAfterSendFailCommandOnExceptionInJobHandler()
        {
            // given
            TestService.AddRequestHandler(typeof(ActivateJobsRequest), request => CreateExpectedResponse());

            // when
            using (var jobWorker = ZeebeClient.NewWorker()
                                   .JobType("foo")
                                   .Handler(async(jobClient, job) =>
            {
                if (job.Key == 2)
                {
                    throw new Exception("Fail");
                }

                await jobClient.NewCompleteJobCommand(job).Send();
            })
                                   .MaxJobsActive(3)
                                   .Name("jobWorker")
                                   .Timeout(TimeSpan.FromSeconds(123L))
                                   .PollInterval(TimeSpan.FromMilliseconds(100))
                                   .Open())
            {
                Assert.True(jobWorker.IsOpen());
                while (TestService.Requests[typeof(ActivateJobsRequest)].Count < 1 ||
                       TestService.Requests[typeof(FailJobRequest)].Count < 1 ||
                       TestService.Requests[typeof(CompleteJobRequest)].Count < 2)
                {
                }
            }

            // then
            var completeRequests = TestService.Requests[typeof(CompleteJobRequest)];

            Assert.AreEqual(1, ((CompleteJobRequest)completeRequests[0]).JobKey);
            Assert.AreEqual(3, ((CompleteJobRequest)completeRequests[1]).JobKey);
        }
Beispiel #6
0
        public void ShouldSendRequestsWithDifferentAmounts()
        {
            // given
            var expectedRequest = new ActivateJobsRequest
            {
                Timeout           = 123_000L,
                MaxJobsToActivate = 4,
                Type           = "foo",
                Worker         = "jobWorker",
                RequestTimeout = 5_000L
            };

            var expectedSecondRequest = new ActivateJobsRequest
            {
                Timeout           = 123_000L,
                MaxJobsToActivate = 2,
                Type           = "foo",
                Worker         = "jobWorker",
                RequestTimeout = 5_000L
            };

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

            // when
            var receivedJobs = new List <IJob>();

            using (var jobWorker = ZeebeClient.NewWorker()
                                   .JobType("foo")
                                   .Handler((jobClient, job) =>
            {
                // block job handling
                receivedJobs.Add(job);
                if (receivedJobs.Count == 2)
                {
                    using (var signal = new EventWaitHandle(false, EventResetMode.AutoReset))
                    {
                        signal.WaitOne();
                    }
                }
            })
                                   .MaxJobsActive(4)
                                   .Name("jobWorker")
                                   .Timeout(TimeSpan.FromSeconds(123L))
                                   .PollInterval(TimeSpan.FromMilliseconds(100))
                                   .PollingTimeout(TimeSpan.FromMilliseconds(5_000L))
                                   .Open())
            {
                Assert.True(jobWorker.IsOpen());
                while (TestService.Requests[typeof(ActivateJobsRequest)].Count < 2)
                {
                }
            }

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

            Assert.AreEqual(expectedRequest, actualRequest);

            var actualSecondRequest = TestService.Requests[typeof(ActivateJobsRequest)][1];

            Assert.AreEqual(expectedSecondRequest, actualSecondRequest);
        }