appsignal 3.9.1-java → 3.9.3-java

data/spec/lib/appsignal/integrations/railtie_spec.rb

@@ -136,8 +136,8 @@ if DependencyHelper.rails_present?
             it "does nothing" do
               with_rails_error_reporter do
                 expect do
-                  Rails.error.record { raise ExampleStandardError }
-                end.to raise_error(ExampleStandardError)
+                  Rails.error.record { raise ExampleStandardError, "error message" }
+                end.to raise_error(ExampleStandardError, "error message")
               end
 
               expect(created_transactions).to be_empty
@@ -156,24 +156,15 @@ if DependencyHelper.rails_present?
 
                 with_rails_error_reporter do
                   with_current_transaction current_transaction do
-                    Rails.error.handle { raise ExampleStandardError }
+                    Rails.error.handle { raise ExampleStandardError, "error message" }
 
                     transaction = last_transaction
-                    transaction_hash = transaction.to_h
-                    expect(transaction_hash).to include(
-                      "action" => "CustomAction",
-                      "namespace" => "custom",
-                      "error" => {
-                        "name" => "ExampleStandardError",
-                        "message" => "ExampleStandardError",
-                        "backtrace" => kind_of(String)
-                      },
-                      "sample_data" => hash_including(
-                        "tags" => hash_including(
-                          "duplicated_tag" => "duplicated value",
-                          "severity" => "warning"
-                        )
-                      )
+                    expect(transaction).to have_namespace("custom")
+                    expect(transaction).to have_action("CustomAction")
+                    expect(transaction).to have_error("ExampleStandardError", "error message")
+                    expect(transaction).to include_tags(
+                      "duplicated_tag" => "duplicated value",
+                      "severity" => "warning"
                     )
                   end
                 end
@@ -188,16 +179,10 @@ if DependencyHelper.rails_present?
                     given_context = { :tag1 => "value1", :tag2 => "value2" }
                     Rails.error.handle(:context => given_context) { raise ExampleStandardError }
 
-                    transaction = last_transaction
-                    transaction_hash = transaction.to_h
-                    expect(transaction_hash).to include(
-                      "sample_data" => hash_including(
-                        "tags" => hash_including(
-                          "tag1" => "value1",
-                          "tag2" => "value2",
-                          "severity" => "warning"
-                        )
-                      )
+                    expect(last_transaction).to include_tags(
+                      "tag1" => "value1",
+                      "tag2" => "value2",
+                      "severity" => "warning"
                     )
                   end
                 end
@@ -219,14 +204,9 @@ if DependencyHelper.rails_present?
                     Rails.error.handle(:context => given_context) { raise ExampleStandardError }
 
                     transaction = last_transaction
-                    transaction_hash = transaction.to_h
-                    expect(transaction_hash).to include(
-                      "sample_data" => hash_including(
-                        "custom_data" => {
-                          "array" => [1, 2],
-                          "hash" => { "one" => 1, "two" => 2 }
-                        }
-                      )
+                    expect(transaction).to include_custom_data(
+                      "array" => [1, 2],
+                      "hash" => { "one" => 1, "two" => 2 }
                     )
                   end
                 end
@@ -245,11 +225,8 @@ if DependencyHelper.rails_present?
                     Rails.error.handle(:context => given_context) { raise ExampleStandardError }
 
                     transaction = last_transaction
-                    transaction_hash = transaction.to_h
-                    expect(transaction_hash).to include(
-                      "namespace" => "context",
-                      "action" => "ContextAction"
-                    )
+                    expect(transaction).to have_namespace("context")
+                    expect(transaction).to have_action("ContextAction")
                   end
                 end
               end
@@ -301,17 +278,9 @@ if DependencyHelper.rails_present?
                 end
 
                 transaction = last_transaction
-                transaction_hash = transaction.to_h
-                expect(transaction_hash).to include(
-                  "action" => "ExampleRailsControllerMock#index",
-                  "metadata" => hash_including(
-                    "path" => "path",
-                    "method" => "GET"
-                  ),
-                  "sample_data" => hash_including(
-                    "params" => { "user_id" => 123, "password" => "[FILTERED]" }
-                  )
-                )
+                expect(transaction).to have_action("ExampleRailsControllerMock#index")
+                expect(transaction).to include_metadata("path" => "path", "method" => "GET")
+                expect(transaction).to include_params("user_id" => 123, "password" => "[FILTERED]")
               end
 
               it "sets no action if no execution context is present" do
@@ -320,11 +289,7 @@ if DependencyHelper.rails_present?
                   Rails.error.handle { raise ExampleStandardError }
                 end
 
-                transaction = last_transaction
-                transaction_hash = transaction.to_h
-                expect(transaction_hash).to include(
-                  "action" => nil
-                )
+                expect(last_transaction).to_not have_action
               end
             end
 
@@ -340,16 +305,10 @@ if DependencyHelper.rails_present?
                 Rails.error.handle(:context => given_context) { raise ExampleStandardError }
               end
 
-              transaction = last_transaction
-              transaction_hash = transaction.to_h
-              expect(transaction_hash).to include(
-                "sample_data" => hash_including(
-                  "tags" => hash_including(
-                    "tag1" => "value1",
-                    "tag2" => "value2",
-                    "severity" => "warning"
-                  )
-                )
+              expect(last_transaction).to include_tags(
+                "tag1" => "value1",
+                "tag2" => "value2",
+                "severity" => "warning"
               )
             end
           end

data/spec/lib/appsignal/integrations/sidekiq_spec.rb

@@ -20,17 +20,11 @@ describe Appsignal::Integrations::SidekiqDeathHandler do
   end
 
   def expect_error_on_transaction
-    expect(last_transaction.to_h).to include(
-      "error" => hash_including(
-        "name" => "ExampleStandardError",
-        "message" => "uh oh",
-        "backtrace" => kind_of(String)
-      )
-    )
+    expect(last_transaction).to have_error("ExampleStandardError", "uh oh")
   end
 
   def expect_no_error_on_transaction
-    expect(last_transaction.to_h).to include("error" => nil)
+    expect(last_transaction).to_not have_error
   end
 
   context "when sidekiq_report_errors = none" do
@@ -90,21 +84,13 @@ describe Appsignal::Integrations::SidekiqErrorHandler do
         described_class.new.call(exception, job_context)
       end.to(change { created_transactions.count }.by(1))
 
-      transaction_hash = last_transaction.to_h
-      expect(transaction_hash).to include(
-        "action" => "SidekiqInternal",
-        "error" => hash_including(
-          "name" => "ExampleStandardError",
-          "message" => "uh oh",
-          "backtrace" => kind_of(String)
-        )
-      )
-      expect(transaction_hash["sample_data"]).to include(
-        "params" => {
-          "jobstr" => "{ bad json }"
-        }
+      transaction = last_transaction
+      expect(transaction).to have_action("SidekiqInternal")
+      expect(transaction).to have_error("ExampleStandardError", "uh oh")
+      expect(transaction).to include_params(
+        "jobstr" => "{ bad json }"
       )
-      expect(transaction_hash["metadata"]).to include(
+      expect(transaction).to include_metadata(
         "sidekiq_error" => "Sidekiq internal error!"
       )
     end
@@ -149,17 +135,11 @@ describe Appsignal::Integrations::SidekiqErrorHandler do
     end
 
     def expect_error_on_transaction
-      expect(last_transaction.to_h).to include(
-        "error" => hash_including(
-          "name" => "ExampleStandardError",
-          "message" => "uh oh",
-          "backtrace" => kind_of(String)
-        )
-      )
+      expect(last_transaction).to have_error("ExampleStandardError", "uh oh")
     end
 
     def expect_no_error_on_transaction
-      expect(last_transaction.to_h).to include("error" => nil)
+      expect(last_transaction).to_not have_error
     end
 
     context "when sidekiq_report_errors = none" do
@@ -270,9 +250,8 @@ describe Appsignal::Integrations::SidekiqMiddleware, :with_yaml_parse_error => f
     it "filters selected arguments" do
       perform_sidekiq_job
 
-      transaction_hash = transaction.to_h
-      expect(transaction_hash["sample_data"]).to include(
-        "params" => [
+      expect(transaction).to include_params(
+        [
           "foo",
           {
             "foo" => "[FILTERED]",
@@ -293,10 +272,7 @@ describe Appsignal::Integrations::SidekiqMiddleware, :with_yaml_parse_error => f
     it "replaces the last argument (the secret bag) with an [encrypted data] string" do
       perform_sidekiq_job
 
-      transaction_hash = transaction.to_h
-      expect(transaction_hash["sample_data"]).to include(
-        "params" => expected_args << "[encrypted data]"
-      )
+      expect(transaction).to include_params(expected_args << "[encrypted data]")
     end
   end
 
@@ -319,11 +295,8 @@ describe Appsignal::Integrations::SidekiqMiddleware, :with_yaml_parse_error => f
     it "uses the delayed class and method name for the action" do
       perform_sidekiq_job
 
-      transaction_hash = transaction.to_h
-      expect(transaction_hash["action"]).to eq("DelayedTestClass.foo_method")
-      expect(transaction_hash["sample_data"]).to include(
-        "params" => ["bar" => "baz"]
-      )
+      expect(transaction).to have_action("DelayedTestClass.foo_method")
+      expect(transaction).to include_params(["bar" => "baz"])
     end
 
     context "when job arguments is a malformed YAML object", :with_yaml_parse_error => true do
@@ -332,9 +305,8 @@ describe Appsignal::Integrations::SidekiqMiddleware, :with_yaml_parse_error => f
       it "logs a warning and uses the default argument" do
         perform_sidekiq_job
 
-        transaction_hash = transaction.to_h
-        expect(transaction_hash["action"]).to eq("Sidekiq::Extensions::DelayedClass#perform")
-        expect(transaction_hash["sample_data"]).to include("params" => [])
+        expect(transaction).to have_action("Sidekiq::Extensions::DelayedClass#perform")
+        expect(transaction).to include_params([])
         expect(log_contents(log)).to contains_log(:warn, "Unable to load YAML")
       end
     end
@@ -359,11 +331,8 @@ describe Appsignal::Integrations::SidekiqMiddleware, :with_yaml_parse_error => f
     it "uses the delayed class and method name for the action" do
       perform_sidekiq_job
 
-      transaction_hash = transaction.to_h
-      expect(transaction_hash["action"]).to eq("DelayedTestClass#foo_method")
-      expect(transaction_hash["sample_data"]).to include(
-        "params" => ["bar" => "baz"]
-      )
+      expect(transaction).to have_action("DelayedTestClass#foo_method")
+      expect(transaction).to include_params(["bar" => "baz"])
     end
 
     context "when job arguments is a malformed YAML object", :with_yaml_parse_error => true do
@@ -372,9 +341,8 @@ describe Appsignal::Integrations::SidekiqMiddleware, :with_yaml_parse_error => f
       it "logs a warning and uses the default argument" do
         perform_sidekiq_job
 
-        transaction_hash = transaction.to_h
-        expect(transaction_hash["action"]).to eq("Sidekiq::Extensions::DelayedModel#perform")
-        expect(transaction_hash["sample_data"]).to include("params" => [])
+        expect(transaction).to have_action("Sidekiq::Extensions::DelayedModel#perform")
+        expect(transaction).to include_params([])
         expect(log_contents(log)).to contains_log(:warn, "Unable to load YAML")
       end
     end
@@ -394,31 +362,20 @@ describe Appsignal::Integrations::SidekiqMiddleware, :with_yaml_parse_error => f
         perform_sidekiq_job { raise error, "uh oh" }
       end.to raise_error(error)
 
-      transaction_hash = transaction.to_h
-      expect(transaction_hash).to include(
-        "id" => jid,
-        "action" => "TestClass#perform",
-        "error" => {
-          "name" => "ExampleException",
-          "message" => "uh oh",
-          # TODO: backtrace should be an Array of Strings
-          # https://github.com/appsignal/appsignal-agent/issues/294
-          "backtrace" => kind_of(String)
-        },
-        "metadata" => {
-          "extra" => "data",
-          "queue" => "default",
-          "retry_count" => "0"
-        },
-        "namespace" => namespace,
-        "sample_data" => {
-          "environment" => {},
-          "params" => expected_args,
-          "tags" => {},
-          "breadcrumbs" => []
-        }
+      expect(transaction).to have_id(jid)
+      expect(transaction).to have_namespace(namespace)
+      expect(transaction).to have_action("TestClass#perform")
+      expect(transaction).to have_error("ExampleException", "uh oh")
+      expect(transaction).to include_metadata(
+        "extra" => "data",
+        "queue" => "default",
+        "retry_count" => "0"
       )
-      expect_transaction_to_have_sidekiq_event(transaction_hash)
+      expect(transaction).to_not include_environment
+      expect(transaction).to include_params(expected_args)
+      expect(transaction).to_not include_tags
+      expect(transaction).to_not include_breadcrumbs
+      expect_transaction_to_have_sidekiq_event(transaction)
     end
   end
 
@@ -438,17 +395,17 @@ describe Appsignal::Integrations::SidekiqMiddleware, :with_yaml_parse_error => f
         end
 
         expect(created_transactions.count).to eq(2)
-        expected_transaction = {
-          "namespace" => "background_job",
-          "action" => "TestClass#perform",
-          "sample_data" => hash_including(
-            "tags" => hash_including("test_tag" => "value")
-          )
-        }
-        sidekiq_transaction = created_transactions.first.to_h
-        error_reporter_transaction = created_transactions.last.to_h
-        expect(sidekiq_transaction).to include(expected_transaction)
-        expect(error_reporter_transaction).to include(expected_transaction)
+        tags = { "test_tag" => "value" }
+        sidekiq_transaction = created_transactions.first
+        error_reporter_transaction = created_transactions.last
+
+        expect(sidekiq_transaction).to have_namespace("background_job")
+        expect(sidekiq_transaction).to have_action("TestClass#perform")
+        expect(sidekiq_transaction).to include_tags(tags)
+
+        expect(error_reporter_transaction).to have_namespace("background_job")
+        expect(error_reporter_transaction).to have_action("TestClass#perform")
+        expect(error_reporter_transaction).to include_tags(tags)
       end
     end
   end
@@ -461,30 +418,21 @@ describe Appsignal::Integrations::SidekiqMiddleware, :with_yaml_parse_error => f
         .with("sidekiq_queue_job_count", 1, { :queue => "default", :status => :processed })
       perform_sidekiq_job
 
-      transaction_hash = transaction.to_h
-      expect(transaction_hash).to include(
-        "id" => jid,
-        "action" => "TestClass#perform",
-        "error" => nil,
-        "metadata" => {
-          "extra" => "data",
-          "queue" => "default",
-          "retry_count" => "0"
-        },
-        "namespace" => namespace,
-        "sample_data" => {
-          "environment" => {},
-          "params" => expected_args,
-          "tags" => {},
-          "breadcrumbs" => []
-        }
-      )
-      # TODO: Not available in transaction.to_h yet.
-      # https://github.com/appsignal/appsignal-agent/issues/293
-      expect(transaction.request.env).to eq(
-        :queue_start => Time.parse("2001-01-01 10:00:00UTC").to_f
+      expect(transaction).to have_id(jid)
+      expect(transaction).to have_namespace(namespace)
+      expect(transaction).to have_action("TestClass#perform")
+      expect(transaction).to_not have_error
+      expect(transaction).to_not include_tags
+      expect(transaction).to_not include_environment
+      expect(transaction).to_not include_breadcrumbs
+      expect(transaction).to_not include_params(expected_args)
+      expect(transaction).to include_metadata(
+        "extra" => "data",
+        "queue" => "default",
+        "retry_count" => "0"
       )
-      expect_transaction_to_have_sidekiq_event(transaction_hash)
+      expect(transaction).to have_queue_start(Time.parse("2001-01-01 10:00:00UTC").to_i * 1000)
+      expect_transaction_to_have_sidekiq_event(transaction)
     end
   end
 
@@ -505,10 +453,9 @@ describe Appsignal::Integrations::SidekiqMiddleware, :with_yaml_parse_error => f
     last_transaction
   end
 
-  def expect_transaction_to_have_sidekiq_event(transaction_hash)
-    events = transaction_hash["events"]
-    expect(events.count).to eq(1)
-    expect(events.first).to include(
+  def expect_transaction_to_have_sidekiq_event(transaction)
+    expect(transaction.to_h["events"].count).to eq(1)
+    expect(transaction).to include_event(
       "name"        => "perform_job.sidekiq",
       "title"       => "",
       "count"       => 1,
@@ -621,25 +568,18 @@ if DependencyHelper.active_job_present?
       perform_sidekiq_job(ActiveJobSidekiqTestJob, given_args)
 
       transaction = last_transaction
-      transaction_hash = transaction.to_h
-      expect(transaction_hash).to include(
-        "action" => "ActiveJobSidekiqTestJob#perform",
-        "error" => nil,
-        "namespace" => namespace,
-        "metadata" => hash_including(
-          "queue" => "default"
-        ),
-        "sample_data" => hash_including(
-          "environment" => {},
-          "params" => [expected_args],
-          "tags" => expected_tags.merge("queue" => "default")
-        )
-      )
-      expect(transaction.request.env).to eq(:queue_start => time.to_f)
-      events = transaction_hash["events"]
+      expect(transaction).to have_namespace(namespace)
+      expect(transaction).to have_action("ActiveJobSidekiqTestJob#perform")
+      expect(transaction).to_not have_error
+      expect(transaction).to include_metadata("queue" => "default")
+      expect(transaction).to_not include_environment
+      expect(transaction).to include_params([expected_args])
+      expect(transaction).to include_tags(expected_tags.merge("queue" => "default"))
+      expect(transaction).to have_queue_start(time.to_i * 1000)
+
+      events = transaction.to_h["events"]
         .sort_by { |e| e["start"] }
         .map { |event| event["name"] }
-
       expect(events).to eq(expected_perform_events)
     end
 
@@ -650,29 +590,18 @@ if DependencyHelper.active_job_present?
         end.to raise_error(RuntimeError, "uh oh")
 
         transaction = last_transaction
-        transaction_hash = transaction.to_h
-        expect(transaction_hash).to include(
-          "action" => "ActiveJobSidekiqErrorTestJob#perform",
-          "error" => {
-            "name" => "RuntimeError",
-            "message" => "uh oh",
-            "backtrace" => kind_of(String)
-          },
-          "namespace" => namespace,
-          "metadata" => hash_including(
-            "queue" => "default"
-          ),
-          "sample_data" => hash_including(
-            "environment" => {},
-            "params" => [expected_args],
-            "tags" => expected_tags.merge("queue" => "default")
-          )
-        )
-        expect(transaction.request.env).to eq(:queue_start => time.to_f)
-        events = transaction_hash["events"]
+        expect(transaction).to have_namespace(namespace)
+        expect(transaction).to have_action("ActiveJobSidekiqErrorTestJob#perform")
+        expect(transaction).to have_error("RuntimeError", "uh oh")
+        expect(transaction).to include_metadata("queue" => "default")
+        expect(transaction).to_not include_environment
+        expect(transaction).to include_params([expected_args])
+        expect(transaction).to include_tags(expected_tags.merge("queue" => "default"))
+        expect(transaction).to have_queue_start(time.to_i * 1000)
+
+        events = transaction.to_h["events"]
           .sort_by { |e| e["start"] }
           .map { |event| event["name"] }
-
         expect(events).to eq(expected_perform_events)
       end
     end
@@ -691,13 +620,10 @@ if DependencyHelper.active_job_present?
         perform_mailer(ActionMailerSidekiqTestJob, :welcome, given_args)
 
         transaction = last_transaction
-        transaction_hash = transaction.to_h
-        expect(transaction_hash).to include(
-          "action" => "ActionMailerSidekiqTestJob#welcome",
-          "sample_data" => hash_including(
-            "params" => ["ActionMailerSidekiqTestJob", "welcome",
-                         "deliver_now"] + expected_wrapped_args
-          )
+        expect(transaction).to have_action("ActionMailerSidekiqTestJob#welcome")
+        expect(transaction).to include_params(
+          ["ActionMailerSidekiqTestJob", "welcome",
+           "deliver_now"] + expected_wrapped_args
         )
       end
     end

data/spec/lib/appsignal/integrations/sinatra_spec.rb

@@ -24,7 +24,6 @@ if DependencyHelper.sinatra_present?
       it "does not start AppSignal again" do
         expect(Appsignal::Config).to_not receive(:new)
         expect(Appsignal).to_not receive(:start)
-        expect(Appsignal).to_not receive(:start_logger)
         install_sinatra_integration
       end
 
@@ -50,9 +49,13 @@ if DependencyHelper.sinatra_present?
         context "when AppSignal is not active" do
           it "does not add the instrumentation middleware to Sinatra::Base" do
             install_sinatra_integration
-            expect(Sinatra::Base.middleware.to_a).to_not include(
+            middlewares = Sinatra::Base.middleware.to_a
+            expect(middlewares).to_not include(
               [Appsignal::Rack::SinatraBaseInstrumentation, [], nil]
             )
+            expect(middlewares).to_not include(
+              [Rack::Events, [Appsignal::Rack::EventHandler], nil]
+            )
           end
         end
 
@@ -63,7 +66,9 @@ if DependencyHelper.sinatra_present?
             ENV["APPSIGNAL_PUSH_API_KEY"] = "my-key"
 
             install_sinatra_integration
-            expect(Sinatra::Base.middleware.to_a).to include(
+            middlewares = Sinatra::Base.middleware.to_a
+            expect(middlewares).to include(
+              [Rack::Events, [[Appsignal::Rack::EventHandler]], nil],
               [Appsignal::Rack::SinatraBaseInstrumentation, [], nil]
             )
           end

data/spec/lib/appsignal/integrations/webmachine_spec.rb

@@ -17,70 +17,59 @@ if DependencyHelper.webmachine_present?
     let(:request) do
       Webmachine::Request.new("GET", "http://google.com:80/foo", {}, nil)
     end
-    let(:resource)    { double(:trace? => false, :handle_exception => true, :"code=" => nil) }
-    let(:response)    { Response.new }
-    let(:transaction) { double(:set_action_if_nil => true) }
+    let(:resource) { double(:trace? => false, :handle_exception => true, :"code=" => nil) }
+    let(:response) { Response.new }
     let(:fsm) { Webmachine::Decision::FSM.new(resource, request, response) }
     before(:context) { start_agent }
+    around { |example| keep_transactions { example.run } }
 
     # Make sure the request responds to the method we need to get query params.
     describe "request" do
-      it "should respond to `query`" do
+      it "responds to #query" do
         expect(request).to respond_to(:query)
       end
     end
 
     describe "#run" do
-      before do
-        allow(SecureRandom).to receive(:uuid).and_return("uuid")
-        allow(Appsignal::Transaction).to receive(:create).and_return(transaction)
-      end
+      before { allow(fsm).to receive(:call).and_call_original }
 
-      it "should create a transaction" do
-        expect(Appsignal::Transaction).to receive(:create).with(
-          "uuid",
-          Appsignal::Transaction::HTTP_REQUEST,
-          request,
-          :params_method => :query
-        ).and_return(transaction)
+      it "creates a transaction" do
+        expect { fsm.run }.to(change { created_transactions.count }.by(1))
       end
 
-      it "should set the action" do
-        expect(transaction).to receive(:set_action_if_nil).with("RSpec::Mocks::Double#GET")
+      it "sets the action" do
+        fsm.run
+        expect(last_transaction).to have_action("RSpec::Mocks::Double#GET")
       end
 
-      it "should call the original method" do
-        expect(fsm).to receive(:run)
+      it "records an instrumentation event" do
+        fsm.run
+        expect(last_transaction).to include_event("name" => "process_action.webmachine")
       end
 
-      it "should instrument the original method" do
-        expect(Appsignal).to receive(:instrument).with("process_action.webmachine")
+      it "closes the transaction" do
+        fsm.run
+        expect(last_transaction).to be_completed
+        expect(current_transaction?).to be_falsy
       end
 
-      it "should close the transaction" do
-        expect(Appsignal::Transaction).to receive(:complete_current!)
-      end
-
-      after { fsm.run }
-
-      describe "concerning the response" do
-        it "sets a response code" do
-          expect(fsm.response.code).to be_nil
-          fsm.run
-          expect(fsm.response.code).not_to be_nil
-        end
+      it "sets a response code" do
+        expect(fsm.response.code).to be_nil
+        fsm.run
+        expect(fsm.response.code).not_to be_nil
       end
     end
 
     describe "#handle_exceptions" do
-      let(:error) { ExampleException }
+      let(:error) { ExampleException.new("error message") }
+      let(:transaction) { http_request_transaction }
 
-      it "should catch the error and send it to AppSignal" do
-        expect(Appsignal).to receive(:set_error).with(error)
-      end
+      it "tracks the error" do
+        with_current_transaction(transaction) do
+          fsm.send(:handle_exceptions) { raise error }
+        end
 
-      after do
-        fsm.send(:handle_exceptions) { raise error }
+        expect(last_transaction).to have_error("ExampleException", "error message")
       end
     end
   end