From a38724e84fa25fda1763a9dd2b71c056c5280924 Mon Sep 17 00:00:00 2001 From: Valentin Zickner Date: Wed, 11 Feb 2026 17:09:39 +0100 Subject: [PATCH 1/2] add tests similar to the tests in the Python repository --- .../BpmnUtils.cs | 108 +++++ .../CassetteHandler.cs | 168 +++++++ .../CmmnUtils.cs | 89 ++++ .../ExternalWorkerClientTests.cs | 212 ++++++++ .../Fixtures/Cases/externalWorkerCase.cmmn | 31 ++ .../Fixtures/Cassettes/TestAcquireJobs.json | 191 ++++++++ .../Fixtures/Cassettes/TestCompleteJob.json | 257 ++++++++++ .../Fixtures/Cassettes/TestConsume.json | 257 ++++++++++ .../TestConsumeWithCmmnTerminate.json | 257 ++++++++++ .../Cassettes/TestConsumeWithFailure.json | 284 +++++++++++ .../Fixtures/Cassettes/TestFailJob.json | 284 +++++++++++ .../Fixtures/Cassettes/TestGetJob.json | 224 +++++++++ .../TestJobWithBpmnErrorWithErrorCode1.json | 257 ++++++++++ .../TestJobWithBpmnErrorWithErrorCode2.json | 257 ++++++++++ .../TestJobWithBpmnErrorWithoutErrorCode.json | 257 ++++++++++ .../Cassettes/TestJobWithCmmnTerminate.json | 224 +++++++++ .../Fixtures/Cassettes/TestListJobs.json | 191 ++++++++ .../Cassettes/TestListJobsInvalidAuth.json | 192 ++++++++ .../Cassettes/TestListJobsWithCustomizer.json | 191 ++++++++ .../Cassettes/TestSubscribeWithBpmnError.json | 290 +++++++++++ .../Processes/externalWorkerProcess.bpmn | 60 +++ .../Fixtures/Processes/withBoundaryEvent.bpmn | 114 +++++ .../FlowableExternalWorkerClient.Tests.csproj | 31 ++ .../RestClientTests.cs | 451 ++++++++++++++++++ FlowableExternalWorkerClient.Tests/Vcr.cs | 21 + .../xunit.runner.json | 5 + FlowableExternalWorkerClient.sln | 7 + .../Client/ExternalWorkerClient.cs | 13 + .../Client/WorkResult.cs | 8 +- .../FlowableExternalWorkerClient.csproj | 2 +- .../Rest/FlowableExternalWorkerRestClient.cs | 18 + 31 files changed, 4946 insertions(+), 5 deletions(-) create mode 100644 FlowableExternalWorkerClient.Tests/BpmnUtils.cs create mode 100644 FlowableExternalWorkerClient.Tests/CassetteHandler.cs create mode 100644 FlowableExternalWorkerClient.Tests/CmmnUtils.cs create mode 100644 FlowableExternalWorkerClient.Tests/ExternalWorkerClientTests.cs create mode 100644 FlowableExternalWorkerClient.Tests/Fixtures/Cases/externalWorkerCase.cmmn create mode 100644 FlowableExternalWorkerClient.Tests/Fixtures/Cassettes/TestAcquireJobs.json create mode 100644 FlowableExternalWorkerClient.Tests/Fixtures/Cassettes/TestCompleteJob.json create mode 100644 FlowableExternalWorkerClient.Tests/Fixtures/Cassettes/TestConsume.json create mode 100644 FlowableExternalWorkerClient.Tests/Fixtures/Cassettes/TestConsumeWithCmmnTerminate.json create mode 100644 FlowableExternalWorkerClient.Tests/Fixtures/Cassettes/TestConsumeWithFailure.json create mode 100644 FlowableExternalWorkerClient.Tests/Fixtures/Cassettes/TestFailJob.json create mode 100644 FlowableExternalWorkerClient.Tests/Fixtures/Cassettes/TestGetJob.json create mode 100644 FlowableExternalWorkerClient.Tests/Fixtures/Cassettes/TestJobWithBpmnErrorWithErrorCode1.json create mode 100644 FlowableExternalWorkerClient.Tests/Fixtures/Cassettes/TestJobWithBpmnErrorWithErrorCode2.json create mode 100644 FlowableExternalWorkerClient.Tests/Fixtures/Cassettes/TestJobWithBpmnErrorWithoutErrorCode.json create mode 100644 FlowableExternalWorkerClient.Tests/Fixtures/Cassettes/TestJobWithCmmnTerminate.json create mode 100644 FlowableExternalWorkerClient.Tests/Fixtures/Cassettes/TestListJobs.json create mode 100644 FlowableExternalWorkerClient.Tests/Fixtures/Cassettes/TestListJobsInvalidAuth.json create mode 100644 FlowableExternalWorkerClient.Tests/Fixtures/Cassettes/TestListJobsWithCustomizer.json create mode 100644 FlowableExternalWorkerClient.Tests/Fixtures/Cassettes/TestSubscribeWithBpmnError.json create mode 100644 FlowableExternalWorkerClient.Tests/Fixtures/Processes/externalWorkerProcess.bpmn create mode 100644 FlowableExternalWorkerClient.Tests/Fixtures/Processes/withBoundaryEvent.bpmn create mode 100644 FlowableExternalWorkerClient.Tests/FlowableExternalWorkerClient.Tests.csproj create mode 100644 FlowableExternalWorkerClient.Tests/RestClientTests.cs create mode 100644 FlowableExternalWorkerClient.Tests/Vcr.cs create mode 100644 FlowableExternalWorkerClient.Tests/xunit.runner.json diff --git a/FlowableExternalWorkerClient.Tests/BpmnUtils.cs b/FlowableExternalWorkerClient.Tests/BpmnUtils.cs new file mode 100644 index 0000000..e7b1a29 --- /dev/null +++ b/FlowableExternalWorkerClient.Tests/BpmnUtils.cs @@ -0,0 +1,108 @@ +using System.Net.Http.Headers; +using System.Text; +using System.Text.Json; +using Xunit; + +namespace FlowableExternalWorkerClient.Tests; + +public static class BpmnUtils +{ + private static readonly JsonSerializerOptions JsonOptions = new() + { + PropertyNamingPolicy = JsonNamingPolicy.CamelCase + }; + + public static async Task DeployProcess(HttpClient client, string baseUrl, string filePath) + { + using var content = new MultipartFormDataContent(); + var fileBytes = await File.ReadAllBytesAsync(filePath); + var fileContent = new ByteArrayContent(fileBytes); + fileContent.Headers.ContentType = new MediaTypeHeaderValue("application/octet-stream"); + content.Add(fileContent, "file", Path.GetFileName(filePath)); + + var response = await client.PostAsync(baseUrl + "/process-api/repository/deployments", content); + Assert.Equal(System.Net.HttpStatusCode.Created, response.StatusCode); + + var json = await JsonSerializer.DeserializeAsync(await response.Content.ReadAsStreamAsync()); + return json.GetProperty("id").GetString()!; + } + + public static async Task DeleteDeployment(HttpClient client, string baseUrl, string deploymentId) + { + var response = await client.DeleteAsync( + baseUrl + "/process-api/repository/deployments/" + deploymentId); + Assert.Equal(System.Net.HttpStatusCode.NoContent, response.StatusCode); + } + + public static async Task GetProcessDefinitionId(HttpClient client, string baseUrl, string deploymentId) + { + var response = await client.GetAsync( + baseUrl + "/process-api/repository/process-definitions?deploymentId=" + deploymentId); + Assert.Equal(System.Net.HttpStatusCode.OK, response.StatusCode); + + var json = await JsonSerializer.DeserializeAsync(await response.Content.ReadAsStreamAsync()); + var data = json.GetProperty("data"); + Assert.Equal(1, data.GetArrayLength()); + return data[0].GetProperty("id").GetString()!; + } + + public static async Task StartProcess(HttpClient client, string baseUrl, string processDefinitionId) + { + var requestBody = new StringContent( + JsonSerializer.Serialize(new { processDefinitionId }, JsonOptions), + Encoding.UTF8, + "application/json" + ); + + var response = await client.PostAsync( + baseUrl + "/process-api/runtime/process-instances", requestBody); + Assert.Equal(System.Net.HttpStatusCode.Created, response.StatusCode); + + var json = await JsonSerializer.DeserializeAsync(await response.Content.ReadAsStreamAsync()); + return json.GetProperty("id").GetString()!; + } + + public static async Task TerminateProcess(HttpClient client, string baseUrl, string processInstanceId) + { + var response = await client.DeleteAsync( + baseUrl + "/process-api/runtime/process-instances/" + processInstanceId); + Assert.Equal(System.Net.HttpStatusCode.NoContent, response.StatusCode); + } + + public static async Task GetProcessVariable(HttpClient client, string baseUrl, + string processInstanceId, string variableName) + { + var response = await client.GetAsync( + baseUrl + "/process-api/history/historic-variable-instances?processInstanceId=" + + processInstanceId + "&variableName=" + variableName); + Assert.Equal(System.Net.HttpStatusCode.OK, response.StatusCode); + + var json = await JsonSerializer.DeserializeAsync(await response.Content.ReadAsStreamAsync()); + var data = json.GetProperty("data"); + if (data.GetArrayLength() == 1) + { + return data[0].GetProperty("variable"); + } + + return null; + } + + public static async Task> ExecutedActivityIds(HttpClient client, string baseUrl, + string processInstanceId) + { + var response = await client.GetAsync( + baseUrl + "/process-api/history/historic-activity-instances?processInstanceId=" + processInstanceId); + Assert.Equal(System.Net.HttpStatusCode.OK, response.StatusCode); + + var json = await JsonSerializer.DeserializeAsync(await response.Content.ReadAsStreamAsync()); + var data = json.GetProperty("data"); + var activityIds = new List(); + foreach (var item in data.EnumerateArray()) + { + activityIds.Add(item.GetProperty("activityId").GetString()!); + } + + activityIds.Sort(); + return activityIds; + } +} diff --git a/FlowableExternalWorkerClient.Tests/CassetteHandler.cs b/FlowableExternalWorkerClient.Tests/CassetteHandler.cs new file mode 100644 index 0000000..9c092cc --- /dev/null +++ b/FlowableExternalWorkerClient.Tests/CassetteHandler.cs @@ -0,0 +1,168 @@ +using System.Net; +using System.Net.Http.Headers; +using System.Text.Json; + +namespace FlowableExternalWorkerClient.Tests; + +/// +/// A DelegatingHandler that records HTTP interactions to a JSON cassette file +/// and replays them in order on subsequent runs. +/// +/// Mode: Auto - if cassette file exists, replays; otherwise records. +/// Replay is sequential (ordered), not matching-based, to correctly handle +/// repeated calls to the same endpoint with different responses. +/// +public class CassetteHandler : DelegatingHandler +{ + private readonly string _cassettePath; + private readonly List _interactions; + private int _replayIndex; + private readonly bool _isReplaying; + + public CassetteHandler(string cassettePath) + : base(new HttpClientHandler()) + { + _cassettePath = cassettePath; + if (File.Exists(cassettePath)) + { + var json = File.ReadAllText(cassettePath); + _interactions = JsonSerializer.Deserialize>(json, + new JsonSerializerOptions { PropertyNamingPolicy = JsonNamingPolicy.CamelCase }) ?? new(); + _isReplaying = true; + } + else + { + _interactions = new(); + _isReplaying = false; + } + } + + public bool IsReplaying => _isReplaying; + + public HttpClient CreateHttpClient() + { + return new HttpClient(this, disposeHandler: false); + } + + protected override async Task SendAsync( + HttpRequestMessage request, CancellationToken cancellationToken) + { + if (_isReplaying) + { + return Replay(request); + } + + return await Record(request, cancellationToken); + } + + private HttpResponseMessage Replay(HttpRequestMessage request) + { + int index; + lock (_interactions) + { + index = _replayIndex++; + } + + if (index >= _interactions.Count) + { + throw new InvalidOperationException( + $"Cassette '{Path.GetFileName(_cassettePath)}' has no more recorded interactions " + + $"(tried index {index}, total {_interactions.Count}). " + + $"Delete the cassette file to re-record."); + } + + return _interactions[index].ToHttpResponseMessage(); + } + + private async Task Record( + HttpRequestMessage request, CancellationToken cancellationToken) + { + var response = await base.SendAsync(request, cancellationToken); + + // Buffer the response body so both recording and caller can use it + var bodyBytes = response.Content != null + ? await response.Content.ReadAsByteArrayAsync(cancellationToken) + : Array.Empty(); + + var interaction = new RecordedInteraction + { + Method = request.Method.Method, + Uri = request.RequestUri?.ToString() ?? "", + StatusCode = (int)response.StatusCode, + ResponseBody = Convert.ToBase64String(bodyBytes), + ResponseContentType = response.Content?.Headers.ContentType?.ToString() + }; + + foreach (var header in response.Headers) + { + interaction.ResponseHeaders[header.Key] = header.Value.ToArray(); + } + + lock (_interactions) + { + _interactions.Add(interaction); + } + + // Return a new response with buffered body so the caller can read it + var newResponse = new HttpResponseMessage(response.StatusCode); + newResponse.Content = new ByteArrayContent(bodyBytes); + if (response.Content?.Headers.ContentType != null) + { + newResponse.Content.Headers.ContentType = response.Content.Headers.ContentType; + } + + foreach (var header in response.Headers) + { + newResponse.Headers.TryAddWithoutValidation(header.Key, header.Value); + } + + newResponse.RequestMessage = request; + return newResponse; + } + + public void Save() + { + if (!_isReplaying) + { + Directory.CreateDirectory(Path.GetDirectoryName(_cassettePath)!); + var json = JsonSerializer.Serialize(_interactions, new JsonSerializerOptions + { + WriteIndented = true, + PropertyNamingPolicy = JsonNamingPolicy.CamelCase + }); + File.WriteAllText(_cassettePath, json); + } + } +} + +public class RecordedInteraction +{ + public string Method { get; set; } = ""; + public string Uri { get; set; } = ""; + public int StatusCode { get; set; } + public string? ResponseBody { get; set; } + public string? ResponseContentType { get; set; } + public Dictionary ResponseHeaders { get; set; } = new(); + + public HttpResponseMessage ToHttpResponseMessage() + { + var response = new HttpResponseMessage((HttpStatusCode)StatusCode); + + if (ResponseBody != null) + { + var bytes = Convert.FromBase64String(ResponseBody); + response.Content = new ByteArrayContent(bytes); + if (ResponseContentType != null) + { + response.Content.Headers.ContentType = MediaTypeHeaderValue.Parse(ResponseContentType); + } + } + + foreach (var header in ResponseHeaders) + { + response.Headers.TryAddWithoutValidation(header.Key, header.Value); + } + + return response; + } +} diff --git a/FlowableExternalWorkerClient.Tests/CmmnUtils.cs b/FlowableExternalWorkerClient.Tests/CmmnUtils.cs new file mode 100644 index 0000000..c6a3e56 --- /dev/null +++ b/FlowableExternalWorkerClient.Tests/CmmnUtils.cs @@ -0,0 +1,89 @@ +using System.Net.Http.Headers; +using System.Text; +using System.Text.Json; +using Xunit; + +namespace FlowableExternalWorkerClient.Tests; + +public static class CmmnUtils +{ + private static readonly JsonSerializerOptions JsonOptions = new() + { + PropertyNamingPolicy = JsonNamingPolicy.CamelCase + }; + + public static async Task DeployCase(HttpClient client, string baseUrl, string filePath) + { + using var content = new MultipartFormDataContent(); + var fileBytes = await File.ReadAllBytesAsync(filePath); + var fileContent = new ByteArrayContent(fileBytes); + fileContent.Headers.ContentType = new MediaTypeHeaderValue("application/octet-stream"); + content.Add(fileContent, "file", Path.GetFileName(filePath)); + + var response = await client.PostAsync(baseUrl + "/cmmn-api/cmmn-repository/deployments", content); + Assert.Equal(System.Net.HttpStatusCode.Created, response.StatusCode); + + var json = await JsonSerializer.DeserializeAsync(await response.Content.ReadAsStreamAsync()); + return json.GetProperty("id").GetString()!; + } + + public static async Task DeleteCaseDeployment(HttpClient client, string baseUrl, string deploymentId) + { + var response = await client.DeleteAsync( + baseUrl + "/cmmn-api/cmmn-repository/deployments/" + deploymentId); + Assert.Equal(System.Net.HttpStatusCode.NoContent, response.StatusCode); + } + + public static async Task GetCaseDefinitionId(HttpClient client, string baseUrl, string deploymentId) + { + var response = await client.GetAsync( + baseUrl + "/cmmn-api/cmmn-repository/case-definitions?deploymentId=" + deploymentId); + Assert.Equal(System.Net.HttpStatusCode.OK, response.StatusCode); + + var json = await JsonSerializer.DeserializeAsync(await response.Content.ReadAsStreamAsync()); + var data = json.GetProperty("data"); + Assert.Equal(1, data.GetArrayLength()); + return data[0].GetProperty("id").GetString()!; + } + + public static async Task StartCase(HttpClient client, string baseUrl, string caseDefinitionId) + { + var requestBody = new StringContent( + JsonSerializer.Serialize(new { caseDefinitionId }, JsonOptions), + Encoding.UTF8, + "application/json" + ); + + var response = await client.PostAsync( + baseUrl + "/cmmn-api/cmmn-runtime/case-instances", requestBody); + Assert.Equal(System.Net.HttpStatusCode.Created, response.StatusCode); + + var json = await JsonSerializer.DeserializeAsync(await response.Content.ReadAsStreamAsync()); + return json.GetProperty("id").GetString()!; + } + + public static async Task TerminateCase(HttpClient client, string baseUrl, string caseInstanceId) + { + var response = await client.DeleteAsync( + baseUrl + "/cmmn-api/cmmn-runtime/case-instances/" + caseInstanceId); + Assert.Equal(System.Net.HttpStatusCode.NoContent, response.StatusCode); + } + + public static async Task GetCaseVariable(HttpClient client, string baseUrl, + string caseInstanceId, string variableName) + { + var response = await client.GetAsync( + baseUrl + "/cmmn-api/cmmn-history/historic-variable-instances?caseInstanceId=" + + caseInstanceId + "&variableName=" + variableName); + Assert.Equal(System.Net.HttpStatusCode.OK, response.StatusCode); + + var json = await JsonSerializer.DeserializeAsync(await response.Content.ReadAsStreamAsync()); + var data = json.GetProperty("data"); + if (data.GetArrayLength() == 1) + { + return data[0].GetProperty("variable"); + } + + return null; + } +} diff --git a/FlowableExternalWorkerClient.Tests/ExternalWorkerClientTests.cs b/FlowableExternalWorkerClient.Tests/ExternalWorkerClientTests.cs new file mode 100644 index 0000000..92ccc96 --- /dev/null +++ b/FlowableExternalWorkerClient.Tests/ExternalWorkerClientTests.cs @@ -0,0 +1,212 @@ +using System.Net.Http.Headers; +using System.Text; +using FlowableExternalWorkerClient.Client; +using FlowableExternalWorkerClient.Rest; +using Xunit; + +namespace FlowableExternalWorkerClient.Tests; + +public class ExternalWorkerClientTests +{ + private const string BaseUrl = "http://localhost:8090/flowable-work"; + + private static readonly AuthenticationHeaderValue Auth = + new("Basic", Convert.ToBase64String(Encoding.UTF8.GetBytes("admin:test"))); + + private string FixturesPath => Path.Combine(AppContext.BaseDirectory, "Fixtures"); + + private ExternalWorkerAcquireJobResponse ConsumeOneCall( + ExternalWorkerClient client, + Func callbackHandler, + string topic = "myTopic") + { + ExternalWorkerAcquireJobResponse? resultJob = null; + var completed = false; + + var handler = new DelegateCallbackHandler((job, work) => + { + var result = callbackHandler(job, work); + resultJob = job; + completed = true; + return result; + }); + + var subscription = client.Subscribe(topic, handler, waitPeriodSeconds: 1); + + var attempts = 0; + while (attempts < 50 && !completed) + { + Thread.Sleep(200); + attempts++; + } + + subscription.Unsubscribe(); + Assert.True(completed, "Callback was not invoked within the timeout period"); + return resultJob!; + } + + [Fact] + public async Task TestConsume() + { + using var cassette = Vcr.UseCassette(); + var httpClient = cassette.CreateHttpClient(); + httpClient.DefaultRequestHeaders.Authorization = Auth; + var client = new ExternalWorkerClient(BaseUrl, "test-worker", httpClient); + + var deploymentId = await BpmnUtils.DeployProcess( + httpClient, BaseUrl, Path.Combine(FixturesPath, "Processes", "externalWorkerProcess.bpmn")); + var definitionId = await BpmnUtils.GetProcessDefinitionId(httpClient, BaseUrl, deploymentId); + var processInstanceId = await BpmnUtils.StartProcess(httpClient, BaseUrl, definitionId); + try + { + ConsumeOneCall(client, (job, work) => work.Success()); + + var activityIds = await BpmnUtils.ExecutedActivityIds(httpClient, BaseUrl, processInstanceId); + Assert.Equal( + new List + { + "bpmnEndEvent_1", "bpmnSequenceFlow_2", "bpmnSequenceFlow_4", "bpmnTask_3", "startnoneevent1" + }, + activityIds); + } + finally + { + await BpmnUtils.DeleteDeployment(httpClient, BaseUrl, deploymentId); + cassette.Save(); + } + } + + [Fact] + public async Task TestConsumeWithFailure() + { + using var cassette = Vcr.UseCassette(); + var httpClient = cassette.CreateHttpClient(); + httpClient.DefaultRequestHeaders.Authorization = Auth; + var client = new ExternalWorkerClient(BaseUrl, "test-worker", httpClient); + + var deploymentId = await BpmnUtils.DeployProcess( + httpClient, BaseUrl, Path.Combine(FixturesPath, "Processes", "externalWorkerProcess.bpmn")); + var definitionId = await BpmnUtils.GetProcessDefinitionId(httpClient, BaseUrl, deploymentId); + var processInstanceId = await BpmnUtils.StartProcess(httpClient, BaseUrl, definitionId); + try + { + ConsumeOneCall(client, (job, work) => + work.Failure() + .ErrorMessage("Test Error Message") + .ErrorDetails("Some error details") + .Retries(3) + .RetryTimeout("PT5M") + ); + + // Give the server a moment to process + if (!cassette.IsReplaying) await Task.Delay(500); + + var activityIds = await BpmnUtils.ExecutedActivityIds(httpClient, BaseUrl, processInstanceId); + Assert.Equal( + new List { "bpmnSequenceFlow_2", "bpmnTask_3", "startnoneevent1" }, + activityIds); + } + finally + { + await BpmnUtils.TerminateProcess(httpClient, BaseUrl, processInstanceId); + await BpmnUtils.DeleteDeployment(httpClient, BaseUrl, deploymentId); + cassette.Save(); + } + } + + [Fact] + public async Task TestConsumeWithCmmnTerminate() + { + using var cassette = Vcr.UseCassette(); + var httpClient = cassette.CreateHttpClient(); + httpClient.DefaultRequestHeaders.Authorization = Auth; + var client = new ExternalWorkerClient(BaseUrl, "test-worker", httpClient); + + var deploymentId = await CmmnUtils.DeployCase( + httpClient, BaseUrl, Path.Combine(FixturesPath, "Cases", "externalWorkerCase.cmmn")); + var definitionId = await CmmnUtils.GetCaseDefinitionId(httpClient, BaseUrl, deploymentId); + var caseInstanceId = await CmmnUtils.StartCase(httpClient, BaseUrl, definitionId); + try + { + ConsumeOneCall( + client, + (job, work) => work.CmmnTerminate().Variable("testVar", "test terminate"), + topic: "cmmnTopic" + ); + + // Give the server a moment to process + if (!cassette.IsReplaying) await Task.Delay(500); + + var variable = await CmmnUtils.GetCaseVariable(httpClient, BaseUrl, caseInstanceId, "testVar"); + Assert.NotNull(variable); + Assert.Equal("string", variable.Value.GetProperty("type").GetString()); + Assert.Equal("test terminate", variable.Value.GetProperty("value").GetString()); + } + finally + { + await CmmnUtils.DeleteCaseDeployment(httpClient, BaseUrl, deploymentId); + cassette.Save(); + } + } + + [Fact] + public async Task TestSubscribeWithBpmnError() + { + using var cassette = Vcr.UseCassette(); + var httpClient = cassette.CreateHttpClient(); + httpClient.DefaultRequestHeaders.Authorization = Auth; + var client = new ExternalWorkerClient(BaseUrl, "test-worker", httpClient); + + var deploymentId = await BpmnUtils.DeployProcess( + httpClient, BaseUrl, Path.Combine(FixturesPath, "Processes", "withBoundaryEvent.bpmn")); + var definitionId = await BpmnUtils.GetProcessDefinitionId(httpClient, BaseUrl, deploymentId); + var processInstanceId = await BpmnUtils.StartProcess(httpClient, BaseUrl, definitionId); + try + { + ConsumeOneCall(client, (job, work) => + work.BpmnError() + .Variable("testVar", "test failure") + .ErrorCode("errorCode1") + ); + + // Give the server a moment to process + if (!cassette.IsReplaying) await Task.Delay(500); + + var variable = + await BpmnUtils.GetProcessVariable(httpClient, BaseUrl, processInstanceId, "testVar"); + Assert.NotNull(variable); + Assert.Equal("string", variable.Value.GetProperty("type").GetString()); + Assert.Equal("test failure", variable.Value.GetProperty("value").GetString()); + + var activityIds = await BpmnUtils.ExecutedActivityIds(httpClient, BaseUrl, processInstanceId); + Assert.Equal( + new List + { + "bpmnBoundaryEvent_3", "bpmnBoundaryEvent_4", "bpmnEndEvent_5", "bpmnSequenceFlow_2", + "bpmnSequenceFlow_6", "bpmnTask_3", "startnoneevent1" + }, + activityIds); + } + finally + { + await BpmnUtils.DeleteDeployment(httpClient, BaseUrl, deploymentId); + cassette.Save(); + } + } + + private class DelegateCallbackHandler : IExternalWorkerCallbackHandler + { + private readonly Func _handler; + + public DelegateCallbackHandler( + Func handler) + { + _handler = handler; + } + + public IWorkResult? Handle(ExternalWorkerAcquireJobResponse job, IWorkResultBuilder work) + { + return _handler(job, work); + } + } +} diff --git a/FlowableExternalWorkerClient.Tests/Fixtures/Cases/externalWorkerCase.cmmn b/FlowableExternalWorkerClient.Tests/Fixtures/Cases/externalWorkerCase.cmmn new file mode 100644 index 0000000..edf1b97 --- /dev/null +++ b/FlowableExternalWorkerClient.Tests/Fixtures/Cases/externalWorkerCase.cmmn @@ -0,0 +1,31 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/FlowableExternalWorkerClient.Tests/Fixtures/Cassettes/TestAcquireJobs.json b/FlowableExternalWorkerClient.Tests/Fixtures/Cassettes/TestAcquireJobs.json new file mode 100644 index 0000000..e59222d --- /dev/null +++ b/FlowableExternalWorkerClient.Tests/Fixtures/Cassettes/TestAcquireJobs.json @@ -0,0 +1,191 @@ +[ + { + "method": "POST", + "uri": "http://localhost:8090/flowable-work/process-api/repository/deployments", + "statusCode": 201, + "responseBody": "eyJ1cmwiOiJodHRwOi8vbG9jYWxob3N0OjgwOTAvZmxvd2FibGUtd29yay9wcm9jZXNzLWFwaS9yZXBvc2l0b3J5L2RlcGxveW1lbnRzL1BSQy00MGEyOTczOC0wNzYzLTExZjEtOTE3Yi0yZWRmZWU0MzlkZTEiLCJjYXRlZ29yeSI6bnVsbCwiZGVwbG95bWVudFRpbWUiOiIyMDI2LTAyLTExVDE2OjAzOjQ5LjI3NVoiLCJpZCI6IlBSQy00MGEyOTczOC0wNzYzLTExZjEtOTE3Yi0yZWRmZWU0MzlkZTEiLCJuYW1lIjoiZXh0ZXJuYWxXb3JrZXJQcm9jZXNzIiwicGFyZW50RGVwbG95bWVudElkIjoiUFJDLTQwYTI5NzM4LTA3NjMtMTFmMS05MTdiLTJlZGZlZTQzOWRlMSIsInRlbmFudElkIjoiIn0=", + "responseContentType": "application/json", + "responseHeaders": { + "Set-Cookie": [ + "XSRF-TOKEN=e7870bd3-f05b-4e8d-9c25-3ee002fe00ae; Path=/flowable-work" + ], + "X-Content-Type-Options": [ + "nosniff" + ], + "X-XSS-Protection": [ + "0" + ], + "Cache-Control": [ + "no-store, must-revalidate, no-cache, max-age=0" + ], + "Pragma": [ + "no-cache" + ], + "X-Frame-Options": [ + "SAMEORIGIN" + ], + "Vary": [ + "accept-encoding" + ], + "Transfer-Encoding": [ + "chunked" + ], + "Date": [ + "Wed, 11 Feb 2026 16:03:49 GMT" + ] + } + }, + { + "method": "GET", + "uri": "http://localhost:8090/flowable-work/process-api/repository/process-definitions?deploymentId=PRC-40a29738-0763-11f1-917b-2edfee439de1", + "statusCode": 200, + "responseBody": "eyJkYXRhIjpbeyJjYXRlZ29yeSI6Imh0dHA6Ly9mbG93YWJsZS5vcmcvdGVzdCIsImRlcGxveW1lbnRJZCI6IlBSQy00MGEyOTczOC0wNzYzLTExZjEtOTE3Yi0yZWRmZWU0MzlkZTEiLCJkZXBsb3ltZW50VXJsIjoiaHR0cDovL2xvY2FsaG9zdDo4MDkwL2Zsb3dhYmxlLXdvcmsvcHJvY2Vzcy1hcGkvcmVwb3NpdG9yeS9kZXBsb3ltZW50cy9QUkMtNDBhMjk3MzgtMDc2My0xMWYxLTkxN2ItMmVkZmVlNDM5ZGUxIiwiZGVzY3JpcHRpb24iOm51bGwsImRpYWdyYW1SZXNvdXJjZSI6bnVsbCwiZ3JhcGhpY2FsTm90YXRpb25EZWZpbmVkIjp0cnVlLCJpZCI6IlBSQy1leHRlcm5hbFdvcmtlclByb2Nlc3M6Mzo0MGEzYThhYS0wNzYzLTExZjEtOTE3Yi0yZWRmZWU0MzlkZTEiLCJrZXkiOiJleHRlcm5hbFdvcmtlclByb2Nlc3MiLCJuYW1lIjoiRXh0ZXJuYWwgV29ya2VyIFByb2Nlc3MiLCJyZXNvdXJjZSI6Imh0dHA6Ly9sb2NhbGhvc3Q6ODA5MC9mbG93YWJsZS13b3JrL3Byb2Nlc3MtYXBpL3JlcG9zaXRvcnkvZGVwbG95bWVudHMvUFJDLTQwYTI5NzM4LTA3NjMtMTFmMS05MTdiLTJlZGZlZTQzOWRlMS9yZXNvdXJjZXMvZXh0ZXJuYWxXb3JrZXJQcm9jZXNzLmJwbW4iLCJzdGFydEZvcm1EZWZpbmVkIjpmYWxzZSwic3VzcGVuZGVkIjpmYWxzZSwidGVuYW50SWQiOiIiLCJ1cmwiOiJodHRwOi8vbG9jYWxob3N0OjgwOTAvZmxvd2FibGUtd29yay9wcm9jZXNzLWFwaS9yZXBvc2l0b3J5L3Byb2Nlc3MtZGVmaW5pdGlvbnMvUFJDLWV4dGVybmFsV29ya2VyUHJvY2VzczozOjQwYTNhOGFhLTA3NjMtMTFmMS05MTdiLTJlZGZlZTQzOWRlMSIsInZlcnNpb24iOjN9XSwib3JkZXIiOiJhc2MiLCJzaXplIjoxLCJzb3J0IjoibmFtZSIsInN0YXJ0IjowLCJ0b3RhbCI6MX0=", + "responseContentType": "application/json", + "responseHeaders": { + "X-Content-Type-Options": [ + "nosniff" + ], + "X-XSS-Protection": [ + "0" + ], + "Cache-Control": [ + "no-store, must-revalidate, no-cache, max-age=0" + ], + "Pragma": [ + "no-cache" + ], + "X-Frame-Options": [ + "SAMEORIGIN" + ], + "Vary": [ + "accept-encoding" + ], + "Transfer-Encoding": [ + "chunked" + ], + "Date": [ + "Wed, 11 Feb 2026 16:03:49 GMT" + ] + } + }, + { + "method": "POST", + "uri": "http://localhost:8090/flowable-work/process-api/runtime/process-instances", + "statusCode": 201, + "responseBody": "eyJhY3Rpdml0eUlkIjpudWxsLCJidXNpbmVzc0tleSI6bnVsbCwiYnVzaW5lc3NTdGF0dXMiOm51bGwsImNhbGxiYWNrSWQiOm51bGwsImNhbGxiYWNrVHlwZSI6bnVsbCwiY29tcGxldGVkIjpmYWxzZSwiZW5kZWQiOmZhbHNlLCJpZCI6IlBSQy00MGJkMjQxYy0wNzYzLTExZjEtOTE3Yi0yZWRmZWU0MzlkZTEiLCJuYW1lIjpudWxsLCJwcm9jZXNzRGVmaW5pdGlvbkRlc2NyaXB0aW9uIjpudWxsLCJwcm9jZXNzRGVmaW5pdGlvbklkIjoiUFJDLWV4dGVybmFsV29ya2VyUHJvY2VzczozOjQwYTNhOGFhLTA3NjMtMTFmMS05MTdiLTJlZGZlZTQzOWRlMSIsInByb2Nlc3NEZWZpbml0aW9uTmFtZSI6IkV4dGVybmFsIFdvcmtlciBQcm9jZXNzIiwicHJvY2Vzc0RlZmluaXRpb25VcmwiOiJodHRwOi8vbG9jYWxob3N0OjgwOTAvZmxvd2FibGUtd29yay9wcm9jZXNzLWFwaS9yZXBvc2l0b3J5L3Byb2Nlc3MtZGVmaW5pdGlvbnMvUFJDLWV4dGVybmFsV29ya2VyUHJvY2VzczozOjQwYTNhOGFhLTA3NjMtMTFmMS05MTdiLTJlZGZlZTQzOWRlMSIsInByb3BhZ2F0ZWRTdGFnZUluc3RhbmNlSWQiOm51bGwsInJlZmVyZW5jZUlkIjpudWxsLCJyZWZlcmVuY2VUeXBlIjpudWxsLCJzdGFydFRpbWUiOiIyMDI2LTAyLTExVDE2OjAzOjQ5LjQ0OVoiLCJzdGFydFVzZXJJZCI6ImFkbWluIiwic3VwZXJQcm9jZXNzSW5zdGFuY2VJZCI6bnVsbCwic3VzcGVuZGVkIjpmYWxzZSwidGVuYW50SWQiOiIiLCJ1cmwiOiJodHRwOi8vbG9jYWxob3N0OjgwOTAvZmxvd2FibGUtd29yay9wcm9jZXNzLWFwaS9ydW50aW1lL3Byb2Nlc3MtaW5zdGFuY2VzL1BSQy00MGJkMjQxYy0wNzYzLTExZjEtOTE3Yi0yZWRmZWU0MzlkZTEiLCJ2YXJpYWJsZXMiOlt7Im5hbWUiOiJpbml0aWF0b3IiLCJzY29wZSI6ImxvY2FsIiwidHlwZSI6InN0cmluZyIsInZhbHVlIjoiYWRtaW4ifV19", + "responseContentType": "application/json", + "responseHeaders": { + "X-Content-Type-Options": [ + "nosniff" + ], + "X-XSS-Protection": [ + "0" + ], + "Cache-Control": [ + "no-store, must-revalidate, no-cache, max-age=0" + ], + "Pragma": [ + "no-cache" + ], + "X-Frame-Options": [ + "SAMEORIGIN" + ], + "Vary": [ + "accept-encoding" + ], + "Transfer-Encoding": [ + "chunked" + ], + "Date": [ + "Wed, 11 Feb 2026 16:03:49 GMT" + ] + } + }, + { + "method": "POST", + "uri": "http://localhost:8090/flowable-work/external-job-api/acquire/jobs", + "statusCode": 200, + "responseBody": "W3siY29ycmVsYXRpb25JZCI6IjQwYmUwZTg1LTA3NjMtMTFmMS05MTdiLTJlZGZlZTQzOWRlMSIsImNyZWF0ZVRpbWUiOiIyMDI2LTAyLTExVDE2OjAzOjQ5LjQ1NVoiLCJkdWVEYXRlIjpudWxsLCJlbGVtZW50SWQiOiJicG1uVGFza18zIiwiZWxlbWVudE5hbWUiOiJFeHRlcm5hbCBXb3JrZXIgdGFzayIsImV4Y2VwdGlvbk1lc3NhZ2UiOm51bGwsImV4ZWN1dGlvbklkIjoiUFJDLTQwYmQ0YjJmLTA3NjMtMTFmMS05MTdiLTJlZGZlZTQzOWRlMSIsImlkIjoiSk9CLTQwYmUwZTg2LTA3NjMtMTFmMS05MTdiLTJlZGZlZTQzOWRlMSIsImxvY2tFeHBpcmF0aW9uVGltZSI6IjIwMjYtMDItMTFUMTY6MDM6NTkuNTQwWiIsImxvY2tPd25lciI6InRlc3Qtd29ya2VyIiwicHJvY2Vzc0RlZmluaXRpb25JZCI6IlBSQy1leHRlcm5hbFdvcmtlclByb2Nlc3M6Mzo0MGEzYThhYS0wNzYzLTExZjEtOTE3Yi0yZWRmZWU0MzlkZTEiLCJwcm9jZXNzSW5zdGFuY2VJZCI6IlBSQy00MGJkMjQxYy0wNzYzLTExZjEtOTE3Yi0yZWRmZWU0MzlkZTEiLCJyZXRyaWVzIjozLCJzY29wZURlZmluaXRpb25JZCI6bnVsbCwic2NvcGVJZCI6bnVsbCwic2NvcGVUeXBlIjpudWxsLCJzdWJTY29wZUlkIjpudWxsLCJ0ZW5hbnRJZCI6IiIsInVybCI6Imh0dHA6Ly9sb2NhbGhvc3Q6ODA5MC9mbG93YWJsZS13b3JrL2V4dGVybmFsLWpvYi1hcGkvam9icy9KT0ItNDBiZTBlODYtMDc2My0xMWYxLTkxN2ItMmVkZmVlNDM5ZGUxIiwidmFyaWFibGVzIjpbeyJuYW1lIjoiaW5pdGlhdG9yIiwidHlwZSI6InN0cmluZyIsInZhbHVlIjoiYWRtaW4ifV19XQ==", + "responseContentType": "application/json", + "responseHeaders": { + "X-Content-Type-Options": [ + "nosniff" + ], + "X-XSS-Protection": [ + "0" + ], + "Cache-Control": [ + "no-store, must-revalidate, no-cache, max-age=0" + ], + "Pragma": [ + "no-cache" + ], + "X-Frame-Options": [ + "SAMEORIGIN" + ], + "Vary": [ + "accept-encoding" + ], + "Transfer-Encoding": [ + "chunked" + ], + "Date": [ + "Wed, 11 Feb 2026 16:03:49 GMT" + ] + } + }, + { + "method": "DELETE", + "uri": "http://localhost:8090/flowable-work/process-api/runtime/process-instances/PRC-40bd241c-0763-11f1-917b-2edfee439de1", + "statusCode": 204, + "responseBody": "", + "responseContentType": null, + "responseHeaders": { + "X-Content-Type-Options": [ + "nosniff" + ], + "X-XSS-Protection": [ + "0" + ], + "Cache-Control": [ + "no-store, must-revalidate, no-cache, max-age=0" + ], + "Pragma": [ + "no-cache" + ], + "X-Frame-Options": [ + "SAMEORIGIN" + ], + "Date": [ + "Wed, 11 Feb 2026 16:03:49 GMT" + ] + } + }, + { + "method": "DELETE", + "uri": "http://localhost:8090/flowable-work/process-api/repository/deployments/PRC-40a29738-0763-11f1-917b-2edfee439de1", + "statusCode": 204, + "responseBody": "", + "responseContentType": null, + "responseHeaders": { + "X-Content-Type-Options": [ + "nosniff" + ], + "X-XSS-Protection": [ + "0" + ], + "Cache-Control": [ + "no-store, must-revalidate, no-cache, max-age=0" + ], + "Pragma": [ + "no-cache" + ], + "X-Frame-Options": [ + "SAMEORIGIN" + ], + "Date": [ + "Wed, 11 Feb 2026 16:03:49 GMT" + ] + } + } +] \ No newline at end of file diff --git a/FlowableExternalWorkerClient.Tests/Fixtures/Cassettes/TestCompleteJob.json b/FlowableExternalWorkerClient.Tests/Fixtures/Cassettes/TestCompleteJob.json new file mode 100644 index 0000000..2e5dcd3 --- /dev/null +++ b/FlowableExternalWorkerClient.Tests/Fixtures/Cassettes/TestCompleteJob.json @@ -0,0 +1,257 @@ +[ + { + "method": "POST", + "uri": "http://localhost:8090/flowable-work/process-api/repository/deployments", + "statusCode": 201, + "responseBody": "eyJ1cmwiOiJodHRwOi8vbG9jYWxob3N0OjgwOTAvZmxvd2FibGUtd29yay9wcm9jZXNzLWFwaS9yZXBvc2l0b3J5L2RlcGxveW1lbnRzL1BSQy00MjFhNmE4My0wNzYzLTExZjEtOTE3Yi0yZWRmZWU0MzlkZTEiLCJjYXRlZ29yeSI6bnVsbCwiZGVwbG95bWVudFRpbWUiOiIyMDI2LTAyLTExVDE2OjAzOjUxLjczOFoiLCJpZCI6IlBSQy00MjFhNmE4My0wNzYzLTExZjEtOTE3Yi0yZWRmZWU0MzlkZTEiLCJuYW1lIjoiZXh0ZXJuYWxXb3JrZXJQcm9jZXNzIiwicGFyZW50RGVwbG95bWVudElkIjoiUFJDLTQyMWE2YTgzLTA3NjMtMTFmMS05MTdiLTJlZGZlZTQzOWRlMSIsInRlbmFudElkIjoiIn0=", + "responseContentType": "application/json", + "responseHeaders": { + "Set-Cookie": [ + "XSRF-TOKEN=c09b4618-487f-4fc9-8f29-bcbc847af3e6; Path=/flowable-work" + ], + "X-Content-Type-Options": [ + "nosniff" + ], + "X-XSS-Protection": [ + "0" + ], + "Cache-Control": [ + "no-store, must-revalidate, no-cache, max-age=0" + ], + "Pragma": [ + "no-cache" + ], + "X-Frame-Options": [ + "SAMEORIGIN" + ], + "Vary": [ + "accept-encoding" + ], + "Transfer-Encoding": [ + "chunked" + ], + "Date": [ + "Wed, 11 Feb 2026 16:03:51 GMT" + ] + } + }, + { + "method": "GET", + "uri": "http://localhost:8090/flowable-work/process-api/repository/process-definitions?deploymentId=PRC-421a6a83-0763-11f1-917b-2edfee439de1", + "statusCode": 200, + "responseBody": "eyJkYXRhIjpbeyJjYXRlZ29yeSI6Imh0dHA6Ly9mbG93YWJsZS5vcmcvdGVzdCIsImRlcGxveW1lbnRJZCI6IlBSQy00MjFhNmE4My0wNzYzLTExZjEtOTE3Yi0yZWRmZWU0MzlkZTEiLCJkZXBsb3ltZW50VXJsIjoiaHR0cDovL2xvY2FsaG9zdDo4MDkwL2Zsb3dhYmxlLXdvcmsvcHJvY2Vzcy1hcGkvcmVwb3NpdG9yeS9kZXBsb3ltZW50cy9QUkMtNDIxYTZhODMtMDc2My0xMWYxLTkxN2ItMmVkZmVlNDM5ZGUxIiwiZGVzY3JpcHRpb24iOm51bGwsImRpYWdyYW1SZXNvdXJjZSI6bnVsbCwiZ3JhcGhpY2FsTm90YXRpb25EZWZpbmVkIjp0cnVlLCJpZCI6IlBSQy1leHRlcm5hbFdvcmtlclByb2Nlc3M6Mzo0MjFiNTRlNS0wNzYzLTExZjEtOTE3Yi0yZWRmZWU0MzlkZTEiLCJrZXkiOiJleHRlcm5hbFdvcmtlclByb2Nlc3MiLCJuYW1lIjoiRXh0ZXJuYWwgV29ya2VyIFByb2Nlc3MiLCJyZXNvdXJjZSI6Imh0dHA6Ly9sb2NhbGhvc3Q6ODA5MC9mbG93YWJsZS13b3JrL3Byb2Nlc3MtYXBpL3JlcG9zaXRvcnkvZGVwbG95bWVudHMvUFJDLTQyMWE2YTgzLTA3NjMtMTFmMS05MTdiLTJlZGZlZTQzOWRlMS9yZXNvdXJjZXMvZXh0ZXJuYWxXb3JrZXJQcm9jZXNzLmJwbW4iLCJzdGFydEZvcm1EZWZpbmVkIjpmYWxzZSwic3VzcGVuZGVkIjpmYWxzZSwidGVuYW50SWQiOiIiLCJ1cmwiOiJodHRwOi8vbG9jYWxob3N0OjgwOTAvZmxvd2FibGUtd29yay9wcm9jZXNzLWFwaS9yZXBvc2l0b3J5L3Byb2Nlc3MtZGVmaW5pdGlvbnMvUFJDLWV4dGVybmFsV29ya2VyUHJvY2VzczozOjQyMWI1NGU1LTA3NjMtMTFmMS05MTdiLTJlZGZlZTQzOWRlMSIsInZlcnNpb24iOjN9XSwib3JkZXIiOiJhc2MiLCJzaXplIjoxLCJzb3J0IjoibmFtZSIsInN0YXJ0IjowLCJ0b3RhbCI6MX0=", + "responseContentType": "application/json", + "responseHeaders": { + "X-Content-Type-Options": [ + "nosniff" + ], + "X-XSS-Protection": [ + "0" + ], + "Cache-Control": [ + "no-store, must-revalidate, no-cache, max-age=0" + ], + "Pragma": [ + "no-cache" + ], + "X-Frame-Options": [ + "SAMEORIGIN" + ], + "Vary": [ + "accept-encoding" + ], + "Transfer-Encoding": [ + "chunked" + ], + "Date": [ + "Wed, 11 Feb 2026 16:03:51 GMT" + ] + } + }, + { + "method": "POST", + "uri": "http://localhost:8090/flowable-work/process-api/runtime/process-instances", + "statusCode": 201, + "responseBody": "eyJhY3Rpdml0eUlkIjpudWxsLCJidXNpbmVzc0tleSI6bnVsbCwiYnVzaW5lc3NTdGF0dXMiOm51bGwsImNhbGxiYWNrSWQiOm51bGwsImNhbGxiYWNrVHlwZSI6bnVsbCwiY29tcGxldGVkIjpmYWxzZSwiZW5kZWQiOmZhbHNlLCJpZCI6IlBSQy00MjMyZDQ4Ny0wNzYzLTExZjEtOTE3Yi0yZWRmZWU0MzlkZTEiLCJuYW1lIjpudWxsLCJwcm9jZXNzRGVmaW5pdGlvbkRlc2NyaXB0aW9uIjpudWxsLCJwcm9jZXNzRGVmaW5pdGlvbklkIjoiUFJDLWV4dGVybmFsV29ya2VyUHJvY2VzczozOjQyMWI1NGU1LTA3NjMtMTFmMS05MTdiLTJlZGZlZTQzOWRlMSIsInByb2Nlc3NEZWZpbml0aW9uTmFtZSI6IkV4dGVybmFsIFdvcmtlciBQcm9jZXNzIiwicHJvY2Vzc0RlZmluaXRpb25VcmwiOiJodHRwOi8vbG9jYWxob3N0OjgwOTAvZmxvd2FibGUtd29yay9wcm9jZXNzLWFwaS9yZXBvc2l0b3J5L3Byb2Nlc3MtZGVmaW5pdGlvbnMvUFJDLWV4dGVybmFsV29ya2VyUHJvY2VzczozOjQyMWI1NGU1LTA3NjMtMTFmMS05MTdiLTJlZGZlZTQzOWRlMSIsInByb3BhZ2F0ZWRTdGFnZUluc3RhbmNlSWQiOm51bGwsInJlZmVyZW5jZUlkIjpudWxsLCJyZWZlcmVuY2VUeXBlIjpudWxsLCJzdGFydFRpbWUiOiIyMDI2LTAyLTExVDE2OjAzOjUxLjg5OFoiLCJzdGFydFVzZXJJZCI6ImFkbWluIiwic3VwZXJQcm9jZXNzSW5zdGFuY2VJZCI6bnVsbCwic3VzcGVuZGVkIjpmYWxzZSwidGVuYW50SWQiOiIiLCJ1cmwiOiJodHRwOi8vbG9jYWxob3N0OjgwOTAvZmxvd2FibGUtd29yay9wcm9jZXNzLWFwaS9ydW50aW1lL3Byb2Nlc3MtaW5zdGFuY2VzL1BSQy00MjMyZDQ4Ny0wNzYzLTExZjEtOTE3Yi0yZWRmZWU0MzlkZTEiLCJ2YXJpYWJsZXMiOlt7Im5hbWUiOiJpbml0aWF0b3IiLCJzY29wZSI6ImxvY2FsIiwidHlwZSI6InN0cmluZyIsInZhbHVlIjoiYWRtaW4ifV19", + "responseContentType": "application/json", + "responseHeaders": { + "X-Content-Type-Options": [ + "nosniff" + ], + "X-XSS-Protection": [ + "0" + ], + "Cache-Control": [ + "no-store, must-revalidate, no-cache, max-age=0" + ], + "Pragma": [ + "no-cache" + ], + "X-Frame-Options": [ + "SAMEORIGIN" + ], + "Vary": [ + "accept-encoding" + ], + "Transfer-Encoding": [ + "chunked" + ], + "Date": [ + "Wed, 11 Feb 2026 16:03:51 GMT" + ] + } + }, + { + "method": "POST", + "uri": "http://localhost:8090/flowable-work/external-job-api/acquire/jobs", + "statusCode": 200, + "responseBody": "W3siY29ycmVsYXRpb25JZCI6IjQyMzM3MGQwLTA3NjMtMTFmMS05MTdiLTJlZGZlZTQzOWRlMSIsImNyZWF0ZVRpbWUiOiIyMDI2LTAyLTExVDE2OjAzOjUxLjkwMloiLCJkdWVEYXRlIjpudWxsLCJlbGVtZW50SWQiOiJicG1uVGFza18zIiwiZWxlbWVudE5hbWUiOiJFeHRlcm5hbCBXb3JrZXIgdGFzayIsImV4Y2VwdGlvbk1lc3NhZ2UiOm51bGwsImV4ZWN1dGlvbklkIjoiUFJDLTQyMzJmYjlhLTA3NjMtMTFmMS05MTdiLTJlZGZlZTQzOWRlMSIsImlkIjoiSk9CLTQyMzM3MGQxLTA3NjMtMTFmMS05MTdiLTJlZGZlZTQzOWRlMSIsImxvY2tFeHBpcmF0aW9uVGltZSI6IjIwMjYtMDItMTFUMTY6MDQ6MDEuOTgzWiIsImxvY2tPd25lciI6InRlc3Qtd29ya2VyIiwicHJvY2Vzc0RlZmluaXRpb25JZCI6IlBSQy1leHRlcm5hbFdvcmtlclByb2Nlc3M6Mzo0MjFiNTRlNS0wNzYzLTExZjEtOTE3Yi0yZWRmZWU0MzlkZTEiLCJwcm9jZXNzSW5zdGFuY2VJZCI6IlBSQy00MjMyZDQ4Ny0wNzYzLTExZjEtOTE3Yi0yZWRmZWU0MzlkZTEiLCJyZXRyaWVzIjozLCJzY29wZURlZmluaXRpb25JZCI6bnVsbCwic2NvcGVJZCI6bnVsbCwic2NvcGVUeXBlIjpudWxsLCJzdWJTY29wZUlkIjpudWxsLCJ0ZW5hbnRJZCI6IiIsInVybCI6Imh0dHA6Ly9sb2NhbGhvc3Q6ODA5MC9mbG93YWJsZS13b3JrL2V4dGVybmFsLWpvYi1hcGkvam9icy9KT0ItNDIzMzcwZDEtMDc2My0xMWYxLTkxN2ItMmVkZmVlNDM5ZGUxIiwidmFyaWFibGVzIjpbeyJuYW1lIjoiaW5pdGlhdG9yIiwidHlwZSI6InN0cmluZyIsInZhbHVlIjoiYWRtaW4ifV19XQ==", + "responseContentType": "application/json", + "responseHeaders": { + "X-Content-Type-Options": [ + "nosniff" + ], + "X-XSS-Protection": [ + "0" + ], + "Cache-Control": [ + "no-store, must-revalidate, no-cache, max-age=0" + ], + "Pragma": [ + "no-cache" + ], + "X-Frame-Options": [ + "SAMEORIGIN" + ], + "Vary": [ + "accept-encoding" + ], + "Transfer-Encoding": [ + "chunked" + ], + "Date": [ + "Wed, 11 Feb 2026 16:03:51 GMT" + ] + } + }, + { + "method": "POST", + "uri": "http://localhost:8090/flowable-work/external-job-api/acquire/jobs/JOB-423370d1-0763-11f1-917b-2edfee439de1/complete", + "statusCode": 204, + "responseBody": "", + "responseContentType": null, + "responseHeaders": { + "X-Content-Type-Options": [ + "nosniff" + ], + "X-XSS-Protection": [ + "0" + ], + "Cache-Control": [ + "no-store, must-revalidate, no-cache, max-age=0" + ], + "Pragma": [ + "no-cache" + ], + "X-Frame-Options": [ + "SAMEORIGIN" + ], + "Date": [ + "Wed, 11 Feb 2026 16:03:52 GMT" + ] + } + }, + { + "method": "GET", + "uri": "http://localhost:8090/flowable-work/process-api/history/historic-variable-instances?processInstanceId=PRC-4232d487-0763-11f1-917b-2edfee439de1\u0026variableName=testVar", + "statusCode": 200, + "responseBody": "eyJkYXRhIjpbeyJleGVjdXRpb25JZCI6IlBSQy00MjMyZDQ4Ny0wNzYzLTExZjEtOTE3Yi0yZWRmZWU0MzlkZTEiLCJpZCI6IlZBUi00MjRkZmRiNS0wNzYzLTExZjEtOTE3Yi0yZWRmZWU0MzlkZTEiLCJwcm9jZXNzSW5zdGFuY2VJZCI6IlBSQy00MjMyZDQ4Ny0wNzYzLTExZjEtOTE3Yi0yZWRmZWU0MzlkZTEiLCJwcm9jZXNzSW5zdGFuY2VVcmwiOiJodHRwOi8vbG9jYWxob3N0OjgwOTAvZmxvd2FibGUtd29yay9wcm9jZXNzLWFwaS9oaXN0b3J5L2hpc3RvcmljLXByb2Nlc3MtaW5zdGFuY2VzL1BSQy00MjMyZDQ4Ny0wNzYzLTExZjEtOTE3Yi0yZWRmZWU0MzlkZTEiLCJ0YXNrSWQiOm51bGwsInZhcmlhYmxlIjp7Im5hbWUiOiJ0ZXN0VmFyIiwic2NvcGUiOiJnbG9iYWwiLCJ0eXBlIjoic3RyaW5nIiwidmFsdWUiOiJ0ZXN0IGNvbnRlbnQifX1dLCJvcmRlciI6ImFzYyIsInNpemUiOjEsInNvcnQiOiJ2YXJpYWJsZU5hbWUiLCJzdGFydCI6MCwidG90YWwiOjF9", + "responseContentType": "application/json", + "responseHeaders": { + "X-Content-Type-Options": [ + "nosniff" + ], + "X-XSS-Protection": [ + "0" + ], + "Cache-Control": [ + "no-store, must-revalidate, no-cache, max-age=0" + ], + "Pragma": [ + "no-cache" + ], + "X-Frame-Options": [ + "SAMEORIGIN" + ], + "Vary": [ + "accept-encoding" + ], + "Transfer-Encoding": [ + "chunked" + ], + "Date": [ + "Wed, 11 Feb 2026 16:03:52 GMT" + ] + } + }, + { + "method": "GET", + "uri": "http://localhost:8090/flowable-work/process-api/history/historic-activity-instances?processInstanceId=PRC-4232d487-0763-11f1-917b-2edfee439de1", + "statusCode": 200, + "responseBody": "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", + "responseContentType": "application/json", + "responseHeaders": { + "X-Content-Type-Options": [ + "nosniff" + ], + "X-XSS-Protection": [ + "0" + ], + "Cache-Control": [ + "no-store, must-revalidate, no-cache, max-age=0" + ], + "Pragma": [ + "no-cache" + ], + "X-Frame-Options": [ + "SAMEORIGIN" + ], + "Vary": [ + "accept-encoding" + ], + "Transfer-Encoding": [ + "chunked" + ], + "Date": [ + "Wed, 11 Feb 2026 16:03:52 GMT" + ] + } + }, + { + "method": "DELETE", + "uri": "http://localhost:8090/flowable-work/process-api/repository/deployments/PRC-421a6a83-0763-11f1-917b-2edfee439de1", + "statusCode": 204, + "responseBody": "", + "responseContentType": null, + "responseHeaders": { + "X-Content-Type-Options": [ + "nosniff" + ], + "X-XSS-Protection": [ + "0" + ], + "Cache-Control": [ + "no-store, must-revalidate, no-cache, max-age=0" + ], + "Pragma": [ + "no-cache" + ], + "X-Frame-Options": [ + "SAMEORIGIN" + ], + "Date": [ + "Wed, 11 Feb 2026 16:03:52 GMT" + ] + } + } +] \ No newline at end of file diff --git a/FlowableExternalWorkerClient.Tests/Fixtures/Cassettes/TestConsume.json b/FlowableExternalWorkerClient.Tests/Fixtures/Cassettes/TestConsume.json new file mode 100644 index 0000000..06fdffb --- /dev/null +++ b/FlowableExternalWorkerClient.Tests/Fixtures/Cassettes/TestConsume.json @@ -0,0 +1,257 @@ +[ + { + "method": "POST", + "uri": "http://localhost:8090/flowable-work/process-api/repository/deployments", + "statusCode": 201, + "responseBody": "eyJ1cmwiOiJodHRwOi8vbG9jYWxob3N0OjgwOTAvZmxvd2FibGUtd29yay9wcm9jZXNzLWFwaS9yZXBvc2l0b3J5L2RlcGxveW1lbnRzL1BSQy00NDY4MmE2Yy0wNzYzLTExZjEtOTE3Yi0yZWRmZWU0MzlkZTEiLCJjYXRlZ29yeSI6bnVsbCwiZGVwbG95bWVudFRpbWUiOiIyMDI2LTAyLTExVDE2OjAzOjU1LjYwM1oiLCJpZCI6IlBSQy00NDY4MmE2Yy0wNzYzLTExZjEtOTE3Yi0yZWRmZWU0MzlkZTEiLCJuYW1lIjoiZXh0ZXJuYWxXb3JrZXJQcm9jZXNzIiwicGFyZW50RGVwbG95bWVudElkIjoiUFJDLTQ0NjgyYTZjLTA3NjMtMTFmMS05MTdiLTJlZGZlZTQzOWRlMSIsInRlbmFudElkIjoiIn0=", + "responseContentType": "application/json", + "responseHeaders": { + "Set-Cookie": [ + "XSRF-TOKEN=3ed0b9ee-b7d6-448f-8f55-d13cf5d3913e; Path=/flowable-work" + ], + "X-Content-Type-Options": [ + "nosniff" + ], + "X-XSS-Protection": [ + "0" + ], + "Cache-Control": [ + "no-store, must-revalidate, no-cache, max-age=0" + ], + "Pragma": [ + "no-cache" + ], + "X-Frame-Options": [ + "SAMEORIGIN" + ], + "Vary": [ + "accept-encoding" + ], + "Transfer-Encoding": [ + "chunked" + ], + "Date": [ + "Wed, 11 Feb 2026 16:03:55 GMT" + ] + } + }, + { + "method": "GET", + "uri": "http://localhost:8090/flowable-work/process-api/repository/process-definitions?deploymentId=PRC-44682a6c-0763-11f1-917b-2edfee439de1", + "statusCode": 200, + "responseBody": "eyJkYXRhIjpbeyJjYXRlZ29yeSI6Imh0dHA6Ly9mbG93YWJsZS5vcmcvdGVzdCIsImRlcGxveW1lbnRJZCI6IlBSQy00NDY4MmE2Yy0wNzYzLTExZjEtOTE3Yi0yZWRmZWU0MzlkZTEiLCJkZXBsb3ltZW50VXJsIjoiaHR0cDovL2xvY2FsaG9zdDo4MDkwL2Zsb3dhYmxlLXdvcmsvcHJvY2Vzcy1hcGkvcmVwb3NpdG9yeS9kZXBsb3ltZW50cy9QUkMtNDQ2ODJhNmMtMDc2My0xMWYxLTkxN2ItMmVkZmVlNDM5ZGUxIiwiZGVzY3JpcHRpb24iOm51bGwsImRpYWdyYW1SZXNvdXJjZSI6bnVsbCwiZ3JhcGhpY2FsTm90YXRpb25EZWZpbmVkIjp0cnVlLCJpZCI6IlBSQy1leHRlcm5hbFdvcmtlclByb2Nlc3M6Mzo0NDY5NjJlZS0wNzYzLTExZjEtOTE3Yi0yZWRmZWU0MzlkZTEiLCJrZXkiOiJleHRlcm5hbFdvcmtlclByb2Nlc3MiLCJuYW1lIjoiRXh0ZXJuYWwgV29ya2VyIFByb2Nlc3MiLCJyZXNvdXJjZSI6Imh0dHA6Ly9sb2NhbGhvc3Q6ODA5MC9mbG93YWJsZS13b3JrL3Byb2Nlc3MtYXBpL3JlcG9zaXRvcnkvZGVwbG95bWVudHMvUFJDLTQ0NjgyYTZjLTA3NjMtMTFmMS05MTdiLTJlZGZlZTQzOWRlMS9yZXNvdXJjZXMvZXh0ZXJuYWxXb3JrZXJQcm9jZXNzLmJwbW4iLCJzdGFydEZvcm1EZWZpbmVkIjpmYWxzZSwic3VzcGVuZGVkIjpmYWxzZSwidGVuYW50SWQiOiIiLCJ1cmwiOiJodHRwOi8vbG9jYWxob3N0OjgwOTAvZmxvd2FibGUtd29yay9wcm9jZXNzLWFwaS9yZXBvc2l0b3J5L3Byb2Nlc3MtZGVmaW5pdGlvbnMvUFJDLWV4dGVybmFsV29ya2VyUHJvY2VzczozOjQ0Njk2MmVlLTA3NjMtMTFmMS05MTdiLTJlZGZlZTQzOWRlMSIsInZlcnNpb24iOjN9XSwib3JkZXIiOiJhc2MiLCJzaXplIjoxLCJzb3J0IjoibmFtZSIsInN0YXJ0IjowLCJ0b3RhbCI6MX0=", + "responseContentType": "application/json", + "responseHeaders": { + "X-Content-Type-Options": [ + "nosniff" + ], + "X-XSS-Protection": [ + "0" + ], + "Cache-Control": [ + "no-store, must-revalidate, no-cache, max-age=0" + ], + "Pragma": [ + "no-cache" + ], + "X-Frame-Options": [ + "SAMEORIGIN" + ], + "Vary": [ + "accept-encoding" + ], + "Transfer-Encoding": [ + "chunked" + ], + "Date": [ + "Wed, 11 Feb 2026 16:03:55 GMT" + ] + } + }, + { + "method": "POST", + "uri": "http://localhost:8090/flowable-work/process-api/runtime/process-instances", + "statusCode": 201, + "responseBody": "eyJhY3Rpdml0eUlkIjpudWxsLCJidXNpbmVzc0tleSI6bnVsbCwiYnVzaW5lc3NTdGF0dXMiOm51bGwsImNhbGxiYWNrSWQiOm51bGwsImNhbGxiYWNrVHlwZSI6bnVsbCwiY29tcGxldGVkIjpmYWxzZSwiZW5kZWQiOmZhbHNlLCJpZCI6IlBSQy00NDgxN2VkMC0wNzYzLTExZjEtOTE3Yi0yZWRmZWU0MzlkZTEiLCJuYW1lIjpudWxsLCJwcm9jZXNzRGVmaW5pdGlvbkRlc2NyaXB0aW9uIjpudWxsLCJwcm9jZXNzRGVmaW5pdGlvbklkIjoiUFJDLWV4dGVybmFsV29ya2VyUHJvY2VzczozOjQ0Njk2MmVlLTA3NjMtMTFmMS05MTdiLTJlZGZlZTQzOWRlMSIsInByb2Nlc3NEZWZpbml0aW9uTmFtZSI6IkV4dGVybmFsIFdvcmtlciBQcm9jZXNzIiwicHJvY2Vzc0RlZmluaXRpb25VcmwiOiJodHRwOi8vbG9jYWxob3N0OjgwOTAvZmxvd2FibGUtd29yay9wcm9jZXNzLWFwaS9yZXBvc2l0b3J5L3Byb2Nlc3MtZGVmaW5pdGlvbnMvUFJDLWV4dGVybmFsV29ya2VyUHJvY2VzczozOjQ0Njk2MmVlLTA3NjMtMTFmMS05MTdiLTJlZGZlZTQzOWRlMSIsInByb3BhZ2F0ZWRTdGFnZUluc3RhbmNlSWQiOm51bGwsInJlZmVyZW5jZUlkIjpudWxsLCJyZWZlcmVuY2VUeXBlIjpudWxsLCJzdGFydFRpbWUiOiIyMDI2LTAyLTExVDE2OjAzOjU1Ljc2OVoiLCJzdGFydFVzZXJJZCI6ImFkbWluIiwic3VwZXJQcm9jZXNzSW5zdGFuY2VJZCI6bnVsbCwic3VzcGVuZGVkIjpmYWxzZSwidGVuYW50SWQiOiIiLCJ1cmwiOiJodHRwOi8vbG9jYWxob3N0OjgwOTAvZmxvd2FibGUtd29yay9wcm9jZXNzLWFwaS9ydW50aW1lL3Byb2Nlc3MtaW5zdGFuY2VzL1BSQy00NDgxN2VkMC0wNzYzLTExZjEtOTE3Yi0yZWRmZWU0MzlkZTEiLCJ2YXJpYWJsZXMiOlt7Im5hbWUiOiJpbml0aWF0b3IiLCJzY29wZSI6ImxvY2FsIiwidHlwZSI6InN0cmluZyIsInZhbHVlIjoiYWRtaW4ifV19", + "responseContentType": "application/json", + "responseHeaders": { + "X-Content-Type-Options": [ + "nosniff" + ], + "X-XSS-Protection": [ + "0" + ], + "Cache-Control": [ + "no-store, must-revalidate, no-cache, max-age=0" + ], + "Pragma": [ + "no-cache" + ], + "X-Frame-Options": [ + "SAMEORIGIN" + ], + "Vary": [ + "accept-encoding" + ], + "Transfer-Encoding": [ + "chunked" + ], + "Date": [ + "Wed, 11 Feb 2026 16:03:55 GMT" + ] + } + }, + { + "method": "POST", + "uri": "http://localhost:8090/flowable-work/external-job-api/acquire/jobs", + "statusCode": 200, + "responseBody": "W3siY29ycmVsYXRpb25JZCI6IjQ0ODIxYjE5LTA3NjMtMTFmMS05MTdiLTJlZGZlZTQzOWRlMSIsImNyZWF0ZVRpbWUiOiIyMDI2LTAyLTExVDE2OjAzOjU1Ljc3M1oiLCJkdWVEYXRlIjpudWxsLCJlbGVtZW50SWQiOiJicG1uVGFza18zIiwiZWxlbWVudE5hbWUiOiJFeHRlcm5hbCBXb3JrZXIgdGFzayIsImV4Y2VwdGlvbk1lc3NhZ2UiOm51bGwsImV4ZWN1dGlvbklkIjoiUFJDLTQ0ODFhNWUzLTA3NjMtMTFmMS05MTdiLTJlZGZlZTQzOWRlMSIsImlkIjoiSk9CLTQ0ODIxYjFhLTA3NjMtMTFmMS05MTdiLTJlZGZlZTQzOWRlMSIsImxvY2tFeHBpcmF0aW9uVGltZSI6IjIwMjYtMDItMTFUMTY6MDQ6NTUuODUzWiIsImxvY2tPd25lciI6InRlc3Qtd29ya2VyIiwicHJvY2Vzc0RlZmluaXRpb25JZCI6IlBSQy1leHRlcm5hbFdvcmtlclByb2Nlc3M6Mzo0NDY5NjJlZS0wNzYzLTExZjEtOTE3Yi0yZWRmZWU0MzlkZTEiLCJwcm9jZXNzSW5zdGFuY2VJZCI6IlBSQy00NDgxN2VkMC0wNzYzLTExZjEtOTE3Yi0yZWRmZWU0MzlkZTEiLCJyZXRyaWVzIjozLCJzY29wZURlZmluaXRpb25JZCI6bnVsbCwic2NvcGVJZCI6bnVsbCwic2NvcGVUeXBlIjpudWxsLCJzdWJTY29wZUlkIjpudWxsLCJ0ZW5hbnRJZCI6IiIsInVybCI6Imh0dHA6Ly9sb2NhbGhvc3Q6ODA5MC9mbG93YWJsZS13b3JrL2V4dGVybmFsLWpvYi1hcGkvam9icy9KT0ItNDQ4MjFiMWEtMDc2My0xMWYxLTkxN2ItMmVkZmVlNDM5ZGUxIiwidmFyaWFibGVzIjpbeyJuYW1lIjoiaW5pdGlhdG9yIiwidHlwZSI6InN0cmluZyIsInZhbHVlIjoiYWRtaW4ifV19XQ==", + "responseContentType": "application/json", + "responseHeaders": { + "X-Content-Type-Options": [ + "nosniff" + ], + "X-XSS-Protection": [ + "0" + ], + "Cache-Control": [ + "no-store, must-revalidate, no-cache, max-age=0" + ], + "Pragma": [ + "no-cache" + ], + "X-Frame-Options": [ + "SAMEORIGIN" + ], + "Vary": [ + "accept-encoding" + ], + "Transfer-Encoding": [ + "chunked" + ], + "Date": [ + "Wed, 11 Feb 2026 16:03:55 GMT" + ] + } + }, + { + "method": "POST", + "uri": "http://localhost:8090/flowable-work/external-job-api/acquire/jobs/JOB-44821b1a-0763-11f1-917b-2edfee439de1/complete", + "statusCode": 204, + "responseBody": "", + "responseContentType": null, + "responseHeaders": { + "X-Content-Type-Options": [ + "nosniff" + ], + "X-XSS-Protection": [ + "0" + ], + "Cache-Control": [ + "no-store, must-revalidate, no-cache, max-age=0" + ], + "Pragma": [ + "no-cache" + ], + "X-Frame-Options": [ + "SAMEORIGIN" + ], + "Date": [ + "Wed, 11 Feb 2026 16:03:55 GMT" + ] + } + }, + { + "method": "POST", + "uri": "http://localhost:8090/flowable-work/external-job-api/acquire/jobs", + "statusCode": 200, + "responseBody": "W10=", + "responseContentType": "application/json", + "responseHeaders": { + "X-Content-Type-Options": [ + "nosniff" + ], + "X-XSS-Protection": [ + "0" + ], + "Cache-Control": [ + "no-store, must-revalidate, no-cache, max-age=0" + ], + "Pragma": [ + "no-cache" + ], + "X-Frame-Options": [ + "SAMEORIGIN" + ], + "Vary": [ + "accept-encoding" + ], + "Transfer-Encoding": [ + "chunked" + ], + "Date": [ + "Wed, 11 Feb 2026 16:03:56 GMT" + ] + } + }, + { + "method": "GET", + "uri": "http://localhost:8090/flowable-work/process-api/history/historic-activity-instances?processInstanceId=PRC-44817ed0-0763-11f1-917b-2edfee439de1", + "statusCode": 200, + "responseBody": "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", + "responseContentType": "application/json", + "responseHeaders": { + "X-Content-Type-Options": [ + "nosniff" + ], + "X-XSS-Protection": [ + "0" + ], + "Cache-Control": [ + "no-store, must-revalidate, no-cache, max-age=0" + ], + "Pragma": [ + "no-cache" + ], + "X-Frame-Options": [ + "SAMEORIGIN" + ], + "Vary": [ + "accept-encoding" + ], + "Transfer-Encoding": [ + "chunked" + ], + "Date": [ + "Wed, 11 Feb 2026 16:03:56 GMT" + ] + } + }, + { + "method": "DELETE", + "uri": "http://localhost:8090/flowable-work/process-api/repository/deployments/PRC-44682a6c-0763-11f1-917b-2edfee439de1", + "statusCode": 204, + "responseBody": "", + "responseContentType": null, + "responseHeaders": { + "X-Content-Type-Options": [ + "nosniff" + ], + "X-XSS-Protection": [ + "0" + ], + "Cache-Control": [ + "no-store, must-revalidate, no-cache, max-age=0" + ], + "Pragma": [ + "no-cache" + ], + "X-Frame-Options": [ + "SAMEORIGIN" + ], + "Date": [ + "Wed, 11 Feb 2026 16:03:56 GMT" + ] + } + } +] \ No newline at end of file diff --git a/FlowableExternalWorkerClient.Tests/Fixtures/Cassettes/TestConsumeWithCmmnTerminate.json b/FlowableExternalWorkerClient.Tests/Fixtures/Cassettes/TestConsumeWithCmmnTerminate.json new file mode 100644 index 0000000..eec50fa --- /dev/null +++ b/FlowableExternalWorkerClient.Tests/Fixtures/Cassettes/TestConsumeWithCmmnTerminate.json @@ -0,0 +1,257 @@ +[ + { + "method": "POST", + "uri": "http://localhost:8090/flowable-work/cmmn-api/cmmn-repository/deployments", + "statusCode": 201, + "responseBody": "eyJ1cmwiOiJodHRwOi8vbG9jYWxob3N0OjgwOTAvZmxvd2FibGUtd29yay9jbW1uLWFwaS9jbW1uLXJlcG9zaXRvcnkvZGVwbG95bWVudHMvQ0FTLTQ0Yzk4NDYxLTA3NjMtMTFmMS05MTdiLTJlZGZlZTQzOWRlMSIsImNhdGVnb3J5IjpudWxsLCJkZXBsb3ltZW50VGltZSI6IjIwMjYtMDItMTFUMTY6MDM6NTYuMjQxWiIsImlkIjoiQ0FTLTQ0Yzk4NDYxLTA3NjMtMTFmMS05MTdiLTJlZGZlZTQzOWRlMSIsIm5hbWUiOiJleHRlcm5hbFdvcmtlckNhc2UiLCJwYXJlbnREZXBsb3ltZW50SWQiOiJDQVMtNDRjOTg0NjEtMDc2My0xMWYxLTkxN2ItMmVkZmVlNDM5ZGUxIiwidGVuYW50SWQiOiIifQ==", + "responseContentType": "application/json", + "responseHeaders": { + "Set-Cookie": [ + "XSRF-TOKEN=e26e75d5-0f8c-4c05-b815-8b6cdc4286bd; Path=/flowable-work" + ], + "X-Content-Type-Options": [ + "nosniff" + ], + "X-XSS-Protection": [ + "0" + ], + "Cache-Control": [ + "no-store, must-revalidate, no-cache, max-age=0" + ], + "Pragma": [ + "no-cache" + ], + "X-Frame-Options": [ + "SAMEORIGIN" + ], + "Vary": [ + "accept-encoding" + ], + "Transfer-Encoding": [ + "chunked" + ], + "Date": [ + "Wed, 11 Feb 2026 16:03:56 GMT" + ] + } + }, + { + "method": "GET", + "uri": "http://localhost:8090/flowable-work/cmmn-api/cmmn-repository/case-definitions?deploymentId=CAS-44c98461-0763-11f1-917b-2edfee439de1", + "statusCode": 200, + "responseBody": "eyJkYXRhIjpbeyJjYXRlZ29yeSI6Imh0dHA6Ly9mbG93YWJsZS5vcmcvY21tbiIsImRlcGxveW1lbnRJZCI6IkNBUy00NGM5ODQ2MS0wNzYzLTExZjEtOTE3Yi0yZWRmZWU0MzlkZTEiLCJkZXBsb3ltZW50VXJsIjoiaHR0cDovL2xvY2FsaG9zdDo4MDkwL2Zsb3dhYmxlLXdvcmsvY21tbi1hcGkvY21tbi1yZXBvc2l0b3J5L2RlcGxveW1lbnRzL0NBUy00NGM5ODQ2MS0wNzYzLTExZjEtOTE3Yi0yZWRmZWU0MzlkZTEiLCJkZXNjcmlwdGlvbiI6bnVsbCwiZGlhZ3JhbVJlc291cmNlIjpudWxsLCJncmFwaGljYWxOb3RhdGlvbkRlZmluZWQiOnRydWUsImlkIjoiQ0FTLTQ0Y2E0N2IzLTA3NjMtMTFmMS05MTdiLTJlZGZlZTQzOWRlMSIsImtleSI6ImV4dGVybmFsV29ya2VyQ2FzZSIsIm5hbWUiOiJFeHRlcm5hbCBXb3JrZXIgQ2FzZSIsInJlc291cmNlIjoiaHR0cDovL2xvY2FsaG9zdDo4MDkwL2Zsb3dhYmxlLXdvcmsvY21tbi1hcGkvY21tbi1yZXBvc2l0b3J5L2RlcGxveW1lbnRzL0NBUy00NGM5ODQ2MS0wNzYzLTExZjEtOTE3Yi0yZWRmZWU0MzlkZTEvcmVzb3VyY2VzL2V4dGVybmFsV29ya2VyQ2FzZS5jbW1uIiwic3RhcnRGb3JtRGVmaW5lZCI6ZmFsc2UsInRlbmFudElkIjoiIiwidXJsIjoiaHR0cDovL2xvY2FsaG9zdDo4MDkwL2Zsb3dhYmxlLXdvcmsvY21tbi1hcGkvY21tbi1yZXBvc2l0b3J5L2Nhc2UtZGVmaW5pdGlvbnMvQ0FTLTQ0Y2E0N2IzLTA3NjMtMTFmMS05MTdiLTJlZGZlZTQzOWRlMSIsInZlcnNpb24iOjF9XSwib3JkZXIiOiJhc2MiLCJzaXplIjoxLCJzb3J0IjoibmFtZSIsInN0YXJ0IjowLCJ0b3RhbCI6MX0=", + "responseContentType": "application/json", + "responseHeaders": { + "X-Content-Type-Options": [ + "nosniff" + ], + "X-XSS-Protection": [ + "0" + ], + "Cache-Control": [ + "no-store, must-revalidate, no-cache, max-age=0" + ], + "Pragma": [ + "no-cache" + ], + "X-Frame-Options": [ + "SAMEORIGIN" + ], + "Vary": [ + "accept-encoding" + ], + "Transfer-Encoding": [ + "chunked" + ], + "Date": [ + "Wed, 11 Feb 2026 16:03:56 GMT" + ] + } + }, + { + "method": "POST", + "uri": "http://localhost:8090/flowable-work/cmmn-api/cmmn-runtime/case-instances", + "statusCode": 201, + "responseBody": "eyJidXNpbmVzc0tleSI6bnVsbCwiYnVzaW5lc3NTdGF0dXMiOm51bGwsImNhbGxiYWNrSWQiOm51bGwsImNhbGxiYWNrVHlwZSI6bnVsbCwiY2FzZURlZmluaXRpb25EZXNjcmlwdGlvbiI6bnVsbCwiY2FzZURlZmluaXRpb25JZCI6IkNBUy00NGNhNDdiMy0wNzYzLTExZjEtOTE3Yi0yZWRmZWU0MzlkZTEiLCJjYXNlRGVmaW5pdGlvbk5hbWUiOiJFeHRlcm5hbCBXb3JrZXIgQ2FzZSIsImNhc2VEZWZpbml0aW9uVXJsIjoiaHR0cDovL2xvY2FsaG9zdDo4MDkwL2Zsb3dhYmxlLXdvcmsvY21tbi1hcGkvY21tbi1yZXBvc2l0b3J5L2Nhc2UtZGVmaW5pdGlvbnMvQ0FTLTQ0Y2E0N2IzLTA3NjMtMTFmMS05MTdiLTJlZGZlZTQzOWRlMSIsImNvbXBsZXRlZCI6ZmFsc2UsImVuZGVkIjpmYWxzZSwiaWQiOiJDQVMtNDRlNWJlZjUtMDc2My0xMWYxLTkxN2ItMmVkZmVlNDM5ZGUxIiwibmFtZSI6bnVsbCwicGFyZW50SWQiOm51bGwsInJlZmVyZW5jZUlkIjpudWxsLCJyZWZlcmVuY2VUeXBlIjpudWxsLCJzdGFydFRpbWUiOiIyMDI2LTAyLTExVDE2OjAzOjU2LjQyNloiLCJzdGFydFVzZXJJZCI6ImFkbWluIiwic3RhdGUiOiJhY3RpdmUiLCJ0ZW5hbnRJZCI6IiIsInVybCI6Imh0dHA6Ly9sb2NhbGhvc3Q6ODA5MC9mbG93YWJsZS13b3JrL2NtbW4tYXBpL2NtbW4tcnVudGltZS9jYXNlLWluc3RhbmNlcy9DQVMtNDRlNWJlZjUtMDc2My0xMWYxLTkxN2ItMmVkZmVlNDM5ZGUxIiwidmFyaWFibGVzIjpbeyJuYW1lIjoiaW5pdGlhdG9yIiwic2NvcGUiOiJsb2NhbCIsInR5cGUiOiJzdHJpbmciLCJ2YWx1ZSI6ImFkbWluIn1dfQ==", + "responseContentType": "application/json", + "responseHeaders": { + "X-Content-Type-Options": [ + "nosniff" + ], + "X-XSS-Protection": [ + "0" + ], + "Cache-Control": [ + "no-store, must-revalidate, no-cache, max-age=0" + ], + "Pragma": [ + "no-cache" + ], + "X-Frame-Options": [ + "SAMEORIGIN" + ], + "Vary": [ + "accept-encoding" + ], + "Transfer-Encoding": [ + "chunked" + ], + "Date": [ + "Wed, 11 Feb 2026 16:03:56 GMT" + ] + } + }, + { + "method": "POST", + "uri": "http://localhost:8090/flowable-work/external-job-api/acquire/jobs", + "statusCode": 200, + "responseBody": "W3siY29ycmVsYXRpb25JZCI6IjQ0ZTY1YjNiLTA3NjMtMTFmMS05MTdiLTJlZGZlZTQzOWRlMSIsImNyZWF0ZVRpbWUiOiIyMDI2LTAyLTExVDE2OjAzOjU2LjQzMFoiLCJkdWVEYXRlIjpudWxsLCJlbGVtZW50SWQiOiJjbW1uVGFza18xIiwiZWxlbWVudE5hbWUiOiJFeHRlcm5hbCBXb3JrZXIgdGFzayIsImV4Y2VwdGlvbk1lc3NhZ2UiOm51bGwsImV4ZWN1dGlvbklkIjpudWxsLCJpZCI6IkpPQi00NGU2NWIzYy0wNzYzLTExZjEtOTE3Yi0yZWRmZWU0MzlkZTEiLCJsb2NrRXhwaXJhdGlvblRpbWUiOiIyMDI2LTAyLTExVDE2OjA0OjU2LjUxN1oiLCJsb2NrT3duZXIiOiJ0ZXN0LXdvcmtlciIsInByb2Nlc3NEZWZpbml0aW9uSWQiOm51bGwsInByb2Nlc3NJbnN0YW5jZUlkIjpudWxsLCJyZXRyaWVzIjozLCJzY29wZURlZmluaXRpb25JZCI6IkNBUy00NGNhNDdiMy0wNzYzLTExZjEtOTE3Yi0yZWRmZWU0MzlkZTEiLCJzY29wZUlkIjoiQ0FTLTQ0ZTViZWY1LTA3NjMtMTFmMS05MTdiLTJlZGZlZTQzOWRlMSIsInNjb3BlVHlwZSI6ImNtbW4iLCJzdWJTY29wZUlkIjoiQ0FTLTQ0ZTYzNDJhLTA3NjMtMTFmMS05MTdiLTJlZGZlZTQzOWRlMSIsInRlbmFudElkIjoiIiwidXJsIjoiaHR0cDovL2xvY2FsaG9zdDo4MDkwL2Zsb3dhYmxlLXdvcmsvZXh0ZXJuYWwtam9iLWFwaS9qb2JzL0pPQi00NGU2NWIzYy0wNzYzLTExZjEtOTE3Yi0yZWRmZWU0MzlkZTEiLCJ2YXJpYWJsZXMiOlt7Im5hbWUiOiJpbml0aWF0b3IiLCJ0eXBlIjoic3RyaW5nIiwidmFsdWUiOiJhZG1pbiJ9XX1d", + "responseContentType": "application/json", + "responseHeaders": { + "X-Content-Type-Options": [ + "nosniff" + ], + "X-XSS-Protection": [ + "0" + ], + "Cache-Control": [ + "no-store, must-revalidate, no-cache, max-age=0" + ], + "Pragma": [ + "no-cache" + ], + "X-Frame-Options": [ + "SAMEORIGIN" + ], + "Vary": [ + "accept-encoding" + ], + "Transfer-Encoding": [ + "chunked" + ], + "Date": [ + "Wed, 11 Feb 2026 16:03:56 GMT" + ] + } + }, + { + "method": "POST", + "uri": "http://localhost:8090/flowable-work/external-job-api/acquire/jobs/JOB-44e65b3c-0763-11f1-917b-2edfee439de1/cmmnTerminate", + "statusCode": 204, + "responseBody": "", + "responseContentType": null, + "responseHeaders": { + "X-Content-Type-Options": [ + "nosniff" + ], + "X-XSS-Protection": [ + "0" + ], + "Cache-Control": [ + "no-store, must-revalidate, no-cache, max-age=0" + ], + "Pragma": [ + "no-cache" + ], + "X-Frame-Options": [ + "SAMEORIGIN" + ], + "Date": [ + "Wed, 11 Feb 2026 16:03:56 GMT" + ] + } + }, + { + "method": "POST", + "uri": "http://localhost:8090/flowable-work/external-job-api/acquire/jobs", + "statusCode": 200, + "responseBody": "W10=", + "responseContentType": "application/json", + "responseHeaders": { + "X-Content-Type-Options": [ + "nosniff" + ], + "X-XSS-Protection": [ + "0" + ], + "Cache-Control": [ + "no-store, must-revalidate, no-cache, max-age=0" + ], + "Pragma": [ + "no-cache" + ], + "X-Frame-Options": [ + "SAMEORIGIN" + ], + "Vary": [ + "accept-encoding" + ], + "Transfer-Encoding": [ + "chunked" + ], + "Date": [ + "Wed, 11 Feb 2026 16:03:56 GMT" + ] + } + }, + { + "method": "GET", + "uri": "http://localhost:8090/flowable-work/cmmn-api/cmmn-history/historic-variable-instances?caseInstanceId=CAS-44e5bef5-0763-11f1-917b-2edfee439de1\u0026variableName=testVar", + "statusCode": 200, + "responseBody": "eyJkYXRhIjpbeyJjYXNlSW5zdGFuY2VJZCI6IkNBUy00NGU1YmVmNS0wNzYzLTExZjEtOTE3Yi0yZWRmZWU0MzlkZTEiLCJjYXNlSW5zdGFuY2VVcmwiOiJodHRwOi8vbG9jYWxob3N0OjgwOTAvZmxvd2FibGUtd29yay9jbW1uLWFwaS9jbW1uLWhpc3RvcnkvaGlzdG9yaWMtY2FzZS1pbnN0YW5jZXMvQ0FTLTQ0ZTViZWY1LTA3NjMtMTFmMS05MTdiLTJlZGZlZTQzOWRlMSIsImlkIjoiVkFSLTQ1MDFkMjgwLTA3NjMtMTFmMS05MTdiLTJlZGZlZTQzOWRlMSIsInBsYW5JdGVtSW5zdGFuY2VJZCI6bnVsbCwidGFza0lkIjpudWxsLCJ2YXJpYWJsZSI6eyJuYW1lIjoidGVzdFZhciIsInNjb3BlIjoiZ2xvYmFsIiwidHlwZSI6InN0cmluZyIsInZhbHVlIjoidGVzdCB0ZXJtaW5hdGUifX1dLCJvcmRlciI6ImFzYyIsInNpemUiOjEsInNvcnQiOiJ2YXJpYWJsZU5hbWUiLCJzdGFydCI6MCwidG90YWwiOjF9", + "responseContentType": "application/json", + "responseHeaders": { + "X-Content-Type-Options": [ + "nosniff" + ], + "X-XSS-Protection": [ + "0" + ], + "Cache-Control": [ + "no-store, must-revalidate, no-cache, max-age=0" + ], + "Pragma": [ + "no-cache" + ], + "X-Frame-Options": [ + "SAMEORIGIN" + ], + "Vary": [ + "accept-encoding" + ], + "Transfer-Encoding": [ + "chunked" + ], + "Date": [ + "Wed, 11 Feb 2026 16:03:57 GMT" + ] + } + }, + { + "method": "DELETE", + "uri": "http://localhost:8090/flowable-work/cmmn-api/cmmn-repository/deployments/CAS-44c98461-0763-11f1-917b-2edfee439de1", + "statusCode": 204, + "responseBody": "", + "responseContentType": null, + "responseHeaders": { + "X-Content-Type-Options": [ + "nosniff" + ], + "X-XSS-Protection": [ + "0" + ], + "Cache-Control": [ + "no-store, must-revalidate, no-cache, max-age=0" + ], + "Pragma": [ + "no-cache" + ], + "X-Frame-Options": [ + "SAMEORIGIN" + ], + "Date": [ + "Wed, 11 Feb 2026 16:03:57 GMT" + ] + } + } +] \ No newline at end of file diff --git a/FlowableExternalWorkerClient.Tests/Fixtures/Cassettes/TestConsumeWithFailure.json b/FlowableExternalWorkerClient.Tests/Fixtures/Cassettes/TestConsumeWithFailure.json new file mode 100644 index 0000000..5939596 --- /dev/null +++ b/FlowableExternalWorkerClient.Tests/Fixtures/Cassettes/TestConsumeWithFailure.json @@ -0,0 +1,284 @@ +[ + { + "method": "POST", + "uri": "http://localhost:8090/flowable-work/process-api/repository/deployments", + "statusCode": 201, + "responseBody": "eyJ1cmwiOiJodHRwOi8vbG9jYWxob3N0OjgwOTAvZmxvd2FibGUtd29yay9wcm9jZXNzLWFwaS9yZXBvc2l0b3J5L2RlcGxveW1lbnRzL1BSQy00MmVmOTNmZC0wNzYzLTExZjEtOTE3Yi0yZWRmZWU0MzlkZTEiLCJjYXRlZ29yeSI6bnVsbCwiZGVwbG95bWVudFRpbWUiOiIyMDI2LTAyLTExVDE2OjAzOjUzLjEzNVoiLCJpZCI6IlBSQy00MmVmOTNmZC0wNzYzLTExZjEtOTE3Yi0yZWRmZWU0MzlkZTEiLCJuYW1lIjoiZXh0ZXJuYWxXb3JrZXJQcm9jZXNzIiwicGFyZW50RGVwbG95bWVudElkIjoiUFJDLTQyZWY5M2ZkLTA3NjMtMTFmMS05MTdiLTJlZGZlZTQzOWRlMSIsInRlbmFudElkIjoiIn0=", + "responseContentType": "application/json", + "responseHeaders": { + "Set-Cookie": [ + "XSRF-TOKEN=ce0133bb-fa50-4b29-99aa-cac5ceb67d8d; Path=/flowable-work" + ], + "X-Content-Type-Options": [ + "nosniff" + ], + "X-XSS-Protection": [ + "0" + ], + "Cache-Control": [ + "no-store, must-revalidate, no-cache, max-age=0" + ], + "Pragma": [ + "no-cache" + ], + "X-Frame-Options": [ + "SAMEORIGIN" + ], + "Vary": [ + "accept-encoding" + ], + "Transfer-Encoding": [ + "chunked" + ], + "Date": [ + "Wed, 11 Feb 2026 16:03:53 GMT" + ] + } + }, + { + "method": "GET", + "uri": "http://localhost:8090/flowable-work/process-api/repository/process-definitions?deploymentId=PRC-42ef93fd-0763-11f1-917b-2edfee439de1", + "statusCode": 200, + "responseBody": "eyJkYXRhIjpbeyJjYXRlZ29yeSI6Imh0dHA6Ly9mbG93YWJsZS5vcmcvdGVzdCIsImRlcGxveW1lbnRJZCI6IlBSQy00MmVmOTNmZC0wNzYzLTExZjEtOTE3Yi0yZWRmZWU0MzlkZTEiLCJkZXBsb3ltZW50VXJsIjoiaHR0cDovL2xvY2FsaG9zdDo4MDkwL2Zsb3dhYmxlLXdvcmsvcHJvY2Vzcy1hcGkvcmVwb3NpdG9yeS9kZXBsb3ltZW50cy9QUkMtNDJlZjkzZmQtMDc2My0xMWYxLTkxN2ItMmVkZmVlNDM5ZGUxIiwiZGVzY3JpcHRpb24iOm51bGwsImRpYWdyYW1SZXNvdXJjZSI6bnVsbCwiZ3JhcGhpY2FsTm90YXRpb25EZWZpbmVkIjp0cnVlLCJpZCI6IlBSQy1leHRlcm5hbFdvcmtlclByb2Nlc3M6Mzo0MmYwYTU2Zi0wNzYzLTExZjEtOTE3Yi0yZWRmZWU0MzlkZTEiLCJrZXkiOiJleHRlcm5hbFdvcmtlclByb2Nlc3MiLCJuYW1lIjoiRXh0ZXJuYWwgV29ya2VyIFByb2Nlc3MiLCJyZXNvdXJjZSI6Imh0dHA6Ly9sb2NhbGhvc3Q6ODA5MC9mbG93YWJsZS13b3JrL3Byb2Nlc3MtYXBpL3JlcG9zaXRvcnkvZGVwbG95bWVudHMvUFJDLTQyZWY5M2ZkLTA3NjMtMTFmMS05MTdiLTJlZGZlZTQzOWRlMS9yZXNvdXJjZXMvZXh0ZXJuYWxXb3JrZXJQcm9jZXNzLmJwbW4iLCJzdGFydEZvcm1EZWZpbmVkIjpmYWxzZSwic3VzcGVuZGVkIjpmYWxzZSwidGVuYW50SWQiOiIiLCJ1cmwiOiJodHRwOi8vbG9jYWxob3N0OjgwOTAvZmxvd2FibGUtd29yay9wcm9jZXNzLWFwaS9yZXBvc2l0b3J5L3Byb2Nlc3MtZGVmaW5pdGlvbnMvUFJDLWV4dGVybmFsV29ya2VyUHJvY2VzczozOjQyZjBhNTZmLTA3NjMtMTFmMS05MTdiLTJlZGZlZTQzOWRlMSIsInZlcnNpb24iOjN9XSwib3JkZXIiOiJhc2MiLCJzaXplIjoxLCJzb3J0IjoibmFtZSIsInN0YXJ0IjowLCJ0b3RhbCI6MX0=", + "responseContentType": "application/json", + "responseHeaders": { + "X-Content-Type-Options": [ + "nosniff" + ], + "X-XSS-Protection": [ + "0" + ], + "Cache-Control": [ + "no-store, must-revalidate, no-cache, max-age=0" + ], + "Pragma": [ + "no-cache" + ], + "X-Frame-Options": [ + "SAMEORIGIN" + ], + "Vary": [ + "accept-encoding" + ], + "Transfer-Encoding": [ + "chunked" + ], + "Date": [ + "Wed, 11 Feb 2026 16:03:53 GMT" + ] + } + }, + { + "method": "POST", + "uri": "http://localhost:8090/flowable-work/process-api/runtime/process-instances", + "statusCode": 201, + "responseBody": "eyJhY3Rpdml0eUlkIjpudWxsLCJidXNpbmVzc0tleSI6bnVsbCwiYnVzaW5lc3NTdGF0dXMiOm51bGwsImNhbGxiYWNrSWQiOm51bGwsImNhbGxiYWNrVHlwZSI6bnVsbCwiY29tcGxldGVkIjpmYWxzZSwiZW5kZWQiOmZhbHNlLCJpZCI6IlBSQy00MzA5ODRhMS0wNzYzLTExZjEtOTE3Yi0yZWRmZWU0MzlkZTEiLCJuYW1lIjpudWxsLCJwcm9jZXNzRGVmaW5pdGlvbkRlc2NyaXB0aW9uIjpudWxsLCJwcm9jZXNzRGVmaW5pdGlvbklkIjoiUFJDLWV4dGVybmFsV29ya2VyUHJvY2VzczozOjQyZjBhNTZmLTA3NjMtMTFmMS05MTdiLTJlZGZlZTQzOWRlMSIsInByb2Nlc3NEZWZpbml0aW9uTmFtZSI6IkV4dGVybmFsIFdvcmtlciBQcm9jZXNzIiwicHJvY2Vzc0RlZmluaXRpb25VcmwiOiJodHRwOi8vbG9jYWxob3N0OjgwOTAvZmxvd2FibGUtd29yay9wcm9jZXNzLWFwaS9yZXBvc2l0b3J5L3Byb2Nlc3MtZGVmaW5pdGlvbnMvUFJDLWV4dGVybmFsV29ya2VyUHJvY2VzczozOjQyZjBhNTZmLTA3NjMtMTFmMS05MTdiLTJlZGZlZTQzOWRlMSIsInByb3BhZ2F0ZWRTdGFnZUluc3RhbmNlSWQiOm51bGwsInJlZmVyZW5jZUlkIjpudWxsLCJyZWZlcmVuY2VUeXBlIjpudWxsLCJzdGFydFRpbWUiOiIyMDI2LTAyLTExVDE2OjAzOjUzLjMwNVoiLCJzdGFydFVzZXJJZCI6ImFkbWluIiwic3VwZXJQcm9jZXNzSW5zdGFuY2VJZCI6bnVsbCwic3VzcGVuZGVkIjpmYWxzZSwidGVuYW50SWQiOiIiLCJ1cmwiOiJodHRwOi8vbG9jYWxob3N0OjgwOTAvZmxvd2FibGUtd29yay9wcm9jZXNzLWFwaS9ydW50aW1lL3Byb2Nlc3MtaW5zdGFuY2VzL1BSQy00MzA5ODRhMS0wNzYzLTExZjEtOTE3Yi0yZWRmZWU0MzlkZTEiLCJ2YXJpYWJsZXMiOlt7Im5hbWUiOiJpbml0aWF0b3IiLCJzY29wZSI6ImxvY2FsIiwidHlwZSI6InN0cmluZyIsInZhbHVlIjoiYWRtaW4ifV19", + "responseContentType": "application/json", + "responseHeaders": { + "X-Content-Type-Options": [ + "nosniff" + ], + "X-XSS-Protection": [ + "0" + ], + "Cache-Control": [ + "no-store, must-revalidate, no-cache, max-age=0" + ], + "Pragma": [ + "no-cache" + ], + "X-Frame-Options": [ + "SAMEORIGIN" + ], + "Vary": [ + "accept-encoding" + ], + "Transfer-Encoding": [ + "chunked" + ], + "Date": [ + "Wed, 11 Feb 2026 16:03:53 GMT" + ] + } + }, + { + "method": "POST", + "uri": "http://localhost:8090/flowable-work/external-job-api/acquire/jobs", + "statusCode": 200, + "responseBody": "W3siY29ycmVsYXRpb25JZCI6IjQzMGEyMGVhLTA3NjMtMTFmMS05MTdiLTJlZGZlZTQzOWRlMSIsImNyZWF0ZVRpbWUiOiIyMDI2LTAyLTExVDE2OjAzOjUzLjMwOVoiLCJkdWVEYXRlIjpudWxsLCJlbGVtZW50SWQiOiJicG1uVGFza18zIiwiZWxlbWVudE5hbWUiOiJFeHRlcm5hbCBXb3JrZXIgdGFzayIsImV4Y2VwdGlvbk1lc3NhZ2UiOm51bGwsImV4ZWN1dGlvbklkIjoiUFJDLTQzMDk4NGE0LTA3NjMtMTFmMS05MTdiLTJlZGZlZTQzOWRlMSIsImlkIjoiSk9CLTQzMGEyMGViLTA3NjMtMTFmMS05MTdiLTJlZGZlZTQzOWRlMSIsImxvY2tFeHBpcmF0aW9uVGltZSI6IjIwMjYtMDItMTFUMTY6MDQ6NTMuMzk1WiIsImxvY2tPd25lciI6InRlc3Qtd29ya2VyIiwicHJvY2Vzc0RlZmluaXRpb25JZCI6IlBSQy1leHRlcm5hbFdvcmtlclByb2Nlc3M6Mzo0MmYwYTU2Zi0wNzYzLTExZjEtOTE3Yi0yZWRmZWU0MzlkZTEiLCJwcm9jZXNzSW5zdGFuY2VJZCI6IlBSQy00MzA5ODRhMS0wNzYzLTExZjEtOTE3Yi0yZWRmZWU0MzlkZTEiLCJyZXRyaWVzIjozLCJzY29wZURlZmluaXRpb25JZCI6bnVsbCwic2NvcGVJZCI6bnVsbCwic2NvcGVUeXBlIjpudWxsLCJzdWJTY29wZUlkIjpudWxsLCJ0ZW5hbnRJZCI6IiIsInVybCI6Imh0dHA6Ly9sb2NhbGhvc3Q6ODA5MC9mbG93YWJsZS13b3JrL2V4dGVybmFsLWpvYi1hcGkvam9icy9KT0ItNDMwYTIwZWItMDc2My0xMWYxLTkxN2ItMmVkZmVlNDM5ZGUxIiwidmFyaWFibGVzIjpbeyJuYW1lIjoiaW5pdGlhdG9yIiwidHlwZSI6InN0cmluZyIsInZhbHVlIjoiYWRtaW4ifV19XQ==", + "responseContentType": "application/json", + "responseHeaders": { + "X-Content-Type-Options": [ + "nosniff" + ], + "X-XSS-Protection": [ + "0" + ], + "Cache-Control": [ + "no-store, must-revalidate, no-cache, max-age=0" + ], + "Pragma": [ + "no-cache" + ], + "X-Frame-Options": [ + "SAMEORIGIN" + ], + "Vary": [ + "accept-encoding" + ], + "Transfer-Encoding": [ + "chunked" + ], + "Date": [ + "Wed, 11 Feb 2026 16:03:53 GMT" + ] + } + }, + { + "method": "POST", + "uri": "http://localhost:8090/flowable-work/external-job-api/acquire/jobs/JOB-430a20eb-0763-11f1-917b-2edfee439de1/fail", + "statusCode": 204, + "responseBody": "", + "responseContentType": null, + "responseHeaders": { + "X-Content-Type-Options": [ + "nosniff" + ], + "X-XSS-Protection": [ + "0" + ], + "Cache-Control": [ + "no-store, must-revalidate, no-cache, max-age=0" + ], + "Pragma": [ + "no-cache" + ], + "X-Frame-Options": [ + "SAMEORIGIN" + ], + "Date": [ + "Wed, 11 Feb 2026 16:03:53 GMT" + ] + } + }, + { + "method": "POST", + "uri": "http://localhost:8090/flowable-work/external-job-api/acquire/jobs", + "statusCode": 200, + "responseBody": "W10=", + "responseContentType": "application/json", + "responseHeaders": { + "X-Content-Type-Options": [ + "nosniff" + ], + "X-XSS-Protection": [ + "0" + ], + "Cache-Control": [ + "no-store, must-revalidate, no-cache, max-age=0" + ], + "Pragma": [ + "no-cache" + ], + "X-Frame-Options": [ + "SAMEORIGIN" + ], + "Vary": [ + "accept-encoding" + ], + "Transfer-Encoding": [ + "chunked" + ], + "Date": [ + "Wed, 11 Feb 2026 16:03:53 GMT" + ] + } + }, + { + "method": "GET", + "uri": "http://localhost:8090/flowable-work/process-api/history/historic-activity-instances?processInstanceId=PRC-430984a1-0763-11f1-917b-2edfee439de1", + "statusCode": 200, + "responseBody": "eyJkYXRhIjpbeyJhY3Rpdml0eUlkIjoic3RhcnRub25lZXZlbnQxIiwiYWN0aXZpdHlOYW1lIjpudWxsLCJhY3Rpdml0eVR5cGUiOiJzdGFydEV2ZW50IiwiYXNzaWduZWUiOm51bGwsImNhbGxlZFByb2Nlc3NJbnN0YW5jZUlkIjpudWxsLCJkdXJhdGlvbkluTWlsbGlzIjoyLCJlbmRUaW1lIjoiMjAyNi0wMi0xMVQxNjowMzo1My4zMDdaIiwiZXhlY3V0aW9uSWQiOiJQUkMtNDMwOTg0YTQtMDc2My0xMWYxLTkxN2ItMmVkZmVlNDM5ZGUxIiwiaWQiOiJQUkMtNDMwOTg0YTUtMDc2My0xMWYxLTkxN2ItMmVkZmVlNDM5ZGUxIiwicHJvY2Vzc0RlZmluaXRpb25JZCI6IlBSQy1leHRlcm5hbFdvcmtlclByb2Nlc3M6Mzo0MmYwYTU2Zi0wNzYzLTExZjEtOTE3Yi0yZWRmZWU0MzlkZTEiLCJwcm9jZXNzRGVmaW5pdGlvblVybCI6Imh0dHA6Ly9sb2NhbGhvc3Q6ODA5MC9mbG93YWJsZS13b3JrL3Byb2Nlc3MtYXBpL3JlcG9zaXRvcnkvcHJvY2Vzcy1kZWZpbml0aW9ucy9QUkMtZXh0ZXJuYWxXb3JrZXJQcm9jZXNzOjM6NDJmMGE1NmYtMDc2My0xMWYxLTkxN2ItMmVkZmVlNDM5ZGUxIiwicHJvY2Vzc0luc3RhbmNlSWQiOiJQUkMtNDMwOTg0YTEtMDc2My0xMWYxLTkxN2ItMmVkZmVlNDM5ZGUxIiwicHJvY2Vzc0luc3RhbmNlVXJsIjoiaHR0cDovL2xvY2FsaG9zdDo4MDkwL2Zsb3dhYmxlLXdvcmsvcHJvY2Vzcy1hcGkvaGlzdG9yeS9oaXN0b3JpYy1wcm9jZXNzLWluc3RhbmNlcy9QUkMtNDMwOTg0YTEtMDc2My0xMWYxLTkxN2ItMmVkZmVlNDM5ZGUxIiwic3RhcnRUaW1lIjoiMjAyNi0wMi0xMVQxNjowMzo1My4zMDVaIiwidGFza0lkIjpudWxsLCJ0ZW5hbnRJZCI6IiJ9LHsiYWN0aXZpdHlJZCI6ImJwbW5TZXF1ZW5jZUZsb3dfMiIsImFjdGl2aXR5TmFtZSI6bnVsbCwiYWN0aXZpdHlUeXBlIjoic2VxdWVuY2VGbG93IiwiYXNzaWduZWUiOm51bGwsImNhbGxlZFByb2Nlc3NJbnN0YW5jZUlkIjpudWxsLCJkdXJhdGlvbkluTWlsbGlzIjowLCJlbmRUaW1lIjoiMjAyNi0wMi0xMVQxNjowMzo1My4zMDhaIiwiZXhlY3V0aW9uSWQiOiJQUkMtNDMwOTg0YTQtMDc2My0xMWYxLTkxN2ItMmVkZmVlNDM5ZGUxIiwiaWQiOiJQUkMtNDMwOWY5ZDgtMDc2My0xMWYxLTkxN2ItMmVkZmVlNDM5ZGUxIiwicHJvY2Vzc0RlZmluaXRpb25JZCI6IlBSQy1leHRlcm5hbFdvcmtlclByb2Nlc3M6Mzo0MmYwYTU2Zi0wNzYzLTExZjEtOTE3Yi0yZWRmZWU0MzlkZTEiLCJwcm9jZXNzRGVmaW5pdGlvblVybCI6Imh0dHA6Ly9sb2NhbGhvc3Q6ODA5MC9mbG93YWJsZS13b3JrL3Byb2Nlc3MtYXBpL3JlcG9zaXRvcnkvcHJvY2Vzcy1kZWZpbml0aW9ucy9QUkMtZXh0ZXJuYWxXb3JrZXJQcm9jZXNzOjM6NDJmMGE1NmYtMDc2My0xMWYxLTkxN2ItMmVkZmVlNDM5ZGUxIiwicHJvY2Vzc0luc3RhbmNlSWQiOiJQUkMtNDMwOTg0YTEtMDc2My0xMWYxLTkxN2ItMmVkZmVlNDM5ZGUxIiwicHJvY2Vzc0luc3RhbmNlVXJsIjoiaHR0cDovL2xvY2FsaG9zdDo4MDkwL2Zsb3dhYmxlLXdvcmsvcHJvY2Vzcy1hcGkvaGlzdG9yeS9oaXN0b3JpYy1wcm9jZXNzLWluc3RhbmNlcy9QUkMtNDMwOTg0YTEtMDc2My0xMWYxLTkxN2ItMmVkZmVlNDM5ZGUxIiwic3RhcnRUaW1lIjoiMjAyNi0wMi0xMVQxNjowMzo1My4zMDhaIiwidGFza0lkIjpudWxsLCJ0ZW5hbnRJZCI6IiJ9LHsiYWN0aXZpdHlJZCI6ImJwbW5UYXNrXzMiLCJhY3Rpdml0eU5hbWUiOiJFeHRlcm5hbCBXb3JrZXIgdGFzayIsImFjdGl2aXR5VHlwZSI6ImV4dGVybmFsV29ya2VyU2VydmljZVRhc2siLCJhc3NpZ25lZSI6bnVsbCwiY2FsbGVkUHJvY2Vzc0luc3RhbmNlSWQiOm51bGwsImR1cmF0aW9uSW5NaWxsaXMiOm51bGwsImVuZFRpbWUiOm51bGwsImV4ZWN1dGlvbklkIjoiUFJDLTQzMDk4NGE0LTA3NjMtMTFmMS05MTdiLTJlZGZlZTQzOWRlMSIsImlkIjoiUFJDLTQzMGEyMGU5LTA3NjMtMTFmMS05MTdiLTJlZGZlZTQzOWRlMSIsInByb2Nlc3NEZWZpbml0aW9uSWQiOiJQUkMtZXh0ZXJuYWxXb3JrZXJQcm9jZXNzOjM6NDJmMGE1NmYtMDc2My0xMWYxLTkxN2ItMmVkZmVlNDM5ZGUxIiwicHJvY2Vzc0RlZmluaXRpb25VcmwiOiJodHRwOi8vbG9jYWxob3N0OjgwOTAvZmxvd2FibGUtd29yay9wcm9jZXNzLWFwaS9yZXBvc2l0b3J5L3Byb2Nlc3MtZGVmaW5pdGlvbnMvUFJDLWV4dGVybmFsV29ya2VyUHJvY2VzczozOjQyZjBhNTZmLTA3NjMtMTFmMS05MTdiLTJlZGZlZTQzOWRlMSIsInByb2Nlc3NJbnN0YW5jZUlkIjoiUFJDLTQzMDk4NGExLTA3NjMtMTFmMS05MTdiLTJlZGZlZTQzOWRlMSIsInByb2Nlc3NJbnN0YW5jZVVybCI6Imh0dHA6Ly9sb2NhbGhvc3Q6ODA5MC9mbG93YWJsZS13b3JrL3Byb2Nlc3MtYXBpL2hpc3RvcnkvaGlzdG9yaWMtcHJvY2Vzcy1pbnN0YW5jZXMvUFJDLTQzMDk4NGExLTA3NjMtMTFmMS05MTdiLTJlZGZlZTQzOWRlMSIsInN0YXJ0VGltZSI6IjIwMjYtMDItMTFUMTY6MDM6NTMuMzA5WiIsInRhc2tJZCI6bnVsbCwidGVuYW50SWQiOiIifV0sIm9yZGVyIjoiYXNjIiwic2l6ZSI6Mywic29ydCI6InN0YXJ0VGltZSIsInN0YXJ0IjowLCJ0b3RhbCI6M30=", + "responseContentType": "application/json", + "responseHeaders": { + "X-Content-Type-Options": [ + "nosniff" + ], + "X-XSS-Protection": [ + "0" + ], + "Cache-Control": [ + "no-store, must-revalidate, no-cache, max-age=0" + ], + "Pragma": [ + "no-cache" + ], + "X-Frame-Options": [ + "SAMEORIGIN" + ], + "Vary": [ + "accept-encoding" + ], + "Transfer-Encoding": [ + "chunked" + ], + "Date": [ + "Wed, 11 Feb 2026 16:03:54 GMT" + ] + } + }, + { + "method": "DELETE", + "uri": "http://localhost:8090/flowable-work/process-api/runtime/process-instances/PRC-430984a1-0763-11f1-917b-2edfee439de1", + "statusCode": 204, + "responseBody": "", + "responseContentType": null, + "responseHeaders": { + "X-Content-Type-Options": [ + "nosniff" + ], + "X-XSS-Protection": [ + "0" + ], + "Cache-Control": [ + "no-store, must-revalidate, no-cache, max-age=0" + ], + "Pragma": [ + "no-cache" + ], + "X-Frame-Options": [ + "SAMEORIGIN" + ], + "Date": [ + "Wed, 11 Feb 2026 16:03:54 GMT" + ] + } + }, + { + "method": "DELETE", + "uri": "http://localhost:8090/flowable-work/process-api/repository/deployments/PRC-42ef93fd-0763-11f1-917b-2edfee439de1", + "statusCode": 204, + "responseBody": "", + "responseContentType": null, + "responseHeaders": { + "X-Content-Type-Options": [ + "nosniff" + ], + "X-XSS-Protection": [ + "0" + ], + "Cache-Control": [ + "no-store, must-revalidate, no-cache, max-age=0" + ], + "Pragma": [ + "no-cache" + ], + "X-Frame-Options": [ + "SAMEORIGIN" + ], + "Date": [ + "Wed, 11 Feb 2026 16:03:54 GMT" + ] + } + } +] \ No newline at end of file diff --git a/FlowableExternalWorkerClient.Tests/Fixtures/Cassettes/TestFailJob.json b/FlowableExternalWorkerClient.Tests/Fixtures/Cassettes/TestFailJob.json new file mode 100644 index 0000000..7b55c37 --- /dev/null +++ b/FlowableExternalWorkerClient.Tests/Fixtures/Cassettes/TestFailJob.json @@ -0,0 +1,284 @@ +[ + { + "method": "POST", + "uri": "http://localhost:8090/flowable-work/process-api/repository/deployments", + "statusCode": 201, + "responseBody": "eyJ1cmwiOiJodHRwOi8vbG9jYWxob3N0OjgwOTAvZmxvd2FibGUtd29yay9wcm9jZXNzLWFwaS9yZXBvc2l0b3J5L2RlcGxveW1lbnRzL1BSQy0zZjE0Y2FmNC0wNzYzLTExZjEtOTE3Yi0yZWRmZWU0MzlkZTEiLCJjYXRlZ29yeSI6bnVsbCwiZGVwbG95bWVudFRpbWUiOiIyMDI2LTAyLTExVDE2OjAzOjQ2LjY2OFoiLCJpZCI6IlBSQy0zZjE0Y2FmNC0wNzYzLTExZjEtOTE3Yi0yZWRmZWU0MzlkZTEiLCJuYW1lIjoiZXh0ZXJuYWxXb3JrZXJQcm9jZXNzIiwicGFyZW50RGVwbG95bWVudElkIjoiUFJDLTNmMTRjYWY0LTA3NjMtMTFmMS05MTdiLTJlZGZlZTQzOWRlMSIsInRlbmFudElkIjoiIn0=", + "responseContentType": "application/json", + "responseHeaders": { + "Set-Cookie": [ + "XSRF-TOKEN=ee366dd9-1ae8-4865-8610-ae499ef73c1d; Path=/flowable-work" + ], + "X-Content-Type-Options": [ + "nosniff" + ], + "X-XSS-Protection": [ + "0" + ], + "Cache-Control": [ + "no-store, must-revalidate, no-cache, max-age=0" + ], + "Pragma": [ + "no-cache" + ], + "X-Frame-Options": [ + "SAMEORIGIN" + ], + "Vary": [ + "accept-encoding" + ], + "Transfer-Encoding": [ + "chunked" + ], + "Date": [ + "Wed, 11 Feb 2026 16:03:46 GMT" + ] + } + }, + { + "method": "GET", + "uri": "http://localhost:8090/flowable-work/process-api/repository/process-definitions?deploymentId=PRC-3f14caf4-0763-11f1-917b-2edfee439de1", + "statusCode": 200, + "responseBody": "eyJkYXRhIjpbeyJjYXRlZ29yeSI6Imh0dHA6Ly9mbG93YWJsZS5vcmcvdGVzdCIsImRlcGxveW1lbnRJZCI6IlBSQy0zZjE0Y2FmNC0wNzYzLTExZjEtOTE3Yi0yZWRmZWU0MzlkZTEiLCJkZXBsb3ltZW50VXJsIjoiaHR0cDovL2xvY2FsaG9zdDo4MDkwL2Zsb3dhYmxlLXdvcmsvcHJvY2Vzcy1hcGkvcmVwb3NpdG9yeS9kZXBsb3ltZW50cy9QUkMtM2YxNGNhZjQtMDc2My0xMWYxLTkxN2ItMmVkZmVlNDM5ZGUxIiwiZGVzY3JpcHRpb24iOm51bGwsImRpYWdyYW1SZXNvdXJjZSI6bnVsbCwiZ3JhcGhpY2FsTm90YXRpb25EZWZpbmVkIjp0cnVlLCJpZCI6IlBSQy1leHRlcm5hbFdvcmtlclByb2Nlc3M6MzozZjE2OWZiNi0wNzYzLTExZjEtOTE3Yi0yZWRmZWU0MzlkZTEiLCJrZXkiOiJleHRlcm5hbFdvcmtlclByb2Nlc3MiLCJuYW1lIjoiRXh0ZXJuYWwgV29ya2VyIFByb2Nlc3MiLCJyZXNvdXJjZSI6Imh0dHA6Ly9sb2NhbGhvc3Q6ODA5MC9mbG93YWJsZS13b3JrL3Byb2Nlc3MtYXBpL3JlcG9zaXRvcnkvZGVwbG95bWVudHMvUFJDLTNmMTRjYWY0LTA3NjMtMTFmMS05MTdiLTJlZGZlZTQzOWRlMS9yZXNvdXJjZXMvZXh0ZXJuYWxXb3JrZXJQcm9jZXNzLmJwbW4iLCJzdGFydEZvcm1EZWZpbmVkIjpmYWxzZSwic3VzcGVuZGVkIjpmYWxzZSwidGVuYW50SWQiOiIiLCJ1cmwiOiJodHRwOi8vbG9jYWxob3N0OjgwOTAvZmxvd2FibGUtd29yay9wcm9jZXNzLWFwaS9yZXBvc2l0b3J5L3Byb2Nlc3MtZGVmaW5pdGlvbnMvUFJDLWV4dGVybmFsV29ya2VyUHJvY2VzczozOjNmMTY5ZmI2LTA3NjMtMTFmMS05MTdiLTJlZGZlZTQzOWRlMSIsInZlcnNpb24iOjN9XSwib3JkZXIiOiJhc2MiLCJzaXplIjoxLCJzb3J0IjoibmFtZSIsInN0YXJ0IjowLCJ0b3RhbCI6MX0=", + "responseContentType": "application/json", + "responseHeaders": { + "X-Content-Type-Options": [ + "nosniff" + ], + "X-XSS-Protection": [ + "0" + ], + "Cache-Control": [ + "no-store, must-revalidate, no-cache, max-age=0" + ], + "Pragma": [ + "no-cache" + ], + "X-Frame-Options": [ + "SAMEORIGIN" + ], + "Vary": [ + "accept-encoding" + ], + "Transfer-Encoding": [ + "chunked" + ], + "Date": [ + "Wed, 11 Feb 2026 16:03:46 GMT" + ] + } + }, + { + "method": "POST", + "uri": "http://localhost:8090/flowable-work/process-api/runtime/process-instances", + "statusCode": 201, + "responseBody": "eyJhY3Rpdml0eUlkIjpudWxsLCJidXNpbmVzc0tleSI6bnVsbCwiYnVzaW5lc3NTdGF0dXMiOm51bGwsImNhbGxiYWNrSWQiOm51bGwsImNhbGxiYWNrVHlwZSI6bnVsbCwiY29tcGxldGVkIjpmYWxzZSwiZW5kZWQiOmZhbHNlLCJpZCI6IlBSQy0zZjMwNjk0OC0wNzYzLTExZjEtOTE3Yi0yZWRmZWU0MzlkZTEiLCJuYW1lIjpudWxsLCJwcm9jZXNzRGVmaW5pdGlvbkRlc2NyaXB0aW9uIjpudWxsLCJwcm9jZXNzRGVmaW5pdGlvbklkIjoiUFJDLWV4dGVybmFsV29ya2VyUHJvY2VzczozOjNmMTY5ZmI2LTA3NjMtMTFmMS05MTdiLTJlZGZlZTQzOWRlMSIsInByb2Nlc3NEZWZpbml0aW9uTmFtZSI6IkV4dGVybmFsIFdvcmtlciBQcm9jZXNzIiwicHJvY2Vzc0RlZmluaXRpb25VcmwiOiJodHRwOi8vbG9jYWxob3N0OjgwOTAvZmxvd2FibGUtd29yay9wcm9jZXNzLWFwaS9yZXBvc2l0b3J5L3Byb2Nlc3MtZGVmaW5pdGlvbnMvUFJDLWV4dGVybmFsV29ya2VyUHJvY2VzczozOjNmMTY5ZmI2LTA3NjMtMTFmMS05MTdiLTJlZGZlZTQzOWRlMSIsInByb3BhZ2F0ZWRTdGFnZUluc3RhbmNlSWQiOm51bGwsInJlZmVyZW5jZUlkIjpudWxsLCJyZWZlcmVuY2VUeXBlIjpudWxsLCJzdGFydFRpbWUiOiIyMDI2LTAyLTExVDE2OjAzOjQ2Ljg0OVoiLCJzdGFydFVzZXJJZCI6ImFkbWluIiwic3VwZXJQcm9jZXNzSW5zdGFuY2VJZCI6bnVsbCwic3VzcGVuZGVkIjpmYWxzZSwidGVuYW50SWQiOiIiLCJ1cmwiOiJodHRwOi8vbG9jYWxob3N0OjgwOTAvZmxvd2FibGUtd29yay9wcm9jZXNzLWFwaS9ydW50aW1lL3Byb2Nlc3MtaW5zdGFuY2VzL1BSQy0zZjMwNjk0OC0wNzYzLTExZjEtOTE3Yi0yZWRmZWU0MzlkZTEiLCJ2YXJpYWJsZXMiOlt7Im5hbWUiOiJpbml0aWF0b3IiLCJzY29wZSI6ImxvY2FsIiwidHlwZSI6InN0cmluZyIsInZhbHVlIjoiYWRtaW4ifV19", + "responseContentType": "application/json", + "responseHeaders": { + "X-Content-Type-Options": [ + "nosniff" + ], + "X-XSS-Protection": [ + "0" + ], + "Cache-Control": [ + "no-store, must-revalidate, no-cache, max-age=0" + ], + "Pragma": [ + "no-cache" + ], + "X-Frame-Options": [ + "SAMEORIGIN" + ], + "Vary": [ + "accept-encoding" + ], + "Transfer-Encoding": [ + "chunked" + ], + "Date": [ + "Wed, 11 Feb 2026 16:03:46 GMT" + ] + } + }, + { + "method": "POST", + "uri": "http://localhost:8090/flowable-work/external-job-api/acquire/jobs", + "statusCode": 200, + "responseBody": "W3siY29ycmVsYXRpb25JZCI6IjNmMzE3YWMxLTA3NjMtMTFmMS05MTdiLTJlZGZlZTQzOWRlMSIsImNyZWF0ZVRpbWUiOiIyMDI2LTAyLTExVDE2OjAzOjQ2Ljg1NloiLCJkdWVEYXRlIjpudWxsLCJlbGVtZW50SWQiOiJicG1uVGFza18zIiwiZWxlbWVudE5hbWUiOiJFeHRlcm5hbCBXb3JrZXIgdGFzayIsImV4Y2VwdGlvbk1lc3NhZ2UiOm51bGwsImV4ZWN1dGlvbklkIjoiUFJDLTNmMzA5MDViLTA3NjMtMTFmMS05MTdiLTJlZGZlZTQzOWRlMSIsImlkIjoiSk9CLTNmMzE3YWMyLTA3NjMtMTFmMS05MTdiLTJlZGZlZTQzOWRlMSIsImxvY2tFeHBpcmF0aW9uVGltZSI6IjIwMjYtMDItMTFUMTY6MDM6NTYuOTUwWiIsImxvY2tPd25lciI6InRlc3Qtd29ya2VyIiwicHJvY2Vzc0RlZmluaXRpb25JZCI6IlBSQy1leHRlcm5hbFdvcmtlclByb2Nlc3M6MzozZjE2OWZiNi0wNzYzLTExZjEtOTE3Yi0yZWRmZWU0MzlkZTEiLCJwcm9jZXNzSW5zdGFuY2VJZCI6IlBSQy0zZjMwNjk0OC0wNzYzLTExZjEtOTE3Yi0yZWRmZWU0MzlkZTEiLCJyZXRyaWVzIjozLCJzY29wZURlZmluaXRpb25JZCI6bnVsbCwic2NvcGVJZCI6bnVsbCwic2NvcGVUeXBlIjpudWxsLCJzdWJTY29wZUlkIjpudWxsLCJ0ZW5hbnRJZCI6IiIsInVybCI6Imh0dHA6Ly9sb2NhbGhvc3Q6ODA5MC9mbG93YWJsZS13b3JrL2V4dGVybmFsLWpvYi1hcGkvam9icy9KT0ItM2YzMTdhYzItMDc2My0xMWYxLTkxN2ItMmVkZmVlNDM5ZGUxIiwidmFyaWFibGVzIjpbeyJuYW1lIjoiaW5pdGlhdG9yIiwidHlwZSI6InN0cmluZyIsInZhbHVlIjoiYWRtaW4ifV19XQ==", + "responseContentType": "application/json", + "responseHeaders": { + "X-Content-Type-Options": [ + "nosniff" + ], + "X-XSS-Protection": [ + "0" + ], + "Cache-Control": [ + "no-store, must-revalidate, no-cache, max-age=0" + ], + "Pragma": [ + "no-cache" + ], + "X-Frame-Options": [ + "SAMEORIGIN" + ], + "Vary": [ + "accept-encoding" + ], + "Transfer-Encoding": [ + "chunked" + ], + "Date": [ + "Wed, 11 Feb 2026 16:03:46 GMT" + ] + } + }, + { + "method": "POST", + "uri": "http://localhost:8090/flowable-work/external-job-api/acquire/jobs/JOB-3f317ac2-0763-11f1-917b-2edfee439de1/fail", + "statusCode": 204, + "responseBody": "", + "responseContentType": null, + "responseHeaders": { + "X-Content-Type-Options": [ + "nosniff" + ], + "X-XSS-Protection": [ + "0" + ], + "Cache-Control": [ + "no-store, must-revalidate, no-cache, max-age=0" + ], + "Pragma": [ + "no-cache" + ], + "X-Frame-Options": [ + "SAMEORIGIN" + ], + "Date": [ + "Wed, 11 Feb 2026 16:03:47 GMT" + ] + } + }, + { + "method": "GET", + "uri": "http://localhost:8090/flowable-work/external-job-api/jobs/JOB-3f317ac2-0763-11f1-917b-2edfee439de1", + "statusCode": 200, + "responseBody": "eyJjb3JyZWxhdGlvbklkIjoiM2YzMTdhYzEtMDc2My0xMWYxLTkxN2ItMmVkZmVlNDM5ZGUxIiwiY3JlYXRlVGltZSI6IjIwMjYtMDItMTFUMTY6MDM6NDYuODU2WiIsImR1ZURhdGUiOm51bGwsImVsZW1lbnRJZCI6ImJwbW5UYXNrXzMiLCJlbGVtZW50TmFtZSI6IkV4dGVybmFsIFdvcmtlciB0YXNrIiwiZXhjZXB0aW9uTWVzc2FnZSI6bnVsbCwiZXhlY3V0aW9uSWQiOiJQUkMtM2YzMDkwNWItMDc2My0xMWYxLTkxN2ItMmVkZmVlNDM5ZGUxIiwiaWQiOiJKT0ItM2YzMTdhYzItMDc2My0xMWYxLTkxN2ItMmVkZmVlNDM5ZGUxIiwibG9ja0V4cGlyYXRpb25UaW1lIjpudWxsLCJsb2NrT3duZXIiOm51bGwsInByb2Nlc3NEZWZpbml0aW9uSWQiOiJQUkMtZXh0ZXJuYWxXb3JrZXJQcm9jZXNzOjM6M2YxNjlmYjYtMDc2My0xMWYxLTkxN2ItMmVkZmVlNDM5ZGUxIiwicHJvY2Vzc0luc3RhbmNlSWQiOiJQUkMtM2YzMDY5NDgtMDc2My0xMWYxLTkxN2ItMmVkZmVlNDM5ZGUxIiwicmV0cmllcyI6Miwic2NvcGVEZWZpbml0aW9uSWQiOm51bGwsInNjb3BlSWQiOm51bGwsInNjb3BlVHlwZSI6bnVsbCwic3ViU2NvcGVJZCI6bnVsbCwidGVuYW50SWQiOiIiLCJ1cmwiOiJodHRwOi8vbG9jYWxob3N0OjgwOTAvZmxvd2FibGUtd29yay9leHRlcm5hbC1qb2ItYXBpL2pvYnMvSk9CLTNmMzE3YWMyLTA3NjMtMTFmMS05MTdiLTJlZGZlZTQzOWRlMSJ9", + "responseContentType": "application/json", + "responseHeaders": { + "X-Content-Type-Options": [ + "nosniff" + ], + "X-XSS-Protection": [ + "0" + ], + "Cache-Control": [ + "no-store, must-revalidate, no-cache, max-age=0" + ], + "Pragma": [ + "no-cache" + ], + "X-Frame-Options": [ + "SAMEORIGIN" + ], + "Vary": [ + "accept-encoding" + ], + "Transfer-Encoding": [ + "chunked" + ], + "Date": [ + "Wed, 11 Feb 2026 16:03:47 GMT" + ] + } + }, + { + "method": "GET", + "uri": "http://localhost:8090/flowable-work/process-api/history/historic-activity-instances?processInstanceId=PRC-3f306948-0763-11f1-917b-2edfee439de1", + "statusCode": 200, + "responseBody": "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", + "responseContentType": "application/json", + "responseHeaders": { + "X-Content-Type-Options": [ + "nosniff" + ], + "X-XSS-Protection": [ + "0" + ], + "Cache-Control": [ + "no-store, must-revalidate, no-cache, max-age=0" + ], + "Pragma": [ + "no-cache" + ], + "X-Frame-Options": [ + "SAMEORIGIN" + ], + "Vary": [ + "accept-encoding" + ], + "Transfer-Encoding": [ + "chunked" + ], + "Date": [ + "Wed, 11 Feb 2026 16:03:47 GMT" + ] + } + }, + { + "method": "DELETE", + "uri": "http://localhost:8090/flowable-work/process-api/runtime/process-instances/PRC-3f306948-0763-11f1-917b-2edfee439de1", + "statusCode": 204, + "responseBody": "", + "responseContentType": null, + "responseHeaders": { + "X-Content-Type-Options": [ + "nosniff" + ], + "X-XSS-Protection": [ + "0" + ], + "Cache-Control": [ + "no-store, must-revalidate, no-cache, max-age=0" + ], + "Pragma": [ + "no-cache" + ], + "X-Frame-Options": [ + "SAMEORIGIN" + ], + "Date": [ + "Wed, 11 Feb 2026 16:03:47 GMT" + ] + } + }, + { + "method": "DELETE", + "uri": "http://localhost:8090/flowable-work/process-api/repository/deployments/PRC-3f14caf4-0763-11f1-917b-2edfee439de1", + "statusCode": 204, + "responseBody": "", + "responseContentType": null, + "responseHeaders": { + "X-Content-Type-Options": [ + "nosniff" + ], + "X-XSS-Protection": [ + "0" + ], + "Cache-Control": [ + "no-store, must-revalidate, no-cache, max-age=0" + ], + "Pragma": [ + "no-cache" + ], + "X-Frame-Options": [ + "SAMEORIGIN" + ], + "Date": [ + "Wed, 11 Feb 2026 16:03:47 GMT" + ] + } + } +] \ No newline at end of file diff --git a/FlowableExternalWorkerClient.Tests/Fixtures/Cassettes/TestGetJob.json b/FlowableExternalWorkerClient.Tests/Fixtures/Cassettes/TestGetJob.json new file mode 100644 index 0000000..77ea0a9 --- /dev/null +++ b/FlowableExternalWorkerClient.Tests/Fixtures/Cassettes/TestGetJob.json @@ -0,0 +1,224 @@ +[ + { + "method": "POST", + "uri": "http://localhost:8090/flowable-work/process-api/repository/deployments", + "statusCode": 201, + "responseBody": "eyJ1cmwiOiJodHRwOi8vbG9jYWxob3N0OjgwOTAvZmxvd2FibGUtd29yay9wcm9jZXNzLWFwaS9yZXBvc2l0b3J5L2RlcGxveW1lbnRzL1BSQy00MjdkOTkzYS0wNzYzLTExZjEtOTE3Yi0yZWRmZWU0MzlkZTEiLCJjYXRlZ29yeSI6bnVsbCwiZGVwbG95bWVudFRpbWUiOiIyMDI2LTAyLTExVDE2OjAzOjUyLjM4OFoiLCJpZCI6IlBSQy00MjdkOTkzYS0wNzYzLTExZjEtOTE3Yi0yZWRmZWU0MzlkZTEiLCJuYW1lIjoiZXh0ZXJuYWxXb3JrZXJQcm9jZXNzIiwicGFyZW50RGVwbG95bWVudElkIjoiUFJDLTQyN2Q5OTNhLTA3NjMtMTFmMS05MTdiLTJlZGZlZTQzOWRlMSIsInRlbmFudElkIjoiIn0=", + "responseContentType": "application/json", + "responseHeaders": { + "Set-Cookie": [ + "XSRF-TOKEN=a90586ad-8f36-4d72-8c6b-ffa700d41fa5; Path=/flowable-work" + ], + "X-Content-Type-Options": [ + "nosniff" + ], + "X-XSS-Protection": [ + "0" + ], + "Cache-Control": [ + "no-store, must-revalidate, no-cache, max-age=0" + ], + "Pragma": [ + "no-cache" + ], + "X-Frame-Options": [ + "SAMEORIGIN" + ], + "Vary": [ + "accept-encoding" + ], + "Transfer-Encoding": [ + "chunked" + ], + "Date": [ + "Wed, 11 Feb 2026 16:03:52 GMT" + ] + } + }, + { + "method": "GET", + "uri": "http://localhost:8090/flowable-work/process-api/repository/process-definitions?deploymentId=PRC-427d993a-0763-11f1-917b-2edfee439de1", + "statusCode": 200, + "responseBody": "eyJkYXRhIjpbeyJjYXRlZ29yeSI6Imh0dHA6Ly9mbG93YWJsZS5vcmcvdGVzdCIsImRlcGxveW1lbnRJZCI6IlBSQy00MjdkOTkzYS0wNzYzLTExZjEtOTE3Yi0yZWRmZWU0MzlkZTEiLCJkZXBsb3ltZW50VXJsIjoiaHR0cDovL2xvY2FsaG9zdDo4MDkwL2Zsb3dhYmxlLXdvcmsvcHJvY2Vzcy1hcGkvcmVwb3NpdG9yeS9kZXBsb3ltZW50cy9QUkMtNDI3ZDk5M2EtMDc2My0xMWYxLTkxN2ItMmVkZmVlNDM5ZGUxIiwiZGVzY3JpcHRpb24iOm51bGwsImRpYWdyYW1SZXNvdXJjZSI6bnVsbCwiZ3JhcGhpY2FsTm90YXRpb25EZWZpbmVkIjp0cnVlLCJpZCI6IlBSQy1leHRlcm5hbFdvcmtlclByb2Nlc3M6Mzo0MjdlZDFiYy0wNzYzLTExZjEtOTE3Yi0yZWRmZWU0MzlkZTEiLCJrZXkiOiJleHRlcm5hbFdvcmtlclByb2Nlc3MiLCJuYW1lIjoiRXh0ZXJuYWwgV29ya2VyIFByb2Nlc3MiLCJyZXNvdXJjZSI6Imh0dHA6Ly9sb2NhbGhvc3Q6ODA5MC9mbG93YWJsZS13b3JrL3Byb2Nlc3MtYXBpL3JlcG9zaXRvcnkvZGVwbG95bWVudHMvUFJDLTQyN2Q5OTNhLTA3NjMtMTFmMS05MTdiLTJlZGZlZTQzOWRlMS9yZXNvdXJjZXMvZXh0ZXJuYWxXb3JrZXJQcm9jZXNzLmJwbW4iLCJzdGFydEZvcm1EZWZpbmVkIjpmYWxzZSwic3VzcGVuZGVkIjpmYWxzZSwidGVuYW50SWQiOiIiLCJ1cmwiOiJodHRwOi8vbG9jYWxob3N0OjgwOTAvZmxvd2FibGUtd29yay9wcm9jZXNzLWFwaS9yZXBvc2l0b3J5L3Byb2Nlc3MtZGVmaW5pdGlvbnMvUFJDLWV4dGVybmFsV29ya2VyUHJvY2VzczozOjQyN2VkMWJjLTA3NjMtMTFmMS05MTdiLTJlZGZlZTQzOWRlMSIsInZlcnNpb24iOjN9XSwib3JkZXIiOiJhc2MiLCJzaXplIjoxLCJzb3J0IjoibmFtZSIsInN0YXJ0IjowLCJ0b3RhbCI6MX0=", + "responseContentType": "application/json", + "responseHeaders": { + "X-Content-Type-Options": [ + "nosniff" + ], + "X-XSS-Protection": [ + "0" + ], + "Cache-Control": [ + "no-store, must-revalidate, no-cache, max-age=0" + ], + "Pragma": [ + "no-cache" + ], + "X-Frame-Options": [ + "SAMEORIGIN" + ], + "Vary": [ + "accept-encoding" + ], + "Transfer-Encoding": [ + "chunked" + ], + "Date": [ + "Wed, 11 Feb 2026 16:03:52 GMT" + ] + } + }, + { + "method": "POST", + "uri": "http://localhost:8090/flowable-work/process-api/runtime/process-instances", + "statusCode": 201, + "responseBody": "eyJhY3Rpdml0eUlkIjpudWxsLCJidXNpbmVzc0tleSI6bnVsbCwiYnVzaW5lc3NTdGF0dXMiOm51bGwsImNhbGxiYWNrSWQiOm51bGwsImNhbGxiYWNrVHlwZSI6bnVsbCwiY29tcGxldGVkIjpmYWxzZSwiZW5kZWQiOmZhbHNlLCJpZCI6IlBSQy00Mjk3ZDdmZS0wNzYzLTExZjEtOTE3Yi0yZWRmZWU0MzlkZTEiLCJuYW1lIjpudWxsLCJwcm9jZXNzRGVmaW5pdGlvbkRlc2NyaXB0aW9uIjpudWxsLCJwcm9jZXNzRGVmaW5pdGlvbklkIjoiUFJDLWV4dGVybmFsV29ya2VyUHJvY2VzczozOjQyN2VkMWJjLTA3NjMtMTFmMS05MTdiLTJlZGZlZTQzOWRlMSIsInByb2Nlc3NEZWZpbml0aW9uTmFtZSI6IkV4dGVybmFsIFdvcmtlciBQcm9jZXNzIiwicHJvY2Vzc0RlZmluaXRpb25VcmwiOiJodHRwOi8vbG9jYWxob3N0OjgwOTAvZmxvd2FibGUtd29yay9wcm9jZXNzLWFwaS9yZXBvc2l0b3J5L3Byb2Nlc3MtZGVmaW5pdGlvbnMvUFJDLWV4dGVybmFsV29ya2VyUHJvY2VzczozOjQyN2VkMWJjLTA3NjMtMTFmMS05MTdiLTJlZGZlZTQzOWRlMSIsInByb3BhZ2F0ZWRTdGFnZUluc3RhbmNlSWQiOm51bGwsInJlZmVyZW5jZUlkIjpudWxsLCJyZWZlcmVuY2VUeXBlIjpudWxsLCJzdGFydFRpbWUiOiIyMDI2LTAyLTExVDE2OjAzOjUyLjU2MFoiLCJzdGFydFVzZXJJZCI6ImFkbWluIiwic3VwZXJQcm9jZXNzSW5zdGFuY2VJZCI6bnVsbCwic3VzcGVuZGVkIjpmYWxzZSwidGVuYW50SWQiOiIiLCJ1cmwiOiJodHRwOi8vbG9jYWxob3N0OjgwOTAvZmxvd2FibGUtd29yay9wcm9jZXNzLWFwaS9ydW50aW1lL3Byb2Nlc3MtaW5zdGFuY2VzL1BSQy00Mjk3ZDdmZS0wNzYzLTExZjEtOTE3Yi0yZWRmZWU0MzlkZTEiLCJ2YXJpYWJsZXMiOlt7Im5hbWUiOiJpbml0aWF0b3IiLCJzY29wZSI6ImxvY2FsIiwidHlwZSI6InN0cmluZyIsInZhbHVlIjoiYWRtaW4ifV19", + "responseContentType": "application/json", + "responseHeaders": { + "X-Content-Type-Options": [ + "nosniff" + ], + "X-XSS-Protection": [ + "0" + ], + "Cache-Control": [ + "no-store, must-revalidate, no-cache, max-age=0" + ], + "Pragma": [ + "no-cache" + ], + "X-Frame-Options": [ + "SAMEORIGIN" + ], + "Vary": [ + "accept-encoding" + ], + "Transfer-Encoding": [ + "chunked" + ], + "Date": [ + "Wed, 11 Feb 2026 16:03:52 GMT" + ] + } + }, + { + "method": "GET", + "uri": "http://localhost:8090/flowable-work/external-job-api/jobs", + "statusCode": 200, + "responseBody": "eyJkYXRhIjpbeyJjb3JyZWxhdGlvbklkIjoiNDI5ODlhNTctMDc2My0xMWYxLTkxN2ItMmVkZmVlNDM5ZGUxIiwiY3JlYXRlVGltZSI6IjIwMjYtMDItMTFUMTY6MDM6NTIuNTY1WiIsImR1ZURhdGUiOm51bGwsImVsZW1lbnRJZCI6ImJwbW5UYXNrXzMiLCJlbGVtZW50TmFtZSI6IkV4dGVybmFsIFdvcmtlciB0YXNrIiwiZXhjZXB0aW9uTWVzc2FnZSI6bnVsbCwiZXhlY3V0aW9uSWQiOiJQUkMtNDI5N2ZlMTEtMDc2My0xMWYxLTkxN2ItMmVkZmVlNDM5ZGUxIiwiaWQiOiJKT0ItNDI5ODlhNTgtMDc2My0xMWYxLTkxN2ItMmVkZmVlNDM5ZGUxIiwibG9ja0V4cGlyYXRpb25UaW1lIjpudWxsLCJsb2NrT3duZXIiOm51bGwsInByb2Nlc3NEZWZpbml0aW9uSWQiOiJQUkMtZXh0ZXJuYWxXb3JrZXJQcm9jZXNzOjM6NDI3ZWQxYmMtMDc2My0xMWYxLTkxN2ItMmVkZmVlNDM5ZGUxIiwicHJvY2Vzc0luc3RhbmNlSWQiOiJQUkMtNDI5N2Q3ZmUtMDc2My0xMWYxLTkxN2ItMmVkZmVlNDM5ZGUxIiwicmV0cmllcyI6Mywic2NvcGVEZWZpbml0aW9uSWQiOm51bGwsInNjb3BlSWQiOm51bGwsInNjb3BlVHlwZSI6bnVsbCwic3ViU2NvcGVJZCI6bnVsbCwidGVuYW50SWQiOiIiLCJ1cmwiOiJodHRwOi8vbG9jYWxob3N0OjgwOTAvZmxvd2FibGUtd29yay9leHRlcm5hbC1qb2ItYXBpL2pvYnMvSk9CLTQyOTg5YTU4LTA3NjMtMTFmMS05MTdiLTJlZGZlZTQzOWRlMSJ9XSwib3JkZXIiOiJhc2MiLCJzaXplIjoxLCJzb3J0IjoiaWQiLCJzdGFydCI6MCwidG90YWwiOjF9", + "responseContentType": "application/json", + "responseHeaders": { + "X-Content-Type-Options": [ + "nosniff" + ], + "X-XSS-Protection": [ + "0" + ], + "Cache-Control": [ + "no-store, must-revalidate, no-cache, max-age=0" + ], + "Pragma": [ + "no-cache" + ], + "X-Frame-Options": [ + "SAMEORIGIN" + ], + "Vary": [ + "accept-encoding" + ], + "Transfer-Encoding": [ + "chunked" + ], + "Date": [ + "Wed, 11 Feb 2026 16:03:52 GMT" + ] + } + }, + { + "method": "GET", + "uri": "http://localhost:8090/flowable-work/external-job-api/jobs/JOB-42989a58-0763-11f1-917b-2edfee439de1", + "statusCode": 200, + "responseBody": "eyJjb3JyZWxhdGlvbklkIjoiNDI5ODlhNTctMDc2My0xMWYxLTkxN2ItMmVkZmVlNDM5ZGUxIiwiY3JlYXRlVGltZSI6IjIwMjYtMDItMTFUMTY6MDM6NTIuNTY1WiIsImR1ZURhdGUiOm51bGwsImVsZW1lbnRJZCI6ImJwbW5UYXNrXzMiLCJlbGVtZW50TmFtZSI6IkV4dGVybmFsIFdvcmtlciB0YXNrIiwiZXhjZXB0aW9uTWVzc2FnZSI6bnVsbCwiZXhlY3V0aW9uSWQiOiJQUkMtNDI5N2ZlMTEtMDc2My0xMWYxLTkxN2ItMmVkZmVlNDM5ZGUxIiwiaWQiOiJKT0ItNDI5ODlhNTgtMDc2My0xMWYxLTkxN2ItMmVkZmVlNDM5ZGUxIiwibG9ja0V4cGlyYXRpb25UaW1lIjpudWxsLCJsb2NrT3duZXIiOm51bGwsInByb2Nlc3NEZWZpbml0aW9uSWQiOiJQUkMtZXh0ZXJuYWxXb3JrZXJQcm9jZXNzOjM6NDI3ZWQxYmMtMDc2My0xMWYxLTkxN2ItMmVkZmVlNDM5ZGUxIiwicHJvY2Vzc0luc3RhbmNlSWQiOiJQUkMtNDI5N2Q3ZmUtMDc2My0xMWYxLTkxN2ItMmVkZmVlNDM5ZGUxIiwicmV0cmllcyI6Mywic2NvcGVEZWZpbml0aW9uSWQiOm51bGwsInNjb3BlSWQiOm51bGwsInNjb3BlVHlwZSI6bnVsbCwic3ViU2NvcGVJZCI6bnVsbCwidGVuYW50SWQiOiIiLCJ1cmwiOiJodHRwOi8vbG9jYWxob3N0OjgwOTAvZmxvd2FibGUtd29yay9leHRlcm5hbC1qb2ItYXBpL2pvYnMvSk9CLTQyOTg5YTU4LTA3NjMtMTFmMS05MTdiLTJlZGZlZTQzOWRlMSJ9", + "responseContentType": "application/json", + "responseHeaders": { + "X-Content-Type-Options": [ + "nosniff" + ], + "X-XSS-Protection": [ + "0" + ], + "Cache-Control": [ + "no-store, must-revalidate, no-cache, max-age=0" + ], + "Pragma": [ + "no-cache" + ], + "X-Frame-Options": [ + "SAMEORIGIN" + ], + "Vary": [ + "accept-encoding" + ], + "Transfer-Encoding": [ + "chunked" + ], + "Date": [ + "Wed, 11 Feb 2026 16:03:52 GMT" + ] + } + }, + { + "method": "DELETE", + "uri": "http://localhost:8090/flowable-work/process-api/runtime/process-instances/PRC-4297d7fe-0763-11f1-917b-2edfee439de1", + "statusCode": 204, + "responseBody": "", + "responseContentType": null, + "responseHeaders": { + "X-Content-Type-Options": [ + "nosniff" + ], + "X-XSS-Protection": [ + "0" + ], + "Cache-Control": [ + "no-store, must-revalidate, no-cache, max-age=0" + ], + "Pragma": [ + "no-cache" + ], + "X-Frame-Options": [ + "SAMEORIGIN" + ], + "Date": [ + "Wed, 11 Feb 2026 16:03:52 GMT" + ] + } + }, + { + "method": "DELETE", + "uri": "http://localhost:8090/flowable-work/process-api/repository/deployments/PRC-427d993a-0763-11f1-917b-2edfee439de1", + "statusCode": 204, + "responseBody": "", + "responseContentType": null, + "responseHeaders": { + "X-Content-Type-Options": [ + "nosniff" + ], + "X-XSS-Protection": [ + "0" + ], + "Cache-Control": [ + "no-store, must-revalidate, no-cache, max-age=0" + ], + "Pragma": [ + "no-cache" + ], + "X-Frame-Options": [ + "SAMEORIGIN" + ], + "Date": [ + "Wed, 11 Feb 2026 16:03:52 GMT" + ] + } + } +] \ No newline at end of file diff --git a/FlowableExternalWorkerClient.Tests/Fixtures/Cassettes/TestJobWithBpmnErrorWithErrorCode1.json b/FlowableExternalWorkerClient.Tests/Fixtures/Cassettes/TestJobWithBpmnErrorWithErrorCode1.json new file mode 100644 index 0000000..1ebd687 --- /dev/null +++ b/FlowableExternalWorkerClient.Tests/Fixtures/Cassettes/TestJobWithBpmnErrorWithErrorCode1.json @@ -0,0 +1,257 @@ +[ + { + "method": "POST", + "uri": "http://localhost:8090/flowable-work/process-api/repository/deployments", + "statusCode": 201, + "responseBody": "eyJ1cmwiOiJodHRwOi8vbG9jYWxob3N0OjgwOTAvZmxvd2FibGUtd29yay9wcm9jZXNzLWFwaS9yZXBvc2l0b3J5L2RlcGxveW1lbnRzL1BSQy0zZmU4NmVjYS0wNzYzLTExZjEtOTE3Yi0yZWRmZWU0MzlkZTEiLCJjYXRlZ29yeSI6bnVsbCwiZGVwbG95bWVudFRpbWUiOiIyMDI2LTAyLTExVDE2OjAzOjQ4LjA1NVoiLCJpZCI6IlBSQy0zZmU4NmVjYS0wNzYzLTExZjEtOTE3Yi0yZWRmZWU0MzlkZTEiLCJuYW1lIjoid2l0aEJvdW5kYXJ5RXZlbnQiLCJwYXJlbnREZXBsb3ltZW50SWQiOiJQUkMtM2ZlODZlY2EtMDc2My0xMWYxLTkxN2ItMmVkZmVlNDM5ZGUxIiwidGVuYW50SWQiOiIifQ==", + "responseContentType": "application/json", + "responseHeaders": { + "Set-Cookie": [ + "XSRF-TOKEN=709771cb-ba72-4410-ad51-ce4a94039c49; Path=/flowable-work" + ], + "X-Content-Type-Options": [ + "nosniff" + ], + "X-XSS-Protection": [ + "0" + ], + "Cache-Control": [ + "no-store, must-revalidate, no-cache, max-age=0" + ], + "Pragma": [ + "no-cache" + ], + "X-Frame-Options": [ + "SAMEORIGIN" + ], + "Vary": [ + "accept-encoding" + ], + "Transfer-Encoding": [ + "chunked" + ], + "Date": [ + "Wed, 11 Feb 2026 16:03:48 GMT" + ] + } + }, + { + "method": "GET", + "uri": "http://localhost:8090/flowable-work/process-api/repository/process-definitions?deploymentId=PRC-3fe86eca-0763-11f1-917b-2edfee439de1", + "statusCode": 200, + "responseBody": "eyJkYXRhIjpbeyJjYXRlZ29yeSI6Imh0dHA6Ly9mbG93YWJsZS5vcmcvdGVzdCIsImRlcGxveW1lbnRJZCI6IlBSQy0zZmU4NmVjYS0wNzYzLTExZjEtOTE3Yi0yZWRmZWU0MzlkZTEiLCJkZXBsb3ltZW50VXJsIjoiaHR0cDovL2xvY2FsaG9zdDo4MDkwL2Zsb3dhYmxlLXdvcmsvcHJvY2Vzcy1hcGkvcmVwb3NpdG9yeS9kZXBsb3ltZW50cy9QUkMtM2ZlODZlY2EtMDc2My0xMWYxLTkxN2ItMmVkZmVlNDM5ZGUxIiwiZGVzY3JpcHRpb24iOm51bGwsImRpYWdyYW1SZXNvdXJjZSI6bnVsbCwiZ3JhcGhpY2FsTm90YXRpb25EZWZpbmVkIjp0cnVlLCJpZCI6IlBSQy1leHRlcm5hbFdvcmtlclByb2Nlc3M6MzozZmVhMWM3Yy0wNzYzLTExZjEtOTE3Yi0yZWRmZWU0MzlkZTEiLCJrZXkiOiJleHRlcm5hbFdvcmtlclByb2Nlc3MiLCJuYW1lIjoiRXh0ZXJuYWwgV29ya2VyIFByb2Nlc3MiLCJyZXNvdXJjZSI6Imh0dHA6Ly9sb2NhbGhvc3Q6ODA5MC9mbG93YWJsZS13b3JrL3Byb2Nlc3MtYXBpL3JlcG9zaXRvcnkvZGVwbG95bWVudHMvUFJDLTNmZTg2ZWNhLTA3NjMtMTFmMS05MTdiLTJlZGZlZTQzOWRlMS9yZXNvdXJjZXMvd2l0aEJvdW5kYXJ5RXZlbnQuYnBtbiIsInN0YXJ0Rm9ybURlZmluZWQiOmZhbHNlLCJzdXNwZW5kZWQiOmZhbHNlLCJ0ZW5hbnRJZCI6IiIsInVybCI6Imh0dHA6Ly9sb2NhbGhvc3Q6ODA5MC9mbG93YWJsZS13b3JrL3Byb2Nlc3MtYXBpL3JlcG9zaXRvcnkvcHJvY2Vzcy1kZWZpbml0aW9ucy9QUkMtZXh0ZXJuYWxXb3JrZXJQcm9jZXNzOjM6M2ZlYTFjN2MtMDc2My0xMWYxLTkxN2ItMmVkZmVlNDM5ZGUxIiwidmVyc2lvbiI6M31dLCJvcmRlciI6ImFzYyIsInNpemUiOjEsInNvcnQiOiJuYW1lIiwic3RhcnQiOjAsInRvdGFsIjoxfQ==", + "responseContentType": "application/json", + "responseHeaders": { + "X-Content-Type-Options": [ + "nosniff" + ], + "X-XSS-Protection": [ + "0" + ], + "Cache-Control": [ + "no-store, must-revalidate, no-cache, max-age=0" + ], + "Pragma": [ + "no-cache" + ], + "X-Frame-Options": [ + "SAMEORIGIN" + ], + "Vary": [ + "accept-encoding" + ], + "Transfer-Encoding": [ + "chunked" + ], + "Date": [ + "Wed, 11 Feb 2026 16:03:48 GMT" + ] + } + }, + { + "method": "POST", + "uri": "http://localhost:8090/flowable-work/process-api/runtime/process-instances", + "statusCode": 201, + "responseBody": "eyJhY3Rpdml0eUlkIjpudWxsLCJidXNpbmVzc0tleSI6bnVsbCwiYnVzaW5lc3NTdGF0dXMiOm51bGwsImNhbGxiYWNrSWQiOm51bGwsImNhbGxiYWNrVHlwZSI6bnVsbCwiY29tcGxldGVkIjpmYWxzZSwiZW5kZWQiOmZhbHNlLCJpZCI6IlBSQy00MDAzOTdlZS0wNzYzLTExZjEtOTE3Yi0yZWRmZWU0MzlkZTEiLCJuYW1lIjpudWxsLCJwcm9jZXNzRGVmaW5pdGlvbkRlc2NyaXB0aW9uIjpudWxsLCJwcm9jZXNzRGVmaW5pdGlvbklkIjoiUFJDLWV4dGVybmFsV29ya2VyUHJvY2VzczozOjNmZWExYzdjLTA3NjMtMTFmMS05MTdiLTJlZGZlZTQzOWRlMSIsInByb2Nlc3NEZWZpbml0aW9uTmFtZSI6IkV4dGVybmFsIFdvcmtlciBQcm9jZXNzIiwicHJvY2Vzc0RlZmluaXRpb25VcmwiOiJodHRwOi8vbG9jYWxob3N0OjgwOTAvZmxvd2FibGUtd29yay9wcm9jZXNzLWFwaS9yZXBvc2l0b3J5L3Byb2Nlc3MtZGVmaW5pdGlvbnMvUFJDLWV4dGVybmFsV29ya2VyUHJvY2VzczozOjNmZWExYzdjLTA3NjMtMTFmMS05MTdiLTJlZGZlZTQzOWRlMSIsInByb3BhZ2F0ZWRTdGFnZUluc3RhbmNlSWQiOm51bGwsInJlZmVyZW5jZUlkIjpudWxsLCJyZWZlcmVuY2VUeXBlIjpudWxsLCJzdGFydFRpbWUiOiIyMDI2LTAyLTExVDE2OjAzOjQ4LjIzM1oiLCJzdGFydFVzZXJJZCI6ImFkbWluIiwic3VwZXJQcm9jZXNzSW5zdGFuY2VJZCI6bnVsbCwic3VzcGVuZGVkIjpmYWxzZSwidGVuYW50SWQiOiIiLCJ1cmwiOiJodHRwOi8vbG9jYWxob3N0OjgwOTAvZmxvd2FibGUtd29yay9wcm9jZXNzLWFwaS9ydW50aW1lL3Byb2Nlc3MtaW5zdGFuY2VzL1BSQy00MDAzOTdlZS0wNzYzLTExZjEtOTE3Yi0yZWRmZWU0MzlkZTEiLCJ2YXJpYWJsZXMiOlt7Im5hbWUiOiJpbml0aWF0b3IiLCJzY29wZSI6ImxvY2FsIiwidHlwZSI6InN0cmluZyIsInZhbHVlIjoiYWRtaW4ifV19", + "responseContentType": "application/json", + "responseHeaders": { + "X-Content-Type-Options": [ + "nosniff" + ], + "X-XSS-Protection": [ + "0" + ], + "Cache-Control": [ + "no-store, must-revalidate, no-cache, max-age=0" + ], + "Pragma": [ + "no-cache" + ], + "X-Frame-Options": [ + "SAMEORIGIN" + ], + "Vary": [ + "accept-encoding" + ], + "Transfer-Encoding": [ + "chunked" + ], + "Date": [ + "Wed, 11 Feb 2026 16:03:48 GMT" + ] + } + }, + { + "method": "POST", + "uri": "http://localhost:8090/flowable-work/external-job-api/acquire/jobs", + "statusCode": 200, + "responseBody": "W3siY29ycmVsYXRpb25JZCI6IjQwMDRkMDdiLTA3NjMtMTFmMS05MTdiLTJlZGZlZTQzOWRlMSIsImNyZWF0ZVRpbWUiOiIyMDI2LTAyLTExVDE2OjAzOjQ4LjI0MVoiLCJkdWVEYXRlIjpudWxsLCJlbGVtZW50SWQiOiJicG1uVGFza18zIiwiZWxlbWVudE5hbWUiOiJFeHRlcm5hbCBXb3JrZXIgdGFzayIsImV4Y2VwdGlvbk1lc3NhZ2UiOm51bGwsImV4ZWN1dGlvbklkIjoiUFJDLTQwMDNiZjAxLTA3NjMtMTFmMS05MTdiLTJlZGZlZTQzOWRlMSIsImlkIjoiSk9CLTQwMDRkMDdjLTA3NjMtMTFmMS05MTdiLTJlZGZlZTQzOWRlMSIsImxvY2tFeHBpcmF0aW9uVGltZSI6IjIwMjYtMDItMTFUMTY6MDM6NTguMzI5WiIsImxvY2tPd25lciI6InRlc3Qtd29ya2VyIiwicHJvY2Vzc0RlZmluaXRpb25JZCI6IlBSQy1leHRlcm5hbFdvcmtlclByb2Nlc3M6MzozZmVhMWM3Yy0wNzYzLTExZjEtOTE3Yi0yZWRmZWU0MzlkZTEiLCJwcm9jZXNzSW5zdGFuY2VJZCI6IlBSQy00MDAzOTdlZS0wNzYzLTExZjEtOTE3Yi0yZWRmZWU0MzlkZTEiLCJyZXRyaWVzIjozLCJzY29wZURlZmluaXRpb25JZCI6bnVsbCwic2NvcGVJZCI6bnVsbCwic2NvcGVUeXBlIjpudWxsLCJzdWJTY29wZUlkIjpudWxsLCJ0ZW5hbnRJZCI6IiIsInVybCI6Imh0dHA6Ly9sb2NhbGhvc3Q6ODA5MC9mbG93YWJsZS13b3JrL2V4dGVybmFsLWpvYi1hcGkvam9icy9KT0ItNDAwNGQwN2MtMDc2My0xMWYxLTkxN2ItMmVkZmVlNDM5ZGUxIiwidmFyaWFibGVzIjpbeyJuYW1lIjoiaW5pdGlhdG9yIiwidHlwZSI6InN0cmluZyIsInZhbHVlIjoiYWRtaW4ifV19XQ==", + "responseContentType": "application/json", + "responseHeaders": { + "X-Content-Type-Options": [ + "nosniff" + ], + "X-XSS-Protection": [ + "0" + ], + "Cache-Control": [ + "no-store, must-revalidate, no-cache, max-age=0" + ], + "Pragma": [ + "no-cache" + ], + "X-Frame-Options": [ + "SAMEORIGIN" + ], + "Vary": [ + "accept-encoding" + ], + "Transfer-Encoding": [ + "chunked" + ], + "Date": [ + "Wed, 11 Feb 2026 16:03:48 GMT" + ] + } + }, + { + "method": "POST", + "uri": "http://localhost:8090/flowable-work/external-job-api/acquire/jobs/JOB-4004d07c-0763-11f1-917b-2edfee439de1/bpmnError", + "statusCode": 204, + "responseBody": "", + "responseContentType": null, + "responseHeaders": { + "X-Content-Type-Options": [ + "nosniff" + ], + "X-XSS-Protection": [ + "0" + ], + "Cache-Control": [ + "no-store, must-revalidate, no-cache, max-age=0" + ], + "Pragma": [ + "no-cache" + ], + "X-Frame-Options": [ + "SAMEORIGIN" + ], + "Date": [ + "Wed, 11 Feb 2026 16:03:48 GMT" + ] + } + }, + { + "method": "GET", + "uri": "http://localhost:8090/flowable-work/process-api/history/historic-variable-instances?processInstanceId=PRC-400397ee-0763-11f1-917b-2edfee439de1\u0026variableName=testVar", + "statusCode": 200, + "responseBody": "eyJkYXRhIjpbeyJleGVjdXRpb25JZCI6IlBSQy00MDAzOTdlZS0wNzYzLTExZjEtOTE3Yi0yZWRmZWU0MzlkZTEiLCJpZCI6IlZBUi00MDIyZGZkMC0wNzYzLTExZjEtOTE3Yi0yZWRmZWU0MzlkZTEiLCJwcm9jZXNzSW5zdGFuY2VJZCI6IlBSQy00MDAzOTdlZS0wNzYzLTExZjEtOTE3Yi0yZWRmZWU0MzlkZTEiLCJwcm9jZXNzSW5zdGFuY2VVcmwiOiJodHRwOi8vbG9jYWxob3N0OjgwOTAvZmxvd2FibGUtd29yay9wcm9jZXNzLWFwaS9oaXN0b3J5L2hpc3RvcmljLXByb2Nlc3MtaW5zdGFuY2VzL1BSQy00MDAzOTdlZS0wNzYzLTExZjEtOTE3Yi0yZWRmZWU0MzlkZTEiLCJ0YXNrSWQiOm51bGwsInZhcmlhYmxlIjp7Im5hbWUiOiJ0ZXN0VmFyIiwic2NvcGUiOiJnbG9iYWwiLCJ0eXBlIjoic3RyaW5nIiwidmFsdWUiOiJ0ZXN0IGZhaWx1cmUifX1dLCJvcmRlciI6ImFzYyIsInNpemUiOjEsInNvcnQiOiJ2YXJpYWJsZU5hbWUiLCJzdGFydCI6MCwidG90YWwiOjF9", + "responseContentType": "application/json", + "responseHeaders": { + "X-Content-Type-Options": [ + "nosniff" + ], + "X-XSS-Protection": [ + "0" + ], + "Cache-Control": [ + "no-store, must-revalidate, no-cache, max-age=0" + ], + "Pragma": [ + "no-cache" + ], + "X-Frame-Options": [ + "SAMEORIGIN" + ], + "Vary": [ + "accept-encoding" + ], + "Transfer-Encoding": [ + "chunked" + ], + "Date": [ + "Wed, 11 Feb 2026 16:03:48 GMT" + ] + } + }, + { + "method": "GET", + "uri": "http://localhost:8090/flowable-work/process-api/history/historic-activity-instances?processInstanceId=PRC-400397ee-0763-11f1-917b-2edfee439de1", + "statusCode": 200, + "responseBody": "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", + "responseContentType": "application/json", + "responseHeaders": { + "X-Content-Type-Options": [ + "nosniff" + ], + "X-XSS-Protection": [ + "0" + ], + "Cache-Control": [ + "no-store, must-revalidate, no-cache, max-age=0" + ], + "Pragma": [ + "no-cache" + ], + "X-Frame-Options": [ + "SAMEORIGIN" + ], + "Vary": [ + "accept-encoding" + ], + "Transfer-Encoding": [ + "chunked" + ], + "Date": [ + "Wed, 11 Feb 2026 16:03:48 GMT" + ] + } + }, + { + "method": "DELETE", + "uri": "http://localhost:8090/flowable-work/process-api/repository/deployments/PRC-3fe86eca-0763-11f1-917b-2edfee439de1", + "statusCode": 204, + "responseBody": "", + "responseContentType": null, + "responseHeaders": { + "X-Content-Type-Options": [ + "nosniff" + ], + "X-XSS-Protection": [ + "0" + ], + "Cache-Control": [ + "no-store, must-revalidate, no-cache, max-age=0" + ], + "Pragma": [ + "no-cache" + ], + "X-Frame-Options": [ + "SAMEORIGIN" + ], + "Date": [ + "Wed, 11 Feb 2026 16:03:48 GMT" + ] + } + } +] \ No newline at end of file diff --git a/FlowableExternalWorkerClient.Tests/Fixtures/Cassettes/TestJobWithBpmnErrorWithErrorCode2.json b/FlowableExternalWorkerClient.Tests/Fixtures/Cassettes/TestJobWithBpmnErrorWithErrorCode2.json new file mode 100644 index 0000000..2d84fe6 --- /dev/null +++ b/FlowableExternalWorkerClient.Tests/Fixtures/Cassettes/TestJobWithBpmnErrorWithErrorCode2.json @@ -0,0 +1,257 @@ +[ + { + "method": "POST", + "uri": "http://localhost:8090/flowable-work/process-api/repository/deployments", + "statusCode": 201, + "responseBody": "eyJ1cmwiOiJodHRwOi8vbG9jYWxob3N0OjgwOTAvZmxvd2FibGUtd29yay9wcm9jZXNzLWFwaS9yZXBvc2l0b3J5L2RlcGxveW1lbnRzL1BSQy00MWI0ZjFkOC0wNzYzLTExZjEtOTE3Yi0yZWRmZWU0MzlkZTEiLCJjYXRlZ29yeSI6bnVsbCwiZGVwbG95bWVudFRpbWUiOiIyMDI2LTAyLTExVDE2OjAzOjUxLjA3M1oiLCJpZCI6IlBSQy00MWI0ZjFkOC0wNzYzLTExZjEtOTE3Yi0yZWRmZWU0MzlkZTEiLCJuYW1lIjoid2l0aEJvdW5kYXJ5RXZlbnQiLCJwYXJlbnREZXBsb3ltZW50SWQiOiJQUkMtNDFiNGYxZDgtMDc2My0xMWYxLTkxN2ItMmVkZmVlNDM5ZGUxIiwidGVuYW50SWQiOiIifQ==", + "responseContentType": "application/json", + "responseHeaders": { + "Set-Cookie": [ + "XSRF-TOKEN=40b93f48-7e4e-4d90-8e93-600714bb7084; Path=/flowable-work" + ], + "X-Content-Type-Options": [ + "nosniff" + ], + "X-XSS-Protection": [ + "0" + ], + "Cache-Control": [ + "no-store, must-revalidate, no-cache, max-age=0" + ], + "Pragma": [ + "no-cache" + ], + "X-Frame-Options": [ + "SAMEORIGIN" + ], + "Vary": [ + "accept-encoding" + ], + "Transfer-Encoding": [ + "chunked" + ], + "Date": [ + "Wed, 11 Feb 2026 16:03:51 GMT" + ] + } + }, + { + "method": "GET", + "uri": "http://localhost:8090/flowable-work/process-api/repository/process-definitions?deploymentId=PRC-41b4f1d8-0763-11f1-917b-2edfee439de1", + "statusCode": 200, + "responseBody": "eyJkYXRhIjpbeyJjYXRlZ29yeSI6Imh0dHA6Ly9mbG93YWJsZS5vcmcvdGVzdCIsImRlcGxveW1lbnRJZCI6IlBSQy00MWI0ZjFkOC0wNzYzLTExZjEtOTE3Yi0yZWRmZWU0MzlkZTEiLCJkZXBsb3ltZW50VXJsIjoiaHR0cDovL2xvY2FsaG9zdDo4MDkwL2Zsb3dhYmxlLXdvcmsvcHJvY2Vzcy1hcGkvcmVwb3NpdG9yeS9kZXBsb3ltZW50cy9QUkMtNDFiNGYxZDgtMDc2My0xMWYxLTkxN2ItMmVkZmVlNDM5ZGUxIiwiZGVzY3JpcHRpb24iOm51bGwsImRpYWdyYW1SZXNvdXJjZSI6bnVsbCwiZ3JhcGhpY2FsTm90YXRpb25EZWZpbmVkIjp0cnVlLCJpZCI6IlBSQy1leHRlcm5hbFdvcmtlclByb2Nlc3M6Mzo0MWI2MDM0YS0wNzYzLTExZjEtOTE3Yi0yZWRmZWU0MzlkZTEiLCJrZXkiOiJleHRlcm5hbFdvcmtlclByb2Nlc3MiLCJuYW1lIjoiRXh0ZXJuYWwgV29ya2VyIFByb2Nlc3MiLCJyZXNvdXJjZSI6Imh0dHA6Ly9sb2NhbGhvc3Q6ODA5MC9mbG93YWJsZS13b3JrL3Byb2Nlc3MtYXBpL3JlcG9zaXRvcnkvZGVwbG95bWVudHMvUFJDLTQxYjRmMWQ4LTA3NjMtMTFmMS05MTdiLTJlZGZlZTQzOWRlMS9yZXNvdXJjZXMvd2l0aEJvdW5kYXJ5RXZlbnQuYnBtbiIsInN0YXJ0Rm9ybURlZmluZWQiOmZhbHNlLCJzdXNwZW5kZWQiOmZhbHNlLCJ0ZW5hbnRJZCI6IiIsInVybCI6Imh0dHA6Ly9sb2NhbGhvc3Q6ODA5MC9mbG93YWJsZS13b3JrL3Byb2Nlc3MtYXBpL3JlcG9zaXRvcnkvcHJvY2Vzcy1kZWZpbml0aW9ucy9QUkMtZXh0ZXJuYWxXb3JrZXJQcm9jZXNzOjM6NDFiNjAzNGEtMDc2My0xMWYxLTkxN2ItMmVkZmVlNDM5ZGUxIiwidmVyc2lvbiI6M31dLCJvcmRlciI6ImFzYyIsInNpemUiOjEsInNvcnQiOiJuYW1lIiwic3RhcnQiOjAsInRvdGFsIjoxfQ==", + "responseContentType": "application/json", + "responseHeaders": { + "X-Content-Type-Options": [ + "nosniff" + ], + "X-XSS-Protection": [ + "0" + ], + "Cache-Control": [ + "no-store, must-revalidate, no-cache, max-age=0" + ], + "Pragma": [ + "no-cache" + ], + "X-Frame-Options": [ + "SAMEORIGIN" + ], + "Vary": [ + "accept-encoding" + ], + "Transfer-Encoding": [ + "chunked" + ], + "Date": [ + "Wed, 11 Feb 2026 16:03:51 GMT" + ] + } + }, + { + "method": "POST", + "uri": "http://localhost:8090/flowable-work/process-api/runtime/process-instances", + "statusCode": 201, + "responseBody": "eyJhY3Rpdml0eUlkIjpudWxsLCJidXNpbmVzc0tleSI6bnVsbCwiYnVzaW5lc3NTdGF0dXMiOm51bGwsImNhbGxiYWNrSWQiOm51bGwsImNhbGxiYWNrVHlwZSI6bnVsbCwiY29tcGxldGVkIjpmYWxzZSwiZW5kZWQiOmZhbHNlLCJpZCI6IlBSQy00MWNlNmQ0Yy0wNzYzLTExZjEtOTE3Yi0yZWRmZWU0MzlkZTEiLCJuYW1lIjpudWxsLCJwcm9jZXNzRGVmaW5pdGlvbkRlc2NyaXB0aW9uIjpudWxsLCJwcm9jZXNzRGVmaW5pdGlvbklkIjoiUFJDLWV4dGVybmFsV29ya2VyUHJvY2VzczozOjQxYjYwMzRhLTA3NjMtMTFmMS05MTdiLTJlZGZlZTQzOWRlMSIsInByb2Nlc3NEZWZpbml0aW9uTmFtZSI6IkV4dGVybmFsIFdvcmtlciBQcm9jZXNzIiwicHJvY2Vzc0RlZmluaXRpb25VcmwiOiJodHRwOi8vbG9jYWxob3N0OjgwOTAvZmxvd2FibGUtd29yay9wcm9jZXNzLWFwaS9yZXBvc2l0b3J5L3Byb2Nlc3MtZGVmaW5pdGlvbnMvUFJDLWV4dGVybmFsV29ya2VyUHJvY2VzczozOjQxYjYwMzRhLTA3NjMtMTFmMS05MTdiLTJlZGZlZTQzOWRlMSIsInByb3BhZ2F0ZWRTdGFnZUluc3RhbmNlSWQiOm51bGwsInJlZmVyZW5jZUlkIjpudWxsLCJyZWZlcmVuY2VUeXBlIjpudWxsLCJzdGFydFRpbWUiOiIyMDI2LTAyLTExVDE2OjAzOjUxLjI0MFoiLCJzdGFydFVzZXJJZCI6ImFkbWluIiwic3VwZXJQcm9jZXNzSW5zdGFuY2VJZCI6bnVsbCwic3VzcGVuZGVkIjpmYWxzZSwidGVuYW50SWQiOiIiLCJ1cmwiOiJodHRwOi8vbG9jYWxob3N0OjgwOTAvZmxvd2FibGUtd29yay9wcm9jZXNzLWFwaS9ydW50aW1lL3Byb2Nlc3MtaW5zdGFuY2VzL1BSQy00MWNlNmQ0Yy0wNzYzLTExZjEtOTE3Yi0yZWRmZWU0MzlkZTEiLCJ2YXJpYWJsZXMiOlt7Im5hbWUiOiJpbml0aWF0b3IiLCJzY29wZSI6ImxvY2FsIiwidHlwZSI6InN0cmluZyIsInZhbHVlIjoiYWRtaW4ifV19", + "responseContentType": "application/json", + "responseHeaders": { + "X-Content-Type-Options": [ + "nosniff" + ], + "X-XSS-Protection": [ + "0" + ], + "Cache-Control": [ + "no-store, must-revalidate, no-cache, max-age=0" + ], + "Pragma": [ + "no-cache" + ], + "X-Frame-Options": [ + "SAMEORIGIN" + ], + "Vary": [ + "accept-encoding" + ], + "Transfer-Encoding": [ + "chunked" + ], + "Date": [ + "Wed, 11 Feb 2026 16:03:51 GMT" + ] + } + }, + { + "method": "POST", + "uri": "http://localhost:8090/flowable-work/external-job-api/acquire/jobs", + "statusCode": 200, + "responseBody": "W3siY29ycmVsYXRpb25JZCI6IjQxY2Y1N2I5LTA3NjMtMTFmMS05MTdiLTJlZGZlZTQzOWRlMSIsImNyZWF0ZVRpbWUiOiIyMDI2LTAyLTExVDE2OjAzOjUxLjI0NloiLCJkdWVEYXRlIjpudWxsLCJlbGVtZW50SWQiOiJicG1uVGFza18zIiwiZWxlbWVudE5hbWUiOiJFeHRlcm5hbCBXb3JrZXIgdGFzayIsImV4Y2VwdGlvbk1lc3NhZ2UiOm51bGwsImV4ZWN1dGlvbklkIjoiUFJDLTQxY2U5NDVmLTA3NjMtMTFmMS05MTdiLTJlZGZlZTQzOWRlMSIsImlkIjoiSk9CLTQxY2Y1N2JhLTA3NjMtMTFmMS05MTdiLTJlZGZlZTQzOWRlMSIsImxvY2tFeHBpcmF0aW9uVGltZSI6IjIwMjYtMDItMTFUMTY6MDQ6MDEuMzM0WiIsImxvY2tPd25lciI6InRlc3Qtd29ya2VyIiwicHJvY2Vzc0RlZmluaXRpb25JZCI6IlBSQy1leHRlcm5hbFdvcmtlclByb2Nlc3M6Mzo0MWI2MDM0YS0wNzYzLTExZjEtOTE3Yi0yZWRmZWU0MzlkZTEiLCJwcm9jZXNzSW5zdGFuY2VJZCI6IlBSQy00MWNlNmQ0Yy0wNzYzLTExZjEtOTE3Yi0yZWRmZWU0MzlkZTEiLCJyZXRyaWVzIjozLCJzY29wZURlZmluaXRpb25JZCI6bnVsbCwic2NvcGVJZCI6bnVsbCwic2NvcGVUeXBlIjpudWxsLCJzdWJTY29wZUlkIjpudWxsLCJ0ZW5hbnRJZCI6IiIsInVybCI6Imh0dHA6Ly9sb2NhbGhvc3Q6ODA5MC9mbG93YWJsZS13b3JrL2V4dGVybmFsLWpvYi1hcGkvam9icy9KT0ItNDFjZjU3YmEtMDc2My0xMWYxLTkxN2ItMmVkZmVlNDM5ZGUxIiwidmFyaWFibGVzIjpbeyJuYW1lIjoiaW5pdGlhdG9yIiwidHlwZSI6InN0cmluZyIsInZhbHVlIjoiYWRtaW4ifV19XQ==", + "responseContentType": "application/json", + "responseHeaders": { + "X-Content-Type-Options": [ + "nosniff" + ], + "X-XSS-Protection": [ + "0" + ], + "Cache-Control": [ + "no-store, must-revalidate, no-cache, max-age=0" + ], + "Pragma": [ + "no-cache" + ], + "X-Frame-Options": [ + "SAMEORIGIN" + ], + "Vary": [ + "accept-encoding" + ], + "Transfer-Encoding": [ + "chunked" + ], + "Date": [ + "Wed, 11 Feb 2026 16:03:51 GMT" + ] + } + }, + { + "method": "POST", + "uri": "http://localhost:8090/flowable-work/external-job-api/acquire/jobs/JOB-41cf57ba-0763-11f1-917b-2edfee439de1/bpmnError", + "statusCode": 204, + "responseBody": "", + "responseContentType": null, + "responseHeaders": { + "X-Content-Type-Options": [ + "nosniff" + ], + "X-XSS-Protection": [ + "0" + ], + "Cache-Control": [ + "no-store, must-revalidate, no-cache, max-age=0" + ], + "Pragma": [ + "no-cache" + ], + "X-Frame-Options": [ + "SAMEORIGIN" + ], + "Date": [ + "Wed, 11 Feb 2026 16:03:51 GMT" + ] + } + }, + { + "method": "GET", + "uri": "http://localhost:8090/flowable-work/process-api/history/historic-variable-instances?processInstanceId=PRC-41ce6d4c-0763-11f1-917b-2edfee439de1\u0026variableName=testVar", + "statusCode": 200, + "responseBody": "eyJkYXRhIjpbeyJleGVjdXRpb25JZCI6IlBSQy00MWNlNmQ0Yy0wNzYzLTExZjEtOTE3Yi0yZWRmZWU0MzlkZTEiLCJpZCI6IlZBUi00MWViMWQxZS0wNzYzLTExZjEtOTE3Yi0yZWRmZWU0MzlkZTEiLCJwcm9jZXNzSW5zdGFuY2VJZCI6IlBSQy00MWNlNmQ0Yy0wNzYzLTExZjEtOTE3Yi0yZWRmZWU0MzlkZTEiLCJwcm9jZXNzSW5zdGFuY2VVcmwiOiJodHRwOi8vbG9jYWxob3N0OjgwOTAvZmxvd2FibGUtd29yay9wcm9jZXNzLWFwaS9oaXN0b3J5L2hpc3RvcmljLXByb2Nlc3MtaW5zdGFuY2VzL1BSQy00MWNlNmQ0Yy0wNzYzLTExZjEtOTE3Yi0yZWRmZWU0MzlkZTEiLCJ0YXNrSWQiOm51bGwsInZhcmlhYmxlIjp7Im5hbWUiOiJ0ZXN0VmFyIiwic2NvcGUiOiJnbG9iYWwiLCJ0eXBlIjoic3RyaW5nIiwidmFsdWUiOiJ0ZXN0IGZhaWx1cmUifX1dLCJvcmRlciI6ImFzYyIsInNpemUiOjEsInNvcnQiOiJ2YXJpYWJsZU5hbWUiLCJzdGFydCI6MCwidG90YWwiOjF9", + "responseContentType": "application/json", + "responseHeaders": { + "X-Content-Type-Options": [ + "nosniff" + ], + "X-XSS-Protection": [ + "0" + ], + "Cache-Control": [ + "no-store, must-revalidate, no-cache, max-age=0" + ], + "Pragma": [ + "no-cache" + ], + "X-Frame-Options": [ + "SAMEORIGIN" + ], + "Vary": [ + "accept-encoding" + ], + "Transfer-Encoding": [ + "chunked" + ], + "Date": [ + "Wed, 11 Feb 2026 16:03:51 GMT" + ] + } + }, + { + "method": "GET", + "uri": "http://localhost:8090/flowable-work/process-api/history/historic-activity-instances?processInstanceId=PRC-41ce6d4c-0763-11f1-917b-2edfee439de1", + "statusCode": 200, + "responseBody": "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", + "responseContentType": "application/json", + "responseHeaders": { + "X-Content-Type-Options": [ + "nosniff" + ], + "X-XSS-Protection": [ + "0" + ], + "Cache-Control": [ + "no-store, must-revalidate, no-cache, max-age=0" + ], + "Pragma": [ + "no-cache" + ], + "X-Frame-Options": [ + "SAMEORIGIN" + ], + "Vary": [ + "accept-encoding" + ], + "Transfer-Encoding": [ + "chunked" + ], + "Date": [ + "Wed, 11 Feb 2026 16:03:51 GMT" + ] + } + }, + { + "method": "DELETE", + "uri": "http://localhost:8090/flowable-work/process-api/repository/deployments/PRC-41b4f1d8-0763-11f1-917b-2edfee439de1", + "statusCode": 204, + "responseBody": "", + "responseContentType": null, + "responseHeaders": { + "X-Content-Type-Options": [ + "nosniff" + ], + "X-XSS-Protection": [ + "0" + ], + "Cache-Control": [ + "no-store, must-revalidate, no-cache, max-age=0" + ], + "Pragma": [ + "no-cache" + ], + "X-Frame-Options": [ + "SAMEORIGIN" + ], + "Date": [ + "Wed, 11 Feb 2026 16:03:51 GMT" + ] + } + } +] \ No newline at end of file diff --git a/FlowableExternalWorkerClient.Tests/Fixtures/Cassettes/TestJobWithBpmnErrorWithoutErrorCode.json b/FlowableExternalWorkerClient.Tests/Fixtures/Cassettes/TestJobWithBpmnErrorWithoutErrorCode.json new file mode 100644 index 0000000..f4e7cde --- /dev/null +++ b/FlowableExternalWorkerClient.Tests/Fixtures/Cassettes/TestJobWithBpmnErrorWithoutErrorCode.json @@ -0,0 +1,257 @@ +[ + { + "method": "POST", + "uri": "http://localhost:8090/flowable-work/process-api/repository/deployments", + "statusCode": 201, + "responseBody": "eyJ1cmwiOiJodHRwOi8vbG9jYWxob3N0OjgwOTAvZmxvd2FibGUtd29yay9wcm9jZXNzLWFwaS9yZXBvc2l0b3J5L2RlcGxveW1lbnRzL1BSQy00MTUxYzMxZC0wNzYzLTExZjEtOTE3Yi0yZWRmZWU0MzlkZTEiLCJjYXRlZ29yeSI6bnVsbCwiZGVwbG95bWVudFRpbWUiOiIyMDI2LTAyLTExVDE2OjAzOjUwLjQyM1oiLCJpZCI6IlBSQy00MTUxYzMxZC0wNzYzLTExZjEtOTE3Yi0yZWRmZWU0MzlkZTEiLCJuYW1lIjoid2l0aEJvdW5kYXJ5RXZlbnQiLCJwYXJlbnREZXBsb3ltZW50SWQiOiJQUkMtNDE1MWMzMWQtMDc2My0xMWYxLTkxN2ItMmVkZmVlNDM5ZGUxIiwidGVuYW50SWQiOiIifQ==", + "responseContentType": "application/json", + "responseHeaders": { + "Set-Cookie": [ + "XSRF-TOKEN=9eecd378-e10a-4b36-8cab-452b6cfc5480; Path=/flowable-work" + ], + "X-Content-Type-Options": [ + "nosniff" + ], + "X-XSS-Protection": [ + "0" + ], + "Cache-Control": [ + "no-store, must-revalidate, no-cache, max-age=0" + ], + "Pragma": [ + "no-cache" + ], + "X-Frame-Options": [ + "SAMEORIGIN" + ], + "Vary": [ + "accept-encoding" + ], + "Transfer-Encoding": [ + "chunked" + ], + "Date": [ + "Wed, 11 Feb 2026 16:03:50 GMT" + ] + } + }, + { + "method": "GET", + "uri": "http://localhost:8090/flowable-work/process-api/repository/process-definitions?deploymentId=PRC-4151c31d-0763-11f1-917b-2edfee439de1", + "statusCode": 200, + "responseBody": "eyJkYXRhIjpbeyJjYXRlZ29yeSI6Imh0dHA6Ly9mbG93YWJsZS5vcmcvdGVzdCIsImRlcGxveW1lbnRJZCI6IlBSQy00MTUxYzMxZC0wNzYzLTExZjEtOTE3Yi0yZWRmZWU0MzlkZTEiLCJkZXBsb3ltZW50VXJsIjoiaHR0cDovL2xvY2FsaG9zdDo4MDkwL2Zsb3dhYmxlLXdvcmsvcHJvY2Vzcy1hcGkvcmVwb3NpdG9yeS9kZXBsb3ltZW50cy9QUkMtNDE1MWMzMWQtMDc2My0xMWYxLTkxN2ItMmVkZmVlNDM5ZGUxIiwiZGVzY3JpcHRpb24iOm51bGwsImRpYWdyYW1SZXNvdXJjZSI6bnVsbCwiZ3JhcGhpY2FsTm90YXRpb25EZWZpbmVkIjp0cnVlLCJpZCI6IlBSQy1leHRlcm5hbFdvcmtlclByb2Nlc3M6Mzo0MTUyZmI5Zi0wNzYzLTExZjEtOTE3Yi0yZWRmZWU0MzlkZTEiLCJrZXkiOiJleHRlcm5hbFdvcmtlclByb2Nlc3MiLCJuYW1lIjoiRXh0ZXJuYWwgV29ya2VyIFByb2Nlc3MiLCJyZXNvdXJjZSI6Imh0dHA6Ly9sb2NhbGhvc3Q6ODA5MC9mbG93YWJsZS13b3JrL3Byb2Nlc3MtYXBpL3JlcG9zaXRvcnkvZGVwbG95bWVudHMvUFJDLTQxNTFjMzFkLTA3NjMtMTFmMS05MTdiLTJlZGZlZTQzOWRlMS9yZXNvdXJjZXMvd2l0aEJvdW5kYXJ5RXZlbnQuYnBtbiIsInN0YXJ0Rm9ybURlZmluZWQiOmZhbHNlLCJzdXNwZW5kZWQiOmZhbHNlLCJ0ZW5hbnRJZCI6IiIsInVybCI6Imh0dHA6Ly9sb2NhbGhvc3Q6ODA5MC9mbG93YWJsZS13b3JrL3Byb2Nlc3MtYXBpL3JlcG9zaXRvcnkvcHJvY2Vzcy1kZWZpbml0aW9ucy9QUkMtZXh0ZXJuYWxXb3JrZXJQcm9jZXNzOjM6NDE1MmZiOWYtMDc2My0xMWYxLTkxN2ItMmVkZmVlNDM5ZGUxIiwidmVyc2lvbiI6M31dLCJvcmRlciI6ImFzYyIsInNpemUiOjEsInNvcnQiOiJuYW1lIiwic3RhcnQiOjAsInRvdGFsIjoxfQ==", + "responseContentType": "application/json", + "responseHeaders": { + "X-Content-Type-Options": [ + "nosniff" + ], + "X-XSS-Protection": [ + "0" + ], + "Cache-Control": [ + "no-store, must-revalidate, no-cache, max-age=0" + ], + "Pragma": [ + "no-cache" + ], + "X-Frame-Options": [ + "SAMEORIGIN" + ], + "Vary": [ + "accept-encoding" + ], + "Transfer-Encoding": [ + "chunked" + ], + "Date": [ + "Wed, 11 Feb 2026 16:03:50 GMT" + ] + } + }, + { + "method": "POST", + "uri": "http://localhost:8090/flowable-work/process-api/runtime/process-instances", + "statusCode": 201, + "responseBody": "eyJhY3Rpdml0eUlkIjpudWxsLCJidXNpbmVzc0tleSI6bnVsbCwiYnVzaW5lc3NTdGF0dXMiOm51bGwsImNhbGxiYWNrSWQiOm51bGwsImNhbGxiYWNrVHlwZSI6bnVsbCwiY29tcGxldGVkIjpmYWxzZSwiZW5kZWQiOmZhbHNlLCJpZCI6IlBSQy00MTZiNjVhMS0wNzYzLTExZjEtOTE3Yi0yZWRmZWU0MzlkZTEiLCJuYW1lIjpudWxsLCJwcm9jZXNzRGVmaW5pdGlvbkRlc2NyaXB0aW9uIjpudWxsLCJwcm9jZXNzRGVmaW5pdGlvbklkIjoiUFJDLWV4dGVybmFsV29ya2VyUHJvY2VzczozOjQxNTJmYjlmLTA3NjMtMTFmMS05MTdiLTJlZGZlZTQzOWRlMSIsInByb2Nlc3NEZWZpbml0aW9uTmFtZSI6IkV4dGVybmFsIFdvcmtlciBQcm9jZXNzIiwicHJvY2Vzc0RlZmluaXRpb25VcmwiOiJodHRwOi8vbG9jYWxob3N0OjgwOTAvZmxvd2FibGUtd29yay9wcm9jZXNzLWFwaS9yZXBvc2l0b3J5L3Byb2Nlc3MtZGVmaW5pdGlvbnMvUFJDLWV4dGVybmFsV29ya2VyUHJvY2VzczozOjQxNTJmYjlmLTA3NjMtMTFmMS05MTdiLTJlZGZlZTQzOWRlMSIsInByb3BhZ2F0ZWRTdGFnZUluc3RhbmNlSWQiOm51bGwsInJlZmVyZW5jZUlkIjpudWxsLCJyZWZlcmVuY2VUeXBlIjpudWxsLCJzdGFydFRpbWUiOiIyMDI2LTAyLTExVDE2OjAzOjUwLjU5MVoiLCJzdGFydFVzZXJJZCI6ImFkbWluIiwic3VwZXJQcm9jZXNzSW5zdGFuY2VJZCI6bnVsbCwic3VzcGVuZGVkIjpmYWxzZSwidGVuYW50SWQiOiIiLCJ1cmwiOiJodHRwOi8vbG9jYWxob3N0OjgwOTAvZmxvd2FibGUtd29yay9wcm9jZXNzLWFwaS9ydW50aW1lL3Byb2Nlc3MtaW5zdGFuY2VzL1BSQy00MTZiNjVhMS0wNzYzLTExZjEtOTE3Yi0yZWRmZWU0MzlkZTEiLCJ2YXJpYWJsZXMiOlt7Im5hbWUiOiJpbml0aWF0b3IiLCJzY29wZSI6ImxvY2FsIiwidHlwZSI6InN0cmluZyIsInZhbHVlIjoiYWRtaW4ifV19", + "responseContentType": "application/json", + "responseHeaders": { + "X-Content-Type-Options": [ + "nosniff" + ], + "X-XSS-Protection": [ + "0" + ], + "Cache-Control": [ + "no-store, must-revalidate, no-cache, max-age=0" + ], + "Pragma": [ + "no-cache" + ], + "X-Frame-Options": [ + "SAMEORIGIN" + ], + "Vary": [ + "accept-encoding" + ], + "Transfer-Encoding": [ + "chunked" + ], + "Date": [ + "Wed, 11 Feb 2026 16:03:50 GMT" + ] + } + }, + { + "method": "POST", + "uri": "http://localhost:8090/flowable-work/external-job-api/acquire/jobs", + "statusCode": 200, + "responseBody": "W3siY29ycmVsYXRpb25JZCI6IjQxNmMwMWVlLTA3NjMtMTFmMS05MTdiLTJlZGZlZTQzOWRlMSIsImNyZWF0ZVRpbWUiOiIyMDI2LTAyLTExVDE2OjAzOjUwLjU5NVoiLCJkdWVEYXRlIjpudWxsLCJlbGVtZW50SWQiOiJicG1uVGFza18zIiwiZWxlbWVudE5hbWUiOiJFeHRlcm5hbCBXb3JrZXIgdGFzayIsImV4Y2VwdGlvbk1lc3NhZ2UiOm51bGwsImV4ZWN1dGlvbklkIjoiUFJDLTQxNmI4Y2I0LTA3NjMtMTFmMS05MTdiLTJlZGZlZTQzOWRlMSIsImlkIjoiSk9CLTQxNmMwMWVmLTA3NjMtMTFmMS05MTdiLTJlZGZlZTQzOWRlMSIsImxvY2tFeHBpcmF0aW9uVGltZSI6IjIwMjYtMDItMTFUMTY6MDQ6MDAuNjc3WiIsImxvY2tPd25lciI6InRlc3Qtd29ya2VyIiwicHJvY2Vzc0RlZmluaXRpb25JZCI6IlBSQy1leHRlcm5hbFdvcmtlclByb2Nlc3M6Mzo0MTUyZmI5Zi0wNzYzLTExZjEtOTE3Yi0yZWRmZWU0MzlkZTEiLCJwcm9jZXNzSW5zdGFuY2VJZCI6IlBSQy00MTZiNjVhMS0wNzYzLTExZjEtOTE3Yi0yZWRmZWU0MzlkZTEiLCJyZXRyaWVzIjozLCJzY29wZURlZmluaXRpb25JZCI6bnVsbCwic2NvcGVJZCI6bnVsbCwic2NvcGVUeXBlIjpudWxsLCJzdWJTY29wZUlkIjpudWxsLCJ0ZW5hbnRJZCI6IiIsInVybCI6Imh0dHA6Ly9sb2NhbGhvc3Q6ODA5MC9mbG93YWJsZS13b3JrL2V4dGVybmFsLWpvYi1hcGkvam9icy9KT0ItNDE2YzAxZWYtMDc2My0xMWYxLTkxN2ItMmVkZmVlNDM5ZGUxIiwidmFyaWFibGVzIjpbeyJuYW1lIjoiaW5pdGlhdG9yIiwidHlwZSI6InN0cmluZyIsInZhbHVlIjoiYWRtaW4ifV19XQ==", + "responseContentType": "application/json", + "responseHeaders": { + "X-Content-Type-Options": [ + "nosniff" + ], + "X-XSS-Protection": [ + "0" + ], + "Cache-Control": [ + "no-store, must-revalidate, no-cache, max-age=0" + ], + "Pragma": [ + "no-cache" + ], + "X-Frame-Options": [ + "SAMEORIGIN" + ], + "Vary": [ + "accept-encoding" + ], + "Transfer-Encoding": [ + "chunked" + ], + "Date": [ + "Wed, 11 Feb 2026 16:03:50 GMT" + ] + } + }, + { + "method": "POST", + "uri": "http://localhost:8090/flowable-work/external-job-api/acquire/jobs/JOB-416c01ef-0763-11f1-917b-2edfee439de1/bpmnError", + "statusCode": 204, + "responseBody": "", + "responseContentType": null, + "responseHeaders": { + "X-Content-Type-Options": [ + "nosniff" + ], + "X-XSS-Protection": [ + "0" + ], + "Cache-Control": [ + "no-store, must-revalidate, no-cache, max-age=0" + ], + "Pragma": [ + "no-cache" + ], + "X-Frame-Options": [ + "SAMEORIGIN" + ], + "Date": [ + "Wed, 11 Feb 2026 16:03:50 GMT" + ] + } + }, + { + "method": "GET", + "uri": "http://localhost:8090/flowable-work/process-api/history/historic-variable-instances?processInstanceId=PRC-416b65a1-0763-11f1-917b-2edfee439de1\u0026variableName=testVar", + "statusCode": 200, + "responseBody": "eyJkYXRhIjpbeyJleGVjdXRpb25JZCI6IlBSQy00MTZiNjVhMS0wNzYzLTExZjEtOTE3Yi0yZWRmZWU0MzlkZTEiLCJpZCI6IlZBUi00MTg2OGVkMy0wNzYzLTExZjEtOTE3Yi0yZWRmZWU0MzlkZTEiLCJwcm9jZXNzSW5zdGFuY2VJZCI6IlBSQy00MTZiNjVhMS0wNzYzLTExZjEtOTE3Yi0yZWRmZWU0MzlkZTEiLCJwcm9jZXNzSW5zdGFuY2VVcmwiOiJodHRwOi8vbG9jYWxob3N0OjgwOTAvZmxvd2FibGUtd29yay9wcm9jZXNzLWFwaS9oaXN0b3J5L2hpc3RvcmljLXByb2Nlc3MtaW5zdGFuY2VzL1BSQy00MTZiNjVhMS0wNzYzLTExZjEtOTE3Yi0yZWRmZWU0MzlkZTEiLCJ0YXNrSWQiOm51bGwsInZhcmlhYmxlIjp7Im5hbWUiOiJ0ZXN0VmFyIiwic2NvcGUiOiJnbG9iYWwiLCJ0eXBlIjoic3RyaW5nIiwidmFsdWUiOiJ0ZXN0IGZhaWx1cmUifX1dLCJvcmRlciI6ImFzYyIsInNpemUiOjEsInNvcnQiOiJ2YXJpYWJsZU5hbWUiLCJzdGFydCI6MCwidG90YWwiOjF9", + "responseContentType": "application/json", + "responseHeaders": { + "X-Content-Type-Options": [ + "nosniff" + ], + "X-XSS-Protection": [ + "0" + ], + "Cache-Control": [ + "no-store, must-revalidate, no-cache, max-age=0" + ], + "Pragma": [ + "no-cache" + ], + "X-Frame-Options": [ + "SAMEORIGIN" + ], + "Vary": [ + "accept-encoding" + ], + "Transfer-Encoding": [ + "chunked" + ], + "Date": [ + "Wed, 11 Feb 2026 16:03:50 GMT" + ] + } + }, + { + "method": "GET", + "uri": "http://localhost:8090/flowable-work/process-api/history/historic-activity-instances?processInstanceId=PRC-416b65a1-0763-11f1-917b-2edfee439de1", + "statusCode": 200, + "responseBody": "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", + "responseContentType": "application/json", + "responseHeaders": { + "X-Content-Type-Options": [ + "nosniff" + ], + "X-XSS-Protection": [ + "0" + ], + "Cache-Control": [ + "no-store, must-revalidate, no-cache, max-age=0" + ], + "Pragma": [ + "no-cache" + ], + "X-Frame-Options": [ + "SAMEORIGIN" + ], + "Vary": [ + "accept-encoding" + ], + "Transfer-Encoding": [ + "chunked" + ], + "Date": [ + "Wed, 11 Feb 2026 16:03:50 GMT" + ] + } + }, + { + "method": "DELETE", + "uri": "http://localhost:8090/flowable-work/process-api/repository/deployments/PRC-4151c31d-0763-11f1-917b-2edfee439de1", + "statusCode": 204, + "responseBody": "", + "responseContentType": null, + "responseHeaders": { + "X-Content-Type-Options": [ + "nosniff" + ], + "X-XSS-Protection": [ + "0" + ], + "Cache-Control": [ + "no-store, must-revalidate, no-cache, max-age=0" + ], + "Pragma": [ + "no-cache" + ], + "X-Frame-Options": [ + "SAMEORIGIN" + ], + "Date": [ + "Wed, 11 Feb 2026 16:03:50 GMT" + ] + } + } +] \ No newline at end of file diff --git a/FlowableExternalWorkerClient.Tests/Fixtures/Cassettes/TestJobWithCmmnTerminate.json b/FlowableExternalWorkerClient.Tests/Fixtures/Cassettes/TestJobWithCmmnTerminate.json new file mode 100644 index 0000000..32da8fd --- /dev/null +++ b/FlowableExternalWorkerClient.Tests/Fixtures/Cassettes/TestJobWithCmmnTerminate.json @@ -0,0 +1,224 @@ +[ + { + "method": "POST", + "uri": "http://localhost:8090/flowable-work/cmmn-api/cmmn-repository/deployments", + "statusCode": 201, + "responseBody": "eyJ1cmwiOiJodHRwOi8vbG9jYWxob3N0OjgwOTAvZmxvd2FibGUtd29yay9jbW1uLWFwaS9jbW1uLXJlcG9zaXRvcnkvZGVwbG95bWVudHMvQ0FTLTQwZjFlZmNiLTA3NjMtMTFmMS05MTdiLTJlZGZlZTQzOWRlMSIsImNhdGVnb3J5IjpudWxsLCJkZXBsb3ltZW50VGltZSI6IjIwMjYtMDItMTFUMTY6MDM6NDkuNzk1WiIsImlkIjoiQ0FTLTQwZjFlZmNiLTA3NjMtMTFmMS05MTdiLTJlZGZlZTQzOWRlMSIsIm5hbWUiOiJleHRlcm5hbFdvcmtlckNhc2UiLCJwYXJlbnREZXBsb3ltZW50SWQiOiJDQVMtNDBmMWVmY2ItMDc2My0xMWYxLTkxN2ItMmVkZmVlNDM5ZGUxIiwidGVuYW50SWQiOiIifQ==", + "responseContentType": "application/json", + "responseHeaders": { + "Set-Cookie": [ + "XSRF-TOKEN=4f4ddcee-00a4-4c6f-8445-d0d1c85ada0e; Path=/flowable-work" + ], + "X-Content-Type-Options": [ + "nosniff" + ], + "X-XSS-Protection": [ + "0" + ], + "Cache-Control": [ + "no-store, must-revalidate, no-cache, max-age=0" + ], + "Pragma": [ + "no-cache" + ], + "X-Frame-Options": [ + "SAMEORIGIN" + ], + "Vary": [ + "accept-encoding" + ], + "Transfer-Encoding": [ + "chunked" + ], + "Date": [ + "Wed, 11 Feb 2026 16:03:49 GMT" + ] + } + }, + { + "method": "GET", + "uri": "http://localhost:8090/flowable-work/cmmn-api/cmmn-repository/case-definitions?deploymentId=CAS-40f1efcb-0763-11f1-917b-2edfee439de1", + "statusCode": 200, + "responseBody": "eyJkYXRhIjpbeyJjYXRlZ29yeSI6Imh0dHA6Ly9mbG93YWJsZS5vcmcvY21tbiIsImRlcGxveW1lbnRJZCI6IkNBUy00MGYxZWZjYi0wNzYzLTExZjEtOTE3Yi0yZWRmZWU0MzlkZTEiLCJkZXBsb3ltZW50VXJsIjoiaHR0cDovL2xvY2FsaG9zdDo4MDkwL2Zsb3dhYmxlLXdvcmsvY21tbi1hcGkvY21tbi1yZXBvc2l0b3J5L2RlcGxveW1lbnRzL0NBUy00MGYxZWZjYi0wNzYzLTExZjEtOTE3Yi0yZWRmZWU0MzlkZTEiLCJkZXNjcmlwdGlvbiI6bnVsbCwiZGlhZ3JhbVJlc291cmNlIjpudWxsLCJncmFwaGljYWxOb3RhdGlvbkRlZmluZWQiOnRydWUsImlkIjoiQ0FTLTQwZjM0ZjVkLTA3NjMtMTFmMS05MTdiLTJlZGZlZTQzOWRlMSIsImtleSI6ImV4dGVybmFsV29ya2VyQ2FzZSIsIm5hbWUiOiJFeHRlcm5hbCBXb3JrZXIgQ2FzZSIsInJlc291cmNlIjoiaHR0cDovL2xvY2FsaG9zdDo4MDkwL2Zsb3dhYmxlLXdvcmsvY21tbi1hcGkvY21tbi1yZXBvc2l0b3J5L2RlcGxveW1lbnRzL0NBUy00MGYxZWZjYi0wNzYzLTExZjEtOTE3Yi0yZWRmZWU0MzlkZTEvcmVzb3VyY2VzL2V4dGVybmFsV29ya2VyQ2FzZS5jbW1uIiwic3RhcnRGb3JtRGVmaW5lZCI6ZmFsc2UsInRlbmFudElkIjoiIiwidXJsIjoiaHR0cDovL2xvY2FsaG9zdDo4MDkwL2Zsb3dhYmxlLXdvcmsvY21tbi1hcGkvY21tbi1yZXBvc2l0b3J5L2Nhc2UtZGVmaW5pdGlvbnMvQ0FTLTQwZjM0ZjVkLTA3NjMtMTFmMS05MTdiLTJlZGZlZTQzOWRlMSIsInZlcnNpb24iOjF9XSwib3JkZXIiOiJhc2MiLCJzaXplIjoxLCJzb3J0IjoibmFtZSIsInN0YXJ0IjowLCJ0b3RhbCI6MX0=", + "responseContentType": "application/json", + "responseHeaders": { + "X-Content-Type-Options": [ + "nosniff" + ], + "X-XSS-Protection": [ + "0" + ], + "Cache-Control": [ + "no-store, must-revalidate, no-cache, max-age=0" + ], + "Pragma": [ + "no-cache" + ], + "X-Frame-Options": [ + "SAMEORIGIN" + ], + "Vary": [ + "accept-encoding" + ], + "Transfer-Encoding": [ + "chunked" + ], + "Date": [ + "Wed, 11 Feb 2026 16:03:49 GMT" + ] + } + }, + { + "method": "POST", + "uri": "http://localhost:8090/flowable-work/cmmn-api/cmmn-runtime/case-instances", + "statusCode": 201, + "responseBody": "eyJidXNpbmVzc0tleSI6bnVsbCwiYnVzaW5lc3NTdGF0dXMiOm51bGwsImNhbGxiYWNrSWQiOm51bGwsImNhbGxiYWNrVHlwZSI6bnVsbCwiY2FzZURlZmluaXRpb25EZXNjcmlwdGlvbiI6bnVsbCwiY2FzZURlZmluaXRpb25JZCI6IkNBUy00MGYzNGY1ZC0wNzYzLTExZjEtOTE3Yi0yZWRmZWU0MzlkZTEiLCJjYXNlRGVmaW5pdGlvbk5hbWUiOiJFeHRlcm5hbCBXb3JrZXIgQ2FzZSIsImNhc2VEZWZpbml0aW9uVXJsIjoiaHR0cDovL2xvY2FsaG9zdDo4MDkwL2Zsb3dhYmxlLXdvcmsvY21tbi1hcGkvY21tbi1yZXBvc2l0b3J5L2Nhc2UtZGVmaW5pdGlvbnMvQ0FTLTQwZjM0ZjVkLTA3NjMtMTFmMS05MTdiLTJlZGZlZTQzOWRlMSIsImNvbXBsZXRlZCI6ZmFsc2UsImVuZGVkIjpmYWxzZSwiaWQiOiJDQVMtNDEwZTAzNGYtMDc2My0xMWYxLTkxN2ItMmVkZmVlNDM5ZGUxIiwibmFtZSI6bnVsbCwicGFyZW50SWQiOm51bGwsInJlZmVyZW5jZUlkIjpudWxsLCJyZWZlcmVuY2VUeXBlIjpudWxsLCJzdGFydFRpbWUiOiIyMDI2LTAyLTExVDE2OjAzOjQ5Ljk3OVoiLCJzdGFydFVzZXJJZCI6ImFkbWluIiwic3RhdGUiOiJhY3RpdmUiLCJ0ZW5hbnRJZCI6IiIsInVybCI6Imh0dHA6Ly9sb2NhbGhvc3Q6ODA5MC9mbG93YWJsZS13b3JrL2NtbW4tYXBpL2NtbW4tcnVudGltZS9jYXNlLWluc3RhbmNlcy9DQVMtNDEwZTAzNGYtMDc2My0xMWYxLTkxN2ItMmVkZmVlNDM5ZGUxIiwidmFyaWFibGVzIjpbeyJuYW1lIjoiaW5pdGlhdG9yIiwic2NvcGUiOiJsb2NhbCIsInR5cGUiOiJzdHJpbmciLCJ2YWx1ZSI6ImFkbWluIn1dfQ==", + "responseContentType": "application/json", + "responseHeaders": { + "X-Content-Type-Options": [ + "nosniff" + ], + "X-XSS-Protection": [ + "0" + ], + "Cache-Control": [ + "no-store, must-revalidate, no-cache, max-age=0" + ], + "Pragma": [ + "no-cache" + ], + "X-Frame-Options": [ + "SAMEORIGIN" + ], + "Vary": [ + "accept-encoding" + ], + "Transfer-Encoding": [ + "chunked" + ], + "Date": [ + "Wed, 11 Feb 2026 16:03:50 GMT" + ] + } + }, + { + "method": "POST", + "uri": "http://localhost:8090/flowable-work/external-job-api/acquire/jobs", + "statusCode": 200, + "responseBody": "W3siY29ycmVsYXRpb25JZCI6IjQxMTAyNjM1LTA3NjMtMTFmMS05MTdiLTJlZGZlZTQzOWRlMSIsImNyZWF0ZVRpbWUiOiIyMDI2LTAyLTExVDE2OjAzOjQ5Ljk5M1oiLCJkdWVEYXRlIjpudWxsLCJlbGVtZW50SWQiOiJjbW1uVGFza18xIiwiZWxlbWVudE5hbWUiOiJFeHRlcm5hbCBXb3JrZXIgdGFzayIsImV4Y2VwdGlvbk1lc3NhZ2UiOm51bGwsImV4ZWN1dGlvbklkIjpudWxsLCJpZCI6IkpPQi00MTEwMjYzNi0wNzYzLTExZjEtOTE3Yi0yZWRmZWU0MzlkZTEiLCJsb2NrRXhwaXJhdGlvblRpbWUiOiIyMDI2LTAyLTExVDE2OjA0OjAwLjA4N1oiLCJsb2NrT3duZXIiOiJ0ZXN0LXdvcmtlciIsInByb2Nlc3NEZWZpbml0aW9uSWQiOm51bGwsInByb2Nlc3NJbnN0YW5jZUlkIjpudWxsLCJyZXRyaWVzIjozLCJzY29wZURlZmluaXRpb25JZCI6IkNBUy00MGYzNGY1ZC0wNzYzLTExZjEtOTE3Yi0yZWRmZWU0MzlkZTEiLCJzY29wZUlkIjoiQ0FTLTQxMGUwMzRmLTA3NjMtMTFmMS05MTdiLTJlZGZlZTQzOWRlMSIsInNjb3BlVHlwZSI6ImNtbW4iLCJzdWJTY29wZUlkIjoiQ0FTLTQxMGY4OWY0LTA3NjMtMTFmMS05MTdiLTJlZGZlZTQzOWRlMSIsInRlbmFudElkIjoiIiwidXJsIjoiaHR0cDovL2xvY2FsaG9zdDo4MDkwL2Zsb3dhYmxlLXdvcmsvZXh0ZXJuYWwtam9iLWFwaS9qb2JzL0pPQi00MTEwMjYzNi0wNzYzLTExZjEtOTE3Yi0yZWRmZWU0MzlkZTEiLCJ2YXJpYWJsZXMiOlt7Im5hbWUiOiJpbml0aWF0b3IiLCJ0eXBlIjoic3RyaW5nIiwidmFsdWUiOiJhZG1pbiJ9XX1d", + "responseContentType": "application/json", + "responseHeaders": { + "X-Content-Type-Options": [ + "nosniff" + ], + "X-XSS-Protection": [ + "0" + ], + "Cache-Control": [ + "no-store, must-revalidate, no-cache, max-age=0" + ], + "Pragma": [ + "no-cache" + ], + "X-Frame-Options": [ + "SAMEORIGIN" + ], + "Vary": [ + "accept-encoding" + ], + "Transfer-Encoding": [ + "chunked" + ], + "Date": [ + "Wed, 11 Feb 2026 16:03:50 GMT" + ] + } + }, + { + "method": "POST", + "uri": "http://localhost:8090/flowable-work/external-job-api/acquire/jobs/JOB-41102636-0763-11f1-917b-2edfee439de1/cmmnTerminate", + "statusCode": 204, + "responseBody": "", + "responseContentType": null, + "responseHeaders": { + "X-Content-Type-Options": [ + "nosniff" + ], + "X-XSS-Protection": [ + "0" + ], + "Cache-Control": [ + "no-store, must-revalidate, no-cache, max-age=0" + ], + "Pragma": [ + "no-cache" + ], + "X-Frame-Options": [ + "SAMEORIGIN" + ], + "Date": [ + "Wed, 11 Feb 2026 16:03:50 GMT" + ] + } + }, + { + "method": "GET", + "uri": "http://localhost:8090/flowable-work/cmmn-api/cmmn-history/historic-variable-instances?caseInstanceId=CAS-410e034f-0763-11f1-917b-2edfee439de1\u0026variableName=testVar", + "statusCode": 200, + "responseBody": "eyJkYXRhIjpbeyJjYXNlSW5zdGFuY2VJZCI6IkNBUy00MTBlMDM0Zi0wNzYzLTExZjEtOTE3Yi0yZWRmZWU0MzlkZTEiLCJjYXNlSW5zdGFuY2VVcmwiOiJodHRwOi8vbG9jYWxob3N0OjgwOTAvZmxvd2FibGUtd29yay9jbW1uLWFwaS9jbW1uLWhpc3RvcnkvaGlzdG9yaWMtY2FzZS1pbnN0YW5jZXMvQ0FTLTQxMGUwMzRmLTA3NjMtMTFmMS05MTdiLTJlZGZlZTQzOWRlMSIsImlkIjoiVkFSLTQxMmQyNDFhLTA3NjMtMTFmMS05MTdiLTJlZGZlZTQzOWRlMSIsInBsYW5JdGVtSW5zdGFuY2VJZCI6bnVsbCwidGFza0lkIjpudWxsLCJ2YXJpYWJsZSI6eyJuYW1lIjoidGVzdFZhciIsInNjb3BlIjoiZ2xvYmFsIiwidHlwZSI6InN0cmluZyIsInZhbHVlIjoidGVzdCB0ZXJtaW5hdGUifX1dLCJvcmRlciI6ImFzYyIsInNpemUiOjEsInNvcnQiOiJ2YXJpYWJsZU5hbWUiLCJzdGFydCI6MCwidG90YWwiOjF9", + "responseContentType": "application/json", + "responseHeaders": { + "X-Content-Type-Options": [ + "nosniff" + ], + "X-XSS-Protection": [ + "0" + ], + "Cache-Control": [ + "no-store, must-revalidate, no-cache, max-age=0" + ], + "Pragma": [ + "no-cache" + ], + "X-Frame-Options": [ + "SAMEORIGIN" + ], + "Vary": [ + "accept-encoding" + ], + "Transfer-Encoding": [ + "chunked" + ], + "Date": [ + "Wed, 11 Feb 2026 16:03:50 GMT" + ] + } + }, + { + "method": "DELETE", + "uri": "http://localhost:8090/flowable-work/cmmn-api/cmmn-repository/deployments/CAS-40f1efcb-0763-11f1-917b-2edfee439de1", + "statusCode": 204, + "responseBody": "", + "responseContentType": null, + "responseHeaders": { + "X-Content-Type-Options": [ + "nosniff" + ], + "X-XSS-Protection": [ + "0" + ], + "Cache-Control": [ + "no-store, must-revalidate, no-cache, max-age=0" + ], + "Pragma": [ + "no-cache" + ], + "X-Frame-Options": [ + "SAMEORIGIN" + ], + "Date": [ + "Wed, 11 Feb 2026 16:03:50 GMT" + ] + } + } +] \ No newline at end of file diff --git a/FlowableExternalWorkerClient.Tests/Fixtures/Cassettes/TestListJobs.json b/FlowableExternalWorkerClient.Tests/Fixtures/Cassettes/TestListJobs.json new file mode 100644 index 0000000..da5afba --- /dev/null +++ b/FlowableExternalWorkerClient.Tests/Fixtures/Cassettes/TestListJobs.json @@ -0,0 +1,191 @@ +[ + { + "method": "POST", + "uri": "http://localhost:8090/flowable-work/process-api/repository/deployments", + "statusCode": 201, + "responseBody": "eyJ1cmwiOiJodHRwOi8vbG9jYWxob3N0OjgwOTAvZmxvd2FibGUtd29yay9wcm9jZXNzLWFwaS9yZXBvc2l0b3J5L2RlcGxveW1lbnRzL1BSQy0zZWFkMmY3MS0wNzYzLTExZjEtOTE3Yi0yZWRmZWU0MzlkZTEiLCJjYXRlZ29yeSI6bnVsbCwiZGVwbG95bWVudFRpbWUiOiIyMDI2LTAyLTExVDE2OjAzOjQ1Ljk4OVoiLCJpZCI6IlBSQy0zZWFkMmY3MS0wNzYzLTExZjEtOTE3Yi0yZWRmZWU0MzlkZTEiLCJuYW1lIjoiZXh0ZXJuYWxXb3JrZXJQcm9jZXNzIiwicGFyZW50RGVwbG95bWVudElkIjoiUFJDLTNlYWQyZjcxLTA3NjMtMTFmMS05MTdiLTJlZGZlZTQzOWRlMSIsInRlbmFudElkIjoiIn0=", + "responseContentType": "application/json", + "responseHeaders": { + "Set-Cookie": [ + "XSRF-TOKEN=6103465d-1c3a-49b0-85a4-1d6c1495304f; Path=/flowable-work" + ], + "X-Content-Type-Options": [ + "nosniff" + ], + "X-XSS-Protection": [ + "0" + ], + "Cache-Control": [ + "no-store, must-revalidate, no-cache, max-age=0" + ], + "Pragma": [ + "no-cache" + ], + "X-Frame-Options": [ + "SAMEORIGIN" + ], + "Vary": [ + "accept-encoding" + ], + "Transfer-Encoding": [ + "chunked" + ], + "Date": [ + "Wed, 11 Feb 2026 16:03:46 GMT" + ] + } + }, + { + "method": "GET", + "uri": "http://localhost:8090/flowable-work/process-api/repository/process-definitions?deploymentId=PRC-3ead2f71-0763-11f1-917b-2edfee439de1", + "statusCode": 200, + "responseBody": "eyJkYXRhIjpbeyJjYXRlZ29yeSI6Imh0dHA6Ly9mbG93YWJsZS5vcmcvdGVzdCIsImRlcGxveW1lbnRJZCI6IlBSQy0zZWFkMmY3MS0wNzYzLTExZjEtOTE3Yi0yZWRmZWU0MzlkZTEiLCJkZXBsb3ltZW50VXJsIjoiaHR0cDovL2xvY2FsaG9zdDo4MDkwL2Zsb3dhYmxlLXdvcmsvcHJvY2Vzcy1hcGkvcmVwb3NpdG9yeS9kZXBsb3ltZW50cy9QUkMtM2VhZDJmNzEtMDc2My0xMWYxLTkxN2ItMmVkZmVlNDM5ZGUxIiwiZGVzY3JpcHRpb24iOm51bGwsImRpYWdyYW1SZXNvdXJjZSI6bnVsbCwiZ3JhcGhpY2FsTm90YXRpb25EZWZpbmVkIjp0cnVlLCJpZCI6IlBSQy1leHRlcm5hbFdvcmtlclByb2Nlc3M6MzozZWI2MDkxMy0wNzYzLTExZjEtOTE3Yi0yZWRmZWU0MzlkZTEiLCJrZXkiOiJleHRlcm5hbFdvcmtlclByb2Nlc3MiLCJuYW1lIjoiRXh0ZXJuYWwgV29ya2VyIFByb2Nlc3MiLCJyZXNvdXJjZSI6Imh0dHA6Ly9sb2NhbGhvc3Q6ODA5MC9mbG93YWJsZS13b3JrL3Byb2Nlc3MtYXBpL3JlcG9zaXRvcnkvZGVwbG95bWVudHMvUFJDLTNlYWQyZjcxLTA3NjMtMTFmMS05MTdiLTJlZGZlZTQzOWRlMS9yZXNvdXJjZXMvZXh0ZXJuYWxXb3JrZXJQcm9jZXNzLmJwbW4iLCJzdGFydEZvcm1EZWZpbmVkIjpmYWxzZSwic3VzcGVuZGVkIjpmYWxzZSwidGVuYW50SWQiOiIiLCJ1cmwiOiJodHRwOi8vbG9jYWxob3N0OjgwOTAvZmxvd2FibGUtd29yay9wcm9jZXNzLWFwaS9yZXBvc2l0b3J5L3Byb2Nlc3MtZGVmaW5pdGlvbnMvUFJDLWV4dGVybmFsV29ya2VyUHJvY2VzczozOjNlYjYwOTEzLTA3NjMtMTFmMS05MTdiLTJlZGZlZTQzOWRlMSIsInZlcnNpb24iOjN9XSwib3JkZXIiOiJhc2MiLCJzaXplIjoxLCJzb3J0IjoibmFtZSIsInN0YXJ0IjowLCJ0b3RhbCI6MX0=", + "responseContentType": "application/json", + "responseHeaders": { + "X-Content-Type-Options": [ + "nosniff" + ], + "X-XSS-Protection": [ + "0" + ], + "Cache-Control": [ + "no-store, must-revalidate, no-cache, max-age=0" + ], + "Pragma": [ + "no-cache" + ], + "X-Frame-Options": [ + "SAMEORIGIN" + ], + "Vary": [ + "accept-encoding" + ], + "Transfer-Encoding": [ + "chunked" + ], + "Date": [ + "Wed, 11 Feb 2026 16:03:46 GMT" + ] + } + }, + { + "method": "POST", + "uri": "http://localhost:8090/flowable-work/process-api/runtime/process-instances", + "statusCode": 201, + "responseBody": "eyJhY3Rpdml0eUlkIjpudWxsLCJidXNpbmVzc0tleSI6bnVsbCwiYnVzaW5lc3NTdGF0dXMiOm51bGwsImNhbGxiYWNrSWQiOm51bGwsImNhbGxiYWNrVHlwZSI6bnVsbCwiY29tcGxldGVkIjpmYWxzZSwiZW5kZWQiOmZhbHNlLCJpZCI6IlBSQy0zZWQyZGZlNS0wNzYzLTExZjEtOTE3Yi0yZWRmZWU0MzlkZTEiLCJuYW1lIjpudWxsLCJwcm9jZXNzRGVmaW5pdGlvbkRlc2NyaXB0aW9uIjpudWxsLCJwcm9jZXNzRGVmaW5pdGlvbklkIjoiUFJDLWV4dGVybmFsV29ya2VyUHJvY2VzczozOjNlYjYwOTEzLTA3NjMtMTFmMS05MTdiLTJlZGZlZTQzOWRlMSIsInByb2Nlc3NEZWZpbml0aW9uTmFtZSI6IkV4dGVybmFsIFdvcmtlciBQcm9jZXNzIiwicHJvY2Vzc0RlZmluaXRpb25VcmwiOiJodHRwOi8vbG9jYWxob3N0OjgwOTAvZmxvd2FibGUtd29yay9wcm9jZXNzLWFwaS9yZXBvc2l0b3J5L3Byb2Nlc3MtZGVmaW5pdGlvbnMvUFJDLWV4dGVybmFsV29ya2VyUHJvY2VzczozOjNlYjYwOTEzLTA3NjMtMTFmMS05MTdiLTJlZGZlZTQzOWRlMSIsInByb3BhZ2F0ZWRTdGFnZUluc3RhbmNlSWQiOm51bGwsInJlZmVyZW5jZUlkIjpudWxsLCJyZWZlcmVuY2VUeXBlIjpudWxsLCJzdGFydFRpbWUiOiIyMDI2LTAyLTExVDE2OjAzOjQ2LjIzNloiLCJzdGFydFVzZXJJZCI6ImFkbWluIiwic3VwZXJQcm9jZXNzSW5zdGFuY2VJZCI6bnVsbCwic3VzcGVuZGVkIjpmYWxzZSwidGVuYW50SWQiOiIiLCJ1cmwiOiJodHRwOi8vbG9jYWxob3N0OjgwOTAvZmxvd2FibGUtd29yay9wcm9jZXNzLWFwaS9ydW50aW1lL3Byb2Nlc3MtaW5zdGFuY2VzL1BSQy0zZWQyZGZlNS0wNzYzLTExZjEtOTE3Yi0yZWRmZWU0MzlkZTEiLCJ2YXJpYWJsZXMiOlt7Im5hbWUiOiJpbml0aWF0b3IiLCJzY29wZSI6ImxvY2FsIiwidHlwZSI6InN0cmluZyIsInZhbHVlIjoiYWRtaW4ifV19", + "responseContentType": "application/json", + "responseHeaders": { + "X-Content-Type-Options": [ + "nosniff" + ], + "X-XSS-Protection": [ + "0" + ], + "Cache-Control": [ + "no-store, must-revalidate, no-cache, max-age=0" + ], + "Pragma": [ + "no-cache" + ], + "X-Frame-Options": [ + "SAMEORIGIN" + ], + "Vary": [ + "accept-encoding" + ], + "Transfer-Encoding": [ + "chunked" + ], + "Date": [ + "Wed, 11 Feb 2026 16:03:46 GMT" + ] + } + }, + { + "method": "GET", + "uri": "http://localhost:8090/flowable-work/external-job-api/jobs", + "statusCode": 200, + "responseBody": "eyJkYXRhIjpbeyJjb3JyZWxhdGlvbklkIjoiM2VkOGQzNWUtMDc2My0xMWYxLTkxN2ItMmVkZmVlNDM5ZGUxIiwiY3JlYXRlVGltZSI6IjIwMjYtMDItMTFUMTY6MDM6NDYuMjc1WiIsImR1ZURhdGUiOm51bGwsImVsZW1lbnRJZCI6ImJwbW5UYXNrXzMiLCJlbGVtZW50TmFtZSI6IkV4dGVybmFsIFdvcmtlciB0YXNrIiwiZXhjZXB0aW9uTWVzc2FnZSI6bnVsbCwiZXhlY3V0aW9uSWQiOiJQUkMtM2VkNTc3ZjgtMDc2My0xMWYxLTkxN2ItMmVkZmVlNDM5ZGUxIiwiaWQiOiJKT0ItM2VkOGQzNWYtMDc2My0xMWYxLTkxN2ItMmVkZmVlNDM5ZGUxIiwibG9ja0V4cGlyYXRpb25UaW1lIjpudWxsLCJsb2NrT3duZXIiOm51bGwsInByb2Nlc3NEZWZpbml0aW9uSWQiOiJQUkMtZXh0ZXJuYWxXb3JrZXJQcm9jZXNzOjM6M2ViNjA5MTMtMDc2My0xMWYxLTkxN2ItMmVkZmVlNDM5ZGUxIiwicHJvY2Vzc0luc3RhbmNlSWQiOiJQUkMtM2VkMmRmZTUtMDc2My0xMWYxLTkxN2ItMmVkZmVlNDM5ZGUxIiwicmV0cmllcyI6Mywic2NvcGVEZWZpbml0aW9uSWQiOm51bGwsInNjb3BlSWQiOm51bGwsInNjb3BlVHlwZSI6bnVsbCwic3ViU2NvcGVJZCI6bnVsbCwidGVuYW50SWQiOiIiLCJ1cmwiOiJodHRwOi8vbG9jYWxob3N0OjgwOTAvZmxvd2FibGUtd29yay9leHRlcm5hbC1qb2ItYXBpL2pvYnMvSk9CLTNlZDhkMzVmLTA3NjMtMTFmMS05MTdiLTJlZGZlZTQzOWRlMSJ9XSwib3JkZXIiOiJhc2MiLCJzaXplIjoxLCJzb3J0IjoiaWQiLCJzdGFydCI6MCwidG90YWwiOjF9", + "responseContentType": "application/json", + "responseHeaders": { + "X-Content-Type-Options": [ + "nosniff" + ], + "X-XSS-Protection": [ + "0" + ], + "Cache-Control": [ + "no-store, must-revalidate, no-cache, max-age=0" + ], + "Pragma": [ + "no-cache" + ], + "X-Frame-Options": [ + "SAMEORIGIN" + ], + "Vary": [ + "accept-encoding" + ], + "Transfer-Encoding": [ + "chunked" + ], + "Date": [ + "Wed, 11 Feb 2026 16:03:46 GMT" + ] + } + }, + { + "method": "DELETE", + "uri": "http://localhost:8090/flowable-work/process-api/runtime/process-instances/PRC-3ed2dfe5-0763-11f1-917b-2edfee439de1", + "statusCode": 204, + "responseBody": "", + "responseContentType": null, + "responseHeaders": { + "X-Content-Type-Options": [ + "nosniff" + ], + "X-XSS-Protection": [ + "0" + ], + "Cache-Control": [ + "no-store, must-revalidate, no-cache, max-age=0" + ], + "Pragma": [ + "no-cache" + ], + "X-Frame-Options": [ + "SAMEORIGIN" + ], + "Date": [ + "Wed, 11 Feb 2026 16:03:46 GMT" + ] + } + }, + { + "method": "DELETE", + "uri": "http://localhost:8090/flowable-work/process-api/repository/deployments/PRC-3ead2f71-0763-11f1-917b-2edfee439de1", + "statusCode": 204, + "responseBody": "", + "responseContentType": null, + "responseHeaders": { + "X-Content-Type-Options": [ + "nosniff" + ], + "X-XSS-Protection": [ + "0" + ], + "Cache-Control": [ + "no-store, must-revalidate, no-cache, max-age=0" + ], + "Pragma": [ + "no-cache" + ], + "X-Frame-Options": [ + "SAMEORIGIN" + ], + "Date": [ + "Wed, 11 Feb 2026 16:03:46 GMT" + ] + } + } +] \ No newline at end of file diff --git a/FlowableExternalWorkerClient.Tests/Fixtures/Cassettes/TestListJobsInvalidAuth.json b/FlowableExternalWorkerClient.Tests/Fixtures/Cassettes/TestListJobsInvalidAuth.json new file mode 100644 index 0000000..81209ef --- /dev/null +++ b/FlowableExternalWorkerClient.Tests/Fixtures/Cassettes/TestListJobsInvalidAuth.json @@ -0,0 +1,192 @@ +[ + { + "method": "POST", + "uri": "http://localhost:8090/flowable-work/process-api/repository/deployments", + "statusCode": 201, + "responseBody": "eyJ1cmwiOiJodHRwOi8vbG9jYWxob3N0OjgwOTAvZmxvd2FibGUtd29yay9wcm9jZXNzLWFwaS9yZXBvc2l0b3J5L2RlcGxveW1lbnRzL1BSQy0zZjkzZTYxNy0wNzYzLTExZjEtOTE3Yi0yZWRmZWU0MzlkZTEiLCJjYXRlZ29yeSI6bnVsbCwiZGVwbG95bWVudFRpbWUiOiIyMDI2LTAyLTExVDE2OjAzOjQ3LjUwMVoiLCJpZCI6IlBSQy0zZjkzZTYxNy0wNzYzLTExZjEtOTE3Yi0yZWRmZWU0MzlkZTEiLCJuYW1lIjoiZXh0ZXJuYWxXb3JrZXJQcm9jZXNzIiwicGFyZW50RGVwbG95bWVudElkIjoiUFJDLTNmOTNlNjE3LTA3NjMtMTFmMS05MTdiLTJlZGZlZTQzOWRlMSIsInRlbmFudElkIjoiIn0=", + "responseContentType": "application/json", + "responseHeaders": { + "Set-Cookie": [ + "XSRF-TOKEN=851aa146-e4c3-45de-9f4a-8cc98399c2e7; Path=/flowable-work" + ], + "X-Content-Type-Options": [ + "nosniff" + ], + "X-XSS-Protection": [ + "0" + ], + "Cache-Control": [ + "no-store, must-revalidate, no-cache, max-age=0" + ], + "Pragma": [ + "no-cache" + ], + "X-Frame-Options": [ + "SAMEORIGIN" + ], + "Vary": [ + "accept-encoding" + ], + "Transfer-Encoding": [ + "chunked" + ], + "Date": [ + "Wed, 11 Feb 2026 16:03:47 GMT" + ] + } + }, + { + "method": "GET", + "uri": "http://localhost:8090/flowable-work/process-api/repository/process-definitions?deploymentId=PRC-3f93e617-0763-11f1-917b-2edfee439de1", + "statusCode": 200, + "responseBody": "eyJkYXRhIjpbeyJjYXRlZ29yeSI6Imh0dHA6Ly9mbG93YWJsZS5vcmcvdGVzdCIsImRlcGxveW1lbnRJZCI6IlBSQy0zZjkzZTYxNy0wNzYzLTExZjEtOTE3Yi0yZWRmZWU0MzlkZTEiLCJkZXBsb3ltZW50VXJsIjoiaHR0cDovL2xvY2FsaG9zdDo4MDkwL2Zsb3dhYmxlLXdvcmsvcHJvY2Vzcy1hcGkvcmVwb3NpdG9yeS9kZXBsb3ltZW50cy9QUkMtM2Y5M2U2MTctMDc2My0xMWYxLTkxN2ItMmVkZmVlNDM5ZGUxIiwiZGVzY3JpcHRpb24iOm51bGwsImRpYWdyYW1SZXNvdXJjZSI6bnVsbCwiZ3JhcGhpY2FsTm90YXRpb25EZWZpbmVkIjp0cnVlLCJpZCI6IlBSQy1leHRlcm5hbFdvcmtlclByb2Nlc3M6MzozZjk1ZTFlOS0wNzYzLTExZjEtOTE3Yi0yZWRmZWU0MzlkZTEiLCJrZXkiOiJleHRlcm5hbFdvcmtlclByb2Nlc3MiLCJuYW1lIjoiRXh0ZXJuYWwgV29ya2VyIFByb2Nlc3MiLCJyZXNvdXJjZSI6Imh0dHA6Ly9sb2NhbGhvc3Q6ODA5MC9mbG93YWJsZS13b3JrL3Byb2Nlc3MtYXBpL3JlcG9zaXRvcnkvZGVwbG95bWVudHMvUFJDLTNmOTNlNjE3LTA3NjMtMTFmMS05MTdiLTJlZGZlZTQzOWRlMS9yZXNvdXJjZXMvZXh0ZXJuYWxXb3JrZXJQcm9jZXNzLmJwbW4iLCJzdGFydEZvcm1EZWZpbmVkIjpmYWxzZSwic3VzcGVuZGVkIjpmYWxzZSwidGVuYW50SWQiOiIiLCJ1cmwiOiJodHRwOi8vbG9jYWxob3N0OjgwOTAvZmxvd2FibGUtd29yay9wcm9jZXNzLWFwaS9yZXBvc2l0b3J5L3Byb2Nlc3MtZGVmaW5pdGlvbnMvUFJDLWV4dGVybmFsV29ya2VyUHJvY2VzczozOjNmOTVlMWU5LTA3NjMtMTFmMS05MTdiLTJlZGZlZTQzOWRlMSIsInZlcnNpb24iOjN9XSwib3JkZXIiOiJhc2MiLCJzaXplIjoxLCJzb3J0IjoibmFtZSIsInN0YXJ0IjowLCJ0b3RhbCI6MX0=", + "responseContentType": "application/json", + "responseHeaders": { + "X-Content-Type-Options": [ + "nosniff" + ], + "X-XSS-Protection": [ + "0" + ], + "Cache-Control": [ + "no-store, must-revalidate, no-cache, max-age=0" + ], + "Pragma": [ + "no-cache" + ], + "X-Frame-Options": [ + "SAMEORIGIN" + ], + "Vary": [ + "accept-encoding" + ], + "Transfer-Encoding": [ + "chunked" + ], + "Date": [ + "Wed, 11 Feb 2026 16:03:47 GMT" + ] + } + }, + { + "method": "POST", + "uri": "http://localhost:8090/flowable-work/process-api/runtime/process-instances", + "statusCode": 201, + "responseBody": "eyJhY3Rpdml0eUlkIjpudWxsLCJidXNpbmVzc0tleSI6bnVsbCwiYnVzaW5lc3NTdGF0dXMiOm51bGwsImNhbGxiYWNrSWQiOm51bGwsImNhbGxiYWNrVHlwZSI6bnVsbCwiY29tcGxldGVkIjpmYWxzZSwiZW5kZWQiOmZhbHNlLCJpZCI6IlBSQy0zZmIwZTNmYi0wNzYzLTExZjEtOTE3Yi0yZWRmZWU0MzlkZTEiLCJuYW1lIjpudWxsLCJwcm9jZXNzRGVmaW5pdGlvbkRlc2NyaXB0aW9uIjpudWxsLCJwcm9jZXNzRGVmaW5pdGlvbklkIjoiUFJDLWV4dGVybmFsV29ya2VyUHJvY2VzczozOjNmOTVlMWU5LTA3NjMtMTFmMS05MTdiLTJlZGZlZTQzOWRlMSIsInByb2Nlc3NEZWZpbml0aW9uTmFtZSI6IkV4dGVybmFsIFdvcmtlciBQcm9jZXNzIiwicHJvY2Vzc0RlZmluaXRpb25VcmwiOiJodHRwOi8vbG9jYWxob3N0OjgwOTAvZmxvd2FibGUtd29yay9wcm9jZXNzLWFwaS9yZXBvc2l0b3J5L3Byb2Nlc3MtZGVmaW5pdGlvbnMvUFJDLWV4dGVybmFsV29ya2VyUHJvY2VzczozOjNmOTVlMWU5LTA3NjMtMTFmMS05MTdiLTJlZGZlZTQzOWRlMSIsInByb3BhZ2F0ZWRTdGFnZUluc3RhbmNlSWQiOm51bGwsInJlZmVyZW5jZUlkIjpudWxsLCJyZWZlcmVuY2VUeXBlIjpudWxsLCJzdGFydFRpbWUiOiIyMDI2LTAyLTExVDE2OjAzOjQ3LjY5MVoiLCJzdGFydFVzZXJJZCI6ImFkbWluIiwic3VwZXJQcm9jZXNzSW5zdGFuY2VJZCI6bnVsbCwic3VzcGVuZGVkIjpmYWxzZSwidGVuYW50SWQiOiIiLCJ1cmwiOiJodHRwOi8vbG9jYWxob3N0OjgwOTAvZmxvd2FibGUtd29yay9wcm9jZXNzLWFwaS9ydW50aW1lL3Byb2Nlc3MtaW5zdGFuY2VzL1BSQy0zZmIwZTNmYi0wNzYzLTExZjEtOTE3Yi0yZWRmZWU0MzlkZTEiLCJ2YXJpYWJsZXMiOlt7Im5hbWUiOiJpbml0aWF0b3IiLCJzY29wZSI6ImxvY2FsIiwidHlwZSI6InN0cmluZyIsInZhbHVlIjoiYWRtaW4ifV19", + "responseContentType": "application/json", + "responseHeaders": { + "X-Content-Type-Options": [ + "nosniff" + ], + "X-XSS-Protection": [ + "0" + ], + "Cache-Control": [ + "no-store, must-revalidate, no-cache, max-age=0" + ], + "Pragma": [ + "no-cache" + ], + "X-Frame-Options": [ + "SAMEORIGIN" + ], + "Vary": [ + "accept-encoding" + ], + "Transfer-Encoding": [ + "chunked" + ], + "Date": [ + "Wed, 11 Feb 2026 16:03:47 GMT" + ] + } + }, + { + "method": "GET", + "uri": "http://localhost:8090/flowable-work/external-job-api/jobs", + "statusCode": 401, + "responseBody": "", + "responseContentType": null, + "responseHeaders": { + "Set-Cookie": [ + "flowable-remember-me=; Expires=Thu, 01 Jan 1970 00:00:10 GMT; Path=/flowable-work", + "JSESSIONID=6CBD5227E803D660B795B4FD6418066C; Path=/flowable-work; HttpOnly" + ], + "WWW-Authenticate": [ + "Basic realm=\u0022Realm\u0022" + ], + "X-Content-Type-Options": [ + "nosniff" + ], + "X-XSS-Protection": [ + "0" + ], + "Cache-Control": [ + "no-store, must-revalidate, no-cache, max-age=0" + ], + "Pragma": [ + "no-cache" + ], + "X-Frame-Options": [ + "SAMEORIGIN" + ], + "Date": [ + "Wed, 11 Feb 2026 16:03:47 GMT" + ] + } + }, + { + "method": "DELETE", + "uri": "http://localhost:8090/flowable-work/process-api/runtime/process-instances/PRC-3fb0e3fb-0763-11f1-917b-2edfee439de1", + "statusCode": 204, + "responseBody": "", + "responseContentType": null, + "responseHeaders": { + "X-Content-Type-Options": [ + "nosniff" + ], + "X-XSS-Protection": [ + "0" + ], + "Cache-Control": [ + "no-store, must-revalidate, no-cache, max-age=0" + ], + "Pragma": [ + "no-cache" + ], + "X-Frame-Options": [ + "SAMEORIGIN" + ], + "Date": [ + "Wed, 11 Feb 2026 16:03:47 GMT" + ] + } + }, + { + "method": "DELETE", + "uri": "http://localhost:8090/flowable-work/process-api/repository/deployments/PRC-3f93e617-0763-11f1-917b-2edfee439de1", + "statusCode": 204, + "responseBody": "", + "responseContentType": null, + "responseHeaders": { + "X-Content-Type-Options": [ + "nosniff" + ], + "X-XSS-Protection": [ + "0" + ], + "Cache-Control": [ + "no-store, must-revalidate, no-cache, max-age=0" + ], + "Pragma": [ + "no-cache" + ], + "X-Frame-Options": [ + "SAMEORIGIN" + ], + "Date": [ + "Wed, 11 Feb 2026 16:03:47 GMT" + ] + } + } +] \ No newline at end of file diff --git a/FlowableExternalWorkerClient.Tests/Fixtures/Cassettes/TestListJobsWithCustomizer.json b/FlowableExternalWorkerClient.Tests/Fixtures/Cassettes/TestListJobsWithCustomizer.json new file mode 100644 index 0000000..5e37bff --- /dev/null +++ b/FlowableExternalWorkerClient.Tests/Fixtures/Cassettes/TestListJobsWithCustomizer.json @@ -0,0 +1,191 @@ +[ + { + "method": "POST", + "uri": "http://localhost:8090/flowable-work/process-api/repository/deployments", + "statusCode": 201, + "responseBody": "eyJ1cmwiOiJodHRwOi8vbG9jYWxob3N0OjgwOTAvZmxvd2FibGUtd29yay9wcm9jZXNzLWFwaS9yZXBvc2l0b3J5L2RlcGxveW1lbnRzL1BSQy00MDUyNTQ0NS0wNzYzLTExZjEtOTE3Yi0yZWRmZWU0MzlkZTEiLCJjYXRlZ29yeSI6bnVsbCwiZGVwbG95bWVudFRpbWUiOiIyMDI2LTAyLTExVDE2OjAzOjQ4Ljc0OVoiLCJpZCI6IlBSQy00MDUyNTQ0NS0wNzYzLTExZjEtOTE3Yi0yZWRmZWU0MzlkZTEiLCJuYW1lIjoiZXh0ZXJuYWxXb3JrZXJQcm9jZXNzIiwicGFyZW50RGVwbG95bWVudElkIjoiUFJDLTQwNTI1NDQ1LTA3NjMtMTFmMS05MTdiLTJlZGZlZTQzOWRlMSIsInRlbmFudElkIjoiIn0=", + "responseContentType": "application/json", + "responseHeaders": { + "Set-Cookie": [ + "XSRF-TOKEN=71da0d9e-d895-4208-bf76-347ef98b4a27; Path=/flowable-work" + ], + "X-Content-Type-Options": [ + "nosniff" + ], + "X-XSS-Protection": [ + "0" + ], + "Cache-Control": [ + "no-store, must-revalidate, no-cache, max-age=0" + ], + "Pragma": [ + "no-cache" + ], + "X-Frame-Options": [ + "SAMEORIGIN" + ], + "Vary": [ + "accept-encoding" + ], + "Transfer-Encoding": [ + "chunked" + ], + "Date": [ + "Wed, 11 Feb 2026 16:03:48 GMT" + ] + } + }, + { + "method": "GET", + "uri": "http://localhost:8090/flowable-work/process-api/repository/process-definitions?deploymentId=PRC-40525445-0763-11f1-917b-2edfee439de1", + "statusCode": 200, + "responseBody": "eyJkYXRhIjpbeyJjYXRlZ29yeSI6Imh0dHA6Ly9mbG93YWJsZS5vcmcvdGVzdCIsImRlcGxveW1lbnRJZCI6IlBSQy00MDUyNTQ0NS0wNzYzLTExZjEtOTE3Yi0yZWRmZWU0MzlkZTEiLCJkZXBsb3ltZW50VXJsIjoiaHR0cDovL2xvY2FsaG9zdDo4MDkwL2Zsb3dhYmxlLXdvcmsvcHJvY2Vzcy1hcGkvcmVwb3NpdG9yeS9kZXBsb3ltZW50cy9QUkMtNDA1MjU0NDUtMDc2My0xMWYxLTkxN2ItMmVkZmVlNDM5ZGUxIiwiZGVzY3JpcHRpb24iOm51bGwsImRpYWdyYW1SZXNvdXJjZSI6bnVsbCwiZ3JhcGhpY2FsTm90YXRpb25EZWZpbmVkIjp0cnVlLCJpZCI6IlBSQy1leHRlcm5hbFdvcmtlclByb2Nlc3M6Mzo0MDUzOGNjNy0wNzYzLTExZjEtOTE3Yi0yZWRmZWU0MzlkZTEiLCJrZXkiOiJleHRlcm5hbFdvcmtlclByb2Nlc3MiLCJuYW1lIjoiRXh0ZXJuYWwgV29ya2VyIFByb2Nlc3MiLCJyZXNvdXJjZSI6Imh0dHA6Ly9sb2NhbGhvc3Q6ODA5MC9mbG93YWJsZS13b3JrL3Byb2Nlc3MtYXBpL3JlcG9zaXRvcnkvZGVwbG95bWVudHMvUFJDLTQwNTI1NDQ1LTA3NjMtMTFmMS05MTdiLTJlZGZlZTQzOWRlMS9yZXNvdXJjZXMvZXh0ZXJuYWxXb3JrZXJQcm9jZXNzLmJwbW4iLCJzdGFydEZvcm1EZWZpbmVkIjpmYWxzZSwic3VzcGVuZGVkIjpmYWxzZSwidGVuYW50SWQiOiIiLCJ1cmwiOiJodHRwOi8vbG9jYWxob3N0OjgwOTAvZmxvd2FibGUtd29yay9wcm9jZXNzLWFwaS9yZXBvc2l0b3J5L3Byb2Nlc3MtZGVmaW5pdGlvbnMvUFJDLWV4dGVybmFsV29ya2VyUHJvY2VzczozOjQwNTM4Y2M3LTA3NjMtMTFmMS05MTdiLTJlZGZlZTQzOWRlMSIsInZlcnNpb24iOjN9XSwib3JkZXIiOiJhc2MiLCJzaXplIjoxLCJzb3J0IjoibmFtZSIsInN0YXJ0IjowLCJ0b3RhbCI6MX0=", + "responseContentType": "application/json", + "responseHeaders": { + "X-Content-Type-Options": [ + "nosniff" + ], + "X-XSS-Protection": [ + "0" + ], + "Cache-Control": [ + "no-store, must-revalidate, no-cache, max-age=0" + ], + "Pragma": [ + "no-cache" + ], + "X-Frame-Options": [ + "SAMEORIGIN" + ], + "Vary": [ + "accept-encoding" + ], + "Transfer-Encoding": [ + "chunked" + ], + "Date": [ + "Wed, 11 Feb 2026 16:03:48 GMT" + ] + } + }, + { + "method": "POST", + "uri": "http://localhost:8090/flowable-work/process-api/runtime/process-instances", + "statusCode": 201, + "responseBody": "eyJhY3Rpdml0eUlkIjpudWxsLCJidXNpbmVzc0tleSI6bnVsbCwiYnVzaW5lc3NTdGF0dXMiOm51bGwsImNhbGxiYWNrSWQiOm51bGwsImNhbGxiYWNrVHlwZSI6bnVsbCwiY29tcGxldGVkIjpmYWxzZSwiZW5kZWQiOmZhbHNlLCJpZCI6IlBSQy00MDZkMmY0OS0wNzYzLTExZjEtOTE3Yi0yZWRmZWU0MzlkZTEiLCJuYW1lIjpudWxsLCJwcm9jZXNzRGVmaW5pdGlvbkRlc2NyaXB0aW9uIjpudWxsLCJwcm9jZXNzRGVmaW5pdGlvbklkIjoiUFJDLWV4dGVybmFsV29ya2VyUHJvY2VzczozOjQwNTM4Y2M3LTA3NjMtMTFmMS05MTdiLTJlZGZlZTQzOWRlMSIsInByb2Nlc3NEZWZpbml0aW9uTmFtZSI6IkV4dGVybmFsIFdvcmtlciBQcm9jZXNzIiwicHJvY2Vzc0RlZmluaXRpb25VcmwiOiJodHRwOi8vbG9jYWxob3N0OjgwOTAvZmxvd2FibGUtd29yay9wcm9jZXNzLWFwaS9yZXBvc2l0b3J5L3Byb2Nlc3MtZGVmaW5pdGlvbnMvUFJDLWV4dGVybmFsV29ya2VyUHJvY2VzczozOjQwNTM4Y2M3LTA3NjMtMTFmMS05MTdiLTJlZGZlZTQzOWRlMSIsInByb3BhZ2F0ZWRTdGFnZUluc3RhbmNlSWQiOm51bGwsInJlZmVyZW5jZUlkIjpudWxsLCJyZWZlcmVuY2VUeXBlIjpudWxsLCJzdGFydFRpbWUiOiIyMDI2LTAyLTExVDE2OjAzOjQ4LjkyNVoiLCJzdGFydFVzZXJJZCI6ImFkbWluIiwic3VwZXJQcm9jZXNzSW5zdGFuY2VJZCI6bnVsbCwic3VzcGVuZGVkIjpmYWxzZSwidGVuYW50SWQiOiIiLCJ1cmwiOiJodHRwOi8vbG9jYWxob3N0OjgwOTAvZmxvd2FibGUtd29yay9wcm9jZXNzLWFwaS9ydW50aW1lL3Byb2Nlc3MtaW5zdGFuY2VzL1BSQy00MDZkMmY0OS0wNzYzLTExZjEtOTE3Yi0yZWRmZWU0MzlkZTEiLCJ2YXJpYWJsZXMiOlt7Im5hbWUiOiJpbml0aWF0b3IiLCJzY29wZSI6ImxvY2FsIiwidHlwZSI6InN0cmluZyIsInZhbHVlIjoiYWRtaW4ifV19", + "responseContentType": "application/json", + "responseHeaders": { + "X-Content-Type-Options": [ + "nosniff" + ], + "X-XSS-Protection": [ + "0" + ], + "Cache-Control": [ + "no-store, must-revalidate, no-cache, max-age=0" + ], + "Pragma": [ + "no-cache" + ], + "X-Frame-Options": [ + "SAMEORIGIN" + ], + "Vary": [ + "accept-encoding" + ], + "Transfer-Encoding": [ + "chunked" + ], + "Date": [ + "Wed, 11 Feb 2026 16:03:48 GMT" + ] + } + }, + { + "method": "GET", + "uri": "http://localhost:8090/flowable-work/external-job-api/jobs", + "statusCode": 200, + "responseBody": "eyJkYXRhIjpbeyJjb3JyZWxhdGlvbklkIjoiNDA2ZTE5YjItMDc2My0xMWYxLTkxN2ItMmVkZmVlNDM5ZGUxIiwiY3JlYXRlVGltZSI6IjIwMjYtMDItMTFUMTY6MDM6NDguOTMxWiIsImR1ZURhdGUiOm51bGwsImVsZW1lbnRJZCI6ImJwbW5UYXNrXzMiLCJlbGVtZW50TmFtZSI6IkV4dGVybmFsIFdvcmtlciB0YXNrIiwiZXhjZXB0aW9uTWVzc2FnZSI6bnVsbCwiZXhlY3V0aW9uSWQiOiJQUkMtNDA2ZDU2NWMtMDc2My0xMWYxLTkxN2ItMmVkZmVlNDM5ZGUxIiwiaWQiOiJKT0ItNDA2ZTE5YjMtMDc2My0xMWYxLTkxN2ItMmVkZmVlNDM5ZGUxIiwibG9ja0V4cGlyYXRpb25UaW1lIjpudWxsLCJsb2NrT3duZXIiOm51bGwsInByb2Nlc3NEZWZpbml0aW9uSWQiOiJQUkMtZXh0ZXJuYWxXb3JrZXJQcm9jZXNzOjM6NDA1MzhjYzctMDc2My0xMWYxLTkxN2ItMmVkZmVlNDM5ZGUxIiwicHJvY2Vzc0luc3RhbmNlSWQiOiJQUkMtNDA2ZDJmNDktMDc2My0xMWYxLTkxN2ItMmVkZmVlNDM5ZGUxIiwicmV0cmllcyI6Mywic2NvcGVEZWZpbml0aW9uSWQiOm51bGwsInNjb3BlSWQiOm51bGwsInNjb3BlVHlwZSI6bnVsbCwic3ViU2NvcGVJZCI6bnVsbCwidGVuYW50SWQiOiIiLCJ1cmwiOiJodHRwOi8vbG9jYWxob3N0OjgwOTAvZmxvd2FibGUtd29yay9leHRlcm5hbC1qb2ItYXBpL2pvYnMvSk9CLTQwNmUxOWIzLTA3NjMtMTFmMS05MTdiLTJlZGZlZTQzOWRlMSJ9XSwib3JkZXIiOiJhc2MiLCJzaXplIjoxLCJzb3J0IjoiaWQiLCJzdGFydCI6MCwidG90YWwiOjF9", + "responseContentType": "application/json", + "responseHeaders": { + "X-Content-Type-Options": [ + "nosniff" + ], + "X-XSS-Protection": [ + "0" + ], + "Cache-Control": [ + "no-store, must-revalidate, no-cache, max-age=0" + ], + "Pragma": [ + "no-cache" + ], + "X-Frame-Options": [ + "SAMEORIGIN" + ], + "Vary": [ + "accept-encoding" + ], + "Transfer-Encoding": [ + "chunked" + ], + "Date": [ + "Wed, 11 Feb 2026 16:03:49 GMT" + ] + } + }, + { + "method": "DELETE", + "uri": "http://localhost:8090/flowable-work/process-api/runtime/process-instances/PRC-406d2f49-0763-11f1-917b-2edfee439de1", + "statusCode": 204, + "responseBody": "", + "responseContentType": null, + "responseHeaders": { + "X-Content-Type-Options": [ + "nosniff" + ], + "X-XSS-Protection": [ + "0" + ], + "Cache-Control": [ + "no-store, must-revalidate, no-cache, max-age=0" + ], + "Pragma": [ + "no-cache" + ], + "X-Frame-Options": [ + "SAMEORIGIN" + ], + "Date": [ + "Wed, 11 Feb 2026 16:03:49 GMT" + ] + } + }, + { + "method": "DELETE", + "uri": "http://localhost:8090/flowable-work/process-api/repository/deployments/PRC-40525445-0763-11f1-917b-2edfee439de1", + "statusCode": 204, + "responseBody": "", + "responseContentType": null, + "responseHeaders": { + "X-Content-Type-Options": [ + "nosniff" + ], + "X-XSS-Protection": [ + "0" + ], + "Cache-Control": [ + "no-store, must-revalidate, no-cache, max-age=0" + ], + "Pragma": [ + "no-cache" + ], + "X-Frame-Options": [ + "SAMEORIGIN" + ], + "Date": [ + "Wed, 11 Feb 2026 16:03:49 GMT" + ] + } + } +] \ No newline at end of file diff --git a/FlowableExternalWorkerClient.Tests/Fixtures/Cassettes/TestSubscribeWithBpmnError.json b/FlowableExternalWorkerClient.Tests/Fixtures/Cassettes/TestSubscribeWithBpmnError.json new file mode 100644 index 0000000..0e40ecc --- /dev/null +++ b/FlowableExternalWorkerClient.Tests/Fixtures/Cassettes/TestSubscribeWithBpmnError.json @@ -0,0 +1,290 @@ +[ + { + "method": "POST", + "uri": "http://localhost:8090/flowable-work/process-api/repository/deployments", + "statusCode": 201, + "responseBody": "eyJ1cmwiOiJodHRwOi8vbG9jYWxob3N0OjgwOTAvZmxvd2FibGUtd29yay9wcm9jZXNzLWFwaS9yZXBvc2l0b3J5L2RlcGxveW1lbnRzL1BSQy00M2FjZjBhMS0wNzYzLTExZjEtOTE3Yi0yZWRmZWU0MzlkZTEiLCJjYXRlZ29yeSI6bnVsbCwiZGVwbG95bWVudFRpbWUiOiIyMDI2LTAyLTExVDE2OjAzOjU0LjM3NloiLCJpZCI6IlBSQy00M2FjZjBhMS0wNzYzLTExZjEtOTE3Yi0yZWRmZWU0MzlkZTEiLCJuYW1lIjoid2l0aEJvdW5kYXJ5RXZlbnQiLCJwYXJlbnREZXBsb3ltZW50SWQiOiJQUkMtNDNhY2YwYTEtMDc2My0xMWYxLTkxN2ItMmVkZmVlNDM5ZGUxIiwidGVuYW50SWQiOiIifQ==", + "responseContentType": "application/json", + "responseHeaders": { + "Set-Cookie": [ + "XSRF-TOKEN=9c53a167-c8b8-4500-991a-3282c3ab5ef5; Path=/flowable-work" + ], + "X-Content-Type-Options": [ + "nosniff" + ], + "X-XSS-Protection": [ + "0" + ], + "Cache-Control": [ + "no-store, must-revalidate, no-cache, max-age=0" + ], + "Pragma": [ + "no-cache" + ], + "X-Frame-Options": [ + "SAMEORIGIN" + ], + "Vary": [ + "accept-encoding" + ], + "Transfer-Encoding": [ + "chunked" + ], + "Date": [ + "Wed, 11 Feb 2026 16:03:54 GMT" + ] + } + }, + { + "method": "GET", + "uri": "http://localhost:8090/flowable-work/process-api/repository/process-definitions?deploymentId=PRC-43acf0a1-0763-11f1-917b-2edfee439de1", + "statusCode": 200, + "responseBody": "eyJkYXRhIjpbeyJjYXRlZ29yeSI6Imh0dHA6Ly9mbG93YWJsZS5vcmcvdGVzdCIsImRlcGxveW1lbnRJZCI6IlBSQy00M2FjZjBhMS0wNzYzLTExZjEtOTE3Yi0yZWRmZWU0MzlkZTEiLCJkZXBsb3ltZW50VXJsIjoiaHR0cDovL2xvY2FsaG9zdDo4MDkwL2Zsb3dhYmxlLXdvcmsvcHJvY2Vzcy1hcGkvcmVwb3NpdG9yeS9kZXBsb3ltZW50cy9QUkMtNDNhY2YwYTEtMDc2My0xMWYxLTkxN2ItMmVkZmVlNDM5ZGUxIiwiZGVzY3JpcHRpb24iOm51bGwsImRpYWdyYW1SZXNvdXJjZSI6bnVsbCwiZ3JhcGhpY2FsTm90YXRpb25EZWZpbmVkIjp0cnVlLCJpZCI6IlBSQy1leHRlcm5hbFdvcmtlclByb2Nlc3M6Mzo0M2FlNTAzMy0wNzYzLTExZjEtOTE3Yi0yZWRmZWU0MzlkZTEiLCJrZXkiOiJleHRlcm5hbFdvcmtlclByb2Nlc3MiLCJuYW1lIjoiRXh0ZXJuYWwgV29ya2VyIFByb2Nlc3MiLCJyZXNvdXJjZSI6Imh0dHA6Ly9sb2NhbGhvc3Q6ODA5MC9mbG93YWJsZS13b3JrL3Byb2Nlc3MtYXBpL3JlcG9zaXRvcnkvZGVwbG95bWVudHMvUFJDLTQzYWNmMGExLTA3NjMtMTFmMS05MTdiLTJlZGZlZTQzOWRlMS9yZXNvdXJjZXMvd2l0aEJvdW5kYXJ5RXZlbnQuYnBtbiIsInN0YXJ0Rm9ybURlZmluZWQiOmZhbHNlLCJzdXNwZW5kZWQiOmZhbHNlLCJ0ZW5hbnRJZCI6IiIsInVybCI6Imh0dHA6Ly9sb2NhbGhvc3Q6ODA5MC9mbG93YWJsZS13b3JrL3Byb2Nlc3MtYXBpL3JlcG9zaXRvcnkvcHJvY2Vzcy1kZWZpbml0aW9ucy9QUkMtZXh0ZXJuYWxXb3JrZXJQcm9jZXNzOjM6NDNhZTUwMzMtMDc2My0xMWYxLTkxN2ItMmVkZmVlNDM5ZGUxIiwidmVyc2lvbiI6M31dLCJvcmRlciI6ImFzYyIsInNpemUiOjEsInNvcnQiOiJuYW1lIiwic3RhcnQiOjAsInRvdGFsIjoxfQ==", + "responseContentType": "application/json", + "responseHeaders": { + "X-Content-Type-Options": [ + "nosniff" + ], + "X-XSS-Protection": [ + "0" + ], + "Cache-Control": [ + "no-store, must-revalidate, no-cache, max-age=0" + ], + "Pragma": [ + "no-cache" + ], + "X-Frame-Options": [ + "SAMEORIGIN" + ], + "Vary": [ + "accept-encoding" + ], + "Transfer-Encoding": [ + "chunked" + ], + "Date": [ + "Wed, 11 Feb 2026 16:03:54 GMT" + ] + } + }, + { + "method": "POST", + "uri": "http://localhost:8090/flowable-work/process-api/runtime/process-instances", + "statusCode": 201, + "responseBody": "eyJhY3Rpdml0eUlkIjpudWxsLCJidXNpbmVzc0tleSI6bnVsbCwiYnVzaW5lc3NTdGF0dXMiOm51bGwsImNhbGxiYWNrSWQiOm51bGwsImNhbGxiYWNrVHlwZSI6bnVsbCwiY29tcGxldGVkIjpmYWxzZSwiZW5kZWQiOmZhbHNlLCJpZCI6IlBSQy00M2M4NjdlNS0wNzYzLTExZjEtOTE3Yi0yZWRmZWU0MzlkZTEiLCJuYW1lIjpudWxsLCJwcm9jZXNzRGVmaW5pdGlvbkRlc2NyaXB0aW9uIjpudWxsLCJwcm9jZXNzRGVmaW5pdGlvbklkIjoiUFJDLWV4dGVybmFsV29ya2VyUHJvY2VzczozOjQzYWU1MDMzLTA3NjMtMTFmMS05MTdiLTJlZGZlZTQzOWRlMSIsInByb2Nlc3NEZWZpbml0aW9uTmFtZSI6IkV4dGVybmFsIFdvcmtlciBQcm9jZXNzIiwicHJvY2Vzc0RlZmluaXRpb25VcmwiOiJodHRwOi8vbG9jYWxob3N0OjgwOTAvZmxvd2FibGUtd29yay9wcm9jZXNzLWFwaS9yZXBvc2l0b3J5L3Byb2Nlc3MtZGVmaW5pdGlvbnMvUFJDLWV4dGVybmFsV29ya2VyUHJvY2VzczozOjQzYWU1MDMzLTA3NjMtMTFmMS05MTdiLTJlZGZlZTQzOWRlMSIsInByb3BhZ2F0ZWRTdGFnZUluc3RhbmNlSWQiOm51bGwsInJlZmVyZW5jZUlkIjpudWxsLCJyZWZlcmVuY2VUeXBlIjpudWxsLCJzdGFydFRpbWUiOiIyMDI2LTAyLTExVDE2OjAzOjU0LjU1NloiLCJzdGFydFVzZXJJZCI6ImFkbWluIiwic3VwZXJQcm9jZXNzSW5zdGFuY2VJZCI6bnVsbCwic3VzcGVuZGVkIjpmYWxzZSwidGVuYW50SWQiOiIiLCJ1cmwiOiJodHRwOi8vbG9jYWxob3N0OjgwOTAvZmxvd2FibGUtd29yay9wcm9jZXNzLWFwaS9ydW50aW1lL3Byb2Nlc3MtaW5zdGFuY2VzL1BSQy00M2M4NjdlNS0wNzYzLTExZjEtOTE3Yi0yZWRmZWU0MzlkZTEiLCJ2YXJpYWJsZXMiOlt7Im5hbWUiOiJpbml0aWF0b3IiLCJzY29wZSI6ImxvY2FsIiwidHlwZSI6InN0cmluZyIsInZhbHVlIjoiYWRtaW4ifV19", + "responseContentType": "application/json", + "responseHeaders": { + "X-Content-Type-Options": [ + "nosniff" + ], + "X-XSS-Protection": [ + "0" + ], + "Cache-Control": [ + "no-store, must-revalidate, no-cache, max-age=0" + ], + "Pragma": [ + "no-cache" + ], + "X-Frame-Options": [ + "SAMEORIGIN" + ], + "Vary": [ + "accept-encoding" + ], + "Transfer-Encoding": [ + "chunked" + ], + "Date": [ + "Wed, 11 Feb 2026 16:03:54 GMT" + ] + } + }, + { + "method": "POST", + "uri": "http://localhost:8090/flowable-work/external-job-api/acquire/jobs", + "statusCode": 200, + "responseBody": "W3siY29ycmVsYXRpb25JZCI6IjQzYzk3OTYyLTA3NjMtMTFmMS05MTdiLTJlZGZlZTQzOWRlMSIsImNyZWF0ZVRpbWUiOiIyMDI2LTAyLTExVDE2OjAzOjU0LjU2M1oiLCJkdWVEYXRlIjpudWxsLCJlbGVtZW50SWQiOiJicG1uVGFza18zIiwiZWxlbWVudE5hbWUiOiJFeHRlcm5hbCBXb3JrZXIgdGFzayIsImV4Y2VwdGlvbk1lc3NhZ2UiOm51bGwsImV4ZWN1dGlvbklkIjoiUFJDLTQzYzg4ZWY4LTA3NjMtMTFmMS05MTdiLTJlZGZlZTQzOWRlMSIsImlkIjoiSk9CLTQzYzk3OTYzLTA3NjMtMTFmMS05MTdiLTJlZGZlZTQzOWRlMSIsImxvY2tFeHBpcmF0aW9uVGltZSI6IjIwMjYtMDItMTFUMTY6MDQ6NTQuNjUwWiIsImxvY2tPd25lciI6InRlc3Qtd29ya2VyIiwicHJvY2Vzc0RlZmluaXRpb25JZCI6IlBSQy1leHRlcm5hbFdvcmtlclByb2Nlc3M6Mzo0M2FlNTAzMy0wNzYzLTExZjEtOTE3Yi0yZWRmZWU0MzlkZTEiLCJwcm9jZXNzSW5zdGFuY2VJZCI6IlBSQy00M2M4NjdlNS0wNzYzLTExZjEtOTE3Yi0yZWRmZWU0MzlkZTEiLCJyZXRyaWVzIjozLCJzY29wZURlZmluaXRpb25JZCI6bnVsbCwic2NvcGVJZCI6bnVsbCwic2NvcGVUeXBlIjpudWxsLCJzdWJTY29wZUlkIjpudWxsLCJ0ZW5hbnRJZCI6IiIsInVybCI6Imh0dHA6Ly9sb2NhbGhvc3Q6ODA5MC9mbG93YWJsZS13b3JrL2V4dGVybmFsLWpvYi1hcGkvam9icy9KT0ItNDNjOTc5NjMtMDc2My0xMWYxLTkxN2ItMmVkZmVlNDM5ZGUxIiwidmFyaWFibGVzIjpbeyJuYW1lIjoiaW5pdGlhdG9yIiwidHlwZSI6InN0cmluZyIsInZhbHVlIjoiYWRtaW4ifV19XQ==", + "responseContentType": "application/json", + "responseHeaders": { + "X-Content-Type-Options": [ + "nosniff" + ], + "X-XSS-Protection": [ + "0" + ], + "Cache-Control": [ + "no-store, must-revalidate, no-cache, max-age=0" + ], + "Pragma": [ + "no-cache" + ], + "X-Frame-Options": [ + "SAMEORIGIN" + ], + "Vary": [ + "accept-encoding" + ], + "Transfer-Encoding": [ + "chunked" + ], + "Date": [ + "Wed, 11 Feb 2026 16:03:54 GMT" + ] + } + }, + { + "method": "POST", + "uri": "http://localhost:8090/flowable-work/external-job-api/acquire/jobs/JOB-43c97963-0763-11f1-917b-2edfee439de1/bpmnError", + "statusCode": 204, + "responseBody": "", + "responseContentType": null, + "responseHeaders": { + "X-Content-Type-Options": [ + "nosniff" + ], + "X-XSS-Protection": [ + "0" + ], + "Cache-Control": [ + "no-store, must-revalidate, no-cache, max-age=0" + ], + "Pragma": [ + "no-cache" + ], + "X-Frame-Options": [ + "SAMEORIGIN" + ], + "Date": [ + "Wed, 11 Feb 2026 16:03:54 GMT" + ] + } + }, + { + "method": "POST", + "uri": "http://localhost:8090/flowable-work/external-job-api/acquire/jobs", + "statusCode": 200, + "responseBody": "W10=", + "responseContentType": "application/json", + "responseHeaders": { + "X-Content-Type-Options": [ + "nosniff" + ], + "X-XSS-Protection": [ + "0" + ], + "Cache-Control": [ + "no-store, must-revalidate, no-cache, max-age=0" + ], + "Pragma": [ + "no-cache" + ], + "X-Frame-Options": [ + "SAMEORIGIN" + ], + "Vary": [ + "accept-encoding" + ], + "Transfer-Encoding": [ + "chunked" + ], + "Date": [ + "Wed, 11 Feb 2026 16:03:54 GMT" + ] + } + }, + { + "method": "GET", + "uri": "http://localhost:8090/flowable-work/process-api/history/historic-variable-instances?processInstanceId=PRC-43c867e5-0763-11f1-917b-2edfee439de1\u0026variableName=testVar", + "statusCode": 200, + "responseBody": "eyJkYXRhIjpbeyJleGVjdXRpb25JZCI6IlBSQy00M2M4NjdlNS0wNzYzLTExZjEtOTE3Yi0yZWRmZWU0MzlkZTEiLCJpZCI6IlZBUi00M2UzZGYzNy0wNzYzLTExZjEtOTE3Yi0yZWRmZWU0MzlkZTEiLCJwcm9jZXNzSW5zdGFuY2VJZCI6IlBSQy00M2M4NjdlNS0wNzYzLTExZjEtOTE3Yi0yZWRmZWU0MzlkZTEiLCJwcm9jZXNzSW5zdGFuY2VVcmwiOiJodHRwOi8vbG9jYWxob3N0OjgwOTAvZmxvd2FibGUtd29yay9wcm9jZXNzLWFwaS9oaXN0b3J5L2hpc3RvcmljLXByb2Nlc3MtaW5zdGFuY2VzL1BSQy00M2M4NjdlNS0wNzYzLTExZjEtOTE3Yi0yZWRmZWU0MzlkZTEiLCJ0YXNrSWQiOm51bGwsInZhcmlhYmxlIjp7Im5hbWUiOiJ0ZXN0VmFyIiwic2NvcGUiOiJnbG9iYWwiLCJ0eXBlIjoic3RyaW5nIiwidmFsdWUiOiJ0ZXN0IGZhaWx1cmUifX1dLCJvcmRlciI6ImFzYyIsInNpemUiOjEsInNvcnQiOiJ2YXJpYWJsZU5hbWUiLCJzdGFydCI6MCwidG90YWwiOjF9", + "responseContentType": "application/json", + "responseHeaders": { + "X-Content-Type-Options": [ + "nosniff" + ], + "X-XSS-Protection": [ + "0" + ], + "Cache-Control": [ + "no-store, must-revalidate, no-cache, max-age=0" + ], + "Pragma": [ + "no-cache" + ], + "X-Frame-Options": [ + "SAMEORIGIN" + ], + "Vary": [ + "accept-encoding" + ], + "Transfer-Encoding": [ + "chunked" + ], + "Date": [ + "Wed, 11 Feb 2026 16:03:55 GMT" + ] + } + }, + { + "method": "GET", + "uri": "http://localhost:8090/flowable-work/process-api/history/historic-activity-instances?processInstanceId=PRC-43c867e5-0763-11f1-917b-2edfee439de1", + "statusCode": 200, + "responseBody": "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", + "responseContentType": "application/json", + "responseHeaders": { + "X-Content-Type-Options": [ + "nosniff" + ], + "X-XSS-Protection": [ + "0" + ], + "Cache-Control": [ + "no-store, must-revalidate, no-cache, max-age=0" + ], + "Pragma": [ + "no-cache" + ], + "X-Frame-Options": [ + "SAMEORIGIN" + ], + "Vary": [ + "accept-encoding" + ], + "Transfer-Encoding": [ + "chunked" + ], + "Date": [ + "Wed, 11 Feb 2026 16:03:55 GMT" + ] + } + }, + { + "method": "DELETE", + "uri": "http://localhost:8090/flowable-work/process-api/repository/deployments/PRC-43acf0a1-0763-11f1-917b-2edfee439de1", + "statusCode": 204, + "responseBody": "", + "responseContentType": null, + "responseHeaders": { + "X-Content-Type-Options": [ + "nosniff" + ], + "X-XSS-Protection": [ + "0" + ], + "Cache-Control": [ + "no-store, must-revalidate, no-cache, max-age=0" + ], + "Pragma": [ + "no-cache" + ], + "X-Frame-Options": [ + "SAMEORIGIN" + ], + "Date": [ + "Wed, 11 Feb 2026 16:03:55 GMT" + ] + } + } +] \ No newline at end of file diff --git a/FlowableExternalWorkerClient.Tests/Fixtures/Processes/externalWorkerProcess.bpmn b/FlowableExternalWorkerClient.Tests/Fixtures/Processes/externalWorkerProcess.bpmn new file mode 100644 index 0000000..2502f66 --- /dev/null +++ b/FlowableExternalWorkerClient.Tests/Fixtures/Processes/externalWorkerProcess.bpmn @@ -0,0 +1,60 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/FlowableExternalWorkerClient.Tests/Fixtures/Processes/withBoundaryEvent.bpmn b/FlowableExternalWorkerClient.Tests/Fixtures/Processes/withBoundaryEvent.bpmn new file mode 100644 index 0000000..412f830 --- /dev/null +++ b/FlowableExternalWorkerClient.Tests/Fixtures/Processes/withBoundaryEvent.bpmn @@ -0,0 +1,114 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/FlowableExternalWorkerClient.Tests/FlowableExternalWorkerClient.Tests.csproj b/FlowableExternalWorkerClient.Tests/FlowableExternalWorkerClient.Tests.csproj new file mode 100644 index 0000000..d30c49c --- /dev/null +++ b/FlowableExternalWorkerClient.Tests/FlowableExternalWorkerClient.Tests.csproj @@ -0,0 +1,31 @@ + + + + net9.0 + enable + enable + false + true + + + + + + + runtime; build; native; contentfiles; analyzers; buildtransitive + all + + + + + + + + + + PreserveNewest + + + + + diff --git a/FlowableExternalWorkerClient.Tests/RestClientTests.cs b/FlowableExternalWorkerClient.Tests/RestClientTests.cs new file mode 100644 index 0000000..35bb46f --- /dev/null +++ b/FlowableExternalWorkerClient.Tests/RestClientTests.cs @@ -0,0 +1,451 @@ +using System.Net.Http.Headers; +using System.Text; +using FlowableExternalWorkerClient.Rest; +using Xunit; + +namespace FlowableExternalWorkerClient.Tests; + +public class RestClientTests +{ + private const string BaseUrl = "http://localhost:8090/flowable-work"; + + private static readonly AuthenticationHeaderValue Auth = + new("Basic", Convert.ToBase64String(Encoding.UTF8.GetBytes("admin:test"))); + + private string FixturesPath => Path.Combine(AppContext.BaseDirectory, "Fixtures"); + + [Fact] + public async Task TestListJobs() + { + using var cassette = Vcr.UseCassette(); + var httpClient = cassette.CreateHttpClient(); + httpClient.DefaultRequestHeaders.Authorization = Auth; + var client = new FlowableExternalWorkerRestClient(BaseUrl, "test-worker", httpClient); + + var deploymentId = await BpmnUtils.DeployProcess( + httpClient, BaseUrl, Path.Combine(FixturesPath, "Processes", "externalWorkerProcess.bpmn")); + var definitionId = await BpmnUtils.GetProcessDefinitionId(httpClient, BaseUrl, deploymentId); + var processInstanceId = await BpmnUtils.StartProcess(httpClient, BaseUrl, definitionId); + try + { + var jobs = await client.ListJobs(); + Assert.True(jobs.Total >= 1); + var entry = jobs.Data.First(j => j.ProcessInstanceId == processInstanceId); + Assert.Equal("External Worker task", entry.ElementName); + Assert.Equal(3, entry.Retries); + Assert.True(entry.CreateTime < DateTime.Now); + } + finally + { + await BpmnUtils.TerminateProcess(httpClient, BaseUrl, processInstanceId); + await BpmnUtils.DeleteDeployment(httpClient, BaseUrl, deploymentId); + cassette.Save(); + } + } + + [Fact] + public async Task TestListJobsWithCustomizer() + { + using var cassette = Vcr.UseCassette(); + var httpClient = cassette.CreateHttpClient(); + httpClient.DefaultRequestHeaders.Authorization = Auth; + + var deploymentId = await BpmnUtils.DeployProcess( + httpClient, BaseUrl, Path.Combine(FixturesPath, "Processes", "externalWorkerProcess.bpmn")); + var definitionId = await BpmnUtils.GetProcessDefinitionId(httpClient, BaseUrl, deploymentId); + var processInstanceId = await BpmnUtils.StartProcess(httpClient, BaseUrl, definitionId); + try + { + var client = new FlowableExternalWorkerRestClient( + BaseUrl, "test-worker", httpClient, customizer: new BasicAuthCustomizer()); + + var jobs = await client.ListJobs(); + Assert.True(jobs.Total >= 1); + } + finally + { + await BpmnUtils.TerminateProcess(httpClient, BaseUrl, processInstanceId); + await BpmnUtils.DeleteDeployment(httpClient, BaseUrl, deploymentId); + cassette.Save(); + } + } + + [Fact] + public async Task TestListJobsInvalidAuth() + { + using var cassette = Vcr.UseCassette(); + var validClient = cassette.CreateHttpClient(); + validClient.DefaultRequestHeaders.Authorization = Auth; + + var invalidClient = cassette.CreateHttpClient(); + invalidClient.DefaultRequestHeaders.Authorization = + new AuthenticationHeaderValue("Basic", Convert.ToBase64String(Encoding.UTF8.GetBytes("invalid:auth"))); + + var deploymentId = await BpmnUtils.DeployProcess( + validClient, BaseUrl, Path.Combine(FixturesPath, "Processes", "externalWorkerProcess.bpmn")); + var definitionId = await BpmnUtils.GetProcessDefinitionId(validClient, BaseUrl, deploymentId); + var processInstanceId = await BpmnUtils.StartProcess(validClient, BaseUrl, definitionId); + try + { + var client = new FlowableExternalWorkerRestClient(BaseUrl, "test-worker", invalidClient); + await Assert.ThrowsAnyAsync(() => client.ListJobs()); + } + finally + { + await BpmnUtils.TerminateProcess(validClient, BaseUrl, processInstanceId); + await BpmnUtils.DeleteDeployment(validClient, BaseUrl, deploymentId); + cassette.Save(); + } + } + + [Fact] + public async Task TestGetJob() + { + using var cassette = Vcr.UseCassette(); + var httpClient = cassette.CreateHttpClient(); + httpClient.DefaultRequestHeaders.Authorization = Auth; + var client = new FlowableExternalWorkerRestClient(BaseUrl, "test-worker", httpClient); + + var deploymentId = await BpmnUtils.DeployProcess( + httpClient, BaseUrl, Path.Combine(FixturesPath, "Processes", "externalWorkerProcess.bpmn")); + var definitionId = await BpmnUtils.GetProcessDefinitionId(httpClient, BaseUrl, deploymentId); + var processInstanceId = await BpmnUtils.StartProcess(httpClient, BaseUrl, definitionId); + try + { + var jobs = await client.ListJobs(); + Assert.True(jobs.Total >= 1); + var entry = jobs.Data.First(j => j.ProcessInstanceId == processInstanceId); + Assert.Equal("External Worker task", entry.ElementName); + Assert.Equal(3, entry.Retries); + Assert.True(entry.CreateTime < DateTime.Now); + + var job = await client.GetJob(entry.Id); + Assert.Equal("External Worker task", job.ElementName); + Assert.Equal(3, job.Retries); + Assert.True(job.CreateTime < DateTime.Now); + } + finally + { + await BpmnUtils.TerminateProcess(httpClient, BaseUrl, processInstanceId); + await BpmnUtils.DeleteDeployment(httpClient, BaseUrl, deploymentId); + cassette.Save(); + } + } + + [Fact] + public async Task TestAcquireJobs() + { + using var cassette = Vcr.UseCassette(); + var httpClient = cassette.CreateHttpClient(); + httpClient.DefaultRequestHeaders.Authorization = Auth; + var client = new FlowableExternalWorkerRestClient(BaseUrl, "test-worker", httpClient); + + var deploymentId = await BpmnUtils.DeployProcess( + httpClient, BaseUrl, Path.Combine(FixturesPath, "Processes", "externalWorkerProcess.bpmn")); + var definitionId = await BpmnUtils.GetProcessDefinitionId(httpClient, BaseUrl, deploymentId); + var processInstanceId = await BpmnUtils.StartProcess(httpClient, BaseUrl, definitionId); + try + { + var acquiredJobs = await client.AcquireJobs("myTopic", "PT10S"); + Assert.Equal(1, acquiredJobs.Count); + + var firstEntry = acquiredJobs[0]; + Assert.Equal("External Worker task", firstEntry.ElementName); + Assert.True(firstEntry.CreateTime < DateTime.Now); + Assert.True(firstEntry.Variables.Count >= 1); + + var initiatorVar = firstEntry.Variables.Find(v => v.Name == "initiator"); + Assert.NotNull(initiatorVar); + Assert.Equal("admin", initiatorVar.Value?.ToString()); + } + finally + { + await BpmnUtils.TerminateProcess(httpClient, BaseUrl, processInstanceId); + await BpmnUtils.DeleteDeployment(httpClient, BaseUrl, deploymentId); + cassette.Save(); + } + } + + [Fact] + public async Task TestCompleteJob() + { + using var cassette = Vcr.UseCassette(); + var httpClient = cassette.CreateHttpClient(); + httpClient.DefaultRequestHeaders.Authorization = Auth; + var client = new FlowableExternalWorkerRestClient(BaseUrl, "test-worker", httpClient); + + var deploymentId = await BpmnUtils.DeployProcess( + httpClient, BaseUrl, Path.Combine(FixturesPath, "Processes", "externalWorkerProcess.bpmn")); + var definitionId = await BpmnUtils.GetProcessDefinitionId(httpClient, BaseUrl, deploymentId); + var processInstanceId = await BpmnUtils.StartProcess(httpClient, BaseUrl, definitionId); + try + { + var acquiredJobs = await client.AcquireJobs("myTopic", "PT10S"); + Assert.Equal(1, acquiredJobs.Count); + + var firstEntry = acquiredJobs[0]; + Assert.Equal("External Worker task", firstEntry.ElementName); + + var variables = new List + { + new("testVar", "string", "test content") + }; + + await client.CompleteJob(firstEntry.Id, variables); + + var variable = await BpmnUtils.GetProcessVariable(httpClient, BaseUrl, processInstanceId, "testVar"); + Assert.NotNull(variable); + Assert.Equal("string", variable.Value.GetProperty("type").GetString()); + Assert.Equal("test content", variable.Value.GetProperty("value").GetString()); + + var activityIds = await BpmnUtils.ExecutedActivityIds(httpClient, BaseUrl, processInstanceId); + Assert.Equal( + new List + { + "bpmnEndEvent_1", "bpmnSequenceFlow_2", "bpmnSequenceFlow_4", "bpmnTask_3", "startnoneevent1" + }, + activityIds); + } + finally + { + await BpmnUtils.DeleteDeployment(httpClient, BaseUrl, deploymentId); + cassette.Save(); + } + } + + [Fact] + public async Task TestJobWithBpmnErrorWithoutErrorCode() + { + using var cassette = Vcr.UseCassette(); + var httpClient = cassette.CreateHttpClient(); + httpClient.DefaultRequestHeaders.Authorization = Auth; + var client = new FlowableExternalWorkerRestClient(BaseUrl, "test-worker", httpClient); + + var deploymentId = await BpmnUtils.DeployProcess( + httpClient, BaseUrl, Path.Combine(FixturesPath, "Processes", "withBoundaryEvent.bpmn")); + var definitionId = await BpmnUtils.GetProcessDefinitionId(httpClient, BaseUrl, deploymentId); + var processInstanceId = await BpmnUtils.StartProcess(httpClient, BaseUrl, definitionId); + try + { + var acquiredJobs = await client.AcquireJobs("myTopic", "PT10S"); + Assert.Equal(1, acquiredJobs.Count); + + var firstEntry = acquiredJobs[0]; + Assert.Equal("External Worker task", firstEntry.ElementName); + + var variables = new List + { + new("testVar", "string", "test failure") + }; + + await client.JobWithBpmnError(firstEntry.Id, variables); + + var variable = + await BpmnUtils.GetProcessVariable(httpClient, BaseUrl, processInstanceId, "testVar"); + Assert.NotNull(variable); + Assert.Equal("string", variable.Value.GetProperty("type").GetString()); + Assert.Equal("test failure", variable.Value.GetProperty("value").GetString()); + + var activityIds = await BpmnUtils.ExecutedActivityIds(httpClient, BaseUrl, processInstanceId); + Assert.Equal( + new List + { + "bpmnBoundaryEvent_3", "bpmnBoundaryEvent_4", "bpmnEndEvent_5", "bpmnSequenceFlow_2", + "bpmnSequenceFlow_6", "bpmnTask_3", "startnoneevent1" + }, + activityIds); + } + finally + { + await BpmnUtils.DeleteDeployment(httpClient, BaseUrl, deploymentId); + cassette.Save(); + } + } + + [Fact] + public async Task TestJobWithBpmnErrorWithErrorCode1() + { + using var cassette = Vcr.UseCassette(); + var httpClient = cassette.CreateHttpClient(); + httpClient.DefaultRequestHeaders.Authorization = Auth; + var client = new FlowableExternalWorkerRestClient(BaseUrl, "test-worker", httpClient); + + var deploymentId = await BpmnUtils.DeployProcess( + httpClient, BaseUrl, Path.Combine(FixturesPath, "Processes", "withBoundaryEvent.bpmn")); + var definitionId = await BpmnUtils.GetProcessDefinitionId(httpClient, BaseUrl, deploymentId); + var processInstanceId = await BpmnUtils.StartProcess(httpClient, BaseUrl, definitionId); + try + { + var acquiredJobs = await client.AcquireJobs("myTopic", "PT10S"); + Assert.Equal(1, acquiredJobs.Count); + + var firstEntry = acquiredJobs[0]; + Assert.Equal("External Worker task", firstEntry.ElementName); + + var variables = new List + { + new("testVar", "string", "test failure") + }; + + await client.JobWithBpmnError(firstEntry.Id, variables, errorCode: "errorCode1"); + + var variable = + await BpmnUtils.GetProcessVariable(httpClient, BaseUrl, processInstanceId, "testVar"); + Assert.NotNull(variable); + Assert.Equal("string", variable.Value.GetProperty("type").GetString()); + Assert.Equal("test failure", variable.Value.GetProperty("value").GetString()); + + var activityIds = await BpmnUtils.ExecutedActivityIds(httpClient, BaseUrl, processInstanceId); + Assert.Equal( + new List + { + "bpmnBoundaryEvent_3", "bpmnBoundaryEvent_4", "bpmnEndEvent_5", "bpmnSequenceFlow_2", + "bpmnSequenceFlow_6", "bpmnTask_3", "startnoneevent1" + }, + activityIds); + } + finally + { + await BpmnUtils.DeleteDeployment(httpClient, BaseUrl, deploymentId); + cassette.Save(); + } + } + + [Fact] + public async Task TestJobWithBpmnErrorWithErrorCode2() + { + using var cassette = Vcr.UseCassette(); + var httpClient = cassette.CreateHttpClient(); + httpClient.DefaultRequestHeaders.Authorization = Auth; + var client = new FlowableExternalWorkerRestClient(BaseUrl, "test-worker", httpClient); + + var deploymentId = await BpmnUtils.DeployProcess( + httpClient, BaseUrl, Path.Combine(FixturesPath, "Processes", "withBoundaryEvent.bpmn")); + var definitionId = await BpmnUtils.GetProcessDefinitionId(httpClient, BaseUrl, deploymentId); + var processInstanceId = await BpmnUtils.StartProcess(httpClient, BaseUrl, definitionId); + try + { + var acquiredJobs = await client.AcquireJobs("myTopic", "PT10S"); + Assert.Equal(1, acquiredJobs.Count); + + var firstEntry = acquiredJobs[0]; + Assert.Equal("External Worker task", firstEntry.ElementName); + + var variables = new List + { + new("testVar", "string", "test failure") + }; + + await client.JobWithBpmnError(firstEntry.Id, variables, errorCode: "errorCode2"); + + var variable = + await BpmnUtils.GetProcessVariable(httpClient, BaseUrl, processInstanceId, "testVar"); + Assert.NotNull(variable); + Assert.Equal("string", variable.Value.GetProperty("type").GetString()); + Assert.Equal("test failure", variable.Value.GetProperty("value").GetString()); + + var activityIds = await BpmnUtils.ExecutedActivityIds(httpClient, BaseUrl, processInstanceId); + Assert.Equal( + new List + { + "bpmnBoundaryEvent_3", "bpmnBoundaryEvent_4", "bpmnEndEvent_7", "bpmnSequenceFlow_2", + "bpmnSequenceFlow_8", "bpmnTask_3", "startnoneevent1" + }, + activityIds); + } + finally + { + await BpmnUtils.DeleteDeployment(httpClient, BaseUrl, deploymentId); + cassette.Save(); + } + } + + [Fact] + public async Task TestFailJob() + { + using var cassette = Vcr.UseCassette(); + var httpClient = cassette.CreateHttpClient(); + httpClient.DefaultRequestHeaders.Authorization = Auth; + var client = new FlowableExternalWorkerRestClient(BaseUrl, "test-worker", httpClient); + + var deploymentId = await BpmnUtils.DeployProcess( + httpClient, BaseUrl, Path.Combine(FixturesPath, "Processes", "externalWorkerProcess.bpmn")); + var definitionId = await BpmnUtils.GetProcessDefinitionId(httpClient, BaseUrl, deploymentId); + var processInstanceId = await BpmnUtils.StartProcess(httpClient, BaseUrl, definitionId); + try + { + var acquiredJobs = await client.AcquireJobs("myTopic", "PT10S"); + Assert.Equal(1, acquiredJobs.Count); + + var firstEntry = acquiredJobs[0]; + Assert.Equal("External Worker task", firstEntry.ElementName); + Assert.Equal(3, firstEntry.Retries); + + await client.FailJob(firstEntry.Id); + + var jobAfterFail = await client.GetJob(firstEntry.Id); + Assert.Equal(2, jobAfterFail.Retries); + + var activityIds = await BpmnUtils.ExecutedActivityIds(httpClient, BaseUrl, processInstanceId); + Assert.Equal( + new List { "bpmnSequenceFlow_2", "bpmnTask_3", "startnoneevent1" }, + activityIds); + } + finally + { + await BpmnUtils.TerminateProcess(httpClient, BaseUrl, processInstanceId); + await BpmnUtils.DeleteDeployment(httpClient, BaseUrl, deploymentId); + cassette.Save(); + } + } + + [Fact] + public async Task TestJobWithCmmnTerminate() + { + using var cassette = Vcr.UseCassette(); + var httpClient = cassette.CreateHttpClient(); + httpClient.DefaultRequestHeaders.Authorization = Auth; + var client = new FlowableExternalWorkerRestClient(BaseUrl, "test-worker", httpClient); + + var deploymentId = await CmmnUtils.DeployCase( + httpClient, BaseUrl, Path.Combine(FixturesPath, "Cases", "externalWorkerCase.cmmn")); + var definitionId = await CmmnUtils.GetCaseDefinitionId(httpClient, BaseUrl, deploymentId); + var caseInstanceId = await CmmnUtils.StartCase(httpClient, BaseUrl, definitionId); + try + { + var acquiredJobs = await client.AcquireJobs("cmmnTopic", "PT10S"); + Assert.Equal(1, acquiredJobs.Count); + + var firstEntry = acquiredJobs[0]; + Assert.Equal("External Worker task", firstEntry.ElementName); + + var variables = new List + { + new("testVar", "string", "test terminate") + }; + + await client.JobWithCmmnTerminate(firstEntry.Id, variables); + + var variable = + await CmmnUtils.GetCaseVariable(httpClient, BaseUrl, caseInstanceId, "testVar"); + Assert.NotNull(variable); + Assert.Equal("string", variable.Value.GetProperty("type").GetString()); + Assert.Equal("test terminate", variable.Value.GetProperty("value").GetString()); + } + finally + { + await CmmnUtils.DeleteCaseDeployment(httpClient, BaseUrl, deploymentId); + cassette.Save(); + } + } + + private class BasicAuthCustomizer : IHttpClientCustomizer + { + public void Customize(HttpClient client) + { + client.DefaultRequestHeaders.Authorization = + new AuthenticationHeaderValue("Basic", + Convert.ToBase64String(Encoding.UTF8.GetBytes("admin:test"))); + } + } +} diff --git a/FlowableExternalWorkerClient.Tests/Vcr.cs b/FlowableExternalWorkerClient.Tests/Vcr.cs new file mode 100644 index 0000000..0fc925a --- /dev/null +++ b/FlowableExternalWorkerClient.Tests/Vcr.cs @@ -0,0 +1,21 @@ +using System.Runtime.CompilerServices; + +namespace FlowableExternalWorkerClient.Tests; + +/// +/// VCR-style HTTP recording/replay helper, similar to Python's VCR.py. +/// Creates a CassetteHandler that auto-records on first run and replays on subsequent runs. +/// Cassette files are stored in the source tree under Fixtures/Cassettes/. +/// +public static class Vcr +{ + public static CassetteHandler UseCassette( + [CallerMemberName] string testName = "", + [CallerFilePath] string callerFilePath = "") + { + var cassettesDir = Path.Combine( + Path.GetDirectoryName(callerFilePath)!, "Fixtures", "Cassettes"); + var cassettePath = Path.Combine(cassettesDir, testName + ".json"); + return new CassetteHandler(cassettePath); + } +} diff --git a/FlowableExternalWorkerClient.Tests/xunit.runner.json b/FlowableExternalWorkerClient.Tests/xunit.runner.json new file mode 100644 index 0000000..dd80f43 --- /dev/null +++ b/FlowableExternalWorkerClient.Tests/xunit.runner.json @@ -0,0 +1,5 @@ +{ + "$schema": "https://xunit.net/schema/current/xunit.runner.schema.json", + "parallelizeAssembly": false, + "parallelizeTestCollections": false +} diff --git a/FlowableExternalWorkerClient.sln b/FlowableExternalWorkerClient.sln index 9f7f06d..02b7949 100644 --- a/FlowableExternalWorkerClient.sln +++ b/FlowableExternalWorkerClient.sln @@ -1,7 +1,10 @@  Microsoft Visual Studio Solution File, Format Version 12.00 +# Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "FlowableExternalWorkerClient", "FlowableExternalWorkerClient\FlowableExternalWorkerClient.csproj", "{8BF2F4EF-0DE1-4F68-AB1A-7DAB7DB4F2ED}" EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "FlowableExternalWorkerClient.Tests", "FlowableExternalWorkerClient.Tests\FlowableExternalWorkerClient.Tests.csproj", "{4E66CBDA-5482-4977-9F60-5D6DD71EEB31}" +EndProject Global GlobalSection(SolutionConfigurationPlatforms) = preSolution Debug|Any CPU = Debug|Any CPU @@ -12,5 +15,9 @@ Global {8BF2F4EF-0DE1-4F68-AB1A-7DAB7DB4F2ED}.Debug|Any CPU.Build.0 = Debug|Any CPU {8BF2F4EF-0DE1-4F68-AB1A-7DAB7DB4F2ED}.Release|Any CPU.ActiveCfg = Release|Any CPU {8BF2F4EF-0DE1-4F68-AB1A-7DAB7DB4F2ED}.Release|Any CPU.Build.0 = Release|Any CPU + {4E66CBDA-5482-4977-9F60-5D6DD71EEB31}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {4E66CBDA-5482-4977-9F60-5D6DD71EEB31}.Debug|Any CPU.Build.0 = Debug|Any CPU + {4E66CBDA-5482-4977-9F60-5D6DD71EEB31}.Release|Any CPU.ActiveCfg = Release|Any CPU + {4E66CBDA-5482-4977-9F60-5D6DD71EEB31}.Release|Any CPU.Build.0 = Release|Any CPU EndGlobalSection EndGlobal diff --git a/FlowableExternalWorkerClient/Client/ExternalWorkerClient.cs b/FlowableExternalWorkerClient/Client/ExternalWorkerClient.cs index 09eac09..a7368bb 100644 --- a/FlowableExternalWorkerClient/Client/ExternalWorkerClient.cs +++ b/FlowableExternalWorkerClient/Client/ExternalWorkerClient.cs @@ -23,6 +23,19 @@ public ExternalWorkerClient( ); } + public ExternalWorkerClient( + string flowableHost, + string workerId, + HttpClient httpClient + ) + { + _flowableExternalWorkerRestClient = new FlowableExternalWorkerRestClient( + flowableHost, + workerId, + httpClient + ); + } + public IExternalWorkerSubscription Subscribe( string topic, IExternalWorkerCallbackHandler callbackHandler, diff --git a/FlowableExternalWorkerClient/Client/WorkResult.cs b/FlowableExternalWorkerClient/Client/WorkResult.cs index 10aee02..798036f 100644 --- a/FlowableExternalWorkerClient/Client/WorkResult.cs +++ b/FlowableExternalWorkerClient/Client/WorkResult.cs @@ -40,25 +40,25 @@ public WorkResultFailure(ExternalWorkerAcquireJobResponse job) _jobId = job.Id; } - WorkResultFailure ErrorMessage(string errorMessage) + public WorkResultFailure ErrorMessage(string errorMessage) { _errorMessage = errorMessage; return this; } - WorkResultFailure ErrorDetails(string errorDetails) + public WorkResultFailure ErrorDetails(string errorDetails) { _errorDetails = errorDetails; return this; } - WorkResultFailure Retries(int retries) + public WorkResultFailure Retries(int retries) { _retries = retries; return this; } - WorkResultFailure RetryTimeout(string retryTimeout) + public WorkResultFailure RetryTimeout(string retryTimeout) { _retryTimeout = retryTimeout; return this; diff --git a/FlowableExternalWorkerClient/FlowableExternalWorkerClient.csproj b/FlowableExternalWorkerClient/FlowableExternalWorkerClient.csproj index e4294a1..3ab62b6 100644 --- a/FlowableExternalWorkerClient/FlowableExternalWorkerClient.csproj +++ b/FlowableExternalWorkerClient/FlowableExternalWorkerClient.csproj @@ -1,7 +1,7 @@ - net7.0 + net9.0 enable enable diff --git a/FlowableExternalWorkerClient/Rest/FlowableExternalWorkerRestClient.cs b/FlowableExternalWorkerClient/Rest/FlowableExternalWorkerRestClient.cs index b27b133..a952ccf 100644 --- a/FlowableExternalWorkerClient/Rest/FlowableExternalWorkerRestClient.cs +++ b/FlowableExternalWorkerClient/Rest/FlowableExternalWorkerRestClient.cs @@ -41,6 +41,24 @@ public FlowableExternalWorkerRestClient( _workerId = workerId; } + public FlowableExternalWorkerRestClient( + string flowableHost, + string workerId, + HttpClient httpClient, + IHttpClientCustomizer? customizer = null + ) + { + _httpClient = httpClient; + + if (customizer != null) + { + customizer.Customize(_httpClient); + } + + _flowableHost = flowableHost; + _workerId = workerId; + } + public async Task> ListJobs() { var response = await _httpClient.GetStreamAsync(_flowableHost + _jobApi + "/jobs"); From 592e5d0e5ee600efe8205b682cc19e73467c7c0a Mon Sep 17 00:00:00 2001 From: Valentin Zickner Date: Wed, 11 Feb 2026 17:37:03 +0100 Subject: [PATCH 2/2] remove static wait and switch to thread subscription --- .../ExternalWorkerClientTests.cs | 77 +++++++++++++------ 1 file changed, 55 insertions(+), 22 deletions(-) diff --git a/FlowableExternalWorkerClient.Tests/ExternalWorkerClientTests.cs b/FlowableExternalWorkerClient.Tests/ExternalWorkerClientTests.cs index 92ccc96..4979b36 100644 --- a/FlowableExternalWorkerClient.Tests/ExternalWorkerClientTests.cs +++ b/FlowableExternalWorkerClient.Tests/ExternalWorkerClientTests.cs @@ -15,33 +15,44 @@ public class ExternalWorkerClientTests private string FixturesPath => Path.Combine(AppContext.BaseDirectory, "Fixtures"); - private ExternalWorkerAcquireJobResponse ConsumeOneCall( + /// + /// Subscribes to a topic, waits for a single job to be processed (including the + /// work result's Execute call), and returns the job. Uses an ExecutionAwareWorkResult + /// wrapper to properly await the subscription's async work, avoiding static delays. + /// + private async Task ConsumeOneCallAsync( ExternalWorkerClient client, Func callbackHandler, string topic = "myTopic") { ExternalWorkerAcquireJobResponse? resultJob = null; - var completed = false; + var executionCompleted = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously); var handler = new DelegateCallbackHandler((job, work) => { var result = callbackHandler(job, work); resultJob = job; - completed = true; - return result; + if (result == null) + { + executionCompleted.TrySetResult(true); + return null; + } + return new ExecutionAwareWorkResult(result, executionCompleted); }); var subscription = client.Subscribe(topic, handler, waitPeriodSeconds: 1); - var attempts = 0; - while (attempts < 50 && !completed) + try + { + await executionCompleted.Task.WaitAsync(TimeSpan.FromSeconds(10)); + } + catch (TimeoutException) { - Thread.Sleep(200); - attempts++; + subscription.Unsubscribe(); + Assert.Fail("Callback was not invoked or execution did not complete within the timeout period"); } subscription.Unsubscribe(); - Assert.True(completed, "Callback was not invoked within the timeout period"); return resultJob!; } @@ -59,7 +70,7 @@ public async Task TestConsume() var processInstanceId = await BpmnUtils.StartProcess(httpClient, BaseUrl, definitionId); try { - ConsumeOneCall(client, (job, work) => work.Success()); + await ConsumeOneCallAsync(client, (job, work) => work.Success()); var activityIds = await BpmnUtils.ExecutedActivityIds(httpClient, BaseUrl, processInstanceId); Assert.Equal( @@ -90,7 +101,7 @@ public async Task TestConsumeWithFailure() var processInstanceId = await BpmnUtils.StartProcess(httpClient, BaseUrl, definitionId); try { - ConsumeOneCall(client, (job, work) => + await ConsumeOneCallAsync(client, (job, work) => work.Failure() .ErrorMessage("Test Error Message") .ErrorDetails("Some error details") @@ -98,9 +109,6 @@ public async Task TestConsumeWithFailure() .RetryTimeout("PT5M") ); - // Give the server a moment to process - if (!cassette.IsReplaying) await Task.Delay(500); - var activityIds = await BpmnUtils.ExecutedActivityIds(httpClient, BaseUrl, processInstanceId); Assert.Equal( new List { "bpmnSequenceFlow_2", "bpmnTask_3", "startnoneevent1" }, @@ -128,15 +136,12 @@ public async Task TestConsumeWithCmmnTerminate() var caseInstanceId = await CmmnUtils.StartCase(httpClient, BaseUrl, definitionId); try { - ConsumeOneCall( + await ConsumeOneCallAsync( client, (job, work) => work.CmmnTerminate().Variable("testVar", "test terminate"), topic: "cmmnTopic" ); - // Give the server a moment to process - if (!cassette.IsReplaying) await Task.Delay(500); - var variable = await CmmnUtils.GetCaseVariable(httpClient, BaseUrl, caseInstanceId, "testVar"); Assert.NotNull(variable); Assert.Equal("string", variable.Value.GetProperty("type").GetString()); @@ -163,15 +168,12 @@ public async Task TestSubscribeWithBpmnError() var processInstanceId = await BpmnUtils.StartProcess(httpClient, BaseUrl, definitionId); try { - ConsumeOneCall(client, (job, work) => + await ConsumeOneCallAsync(client, (job, work) => work.BpmnError() .Variable("testVar", "test failure") .ErrorCode("errorCode1") ); - // Give the server a moment to process - if (!cassette.IsReplaying) await Task.Delay(500); - var variable = await BpmnUtils.GetProcessVariable(httpClient, BaseUrl, processInstanceId, "testVar"); Assert.NotNull(variable); @@ -209,4 +211,35 @@ public DelegateCallbackHandler( return _handler(job, work); } } + + /// + /// Wraps an IWorkResult to signal a TaskCompletionSource when Execute completes. + /// This lets ConsumeOneCallAsync wait for the subscription's async work to finish + /// instead of using a static delay. + /// + private class ExecutionAwareWorkResult : IWorkResult + { + private readonly IWorkResult _inner; + private readonly TaskCompletionSource _tcs; + + public ExecutionAwareWorkResult(IWorkResult inner, TaskCompletionSource tcs) + { + _inner = inner; + _tcs = tcs; + } + + public async Task Execute(IFlowableExternalWorkerRestClient client) + { + try + { + await _inner.Execute(client); + _tcs.TrySetResult(true); + } + catch (Exception ex) + { + _tcs.TrySetException(ex); + throw; + } + } + } }