appsignal 4.0.5 → 4.0.7

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

@@ -1,115 +0,0 @@
-describe Appsignal::Hooks::SidekiqHook do
-  describe "#dependencies_present?" do
-    subject { described_class.new.dependencies_present? }
-
-    context "when Sidekiq constant is found" do
-      before { stub_const "Sidekiq", Class.new }
-
-      it { is_expected.to be_truthy }
-    end
-
-    context "when Sidekiq constant is not found" do
-      before { hide_const "Sidekiq" }
-
-      it { is_expected.to be_falsy }
-    end
-  end
-
-  describe "#install" do
-    class SidekiqMiddlewareMockWithPrepend < Array
-      alias add <<
-      alias exists? include?
-
-      unless method_defined? :prepend
-        # For Ruby < 2.5
-        def prepend(middleware)
-          insert(0, middleware)
-        end
-      end
-    end
-
-    class SidekiqMiddlewareMockWithoutPrepend < Array
-      alias add <<
-      alias exists? include?
-
-      undef_method :prepend if method_defined? :prepend # For Ruby >= 2.5
-    end
-
-    module SidekiqMock
-      def self.middleware_mock=(mock)
-        @middlewares = mock.new
-      end
-
-      def self.middlewares
-        @middlewares
-      end
-
-      def self.configure_server
-        yield self
-      end
-
-      def self.server_middleware
-        yield middlewares if block_given?
-        middlewares
-      end
-
-      def self.error_handlers
-        @error_handlers ||= []
-      end
-    end
-
-    def add_middleware(middleware)
-      Sidekiq.configure_server do |sidekiq_config|
-        sidekiq_config.middlewares.add(middleware)
-      end
-    end
-
-    before do
-      start_agent
-      stub_const "Sidekiq", SidekiqMock
-    end
-
-    it "adds error handler" do
-      Sidekiq.middleware_mock = SidekiqMiddlewareMockWithPrepend
-      described_class.new.install
-      expect(Sidekiq.error_handlers).to include(Appsignal::Integrations::SidekiqErrorHandler)
-    end
-
-    context "when Sidekiq middleware responds to prepend method" do # Sidekiq 3.3.0 and newer
-      before { Sidekiq.middleware_mock = SidekiqMiddlewareMockWithPrepend }
-
-      it "adds the AppSignal SidekiqPlugin to the Sidekiq middleware chain in the first position" do
-        user_middleware1 = proc {}
-        add_middleware(user_middleware1)
-        described_class.new.install
-        user_middleware2 = proc {}
-        add_middleware(user_middleware2)
-
-        expect(Sidekiq.server_middleware).to eql([
-          Appsignal::Integrations::SidekiqMiddleware, # Prepend makes it the first entry
-          user_middleware1,
-          user_middleware2
-        ])
-      end
-    end
-
-    context "when Sidekiq middleware does not respond to prepend method" do
-      before { Sidekiq.middleware_mock = SidekiqMiddlewareMockWithoutPrepend }
-
-      it "adds the AppSignal SidekiqPlugin to the Sidekiq middleware chain" do
-        user_middleware1 = proc {}
-        add_middleware(user_middleware1)
-        described_class.new.install
-        user_middleware2 = proc {}
-        add_middleware(user_middleware2)
-
-        # Add middlewares in whatever order they were added
-        expect(Sidekiq.server_middleware).to eql([
-          user_middleware1,
-          Appsignal::Integrations::SidekiqMiddleware,
-          user_middleware2
-        ])
-      end
-    end
-  end
-end

data/spec/lib/appsignal/hooks/unicorn_spec.rb

@@ -1,63 +0,0 @@
-describe Appsignal::Hooks::UnicornHook do
-  context "with unicorn" do
-    before :context do
-      module Unicorn
-        class HttpServer
-          def worker_loop(_worker)
-            @worker_loop = true
-          end
-
-          def worker_loop?
-            @worker_loop == true
-          end
-        end
-
-        class Worker
-          def close
-            @close = true
-          end
-
-          def close?
-            @close == true
-          end
-        end
-      end
-      Appsignal::Hooks::UnicornHook.new.install
-    end
-    after(:context) { Object.send(:remove_const, :Unicorn) }
-
-    describe "#dependencies_present?" do
-      subject { described_class.new.dependencies_present? }
-
-      it { is_expected.to be_truthy }
-    end
-
-    it "adds behavior to Unicorn::HttpServer#worker_loop" do
-      server = Unicorn::HttpServer.new
-      worker = double
-
-      expect(Appsignal).to receive(:forked)
-
-      server.worker_loop(worker)
-
-      expect(server.worker_loop?).to be true
-    end
-
-    it "adds behavior to Unicorn::Worker#close" do
-      worker = Unicorn::Worker.new
-
-      expect(Appsignal).to receive(:stop)
-
-      worker.close
-      expect(worker.close?).to be true
-    end
-  end
-
-  context "without unicorn" do
-    describe "#dependencies_present?" do
-      subject { described_class.new.dependencies_present? }
-
-      it { is_expected.to be_falsy }
-    end
-  end
-end

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

@@ -1,24 +0,0 @@
-describe Appsignal::Hooks::WebmachineHook do
-  if DependencyHelper.webmachine_present?
-    context "with webmachine" do
-      let(:fsm) { Webmachine::Decision::FSM.new(double(:trace? => false), double, double) }
-      before { start_agent }
-
-      describe "#dependencies_present?" do
-        subject { described_class.new.dependencies_present? }
-
-        it { is_expected.to be_truthy }
-      end
-
-      it "adds behavior to Webmachine::Decision::FSM" do
-        expect(fsm.class.ancestors.first).to eq(Appsignal::Integrations::WebmachineIntegration)
-      end
-    end
-  else
-    describe "#dependencies_present?" do
-      subject { described_class.new.dependencies_present? }
-
-      it { is_expected.to be_falsy }
-    end
-  end
-end

data/spec/lib/appsignal/hooks_spec.rb

@@ -1,124 +0,0 @@
-class MockPresentHook < Appsignal::Hooks::Hook
-  def dependencies_present?
-    true
-  end
-
-  def install
-    MockPresentHook.call_something
-  end
-
-  def self.call_something
-  end
-end
-
-class MockNotPresentHook < Appsignal::Hooks::Hook
-  def dependencies_present?
-    false
-  end
-
-  def install
-    MockNotPresentHook.call_something
-  end
-end
-
-class MockErrorHook < Appsignal::Hooks::Hook
-  def dependencies_present?
-    true
-  end
-
-  def install
-    raise "error"
-  end
-end
-
-describe Appsignal::Hooks do
-  it "should register and install a hook once" do
-    Appsignal::Hooks::Hook.register(:mock_present_hook, MockPresentHook)
-
-    expect(Appsignal::Hooks.hooks[:mock_present_hook]).to be_instance_of(MockPresentHook)
-    expect(Appsignal::Hooks.hooks[:mock_present_hook].installed?).to be_falsy
-
-    expect(MockPresentHook).to receive(:call_something).once
-
-    Appsignal::Hooks.load_hooks
-    Appsignal::Hooks.load_hooks
-    Appsignal::Hooks.load_hooks
-    expect(Appsignal::Hooks.hooks[:mock_present_hook].installed?).to be_truthy
-    Appsignal::Hooks.hooks.delete(:mock_present_hook)
-  end
-
-  it "should not install if dependencies are not present" do
-    Appsignal::Hooks::Hook.register(:mock_not_present_hook, MockNotPresentHook)
-
-    expect(Appsignal::Hooks.hooks[:mock_not_present_hook]).to be_instance_of(MockNotPresentHook)
-    expect(Appsignal::Hooks.hooks[:mock_not_present_hook].installed?).to be_falsy
-
-    expect(MockPresentHook).to_not receive(:call_something)
-
-    Appsignal::Hooks.load_hooks
-
-    expect(Appsignal::Hooks.hooks[:mock_not_present_hook].installed?).to be_falsy
-    Appsignal::Hooks.hooks.delete(:mock_not_present_hook)
-  end
-
-  it "should not install if there is an error while installing" do
-    Appsignal::Hooks::Hook.register(:mock_error_hook, MockErrorHook)
-
-    expect(Appsignal::Hooks.hooks[:mock_error_hook]).to be_instance_of(MockErrorHook)
-    expect(Appsignal::Hooks.hooks[:mock_error_hook].installed?).to be_falsy
-
-    expect(Appsignal.internal_logger).to receive(:error)
-      .with("Error while installing mock_error_hook hook: error").once
-    expect(Appsignal.internal_logger).to receive(:debug).ordered do |message|
-      expect(message).to eq("Installing mock_error_hook hook")
-    end
-    expect(Appsignal.internal_logger).to receive(:debug).ordered do |message|
-      # Start of the error backtrace as debug log
-      expect(message).to start_with(File.expand_path("../../..", __dir__))
-    end
-
-    Appsignal::Hooks.load_hooks
-
-    expect(Appsignal::Hooks.hooks[:mock_error_hook].installed?).to be_falsy
-    Appsignal::Hooks.hooks.delete(:mock_error_hook)
-  end
-end
-
-describe Appsignal::Hooks::Helpers do
-  class ClassWithHelpers
-    include Appsignal::Hooks::Helpers
-  end
-  let(:with_helpers) { ClassWithHelpers.new }
-
-  describe "#truncate" do
-    let(:very_long_text) do
-      "a" * 400
-    end
-
-    it "should truncate the text to 200 chars max" do
-      expect(with_helpers.truncate(very_long_text)).to eq "#{"a" * 197}..."
-    end
-  end
-
-  describe "#string_or_inspect" do
-    context "when string" do
-      it "should return the string" do
-        expect(with_helpers.string_or_inspect("foo")).to eq "foo"
-      end
-    end
-
-    context "when integer" do
-      it "should return the string" do
-        expect(with_helpers.string_or_inspect(1)).to eq "1"
-      end
-    end
-
-    context "when object" do
-      let(:object) { Object.new }
-
-      it "should return the string" do
-        expect(with_helpers.string_or_inspect(object)).to eq object.inspect
-      end
-    end
-  end
-end

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

@@ -1,74 +0,0 @@
-require "appsignal/integrations/data_mapper"
-
-describe Appsignal::Hooks::DataMapperLogListener do
-  module DataMapperLog
-    def log(message)
-    end
-  end
-
-  describe "#log" do
-    let(:transaction) { http_request_transaction }
-    let(:message) do
-      double(
-        :query    => "SELECT * from users",
-        :duration => 100_000_000 # nanoseconds
-      )
-    end
-    let(:connection_class) do
-      module DataObjects
-        module Sqlite3
-          class Connection
-            include DataMapperLog
-            include Appsignal::Hooks::DataMapperLogListener
-          end
-        end
-      end
-    end
-    before do
-      start_agent
-      set_current_transaction(transaction)
-    end
-    around { |example| keep_transactions { example.run } }
-
-    def log_message
-      connection_class.new.log(message)
-    end
-
-    it "records the log entry in an event" do
-      log_message
-
-      expect(transaction).to include_event(
-        "name" => "query.data_mapper",
-        "title" => "DataMapper Query",
-        "body" => "SELECT * from users",
-        "body_format" => Appsignal::EventFormatter::SQL_BODY_FORMAT,
-        "duration" => 100.0
-      )
-    end
-
-    context "when the scheme is not sql-like" do
-      let(:connection_class) do
-        module DataObjects
-          module MongoDB
-            class Connection
-              include DataMapperLog
-              include Appsignal::Hooks::DataMapperLogListener
-            end
-          end
-        end
-      end
-
-      it "records the log entry in an event without body" do
-        log_message
-
-        expect(transaction).to include_event(
-          "name" => "query.data_mapper",
-          "title" => "DataMapper Query",
-          "body" => "",
-          "body_format" => Appsignal::EventFormatter::DEFAULT,
-          "duration" => 100.0
-        )
-      end
-    end
-  end
-end