zeebe_bpmn_rspec 0.2.0 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7ee557a1aed97212da2a198eafd8238859e12499f32e8ddf24d97d5240c83c36
-  data.tar.gz: 0105ee8a65e00fbab192cf6f76710e43973bec36324b3defcc4f83882db833ca
+  metadata.gz: dbc8b0a3a6bf05f4ef29f2a5285b452afa1e733f2e166a521ba28e48dc2f94d1
+  data.tar.gz: 5ef538eea22fce15ba4356ea06204891b69ec51170706cc804d005f1639107f6
 SHA512:
-  metadata.gz: 978a61f885179d519ede6340a283b93f9c36e1d712c1279629500732afe01a9f9ac7483a484c17d99356bcebb0258fb04f65771492a6d2b6774cd9be64454f1b
-  data.tar.gz: 6f235e5995f75fd04b7996708bb8a23d81cbb1b7bf1ecd8ebea46a5fba78fa1e5c60f8ab1e305e263d0e16e7ac2005dad78dfdf5e684528ff3cdf3343a2f9c2e
+  metadata.gz: 89756e04128e43c7386cc13f785dc3146568b76a7ed5b841c9ec71851f243f043c5d91e1709dd6a44ec41dc05f6e8c2c2414e20fb4227eb3a896b1ee12efad5f
+  data.tar.gz: 3e2f49b5e1ad94878f83ac4b6efb69028a77728e3f53b8f46b2fa134cc6ea63b19f7f3c9e88717ab9942cc0daf97d103ebdfdb12492e937c5f59361b1ec069dd

data/CHANGELOG.md

@@ -1,5 +1,33 @@
 # zeebe_bpmn_rspec
 
+## v1.0.0
+- Support Zeebe 1.0.0. Method names now use `process` instead of `workflow`
+  to match the renaming in Zeebe. Previous methods are deprecated and will be
+  removed in a future release.
+
+## v0.5.0 (unreleased)
+- Require Ruby 2.6 or later.
+- Require `worker` to be specified when activating a job. This argument is
+  defaulted but can no longer be specified as blank.
+
+## v0.4.1
+- Allow `with_workflow_instance` to be called without a block.
+- Allow `worker` to be specified when activating a job.
+- Expose `workflow_instance_key` for activated jobs.
+
+## v0.4.0
+- Add `ttl_ms` option for `publish_message`.
+- Add `update_retries` method to `ActivatedJob` class.
+- Add `set_variables` helper.
+- Add support for `:fetch_variables` option when activating jobs.
+
+## v0.3.1
+- Use consistent activate request timeout.
+- Provide a better error when a job is not activated.
+
+## v0.3.0
+- Add custom matchers, `have_variables`, `have_headers`, and `have_activated`.
+
 ## v0.2.0
 - Add `retries` option to `ActivatedJob#and_fail`.
 - Add method aliases: `and_complete` (`complete`), `and_fail` (`fail`), `and_throw_error` (`throw_error`).

data/README.md

@@ -39,24 +39,26 @@ end
 
 The gem adds the following helper methods to RSpec.
 
-### Deploy Workflow
+The gem also defines [Custom Matchers](#custom-matchers).
 
-The `deploy_workflow` method requires a path to a BPMN file and deploys it to Zeebe. There is no support for
+### Deploy Process
+
+The `deploy_process` (previously `deploy_workflow`) method requires a path to a BPMN file and deploys it to Zeebe. There is no support for
 removing a BPMN file once deployed, so this can be done once before the examples that use it.
 
 ```ruby
-before(:all) { deploy_workflow(filepath) }
+before(:all) { deploy_process(filepath) }
 ```
 
-A custom name can also be specified for the workflow:
+A custom name can also be specified for the process:
 
 ```ruby
-before(:all) { deploy_workflow(filepath, "custom_name") }
+before(:all) { deploy_process(filepath, "custom_name") }
 ```
 
-### With Workflow Instance
+### With Process Instance
 
-The `with_workflow_instance` method is used to create an instance for the specified workflow
+The `with_process_instance` (previously `with_workflow_instance`) method is used to create an instance for the specified process
 and then yields a block that can interact with the instance.
 
 This method ensures that an active instance is cancelled at the end of the block.
@@ -65,14 +67,14 @@ For testing BPMN files it is expected that most of the test definition will be w
 call to this method.
 
 ```ruby
-with_workflow_instance("file_basename") do
+with_process_instance("file_basename") do
   ...
 end
 ```
 
 ### Processing Jobs
 
-A single job can be processed for a workflow by calling `activate_job` (previously `process_job`).
+A single job can be processed for a process by calling `activate_job` (previously `process_job`).
 `activate_job` is called with a job type:
 
 ```ruby
@@ -127,8 +129,8 @@ activate_job("my_job").
   expect_input(user_id: 123).
   and_complete
 
-# Jobs can be completed with data that is merged with variables in the workflow
-project_job("my_job").
+# Jobs can be completed with data that is merged with variables in the process
+activate_job("my_job").
   and_complete(status: "ACTIVATED")
 ```
 
@@ -155,6 +157,16 @@ job = activate_job("my_job")
 job.fail(retries: 1)
 ```
 
+#### Update Retries
+
+The retries for a job can also be modified using the `update_retries` method:
+
+```ruby
+job = activate_job("my_job")
+
+job.update_retries(3)
+```
+
 #### Throw Error
 
 The `and_throw_error` (also aliased as `throw_error`) method can be used to throw an error for a job. The error code is required and an
@@ -186,17 +198,17 @@ The maximum number of jobs to return can be specified:
 jobs = activate_jobs("my_job", max_jobs: 2).to_a
 ```
 
-### Workflow Complete
+### Process Complete
 
-The `workflow_complete!` method can be used to assert that the current workflow is complete at the end of a
-test. This is implemented by cancelling the workflow and checking for an error that it is already
+The `process_complete!` (previously `workflow_complete!`) method can be used to assert that the current process is complete at the end of a
+test. This is implemented by cancelling the process and checking for an error that it is already
 complete.
 
 ```ruby
-with_workflow_instance("file_basename") do
+with_process_instance("file_basename") do
   ...
 
-  workflow_complete!
+  process_complete!
 end
 ```
 
@@ -217,6 +229,131 @@ publish_message("message_name", correlation_key: expected_value,
                 variables: { foo: "bar" })
 ```
 
+The time-to-live (in milliseconds) cna also be specified for a message.
+It defaults to 5000 milliseconds if unspecified.
+
+```ruby
+publish_message("message_name", correlation_key: expected_value, ttl_ms: 1000)
+```
+
+### Set Variables
+
+The `set_variables` method can be used to set variables for a specified
+scope in Zeebe:
+
+```ruby
+# process_instance_key is a method that returns the key for the current process instance
+set_variables(process_instance_key, { foo: "bar" })
+```
+
+An activated job can be used to determine the key for the task that it is associated with:
+
+```ruby
+job = job_with_type("my_type")
+set_variables(job.task_key, { foo: "baz"})
+```
+
+Variables default to being local to the scope on which they are set. This
+can be overridden by specifying the `:local` option:
+
+```ruby
+set_variables(job.task_key, { foo: "baz"}, local: false)
+```
+
+### Custom Matchers
+
+In addition to the helpers documented above, this gem defines custom RSpec matchers to provide a more typical
+experience of expectations and matchers.
+
+#### expect_job_of_type
+
+The `expect_job_of_type` helper is a convenient wrapper to activate a job and set an expectation target.
+
+```ruby
+expect_job_of_type("my_type")
+```
+
+Similar to the `activate_job` helper, it activates a job and wraps the result in an `ActivatedJob` object.
+That object is then passed to `expect()`. Unlike `activate_job`, this helper does not raise if there is no job activated.
+
+This is equivalent to `expect(job_with_type("my_type")` or `expect(activate_job("my_type", validate: false))`.
+
+`expect_job_of_type` is expected to be used with the matchers below.
+
+#### have_activated
+
+The `have_activated` matcher checks that the target represents an activated job. It will raise an error if no job
+was activated.
+
+```ruby
+expect_job_of_type("my_type").to have_activated
+```
+
+Various additional methods can be chained on the `have_activated` matcher.
+
+The `with_variables` method can be used to check the input variables that the job was activated with:
+
+```ruby
+expect_job_of_type("my_type").to have_activated.with_variables(user_id: 123)
+```
+
+The `with_headers` method can be used to check the headers that the job was activated with:
+
+```ruby
+expect_job_of_type("my_type").to have_activated.with_headers(id_type: "user")
+```
+
+The `with_variables` and `with_headers` methods can be chained on the same expectation:
+
+```ruby
+expect_job_of_type("my_type").to have_activated.
+                                   with_variables(user_id: 123).
+                                   with_headers(id_type: "user")
+```
+
+The matcher also supports methods to complete, fail, or throw an error for a job:
+
+```ruby
+# Complete
+expect_job_of_type("my_type").to have_activated.and_complete
+
+# Complete with new variables
+expect_job_of_type("my_type").to have_activated.and_complete(result_code: 456)
+
+# Fail (sets retries to 0 by default)
+expect_job_of_type("my_type").to have_activated.and_fail
+
+# Fail and specify retries
+expect_job_of_type("my_type").to have_activated.and_fail(retries: 1)
+
+# Fail with an error message
+expect_job_of_type("my_type").to have_activated.and_fail("boom!")
+
+# Fail with an error message and specify retries
+expect_job_of_type("my_type").to have_activated.and_fail("boom!", retries: 2)
+
+# Throw an error (error code is required)
+expect_job_of_type("my_type").to have_activated.and_throw_error("MY_ERROR")
+
+# Throw an error with an error message
+expect_job_of_type("my_type").to have_activated.and_throw_error("MY_ERROR", "went horribly wrong")
+```
+
+Only one of `and_complete`, `and_fail`, or `and_throw_error` can be specified for a single expectation.
+
+#### have_variables and have_headers
+
+In addition to the `with_variables` and `with_headers` methods that can be chained onto the `have_activated`
+matcher, there are matchers that can be used directly to set expectations on the variables or
+headers for an `ActivatedJob`.
+
+```ruby
+job = activate_job("my_type")
+
+expect(job).to have_variables(user: 123)
+expect(job).to have_headers(id_type: "user")
+```
+
 ## Tips & Tricks
 
 ### Enumerator for Multiple Jobs
@@ -233,7 +370,7 @@ to specify a short duration.
 
 The current gem and approach have some limitations:
 
-1. You can interact with only one workflow at a time.
+1. You can interact with only one process at a time.
 
 ## Development
 

data/docker-compose.simple-monitor.yml

@@ -0,0 +1,17 @@
+version: "3.4"
+
+services:
+  zeebe:
+    volumes:
+      - ./compose/zeebe-hazelcast-exporter.jar:/usr/local/zeebe/exporters/zeebe-hazelcast-exporter.jar
+      - ./compose/application.yml:/usr/local/zeebe/config/application.yaml
+
+  monitor:
+    image: camunda/zeebe-simple-monitor:0.19.1
+    environment:
+      - zeebe.client.broker.contactPoint=zeebe:26500
+      - zeebe.client.worker.hazelcast.connection=zeebe:5701
+    ports:
+      - "8082:8082"
+    depends_on:
+      - zeebe

data/docker-compose.yml

@@ -8,7 +8,7 @@ x-environment: &default-environment
   BUNDLE_DISABLE_SHARED_GEMS: "true"
   ZEEBE_ADDRESS: zeebe:26500
 x-service: &default-service
-  image: ruby:2.6.6
+  image: ruby:2.7.3
   volumes:
     - .:/usr/src/gem
     - ./compose/entrypoint.sh:/tmp/entrypoint.sh
@@ -18,22 +18,9 @@ x-service: &default-service
   stdin_open: true
 services:
   zeebe:
-    image: camunda/zeebe:0.23.4
+    image: camunda/zeebe:${ZEEBE_VERSION:-1.0.0}
     environment:
       ZEEBE_LOG_LEVEL: debug
-    volumes:
-      - ./compose/zeebe-hazelcast-exporter.jar:/usr/local/zeebe/exporters/zeebe-hazelcast-exporter.jar
-      - ./compose/application.yml:/usr/local/zeebe/config/application.yaml
-
-  monitor:
-    image: camunda/zeebe-simple-monitor:0.19.0
-    environment:
-      - zeebe.client.broker.contactPoint=zeebe:26500
-      - zeebe.client.worker.hazelcast.connection=zeebe:5701
-    ports:
-      - "8082:8082"
-    depends_on:
-      - zeebe
 
   console:
     <<: *default-service

data/lib/zeebe_bpmn_rspec.rb

@@ -1,14 +1,17 @@
 # frozen_string_literal: true
 
+require "active_support"
 require "rspec"
 require "zeebe/client"
+require "zeebe_bpmn_rspec/deprecate_workflow_alias"
 require "zeebe_bpmn_rspec/helpers"
 require "zeebe_bpmn_rspec/version"
+require "zeebe_bpmn_rspec/matchers/have_activated"
 
 # Top-level gem module
 module ZeebeBpmnRspec
   class << self
-    attr_writer :client, :zeebe_address
+    attr_writer :client, :zeebe_address, :activate_request_timeout
 
     def configure
       yield(self)
@@ -23,6 +26,10 @@ module ZeebeBpmnRspec
     def zeebe_address
       @zeebe_address || ENV["ZEEBE_ADDRESS"] || (raise "zeebe_address must be set")
     end
+
+    def activate_request_timeout
+      @activate_request_timeout || 1000
+    end
   end
 end
 

data/lib/zeebe_bpmn_rspec/activated_job.rb

@@ -1,34 +1,58 @@
 # frozen_string_literal: true
 
-require "active_support"
 require "active_support/core_ext/hash/keys"
 require "json"
 
 module ZeebeBpmnRspec
   class ActivatedJob
     include ::Zeebe::Client::GatewayProtocol # for direct reference of request classes
+    extend DeprecateWorkflowAlias
 
-    attr_reader :job, :type, :workflow_instance_key
+    attr_reader :job, :type
 
-    def initialize(job, type:, workflow_instance_key:, client:, context:)
+    def initialize(job, type:, process_instance_key:, client:, context:, validate:) # rubocop:disable Metrics/ParameterLists
       @job = job
       @type = type
-      @workflow_instance_key = workflow_instance_key
+      @process_instance_key = process_instance_key
       @client = client
       @context = context
 
-      context.instance_eval do
-        aggregate_failures do
-          expect(job.workflowInstanceKey).to eq(workflow_instance_key)
-          expect(job.type).to eq(type)
+      if validate
+        context.instance_eval do
+          expect(job).not_to be_nil, "expected to receive job of type '#{type}' but received none"
+          aggregate_failures do
+            expect(job.processInstanceKey).to eq(process_instance_key)
+            expect(job.type).to eq(type)
+          end
         end
       end
     end
 
+    def raw
+      job
+    end
+
     def key
       job.key
     end
 
+    def process_instance_key
+      job.processInstanceKey
+    end
+    deprecate_workflow_alias :workflow_instance_key, :process_instance_key
+
+    def retries
+      job.retries
+    end
+
+    def task_key
+      job.elementInstanceKey
+    end
+
+    def to_s
+      raw.to_s
+    end
+
     def variables
       @_variables ||= JSON.parse(job.variables)
     end
@@ -87,6 +111,13 @@ module ZeebeBpmnRspec
     end
     alias complete and_complete
 
+    def update_retries(retries = 1)
+      client.update_job_retries(UpdateJobRetriesRequest.new(
+                                  jobKey: job.key,
+                                  retries: retries
+                                ))
+    end
+
     private
 
     attr_reader :client, :context

data/lib/zeebe_bpmn_rspec/deprecate_workflow_alias.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require "active_support/deprecation"
+
+module ZeebeBpmnRspec
+  module DeprecateWorkflowAlias
+    WorkflowDeprecation = ActiveSupport::Deprecation.new("v2.0", "ZeebeBpmnRspec")
+
+    def deprecate_workflow_alias(deprecated_name, new_name)
+      alias_method deprecated_name, new_name
+      deprecate deprecated_name => new_name, deprecator: WorkflowDeprecation
+    end
+  end
+end

data/lib/zeebe_bpmn_rspec/helpers.rb

@@ -1,42 +1,44 @@
 # frozen_string_literal: true
 
+require "active_support/core_ext/object/blank"
 require "zeebe_bpmn_rspec/activated_job"
 
 module ZeebeBpmnRspec
   module Helpers # rubocop:disable Metrics/ModuleLength
     include ::Zeebe::Client::GatewayProtocol # for direct reference of request classes
-
-    def deploy_workflow(path, name = nil)
-      _zeebe_client.deploy_workflow(DeployWorkflowRequest.new(
-                                      workflows: [WorkflowRequestObject.new(
-                                        name: (name && "#{name}.bpmn") || File.basename(path),
-                                        type: WorkflowRequestObject::ResourceType::FILE,
-                                        definition: File.read(path)
-                                      )]
-                                    ))
+    extend DeprecateWorkflowAlias
+
+    def deploy_process(path, name = nil)
+      _zeebe_client.deploy_process(DeployProcessRequest.new(
+                                     processes: [ProcessRequestObject.new(
+                                       name: (name && "#{name}.bpmn") || File.basename(path),
+                                       definition: File.read(path)
+                                     )]
+                                   ))
     rescue StandardError => e
-      raise "Failed to deploy workflow: #{e}"
+      raise "Failed to deploy precess: #{e}"
     end
+    deprecate_workflow_alias :deploy_workflow, :deploy_process
 
-    def with_workflow_instance(name, variables = {})
+    def with_process_instance(name, variables = {})
       system_error = nil
-      workflow = _zeebe_client.create_workflow_instance(CreateWorkflowInstanceRequest.new(
-                                                          bpmnProcessId: name,
-                                                          version: -1, # always latest
-                                                          variables: variables.to_json
-                                                        ))
-      @__workflow_instance_key = workflow.workflowInstanceKey
-      yield(workflow.workflowInstanceKey)
+      process = _zeebe_client.create_process_instance(CreateProcessInstanceRequest.new(
+                                                        bpmnProcessId: name,
+                                                        version: -1, # always latest
+                                                        variables: variables.to_json
+                                                      ))
+      @__process_instance_key = process.processInstanceKey
+      yield(process.processInstanceKey) if block_given?
     rescue Exception => e # rubocop:disable Lint/RescueException
       # exceptions are rescued to ensure that instances are cancelled
       # any error is re-raised below
       system_error = e
     ensure
-      if workflow&.workflowInstanceKey
+      if process&.processInstanceKey
         begin
-          _zeebe_client.cancel_workflow_instance(CancelWorkflowInstanceRequest.new(
-                                                   workflowInstanceKey: workflow.workflowInstanceKey
-                                                 ))
+          _zeebe_client.cancel_process_instance(CancelProcessInstanceRequest.new(
+                                                  processInstanceKey: process.processInstanceKey
+                                                ))
         rescue GRPC::NotFound => _e
           # expected
         rescue StandardError => _e
@@ -45,56 +47,70 @@ module ZeebeBpmnRspec
       end
       raise system_error if system_error
     end
+    deprecate_workflow_alias :with_workflow_instance, :with_process_instance
 
-    def workflow_complete!
+    def process_complete!(wait_seconds: 0.25)
       error = nil
-      sleep 0.25 # TODO: configurable?
+      sleep(wait_seconds)
       begin
-        _zeebe_client.cancel_workflow_instance(CancelWorkflowInstanceRequest.new(
-                                                 workflowInstanceKey: workflow_instance_key
-                                               ))
+        _zeebe_client.cancel_process_instance(CancelProcessInstanceRequest.new(
+                                                processInstanceKey: process_instance_key
+                                              ))
       rescue GRPC::NotFound => e
         error = e
       end
 
-      raise "Expected workflow instance #{workflow_instance_key} to be complete" if error.nil?
+      raise "Expected process instance #{process_instance_key} to be complete" if error.nil?
     end
+    deprecate_workflow_alias :workflow_complete!, :process_complete!
 
-    def workflow_instance_key
-      @__workflow_instance_key
+    def process_instance_key
+      @__process_instance_key
     end
+    deprecate_workflow_alias :workflow_instance_key, :process_instance_key
 
-    def activate_job(type)
-      stream = _zeebe_client.activate_jobs(ActivateJobsRequest.new(
-                                             type: type,
-                                             worker: "#{type}-#{SecureRandom.hex}",
-                                             maxJobsToActivate: 1,
-                                             timeout: 5000, # TODO: configure
-                                             requestTimeout: 5000
-                                           ))
+    def activate_job(type, fetch_variables: nil, validate: true, worker: "#{type}-#{SecureRandom.hex}")
+      raise ArgumentError.new("'worker' cannot be blank") if worker.blank?
+
+      stream = _zeebe_client.activate_jobs(ActivateJobsRequest.new({
+        type: type,
+        worker: worker,
+        maxJobsToActivate: 1,
+        timeout: 1000,
+        fetchVariable: fetch_variables&.then { |v| Array(v) },
+        requestTimeout: ZeebeBpmnRspec.activate_request_timeout,
+      }.compact))
 
       job = nil
       stream.find { |response| job = response.jobs.first }
-      raise "No job with type #{type.inspect} found" if job.nil?
-
       # puts job.inspect # support debug logging?
 
       ActivatedJob.new(job,
                        type: type,
-                       workflow_instance_key: workflow_instance_key,
+                       process_instance_key: process_instance_key,
                        client: _zeebe_client,
-                       context: self)
+                       context: self,
+                       validate: validate)
     end
     alias process_job activate_job
-    # TODO: deprecate process_job
+    deprecate process_job: :activate_job
 
-    def activate_jobs(type, max_jobs: nil)
+    def job_with_type(type, fetch_variables: nil)
+      activate_job(type, fetch_variables: fetch_variables, validate: false)
+    end
+
+    def expect_job_of_type(type, fetch_variables: nil)
+      expect(job_with_type(type, fetch_variables: fetch_variables))
+    end
+
+    def activate_jobs(type, max_jobs: nil, fetch_variables: nil)
       stream = _zeebe_client.activate_jobs(ActivateJobsRequest.new({
         type: type,
         worker: "#{type}-#{SecureRandom.hex}",
         maxJobsToActivate: max_jobs,
-        timeout: 5000, # TODO: configure
-        requestTimeout: 5000,
+        timeout: 1000,
+        fetchVariable: fetch_variables&.then { |v| Array(v) },
+        requestTimeout: ZeebeBpmnRspec.activate_request_timeout,
       }.compact))
 
       Enumerator.new do |yielder|
@@ -102,27 +118,36 @@ module ZeebeBpmnRspec
           response.jobs.each do |job|
             yielder << ActivatedJob.new(job,
                                         type: type,
-                                        workflow_instance_key: workflow_instance_key,
+                                        process_instance_key: process_instance_key,
                                         client: _zeebe_client,
-                                        context: self)
+                                        context: self,
+                                        validate: true)
           end
         end
       end
     end
 
-    def publish_message(name, correlation_key:, variables: nil)
+    def publish_message(name, correlation_key:, variables: nil, ttl_ms: 5000)
       _zeebe_client.publish_message(PublishMessageRequest.new(
                                       {
                                         name: name,
                                         correlationKey: correlation_key,
-                                        timeToLive: 5000,
+                                        timeToLive: ttl_ms,
                                         variables: variables&.to_json,
                                       }.compact
                                     ))
     end
 
+    def set_variables(key, variables, local: true)
+      _zeebe_client.set_variables(SetVariablesRequest.new(
+                                    elementInstanceKey: key,
+                                    variables: variables.to_json,
+                                    local: local
+                                  ))
+    end
+
     def reset_zeebe!
-      @__workflow_instance_key = nil
+      @__process_instance_key = nil
     end
 
     private

data/lib/zeebe_bpmn_rspec/matchers/have_activated.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+require "zeebe_bpmn_rspec/matchers/have_variables"
+require "zeebe_bpmn_rspec/matchers/have_headers"
+
+module ZeebeBpmnRspec
+  class HaveActivatedMatcherError < StandardError
+    def initialize
+      super("Only one of complete, fail, and throw error can be specified")
+    end
+  end
+end
+
+# rubocop:disable Metrics/BlockLength
+RSpec::Matchers.define :have_activated do
+  match do |job|
+    @job = job
+
+    @matcher_error = nil
+    begin
+      aggregate_failures "activated job#{of_type(job)}" do
+        unless job.is_a?(ZeebeBpmnRspec::ActivatedJob)
+          raise ArgumentError.new("expectation target must be a "\
+                                  "#{ZeebeBpmnRspec::ActivatedJob.name}, got #{job.inspect}")
+        end
+
+        if job.raw.nil?
+          raise RSpec::Expectations::ExpectationNotMetError.new("expected activated job#{of_type(job)}, got nil")
+        end
+
+        expect(job).to have_variables(@variables) if @variables
+        expect(job).to have_headers(@headers) if @headers
+      end
+    rescue Exception => e # rubocop:disable Lint/RescueException
+      @matcher_error = e
+    end
+    return false if @matcher_error
+
+    if @complete
+      job.complete(@output || {})
+    elsif @fail
+      job.fail(@fail_message, retries: @retries)
+    elsif @throw
+      job.throw_error(@error_code, @throw_message)
+    end
+
+    true
+  end
+
+  def of_type(job)
+    job.respond_to?(:type) ? " of type #{job.type}" : nil
+  end
+
+  failure_message do |_job|
+    raise matcher_error
+  end
+
+  attr_reader :job, :matcher_error
+
+  def predestined?
+    @complete || @fail || @throw
+  end
+
+  def check_predestined!
+    raise ZeebeBpmnRspec::HaveActivatedMatcherError.new if predestined?
+  end
+
+  chain :with_variables do |variables|
+    @variables = variables.is_a?(Hash) ? variables.stringify_keys : variables
+  end
+
+  chain :with_headers do |headers|
+    @headers = headers.is_a?(Hash) ? headers.stringify_keys : headers
+  end
+
+  chain :and_complete do |output = nil|
+    check_predestined!
+
+    @output = output
+    @complete = true
+  end
+
+  chain :and_fail do |message = nil, retries: 0|
+    check_predestined!
+
+    @fail_message = message
+    @retries = retries
+    @fail = true
+  end
+
+  chain :and_throw_error do |error_code, message = nil|
+    check_predestined!
+
+    @error_code = error_code
+    @throw_message = message
+    @throw = true
+  end
+end
+# rubocop:enable Metrics/BlockLength

data/lib/zeebe_bpmn_rspec/matchers/have_headers.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+RSpec::Matchers.define :have_headers do
+  match do |actual|
+    @job = actual
+    @actual = @job.headers
+    values_match?(expected, @actual)
+  end
+
+  failure_message do |_actual|
+    "expected that job:\n  #{@job}\n\nwould have headers #{expected}"
+  end
+
+  diffable
+end

data/lib/zeebe_bpmn_rspec/matchers/have_variables.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+RSpec::Matchers.define :have_variables do |expected|
+  match do |actual|
+    @job = actual
+    @actual = @job.variables
+    values_match?(expected, @actual)
+  end
+
+  failure_message do |_actual|
+    "expected that job:\n  #{@job}\n\nwould have variables #{expected}"
+  end
+
+  diffable
+end

data/lib/zeebe_bpmn_rspec/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ZeebeBpmnRspec
-  VERSION = "0.2.0"
+  VERSION = "1.0.0"
 end

data/zeebe_bpmn_rspec.gemspec

@@ -41,7 +41,9 @@ Gem::Specification.new do |spec|
   spec.executables   = []
   spec.require_paths = ["lib"]
 
-  spec.add_development_dependency "bundler", "~> 1.12"
+  spec.required_ruby_version = ">= 2.6"
+
+  spec.add_development_dependency "bundler", "~> 2.1"
   spec.add_development_dependency "ezcater_rubocop", "2.0.0"
   spec.add_development_dependency "overcommit"
   spec.add_development_dependency "rake", "~> 10.0"
@@ -50,5 +52,5 @@ Gem::Specification.new do |spec|
 
   spec.add_runtime_dependency "activesupport"
   spec.add_runtime_dependency "rspec", "~> 3.4"
-  spec.add_runtime_dependency "zeebe-client"
+  spec.add_runtime_dependency "zeebe-client", "~> 0.14.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: zeebe_bpmn_rspec
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 1.0.0
 platform: ruby
 authors:
 - ezCater, Inc
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-07-29 00:00:00.000000000 Z
+date: 2021-05-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.12'
+        version: '2.1'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.12'
+        version: '2.1'
 - !ruby/object:Gem::Dependency
   name: ezcater_rubocop
   requirement: !ruby/object:Gem::Requirement
@@ -126,16 +126,16 @@ dependencies:
   name: zeebe-client
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.14.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.14.0
 description: Zeebe BPMN testing using RSpec
 email:
 - engineering@ezcater.com
@@ -148,10 +148,15 @@ files:
 - Gemfile
 - LICENSE.txt
 - README.md
+- docker-compose.simple-monitor.yml
 - docker-compose.yml
 - lib/zeebe_bpmn_rspec.rb
 - lib/zeebe_bpmn_rspec/activated_job.rb
+- lib/zeebe_bpmn_rspec/deprecate_workflow_alias.rb
 - lib/zeebe_bpmn_rspec/helpers.rb
+- lib/zeebe_bpmn_rspec/matchers/have_activated.rb
+- lib/zeebe_bpmn_rspec/matchers/have_headers.rb
+- lib/zeebe_bpmn_rspec/matchers/have_variables.rb
 - lib/zeebe_bpmn_rspec/version.rb
 - zeebe_bpmn_rspec.gemspec
 homepage: https://github.com/ezcater/zeebe_bpmn_rspec
@@ -167,14 +172,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: '2.6'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
+rubygems_version: 3.1.4
 signing_key:
 specification_version: 4
 summary: Zeebe BPMN testing using RSpec