appsignal 3.11.0-java → 3.12.1-java

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

@@ -1,186 +1,17 @@
 # frozen_string_literal: true
 
-if DependencyHelper.hanami2_present?
+if DependencyHelper.hanami_present?
   describe "Hanami integration" do
-    require "appsignal/integrations/hanami"
+    it "loads the Hanami loader" do
+      ENV["APPSIGNAL_APP_NAME"] = "test/sinatra"
+      ENV["APPSIGNAL_PUSH_API_KEY"] = "test-key"
 
-    before do
-      Appsignal.config = nil
-      allow(::Hanami::Action).to receive(:prepend)
-      uninstall_hanami_middleware
-      ENV["APPSIGNAL_APP_NAME"] = "hanamia-test-app"
-      ENV["APPSIGNAL_APP_ENV"] = "test"
-      ENV["APPSIGNAL_PUSH_API_KEY"] = "0000"
-    end
-
-    def uninstall_hanami_middleware
-      middleware_stack = ::Hanami.app.config.middleware.stack[::Hanami::Router::DEFAULT_PREFIX]
-      middleware_stack.delete_if do |middleware|
-        middleware.first == Appsignal::Rack::HanamiMiddleware ||
-          middleware.first == Rack::Events
-      end
-    end
-
-    describe Appsignal::Integrations::HanamiPlugin do
-      it "starts AppSignal on init" do
-        expect(Appsignal.active?).to be_falsey
-
-        Appsignal::Integrations::HanamiPlugin.init
-
-        expect(Appsignal.active?).to be_truthy
-      end
-
-      it "prepends the integration to Hanami::Action" do
-        Appsignal::Integrations::HanamiPlugin.init
-
-        expect(::Hanami::Action)
-          .to have_received(:prepend).with(Appsignal::Integrations::HanamiIntegration)
-      end
-
-      it "adds middleware to the Hanami app" do
-        Appsignal::Integrations::HanamiPlugin.init
-
-        expect(::Hanami.app.config.middleware.stack[::Hanami::Router::DEFAULT_PREFIX])
-          .to include(
-            [Rack::Events, [[kind_of(Appsignal::Rack::EventHandler)]], *hanami_middleware_options],
-            [Appsignal::Rack::HanamiMiddleware, [], *hanami_middleware_options]
-          )
-      end
-
-      context "when not active" do
-        before do
-          ENV.delete("APPSIGNAL_APP_NAME")
-          ENV.delete("APPSIGNAL_APP_ENV")
-          ENV.delete("APPSIGNAL_PUSH_API_KEY")
-        end
-
-        it "does not prepend the integration to Hanami::Action" do
-          Appsignal::Integrations::HanamiPlugin.init
-
-          expect(::Hanami::Action).to_not have_received(:prepend)
-            .with(Appsignal::Integrations::HanamiIntegration)
-        end
-
-        it "does not add the middleware to the Hanami app" do
-          Appsignal::Integrations::HanamiPlugin.init
-
-          middleware_stack = ::Hanami.app.config.middleware.stack[::Hanami::Router::DEFAULT_PREFIX]
-          expect(middleware_stack).to_not include(
-            [Rack::Events, [[kind_of(Appsignal::Rack::EventHandler)]], *hanami_middleware_options]
-          )
-          expect(middleware_stack).to_not include(
-            [Appsignal::Rack::HanamiMiddleware, [], *hanami_middleware_options]
-          )
-        end
-      end
-
-      context "when AppSignal is already active" do
-        before do
-          expect(Appsignal).to receive(:active?).at_least(1).and_return(true)
-        end
-
-        it "does not initialize AppSignal again" do
-          expect(Appsignal).to_not receive(:start)
-
-          Appsignal::Integrations::HanamiPlugin.init
-        end
-
-        it "prepends the integration to Hanami::Action" do
-          Appsignal::Integrations::HanamiPlugin.init
-
-          expect(::Hanami::Action)
-            .to have_received(:prepend).with(Appsignal::Integrations::HanamiIntegration)
-        end
-
-        it "adds middleware to the Hanami app" do
-          Appsignal::Integrations::HanamiPlugin.init
-
-          expect(::Hanami.app.config.middleware.stack[::Hanami::Router::DEFAULT_PREFIX])
-            .to include(
-              [
-                Rack::Events,
-                [[kind_of(Appsignal::Rack::EventHandler)]],
-                *hanami_middleware_options
-              ],
-              [Appsignal::Rack::HanamiMiddleware, [], *hanami_middleware_options]
-            )
-        end
-      end
-
-      context "when APPSIGNAL_APP_ENV ENV var is provided" do
-        it "uses this as the environment" do
-          ENV["APPSIGNAL_APP_ENV"] = "custom"
-
-          # Reset the plugin to pull down the latest data
-          Appsignal::Integrations::HanamiPlugin.init
-
-          expect(Appsignal.config.env).to eq("custom")
-        end
-      end
-
-      context "when APPSIGNAL_APP_ENV ENV var is not provided" do
-        it "uses the Hanami environment" do
-          # Reset the plugin to pull down the latest data
-          Appsignal::Integrations::HanamiPlugin.init
-
-          expect(Appsignal.config.env).to eq("test")
-        end
-      end
-    end
-
-    describe Appsignal::Integrations::HanamiIntegration do
-      let(:transaction) { http_request_transaction }
-      let(:app) do
-        Class.new(HanamiApp::Actions::Books::Index) do
-          def self.name
-            "HanamiApp::Actions::Books::Index::TestClass"
-          end
-        end
-      end
-      around { |example| keep_transactions { example.run } }
-      before do
-        ENV["APPSIGNAL_APP_NAME"] = "hanamia-test-app"
-        ENV["APPSIGNAL_APP_ENV"] = "test"
-        ENV["APPSIGNAL_PUSH_API_KEY"] = "0000"
-        Appsignal::Integrations::HanamiPlugin.init
-        allow(app).to receive(:prepend).and_call_original
-        app.prepend(Appsignal::Integrations::HanamiIntegration)
-      end
-
-      def make_request(env)
-        action = app.new
-        action.call(env)
-      end
-
-      describe "#call" do
-        context "without an active transaction" do
-          let(:env) { {} }
-
-          it "does not set the action name" do
-            make_request(env)
-
-            expect(transaction).to_not have_action
-          end
-        end
-
-        context "with an active transaction" do
-          let(:env) { { Appsignal::Rack::APPSIGNAL_TRANSACTION => transaction } }
-
-          it "sets action name on the transaction" do
-            make_request(env)
-
-            expect(transaction).to have_action("HanamiApp::Actions::Books::Index::TestClass")
-          end
-        end
-      end
-    end
+      require "appsignal/integrations/hanami"
 
-    def hanami_middleware_options
-      if DependencyHelper.hanami2_1_present?
-        [{}, nil]
-      else
-        [nil]
-      end
+      expect(Appsignal::Loaders.instances).to include(
+        :hanami => kind_of(Appsignal::Loaders::HanamiLoader)
+      )
+      expect(Appsignal.active?).to be(true)
     end
   end
 end

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

@@ -9,12 +9,8 @@ if DependencyHelper.http_present?
     around do |example|
       keep_transactions { example.run }
     end
-
-    before :context do
-      start_agent
-    end
-
     before do
+      start_agent
       set_current_transaction(transaction)
     end
 

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

@@ -3,8 +3,10 @@ describe Appsignal::Hooks::MongoMonitorSubscriber do
   let(:subscriber) { Appsignal::Hooks::MongoMonitorSubscriber.new }
 
   context "with transaction" do
-    let!(:transaction) do
-      Appsignal::Transaction.create("1", "http_request", {}, {})
+    let(:transaction) { http_request_transaction }
+    before do
+      start_agent
+      set_current_transaction(transaction)
     end
 
     describe "#started" do

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

@@ -2,7 +2,7 @@ require "appsignal/integrations/net_http"
 
 describe Appsignal::Integrations::NetHttpIntegration do
   let(:transaction) { http_request_transaction }
-  before(:context) { start_agent }
+  before { start_agent }
   before { set_current_transaction transaction }
   around { |example| keep_transactions { example.run } }
 

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

@@ -29,7 +29,6 @@ describe Object do
           start_agent
           set_current_transaction(transaction)
         end
-        after { Appsignal.config = nil }
 
         context "with different kind of arguments" do
           let(:klass) do
@@ -195,10 +194,9 @@ describe Object do
       context "when active" do
         let(:transaction) { http_request_transaction }
         before do
-          Appsignal.config = project_fixture_config
+          start_agent
           set_current_transaction(transaction)
         end
-        after { Appsignal.config = nil }
 
         context "with different kind of arguments" do
           let(:klass) do

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

@@ -1,337 +1,15 @@
 if DependencyHelper.padrino_present?
   describe "Padrino integration" do
-    require "appsignal/integrations/padrino"
+    it "loads the Padrino loader" do
+      ENV["APPSIGNAL_APP_NAME"] = "test/sinatra"
+      ENV["APPSIGNAL_PUSH_API_KEY"] = "test-key"
 
-    describe Appsignal::Integrations::PadrinoPlugin do
-      let(:callbacks) { { :before_load => nil } }
-      before do
-        Appsignal.config = nil
-        allow(Padrino).to receive(:before_load)
-          .and_wrap_original do |original_method, *args, &block|
-            callbacks[:before_load] = block
-            original_method.call(*args, &block)
-          end
-      end
-      after { uninstall_padrino_integration }
+      require "appsignal/integrations/padrino"
 
-      def uninstall_padrino_integration
-        expected_middleware = [
-          Rack::Events,
-          Appsignal::Rack::SinatraBaseInstrumentation
-        ]
-        Padrino.middleware.delete_if do |middleware|
-          expected_middleware.include?(middleware.first)
-        end
-      end
-
-      context "when already active" do
-        before { allow(Appsignal).to receive(:active?).and_return(true) }
-
-        it "does not start AppSignal again" do
-          expect(Appsignal::Config).to_not receive(:new)
-          expect(Appsignal).to_not receive(:start)
-
-          Appsignal::Integrations::PadrinoPlugin.init
-          callbacks[:before_load].call
-        end
-
-        it "adds the instrumentation middleware to Sinatra::Base" do
-          Appsignal::Integrations::PadrinoPlugin.init
-          callbacks[:before_load].call
-
-          middlewares = Padrino.middleware
-          expect(middlewares).to include(
-            [Rack::Events, [[instance_of(Appsignal::Rack::EventHandler)]], nil]
-          )
-          expect(middlewares).to include(
-            [
-              Appsignal::Rack::SinatraBaseInstrumentation,
-              [
-                :instrument_event_name => "process_action.padrino"
-              ],
-              nil
-            ]
-          )
-        end
-      end
-
-      context "with active config" do
-        before do
-          ENV["APPSIGNAL_APP_NAME"] = "My Padrino app name"
-          ENV["APPSIGNAL_APP_ENV"] = "test"
-          ENV["APPSIGNAL_PUSH_API_KEY"] = "my-key"
-        end
-
-        it "starts AppSignal on init" do
-          expect(Appsignal).to_not be_active
-
-          Appsignal::Integrations::PadrinoPlugin.init
-          callbacks[:before_load].call
-
-          expect(Appsignal).to be_active
-          middlewares = Padrino.middleware
-          expect(middlewares).to include(
-            [Rack::Events, [[instance_of(Appsignal::Rack::EventHandler)]], nil]
-          )
-          expect(middlewares).to include(
-            [
-              Appsignal::Rack::SinatraBaseInstrumentation,
-              [
-                :instrument_event_name => "process_action.padrino"
-              ],
-              nil
-            ]
-          )
-        end
-
-        context "when APPSIGNAL_APP_ENV ENV var is provided" do
-          it "uses this as the environment" do
-            ENV["APPSIGNAL_APP_ENV"] = "custom"
-
-            Appsignal::Integrations::PadrinoPlugin.init
-            callbacks[:before_load].call
-
-            expect(Appsignal.config.env).to eq("custom")
-          end
-        end
-
-        context "when APPSIGNAL_APP_ENV ENV var is not provided" do
-          it "uses the Padrino environment" do
-            Appsignal::Integrations::PadrinoPlugin.init
-            callbacks[:before_load].call
-
-            expect(Padrino.env.to_s).to eq("test")
-            expect(Appsignal.config.env).to eq(Padrino.env.to_s)
-          end
-        end
-      end
-
-      context "when not active" do
-        it "does not add the listener middleware to the stack" do
-          expect(Appsignal).to_not be_active
-
-          Appsignal::Integrations::PadrinoPlugin.init
-          callbacks[:before_load].call
-
-          expect(Appsignal).to_not be_active
-          middlewares = Padrino.middleware
-          expect(middlewares).to_not include(
-            [Rack::Events, [[instance_of(Appsignal::Rack::EventHandler)]], nil]
-          )
-          expect(middlewares).to_not include(
-            [
-              Appsignal::Rack::SinatraBaseInstrumentation,
-              [
-                :request_class => ::Sinatra::Request,
-                :instrument_event_name => "process_action.padrino"
-              ],
-              nil
-            ]
-          )
-        end
-      end
-    end
-
-    describe Padrino::Routing::InstanceMethods do
-      class PadrinoClassWithRouter
-        include Padrino::Routing
-      end
-
-      let(:base)     { double }
-      let(:router)   { PadrinoClassWithRouter.new }
-      let(:env)      { {} }
-      # TODO: use an instance double
-      let(:settings) { double(:name => "TestApp") }
-      around { |example| keep_transactions { example.run } }
-      before { Appsignal.config = nil }
-
-      describe "routes" do
-        let(:env) do
-          {
-            "REQUEST_METHOD" => "GET",
-            "PATH_INFO" => path,
-            "REQUEST_PATH" => path,
-            "rack.input" => StringIO.new
-          }
-        end
-        let(:app) do
-          Class.new(Padrino::Application) do
-            def self.name
-              "PadrinoTestApp"
-            end
-          end
-        end
-        let(:response) { app.call(env) }
-
-        RSpec::Matchers.define :match_response do |expected_status, expected_content|
-          match do |response|
-            status, _headers, content = response
-            matches_content =
-              if expected_content.is_a?(Regexp)
-                content.join =~ expected_content
-              else
-                content == [expected_content].compact
-              end
-            status == expected_status && matches_content
-          end
-        end
-
-        context "when AppSignal is not active" do
-          let(:path) { "/foo" }
-          before { app.controllers { get(:foo) { "content" } } }
-
-          it "does not instrument the request" do
-            expect do
-              expect(response).to match_response(200, "content")
-            end.to_not(change { created_transactions.count })
-          end
-        end
-
-        context "when AppSignal is active" do
-          let(:transaction) { http_request_transaction }
-          before do
-            start_agent
-            set_current_transaction(transaction)
-          end
-
-          context "with not existing route" do
-            let(:path) { "/404" }
-
-            it "instruments the request" do
-              expect(response).to match_response(404, /^GET /404/)
-              expect(last_transaction).to have_action("PadrinoTestApp#unknown")
-            end
-          end
-
-          context "when Sinatra tells us it's a static file" do
-            let(:path) { "/static" }
-            before do
-              env["sinatra.static_file"] = true
-              app.controllers { get(:static) { "Static!" } }
-            end
-
-            it "does not instrument the request" do
-              expect(response).to match_response(200, "Static!")
-              expect(last_transaction).to_not have_action
-            end
-          end
-
-          # Older Padrino versions don't support `action` (v11.0+)
-          context "without #action on Sinatra::Request" do
-            let(:path) { "/my_original_path/10" }
-            before do
-              allow_any_instance_of(Sinatra::Request).to receive(:action).and_return(nil)
-              app.controllers { get(:my_original_path, :with => :id) { "content" } }
-            end
-
-            it "falls back on Sinatra::Request#route_obj.original_path" do
-              expect(response).to match_response(200, "content")
-              expect(last_transaction).to have_action("PadrinoTestApp:/my_original_path/:id")
-            end
-          end
-
-          context "without Sinatra::Request#route_obj.original_path" do
-            let(:path) { "/my_original_path" }
-            before do
-              allow_any_instance_of(Sinatra::Request).to receive(:action).and_return(nil)
-              allow_any_instance_of(Sinatra::Request).to receive(:route_obj).and_return(nil)
-              app.controllers { get(:my_original_path) { "content" } }
-            end
-
-            it "falls back on app name" do
-              expect(response).to match_response(200, "content")
-              expect(last_transaction).to have_action("PadrinoTestApp#unknown")
-            end
-          end
-
-          context "with existing route" do
-            let(:path) { "/" }
-            def make_request
-              expect(response).to match_response(200, "content")
-            end
-
-            context "with action name as symbol" do
-              context "with :index helper" do
-                before do
-                  # :index == "/"
-                  app.controllers { get(:index) { "content" } }
-                end
-
-                it "sets the action with the app name and action name" do
-                  make_request
-                  expect(last_transaction).to have_action("PadrinoTestApp:#index")
-                end
-              end
-
-              context "with custom action name" do
-                let(:path) { "/foo" }
-                before do
-                  app.controllers { get(:foo) { "content" } }
-                end
-
-                it "sets the action with the app name and action name" do
-                  make_request
-                  expect(last_transaction).to have_action("PadrinoTestApp:#foo")
-                end
-              end
-            end
-
-            context "with an action defined with a path" do
-              context "with root path" do
-                before do
-                  # :index == "/"
-                  app.controllers { get("/") { "content" } }
-                end
-
-                it "sets the action with the app name and action path" do
-                  make_request
-                  expect(last_transaction).to have_action("PadrinoTestApp:#/")
-                end
-              end
-
-              context "with custom path" do
-                let(:path) { "/foo" }
-                before do
-                  app.controllers { get("/foo") { "content" } }
-                end
-
-                it "sets the action with the app name and action path" do
-                  make_request
-                  expect(last_transaction).to have_action("PadrinoTestApp:#/foo")
-                end
-              end
-            end
-
-            context "with controller" do
-              let(:path) { "/my_controller" }
-
-              context "with controller as name" do
-                before do
-                  # :index == "/"
-                  app.controllers(:my_controller) { get(:index) { "content" } }
-                end
-
-                it "sets the action with the app name, controller name and action name" do
-                  make_request
-                  expect(last_transaction).to have_action("PadrinoTestApp:my_controller#index")
-                end
-              end
-
-              context "with controller as path" do
-                before do
-                  # :index == "/"
-                  app.controllers("/my_controller") { get(:index) { "content" } }
-                end
-
-                it "sets the action with the app name, controller name and action path" do
-                  make_request
-                  expect(last_transaction).to have_action("PadrinoTestApp:/my_controller#index")
-                end
-              end
-            end
-          end
-        end
-      end
+      expect(Appsignal::Loaders.instances).to include(
+        :padrino => kind_of(Appsignal::Loaders::PadrinoLoader)
+      )
+      expect(Appsignal.active?).to be(true)
     end
   end
 end