appsignal 2.1.2 → 2.2.0.beta.1

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

@@ -66,29 +66,33 @@ if DependencyHelper.rails_present?
         end
       end
 
-      context "listener middleware" do
-        it "should have added the listener middleware" do
+      describe "Rails listener middleware" do
+        it "adds the Rails listener middleware" do
           expect(app.middleware).to receive(:insert_before).with(
             ActionDispatch::RemoteIp,
             Appsignal::Rack::RailsInstrumentation
           )
         end
 
-        context "when frontend_error_catching is enabled" do
-          let(:config) do
-            Appsignal::Config.new(
-              project_fixture_path,
-              "test",
-              :name => "MyApp",
-              :enable_frontend_error_catching => true
-            )
-          end
+        after { Appsignal::Integrations::Railtie.initialize_appsignal(app) }
+      end
 
-          before do
-            allow(Appsignal).to receive(:config).and_return(config)
-          end
+      describe "frontend_error_catching middleware" do
+        let(:config) do
+          Appsignal::Config.new(
+            project_fixture_path,
+            "test",
+            :name => "MyApp",
+            :enable_frontend_error_catching => enable_frontend_error_catching
+          )
+        end
+        before { allow(Appsignal::Config).to receive(:new).and_return(config) }
+        after { Appsignal::Integrations::Railtie.initialize_appsignal(app) }
 
-          it "should have added the listener and JSExceptionCatcher middleware" do
+        context "when enabled" do
+          let(:enable_frontend_error_catching) { true }
+
+          it "adds the Rails and JSExceptionCatcher middleware" do
             expect(app.middleware).to receive(:insert_before).with(
               ActionDispatch::RemoteIp,
               Appsignal::Rack::RailsInstrumentation
@@ -101,7 +105,21 @@ if DependencyHelper.rails_present?
           end
         end
 
-        after { Appsignal::Integrations::Railtie.initialize_appsignal(app) }
+        context "when not enabled" do
+          let(:enable_frontend_error_catching) { false }
+
+          it "adds the Rails middleware, but not the JSExceptionCatcher middleware" do
+            expect(app.middleware).to receive(:insert_before).with(
+              ActionDispatch::RemoteIp,
+              Appsignal::Rack::RailsInstrumentation
+            )
+
+            expect(app.middleware).to_not receive(:insert_before).with(
+              Appsignal::Rack::RailsInstrumentation,
+              Appsignal::Rack::JSExceptionCatcher
+            )
+          end
+        end
       end
     end
   end

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

@@ -18,7 +18,7 @@ if DependencyHelper.resque_present?
           extend Appsignal::Integrations::ResquePlugin
 
           def self.perform
-            raise VerySpecificError.new
+            raise VerySpecificError
           end
         end
       end

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

@@ -1,19 +1,49 @@
 if DependencyHelper.sinatra_present?
-  ENV["APPSIGNAL_PUSH_API_KEY"] = "key"
   require "appsignal/integrations/sinatra"
 
+  def install_sinatra_integration
+    load File.expand_path("lib/appsignal/integrations/sinatra.rb", project_dir)
+  end
+
+  # "Uninstall" the AppSignal integration
+  def uninstall_sinatra_integration
+    Sinatra::Base.instance_variable_get(:@middleware).delete_if do |middleware|
+      middleware.first == Appsignal::Rack::SinatraBaseInstrumentation
+    end
+  end
+
   describe "Sinatra integration" do
+    before { allow(Appsignal).to receive(:active?).and_return(true) }
+    after { uninstall_sinatra_integration }
+
     context "Appsignal.logger" do
       subject { Appsignal.logger }
 
-      it { is_expected.to be_a Logger }
+      it "sets a logger" do
+        install_sinatra_integration
+        is_expected.to be_a Logger
+      end
     end
 
     describe "middleware" do
-      it "adds the instrumentation middleware to Sinatra::Base" do
-        expect(Sinatra::Base.middleware.to_a).to include(
-          [Appsignal::Rack::SinatraBaseInstrumentation, [], nil]
-        )
+      context "when AppSignal is not active" do
+        before { allow(Appsignal).to receive(:active?).and_return(false) }
+
+        it "does not add the instrumentation middleware to Sinatra::Base" do
+          install_sinatra_integration
+          expect(Sinatra::Base.middleware.to_a).to_not include(
+            [Appsignal::Rack::SinatraBaseInstrumentation, [], nil]
+          )
+        end
+      end
+
+      context "when AppSignal is active" do
+        it "adds the instrumentation middleware to Sinatra::Base" do
+          install_sinatra_integration
+          expect(Sinatra::Base.middleware.to_a).to include(
+            [Appsignal::Rack::SinatraBaseInstrumentation, [], nil]
+          )
+        end
       end
     end
 
@@ -21,9 +51,7 @@ if DependencyHelper.sinatra_present?
       subject { Appsignal.config.env }
 
       context "without APPSIGNAL_APP_ENV" do
-        before do
-          load File.expand_path("lib/appsignal/integrations/sinatra.rb", project_dir)
-        end
+        before { install_sinatra_integration }
 
         it "uses the app environment" do
           expect(subject).to eq("test")
@@ -33,7 +61,7 @@ if DependencyHelper.sinatra_present?
       context "with APPSIGNAL_APP_ENV" do
         before do
           ENV["APPSIGNAL_APP_ENV"] = "env-staging"
-          load File.expand_path("lib/appsignal/integrations/sinatra.rb", project_dir)
+          install_sinatra_integration
         end
 
         it "uses the environment variable" do

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

@@ -7,7 +7,7 @@ if DependencyHelper.webmachine_present?
     end
     let(:resource)    { double(:trace? => false, :handle_exception => true) }
     let(:response)    { double }
-    let(:transaction) { double(:set_action => true) }
+    let(:transaction) { double(:set_action_if_nil => true) }
     let(:fsm) { Webmachine::Decision::FSM.new(resource, request, response) }
     before(:context) { start_agent }
 
@@ -36,7 +36,7 @@ if DependencyHelper.webmachine_present?
       end
 
       it "should set the action" do
-        expect(transaction).to receive(:set_action).with("RSpec::Mocks::Mock#GET")
+        expect(transaction).to receive(:set_action_if_nil).with("RSpec::Mocks::Mock#GET")
       end
 
       it "should call the original method" do

data/spec/lib/appsignal/rack/generic_instrumentation_spec.rb

@@ -36,20 +36,20 @@ describe Appsignal::Rack::GenericInstrumentation do
     after { middleware.call(env) }
   end
 
-  describe "#call_with_appsignal_monitoring" do
+  describe "#call_with_appsignal_monitoring", :error => false do
     it "should create a transaction" do
       expect(Appsignal::Transaction).to receive(:create).with(
         kind_of(String),
         Appsignal::Transaction::HTTP_REQUEST,
         kind_of(Rack::Request)
-      ).and_return(double(:set_action => nil, :set_http_or_background_queue_start => nil, :set_metadata => nil))
+      ).and_return(double(:set_action_if_nil => nil, :set_http_or_background_queue_start => nil, :set_metadata => nil))
     end
 
     it "should call the app" do
       expect(app).to receive(:call).with(env)
     end
 
-    context "with an error" do
+    context "with an error", :error => true do
       let(:error) { VerySpecificError.new }
       let(:app) do
         double.tap do |d|
@@ -63,7 +63,7 @@ describe Appsignal::Rack::GenericInstrumentation do
     end
 
     it "should set the action to unknown" do
-      expect_any_instance_of(Appsignal::Transaction).to receive(:set_action).with("unknown")
+      expect_any_instance_of(Appsignal::Transaction).to receive(:set_action_if_nil).with("unknown")
     end
 
     context "with a route specified in the env" do
@@ -72,7 +72,7 @@ describe Appsignal::Rack::GenericInstrumentation do
       end
 
       it "should set the action" do
-        expect_any_instance_of(Appsignal::Transaction).to receive(:set_action).with("GET /")
+        expect_any_instance_of(Appsignal::Transaction).to receive(:set_action_if_nil).with("GET /")
       end
     end
 
@@ -84,6 +84,7 @@ describe Appsignal::Rack::GenericInstrumentation do
       expect_any_instance_of(Appsignal::Transaction).to receive(:set_http_or_background_queue_start)
     end
 
-    after { middleware.call(env) rescue VerySpecificError }
+    after(:error => false) { middleware.call(env) }
+    after(:error => true) { expect { middleware.call(env) }.to raise_error(VerySpecificError) }
   end
 end

data/spec/lib/appsignal/rack/js_exception_catcher_spec.rb

@@ -1,17 +1,12 @@
 describe Appsignal::Rack::JSExceptionCatcher do
   let(:app)            { double(:call => true) }
-  let(:options)        { double }
-  let(:active)         { true }
+  let(:options)        { nil }
   let(:config_options) { { :enable_frontend_error_catching => true } }
   let(:config)         { project_fixture_config("production", config_options) }
-
-  before do
-    allow(Appsignal).to receive(:config).and_return(config)
-    allow(config).to receive(:active?).and_return(active)
-  end
+  before { Appsignal.config = config }
 
   describe "#initialize" do
-    it "should log to the logger" do
+    it "logs to the logger" do
       expect(Appsignal.logger).to receive(:debug)
         .with("Initializing Appsignal::Rack::JSExceptionCatcher")
 
@@ -21,16 +16,29 @@ describe Appsignal::Rack::JSExceptionCatcher do
 
   describe "#call" do
     let(:catcher) { Appsignal::Rack::JSExceptionCatcher.new(app, options) }
+    after { catcher.call(env) }
 
-    context "when path is not `/appsignal_error_catcher`" do
+    context "when path is not frontend_error_catching_path" do
       let(:env) { { "PATH_INFO" => "/foo" } }
 
-      it "should call the next middleware" do
-        expect(app).to receive(:call).with(env)
+      context "when AppSignal is not active" do
+        before { config[:active] = false }
+
+        it "calls the next middleware" do
+          expect(app).to receive(:call).with(env)
+        end
+      end
+
+      context "when AppSignal is active" do
+        before { config[:active] = true }
+
+        it "calls the next middleware" do
+          expect(app).to receive(:call).with(env)
+        end
       end
     end
 
-    context "when path is `/appsignal_error_catcher`" do
+    context "when path is frontend_error_catching_path" do
       let(:transaction) { double(:complete! => true) }
       let(:env) do
         {
@@ -39,72 +47,101 @@ describe Appsignal::Rack::JSExceptionCatcher do
         }
       end
 
-      it "should create a JSExceptionTransaction" do
-        expect(Appsignal::JSExceptionTransaction).to receive(:new)
-          .with("name" => "error")
-          .and_return(transaction)
+      context "when AppSignal is not active" do
+        before { config[:active] = false }
+
+        it "doesn't create an AppSignal transaction" do
+          expect(Appsignal::JSExceptionTransaction).to_not receive(:new)
+        end
 
-        expect(transaction).to receive(:complete!)
+        it "returns a 202 status" do
+          expect(catcher.call(env)).to eq(
+            [202, {}, ["AppSignal JavaScript error catching endpoint is not active."]]
+          )
+        end
       end
 
-      it "should return 200" do
-        allow(Appsignal::JSExceptionTransaction).to receive(:new)
-          .and_return(transaction)
+      context "when AppSignal is active" do
+        before { config[:active] = true }
 
-        expect(catcher.call(env)).to eql([200, {}, []])
-      end
+        it "creates a JSExceptionTransaction" do
+          expect(Appsignal::JSExceptionTransaction).to receive(:new)
+            .with("name" => "error")
+            .and_return(transaction)
 
-      context "when `frontend_error_catching_path` is different" do
-        let(:config_options) do
-          {
-            :frontend_error_catching_path => "/foo"
-          }
+          expect(transaction).to receive(:complete!)
         end
 
-        it "should not create a transaction" do
-          expect(Appsignal::JSExceptionTransaction).to_not receive(:new)
-        end
+        it "returns 200" do
+          allow(Appsignal::JSExceptionTransaction).to receive(:new)
+            .and_return(transaction)
 
-        it "should call the next middleware" do
-          expect(app).to receive(:call).with(env)
+          expect(catcher.call(env)).to eq([200, {}, []])
         end
-      end
 
-      context "when `name` is empty" do
-        let(:env) do
-          {
-            "PATH_INFO"  => "/appsignal_error_catcher",
-            "rack.input" => double(:read => '{"name": ""}')
-          }
+        context "when request payload is empty" do
+          let(:env) do
+            {
+              "PATH_INFO"  => "/appsignal_error_catcher",
+              "rack.input" => double(:read => "")
+            }
+          end
+
+          it "does not create a transaction" do
+            expect(Appsignal::JSExceptionTransaction).to_not receive(:new)
+          end
+
+          it "returns 400" do
+            expect(catcher.call(env)).to eq([400, {}, ["Request payload is not valid JSON."]])
+          end
         end
 
-        it "should not create a transaction" do
-          expect(Appsignal::JSExceptionTransaction).to_not receive(:new)
-        end
+        context "when `frontend_error_catching_path` is different" do
+          let(:config_options) { { :frontend_error_catching_path => "/foo" } }
 
-        it "should return 422" do
-          expect(catcher.call(env)).to eql([422, {}, []])
-        end
-      end
+          it "does not create a transaction" do
+            expect(Appsignal::JSExceptionTransaction).to_not receive(:new)
+          end
 
-      context "when `name` doesn't exist" do
-        let(:env) do
-          {
-            "PATH_INFO"  => "/appsignal_error_catcher",
-            "rack.input" => double(:read => '{"foo": ""}')
-          }
+          it "calls the next middleware" do
+            expect(app).to receive(:call).with(env)
+          end
         end
 
-        it "should not create a transaction" do
-          expect(Appsignal::JSExceptionTransaction).to_not receive(:new)
+        context "when `name` is empty" do
+          let(:env) do
+            {
+              "PATH_INFO"  => "/appsignal_error_catcher",
+              "rack.input" => double(:read => '{"name": ""}')
+            }
+          end
+
+          it "does not create a transaction" do
+            expect(Appsignal::JSExceptionTransaction).to_not receive(:new)
+          end
+
+          it "returns 422" do
+            expect(catcher.call(env)).to eq([422, {}, []])
+          end
         end
 
-        it "should return 422" do
-          expect(catcher.call(env)).to eql([422, {}, []])
+        context "when `name` doesn't exist" do
+          let(:env) do
+            {
+              "PATH_INFO"  => "/appsignal_error_catcher",
+              "rack.input" => double(:read => '{"foo": ""}')
+            }
+          end
+
+          it "does not create a transaction" do
+            expect(Appsignal::JSExceptionTransaction).to_not receive(:new)
+          end
+
+          it "returns 422" do
+            expect(catcher.call(env)).to eq([422, {}, []])
+          end
         end
       end
     end
-
-    after { catcher.call(env) }
   end
 end

data/spec/lib/appsignal/rack/rails_instrumentation_spec.rb

@@ -46,7 +46,7 @@ if DependencyHelper.rails_present?
       after { middleware.call(env) }
     end
 
-    describe "#call_with_appsignal_monitoring" do
+    describe "#call_with_appsignal_monitoring", :error => false do
       it "should create a transaction" do
         expect(Appsignal::Transaction).to receive(:create).with(
           "1",
@@ -54,8 +54,10 @@ if DependencyHelper.rails_present?
           kind_of(ActionDispatch::Request),
           :params_method => :filtered_parameters
         ).and_return(
-          double(
+          instance_double(
+            "Appsignal::Transaction",
             :set_action => nil,
+            :set_action_if_nil => nil,
             :set_http_or_background_queue_start => nil,
             :set_metadata => nil
           )
@@ -66,8 +68,8 @@ if DependencyHelper.rails_present?
         expect(app).to receive(:call).with(env)
       end
 
-      context "with an error" do
-        let(:error) { VerySpecificError.new }
+      context "with an error", :error => true do
+        let(:error) { VerySpecificError }
         let(:app) do
           double.tap do |d|
             allow(d).to receive(:call).and_raise(error)
@@ -84,11 +86,12 @@ if DependencyHelper.rails_present?
       end
 
       it "should set the action and queue start" do
-        expect_any_instance_of(Appsignal::Transaction).to receive(:set_action).with("MockController#index")
+        expect_any_instance_of(Appsignal::Transaction).to receive(:set_action_if_nil).with("MockController#index")
         expect_any_instance_of(Appsignal::Transaction).to receive(:set_http_or_background_queue_start)
       end
 
-      after { middleware.call(env) rescue VerySpecificError }
+      after(:error => false) { middleware.call(env) }
+      after(:error => true) { expect { middleware.call(env) }.to raise_error(VerySpecificError) }
     end
 
     describe "#request_id" do