appsignal 2.11.9-java → 3.0.0.beta.1-java

data/spec/lib/appsignal/auth_check_spec.rb

@@ -28,29 +28,6 @@ describe Appsignal::AuthCheck do
     end.join("&")
   end
 
-  describe ".new" do
-    describe "with logger argument" do
-      let(:err_stream) { std_stream }
-      let(:stderr) { err_stream.read }
-      let(:log_stream) { std_stream }
-      let(:log) { log_contents(log_stream) }
-
-      it "logs and prints a deprecation message" do
-        Appsignal.logger = test_logger(log_stream)
-
-        capture_std_streams(std_stream, err_stream) do
-          Appsignal::AuthCheck.new(config, Appsignal.logger)
-        end
-
-        deprecation_message =
-          "`Appsignal::AuthCheck.new`'s `logger` argument " \
-          "will be removed in the next major version."
-        expect(stderr).to include "appsignal WARNING: #{deprecation_message}"
-        expect(log).to contains_log :warn, deprecation_message
-      end
-    end
-  end
-
   describe "#perform" do
     subject { auth_check.perform }
 
@@ -62,7 +39,7 @@ describe Appsignal::AuthCheck do
       end
     end
 
-    context "when encountering an exception", :not_ruby19 do
+    context "when encountering an exception" do
       before { stubbed_request.to_timeout }
 
       it "raises an error" do

data/spec/lib/appsignal/cli_spec.rb

@@ -16,7 +16,7 @@ describe Appsignal::CLI do
 
       expect(output).to include "appsignal <command> [options]"
       expect(output).to include \
-        "Available commands: demo, diagnose, install, notify_of_deploy"
+        "Available commands: demo, diagnose, install"
     end
   end
 

data/spec/lib/appsignal/config_spec.rb

@@ -168,8 +168,6 @@ describe Appsignal::Config do
         :push_api_key                   => "abc",
         :name                           => "TestApp",
         :active                         => true,
-        :enable_frontend_error_catching => false,
-        :frontend_error_catching_path   => "/appsignal_error_catcher",
         :enable_allocation_tracking     => true,
         :enable_gc_instrumentation      => false,
         :enable_host_metrics            => true,
@@ -357,70 +355,6 @@ describe Appsignal::Config do
         config
       end
     end
-
-    describe "support for old config keys" do
-      let(:err_stream) { std_stream }
-      let(:stderr) { err_stream.read }
-      let(:config) { project_fixture_config(env, {}, test_logger(log)) }
-      let(:log) { StringIO.new }
-      before { capture_std_streams(std_stream, err_stream) { config } }
-
-      describe ":api_key" do
-        context "without :push_api_key" do
-          let(:env) { "old_config" }
-
-          it "sets the :push_api_key with the old :api_key value" do
-            expect(config[:push_api_key]).to eq "def"
-            expect(config.config_hash).to_not have_key :api_key
-
-            message = "Old configuration key found. Please update the 'api_key' to 'push_api_key'"
-            expect(stderr).to include "appsignal WARNING: #{message}"
-            expect(log_contents(log)).to contains_log :warn, message
-          end
-        end
-
-        context "with :push_api_key" do
-          let(:env) { "old_config_mixed_with_new_config" }
-
-          it "ignores the :api_key config and deletes it" do
-            expect(config[:push_api_key]).to eq "ghi"
-            expect(config.config_hash).to_not have_key :api_key
-
-            message = "Old configuration key found. Please update the 'api_key' to 'push_api_key'"
-            expect(stderr).to include "appsignal WARNING: #{message}"
-            expect(log_contents(log)).to contains_log :warn, message
-          end
-        end
-      end
-
-      describe ":ignore_exceptions" do
-        context "without :ignore_errors" do
-          let(:env) { "old_config" }
-
-          it "sets :ignore_errors with the old :ignore_exceptions value" do
-            expect(config[:ignore_errors]).to eq ["StandardError"]
-            expect(config.config_hash).to_not have_key :ignore_exceptions
-
-            message = "Old configuration key found. Please update the 'ignore_exceptions' to 'ignore_errors'"
-            expect(stderr).to include "appsignal WARNING: #{message}"
-            expect(log_contents(log)).to contains_log :warn, message
-          end
-        end
-
-        context "with :ignore_errors" do
-          let(:env) { "old_config_mixed_with_new_config" }
-
-          it "ignores the :ignore_exceptions config" do
-            expect(config[:ignore_errors]).to eq ["NoMethodError"]
-            expect(config.config_hash).to_not have_key :ignore_exceptions
-
-            message = "Old configuration key found. Please update the 'ignore_exceptions' to 'ignore_errors'"
-            expect(stderr).to include "appsignal WARNING: #{message}"
-            expect(log_contents(log)).to contains_log :warn, message
-          end
-        end
-      end
-    end
   end
 
   context "with config in the environment" do

data/spec/lib/appsignal/event_formatter_spec.rb

@@ -114,43 +114,6 @@ describe Appsignal::EventFormatter do
         end
       end
     end
-
-    context "when registering deprecated formatters" do
-      let(:err_stream) { std_stream }
-      let(:stderr) { err_stream.read }
-      let(:deprecated_formatter) do
-        Class.new(Appsignal::EventFormatter) do
-          register "mock.deprecated"
-
-          def format(_payload)
-          end
-        end
-      end
-
-      it "registers deprecated formatters and logs & prints a warning" do
-        message = "Formatter for 'mock.deprecated' is using a deprecated registration method. " \
-          "This event formatter will not be loaded. " \
-          "Please update the formatter according to the documentation at: " \
-          "https://docs.appsignal.com/ruby/instrumentation/event-formatters.html"
-
-        logs = capture_logs do
-          capture_std_streams(std_stream, err_stream) { deprecated_formatter }
-        end
-        expect(logs).to contains_log :warn, message
-        expect(stderr).to include "appsignal WARNING: #{message}"
-
-        expect(klass.deprecated_formatter_classes.keys).to include("mock.deprecated")
-      end
-
-      it "initializes deprecated formatters" do
-        capture_std_streams(std_stream, err_stream) { deprecated_formatter }
-        klass.initialize_deprecated_formatters
-
-        expect(klass.registered?("mock.deprecated")).to be_truthy
-        expect(klass.formatters["mock.deprecated"]).to be_instance_of(deprecated_formatter)
-        expect(klass.deprecated_formatter_classes["mock.deprecated"]).to eq(deprecated_formatter)
-      end
-    end
   end
 
   describe ".registered?" do

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

@@ -2,8 +2,6 @@ describe Appsignal::Hooks::ActionCableHook do
   if DependencyHelper.action_cable_present?
     context "with ActionCable" do
       require "action_cable/engine"
-      # Require test helper to test with ConnectionStub
-      require "action_cable/channel/test_case" if DependencyHelper.rails6_present?
 
       describe ".dependencies_present?" do
         subject { described_class.new.dependencies_present? }
@@ -264,49 +262,6 @@ describe Appsignal::Hooks::ActionCableHook do
               )
             end
           end
-
-          if DependencyHelper.rails6_present?
-            context "with ConnectionStub" do
-              let(:connection) { ActionCable::Channel::ConnectionStub.new }
-              let(:transaction_id) { "Stubbed transaction id" }
-              before do
-                # Stub future (private AppSignal) transaction id generated by the hook.
-                expect(SecureRandom).to receive(:uuid).and_return(transaction_id)
-              end
-
-              it "does not fail on missing `#env` method on `ConnectionStub`" do
-                instance.subscribe_to_channel
-
-                expect(subject).to include(
-                  "action" => "MyChannel#subscribed",
-                  "error" => nil,
-                  "id" => transaction_id,
-                  "namespace" => Appsignal::Transaction::ACTION_CABLE,
-                  "metadata" => {
-                    "method" => "websocket",
-                    "path" => "" # No path as the ConnectionStub doesn't have the real request env
-                  }
-                )
-                expect(subject["events"].first).to include(
-                  "allocation_count" => kind_of(Integer),
-                  "body" => "",
-                  "body_format" => Appsignal::EventFormatter::DEFAULT,
-                  "child_allocation_count" => kind_of(Integer),
-                  "child_duration" => kind_of(Float),
-                  "child_gc_duration" => kind_of(Float),
-                  "count" => 1,
-                  "gc_duration" => kind_of(Float),
-                  "start" => kind_of(Float),
-                  "duration" => kind_of(Float),
-                  "name" => "subscribed.action_cable",
-                  "title" => ""
-                )
-                expect(subject["sample_data"]).to include(
-                  "params" => { "internal" => "true" }
-                )
-              end
-            end
-          end
         end
 
         describe "unsubscribe callback" do
@@ -394,49 +349,6 @@ describe Appsignal::Hooks::ActionCableHook do
               )
             end
           end
-
-          if DependencyHelper.rails6_present?
-            context "with ConnectionStub" do
-              let(:connection) { ActionCable::Channel::ConnectionStub.new }
-              let(:transaction_id) { "Stubbed transaction id" }
-              before do
-                # Stub future (private AppSignal) transaction id generated by the hook.
-                expect(SecureRandom).to receive(:uuid).and_return(transaction_id)
-              end
-
-              it "does not fail on missing `#env` method on `ConnectionStub`" do
-                instance.unsubscribe_from_channel
-
-                expect(subject).to include(
-                  "action" => "MyChannel#unsubscribed",
-                  "error" => nil,
-                  "id" => transaction_id,
-                  "namespace" => Appsignal::Transaction::ACTION_CABLE,
-                  "metadata" => {
-                    "method" => "websocket",
-                    "path" => "" # No path as the ConnectionStub doesn't have the real request env
-                  }
-                )
-                expect(subject["events"].first).to include(
-                  "allocation_count" => kind_of(Integer),
-                  "body" => "",
-                  "body_format" => Appsignal::EventFormatter::DEFAULT,
-                  "child_allocation_count" => kind_of(Integer),
-                  "child_duration" => kind_of(Float),
-                  "child_gc_duration" => kind_of(Float),
-                  "count" => 1,
-                  "gc_duration" => kind_of(Float),
-                  "start" => kind_of(Float),
-                  "duration" => kind_of(Float),
-                  "name" => "unsubscribed.action_cable",
-                  "title" => ""
-                )
-                expect(subject["sample_data"]).to include(
-                  "params" => { "internal" => "true" }
-                )
-              end
-            end
-          end
         end
       end
     end

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

@@ -3,6 +3,11 @@ describe Appsignal::Hooks::CelluloidHook do
     before :context do
       module Celluloid
         def self.shutdown
+          @shut_down = true
+        end
+
+        def self.shut_down?
+          @shut_down == true
         end
       end
       Appsignal::Hooks::CelluloidHook.new.install
@@ -18,7 +23,7 @@ describe Appsignal::Hooks::CelluloidHook do
     end
 
     specify { expect(Appsignal).to receive(:stop) }
-    specify { expect(Celluloid).to receive(:shutdown_without_appsignal) }
+    specify { expect(Celluloid.shut_down?).to be true }
 
     after do
       Celluloid.shutdown

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

@@ -20,8 +20,7 @@ describe Appsignal::Hooks::RakeHook do
       end
 
       it "calls the original task" do
-        expect(task).to receive(:execute_without_appsignal).with(arguments)
-        perform
+        expect(perform).to eq([])
       end
     end
 

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

@@ -1,33 +1,68 @@
 describe Appsignal::Hooks::RedisHook do
   before do
     Appsignal.config = project_fixture_config
-    Appsignal::Hooks.load_hooks
   end
 
   if DependencyHelper.redis_present?
     context "with redis" do
       context "with instrumentation enabled" do
-        before do
-          Appsignal.config.config_hash[:instrument_redis] = true
-          allow_any_instance_of(Redis::Client).to receive(:process_without_appsignal).and_return(1)
-        end
-
         describe "#dependencies_present?" do
           subject { described_class.new.dependencies_present? }
 
           it { is_expected.to be_truthy }
         end
 
-        it "should instrument a redis call" do
-          Appsignal::Transaction.create("uuid", Appsignal::Transaction::HTTP_REQUEST, "test")
-          expect(Appsignal::Transaction.current).to receive(:start_event)
-            .at_least(:once)
-          expect(Appsignal::Transaction.current).to receive(:finish_event)
-            .at_least(:once)
-            .with("query.redis", "redis://127.0.0.1:6379/0", "get ?", 0)
+        describe "integration" do
+          before do
+            Appsignal.config.config_hash[:instrument_redis] = true
+          end
+
+          context "install" do
+            before do
+              Appsignal::Hooks.load_hooks
+            end
+
+            it "does something" do
+              # Test if the last included module (prepended module) was our
+              # integration. That's not certain with the assertions below
+              # because we have to overwrite the `process` method for the test.
+              expect(Redis::Client.included_modules.first)
+                .to eql(Appsignal::Integrations::RedisIntegration)
+            end
+          end
+
+          context "instrumentation" do
+            before do
+              # Stub Redis::Client class so that it doesn't perform an actual
+              # Redis query. This class will be included (prepended) with the
+              # AppSignal Redis integration.
+              stub_const("Redis::Client", Class.new do
+                def id
+                  :stub_id
+                end
+
+                def process(_commands)
+                  :stub_process
+                end
+              end)
+              # Load the integration again for the stubbed Redis::Client class.
+              # Call it directly because {Appsignal::Hooks.load_hooks} keeps
+              # track if it was installed already or not.
+              Appsignal::Hooks::RedisHook.new.install
+            end
+
+            it "instrument a redis call" do
+              Appsignal::Transaction.create("uuid", Appsignal::Transaction::HTTP_REQUEST, "test")
+              expect(Appsignal::Transaction.current).to receive(:start_event)
+                .at_least(:once)
+              expect(Appsignal::Transaction.current).to receive(:finish_event)
+                .at_least(:once)
+                .with("query.redis", :stub_id, "get ?", 0)
 
-          client = Redis::Client.new
-          expect(client.process([[:get, "key"]])).to eq 1
+              client = Redis::Client.new
+              expect(client.process([[:get, "key"]])).to eql(:stub_process)
+            end
+          end
         end
       end
 

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

@@ -16,31 +16,14 @@ describe Appsignal::Hooks::SidekiqHook do
   end
 
   describe "#install" do
-    class SidekiqMiddlewareMockWithPrepend < Array
-      alias add <<
-      alias exists? include?
-
-      unless method_defined? :prepend
-        def prepend(middleware) # For Ruby < 2.5
-          insert(0, middleware)
-        end
+    class SidekiqMiddlewareMock < Set
+      def exists?(middleware)
+        include?(middleware)
       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
+        @middlewares ||= SidekiqMiddlewareMock.new
       end
 
       def self.configure_server
@@ -53,52 +36,15 @@ describe Appsignal::Hooks::SidekiqHook do
       end
     end
 
-    def add_middleware(middleware)
-      Sidekiq.configure_server do |sidekiq_config|
-        sidekiq_config.middlewares.add(middleware)
-      end
-    end
-
     before do
       Appsignal.config = project_fixture_config
       stub_const "Sidekiq", SidekiqMock
     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)
+    it "adds the AppSignal SidekiqPlugin to the Sidekiq middleware chain" do
+      described_class.new.install
 
-        expect(Sidekiq.server_middleware).to eql([
-          Appsignal::Hooks::SidekiqPlugin, # 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::Hooks::SidekiqPlugin,
-          user_middleware2
-        ])
-      end
+      expect(Sidekiq.server_middleware.exists?(Appsignal::Hooks::SidekiqPlugin)).to be(true)
     end
   end
 end