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

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/unicorn_spec.rb

@@ -3,12 +3,22 @@ describe Appsignal::Hooks::UnicornHook do
     before :context do
       module Unicorn
         class HttpServer
-          def worker_loop(worker)
+          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
@@ -27,18 +37,19 @@ describe Appsignal::Hooks::UnicornHook do
       worker = double
 
       expect(Appsignal).to receive(:forked)
-      expect(server).to receive(:worker_loop_without_appsignal).with(worker)
 
       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)
-      expect(worker).to receive(:close_without_appsignal)
 
       worker.close
+      expect(worker.close?).to be true
     end
   end
 

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

@@ -10,19 +10,8 @@ describe Appsignal::Hooks::WebmachineHook do
         it { is_expected.to be_truthy }
       end
 
-      it "should include the run alias methods" do
-        expect(fsm).to respond_to(:run_with_appsignal)
-        expect(fsm).to respond_to(:run_without_appsignal)
-      end
-
-      it "should include the handle_exceptions alias methods" do
-        expect(
-          fsm.respond_to?(:handle_exceptions_with_appsignal, true)
-        ).to be_truthy
-
-        expect(
-          fsm.respond_to?(:handle_exceptions_without_appsignal, true)
-        ).to be_truthy
+      it "adds behavior to Webmachine::Decision::FSM" do
+        expect(fsm.class.ancestors.first).to eq(Appsignal::Integrations::WebmachineIntegration)
       end
     end
   else

data/spec/lib/appsignal/hooks_spec.rb

@@ -78,63 +78,6 @@ describe Appsignal::Hooks do
     expect(Appsignal::Hooks.hooks[:mock_error_hook].installed?).to be_falsy
     Appsignal::Hooks.hooks.delete(:mock_error_hook)
   end
-
-  describe "missing constants" do
-    let(:err_stream) { std_stream }
-    let(:stderr) { err_stream.read }
-    let(:log_stream) { std_stream }
-    let(:log) { log_contents(log_stream) }
-    before do
-      Appsignal.logger = test_logger(log_stream)
-    end
-
-    def call_constant(&block)
-      capture_std_streams(std_stream, err_stream, &block)
-    end
-
-    describe "SidekiqProbe" do
-      it "logs a deprecation message and returns the new constant" do
-        constant = call_constant { Appsignal::Hooks::SidekiqProbe }
-
-        expect(constant).to eql(Appsignal::Probes::SidekiqProbe)
-        expect(constant.name).to eql("Appsignal::Probes::SidekiqProbe")
-
-        deprecation_message =
-          "The constant Appsignal::Hooks::SidekiqProbe has been deprecated. " \
-          "Please update the constant name to Appsignal::Probes::SidekiqProbe " \
-          "in the following file to remove this message.\n#{__FILE__}:"
-        expect(stderr).to include "appsignal WARNING: #{deprecation_message}"
-        expect(log).to contains_log :warn, deprecation_message
-      end
-    end
-
-    describe "PumaProbe" do
-      it "logs a deprecation message and returns the new constant" do
-        constant = call_constant { Appsignal::Hooks::PumaProbe }
-
-        expect(constant).to eql(Appsignal::Probes::PumaProbe)
-        expect(constant.name).to eql("Appsignal::Probes::PumaProbe")
-
-        deprecation_message =
-          "The constant Appsignal::Hooks::PumaProbe has been deprecated. " \
-          "Please update the constant name to Appsignal::Probes::PumaProbe " \
-          "in the following file to remove this message.\n#{__FILE__}:"
-        expect(stderr).to include "appsignal WARNING: #{deprecation_message}"
-        expect(log).to contains_log :warn, deprecation_message
-      end
-    end
-
-    describe "other constant" do
-      it "raises a NameError like Ruby normally does" do
-        expect do
-          call_constant { Appsignal::Hooks::Unknown }
-        end.to raise_error(NameError)
-
-        expect(stderr).to be_empty
-        expect(log).to be_empty
-      end
-    end
-  end
 end
 
 describe Appsignal::Hooks::Helpers do

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

@@ -1,9 +1,5 @@
 require "appsignal/integrations/object"
 
-def is_ruby_19
-  RUBY_VERSION < "2.0"
-end
-
 describe Object do
   describe "#instrument_method" do
     context "with instance method" do

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

@@ -150,10 +150,9 @@ if DependencyHelper.padrino_present?
             let(:path) { "/static" }
             before do
               env["sinatra.static_file"] = true
-              expect_any_instance_of(app)
-                .to receive(:route_without_appsignal).and_return([200, {}, ["foo"]])
+              app.controllers { get(:static) { "Static!" } }
             end
-            after { expect(response).to match_response(200, "foo") }
+            after { expect(response).to match_response(200, "Static!") }
 
             it "does not instrument the request" do
               expect_no_transaction_to_be_created

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

@@ -79,51 +79,6 @@ if DependencyHelper.rails_present?
 
         after { Appsignal::Integrations::Railtie.initialize_appsignal(app) }
       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) }
-
-        context "when enabled" do
-          let(:enable_frontend_error_catching) { true }
-
-          it "adds the Rails and JSExceptionCatcher middleware" do
-            expect(app.middleware).to receive(:insert_after).with(
-              ActionDispatch::DebugExceptions,
-              Appsignal::Rack::RailsInstrumentation
-            )
-
-            expect(app.middleware).to receive(:insert_before).with(
-              Appsignal::Rack::RailsInstrumentation,
-              Appsignal::Rack::JSExceptionCatcher
-            )
-          end
-        end
-
-        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_after).with(
-              ActionDispatch::DebugExceptions,
-              Appsignal::Rack::RailsInstrumentation
-            )
-
-            expect(app.middleware).to_not receive(:insert_before).with(
-              Appsignal::Rack::RailsInstrumentation,
-              Appsignal::Rack::JSExceptionCatcher
-            )
-          end
-        end
-      end
     end
   end
 end

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

@@ -1,12 +1,24 @@
 if DependencyHelper.webmachine_present?
   require "appsignal/integrations/webmachine"
 
-  describe Appsignal::Integrations::WebmachinePlugin::FSM do
+  class Response
+    attr_accessor :code
+
+    def body
+      ""
+    end
+
+    def headers
+      {}
+    end
+  end
+
+  describe Appsignal::Integrations::WebmachineIntegration do
     let(:request) do
       Webmachine::Request.new("GET", "http://google.com:80/foo", {}, nil)
     end
-    let(:resource)    { double(:trace? => false, :handle_exception => true) }
-    let(:response)    { double }
+    let(:resource)    { double(:trace? => false, :handle_exception => true, :"code=" => nil) }
+    let(:response)    { Response.new }
     let(:transaction) { double(:set_action_if_nil => true) }
     let(:fsm) { Webmachine::Decision::FSM.new(resource, request, response) }
     before(:context) { start_agent }
@@ -18,10 +30,8 @@ if DependencyHelper.webmachine_present?
       end
     end
 
-    describe "#run_with_appsignal" do
+    describe "#run" do
       before do
-        allow(fsm).to receive(:request).and_return(request)
-        allow(fsm).to receive(:run_without_appsignal).and_return(true)
         allow(SecureRandom).to receive(:uuid).and_return("uuid")
         allow(Appsignal::Transaction).to receive(:create).and_return(transaction)
       end
@@ -40,7 +50,7 @@ if DependencyHelper.webmachine_present?
       end
 
       it "should call the original method" do
-        expect(fsm).to receive(:run_without_appsignal)
+        expect(fsm).to receive(:run)
       end
 
       it "should instrument the original method" do
@@ -52,9 +62,17 @@ if DependencyHelper.webmachine_present?
       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
+      end
     end
 
-    describe "#handle_exceptions_with_appsignal" do
+    describe "#handle_exceptions" do
       let(:error) { ExampleException }
 
       it "should catch the error and send it to AppSignal" do

data/spec/lib/appsignal/minutely_spec.rb

@@ -284,25 +284,6 @@ describe Appsignal::Minutely do
       end
     end
 
-    describe "#<<" do
-      let(:err_stream) { std_stream }
-      let(:stderr) { err_stream.read }
-      let(:log_stream) { std_stream }
-      let(:log) { log_contents(log_stream) }
-      before { Appsignal.logger = test_logger(log_stream) }
-
-      it "adds the probe, but prints a deprecation warning" do
-        probe = lambda {}
-        capture_std_streams(std_stream, err_stream) { collection << probe }
-        deprecation_message = "Deprecated " \
-          "`Appsignal::Minute.probes <<` call. Please use " \
-          "`Appsignal::Minutely.probes.register` instead."
-        expect(stderr).to include "appsignal WARNING: #{deprecation_message}"
-        expect(log).to contains_log :warn, deprecation_message
-        expect(collection[probe.object_id]).to eql(probe)
-      end
-    end
-
     describe "#register" do
       let(:log_stream) { std_stream }
       let(:log) { log_contents(log_stream) }

data/spec/lib/appsignal/transaction_spec.rb

@@ -640,7 +640,7 @@ describe Appsignal::Transaction do
       end
 
       context "when the data cannot be converted to JSON" do
-        it "does not update the sample data on the transaction", :not_ruby19 do
+        it "does not update the sample data on the transaction" do
           klass = Class.new do
             def to_s
               raise "foo" # Cause a deliberate error
@@ -652,19 +652,6 @@ describe Appsignal::Transaction do
           expect(log_contents(log)).to contains_log :error,
             "Error generating data (RuntimeError: foo) for"
         end
-
-        it "does not update the sample data on the transaction", :only_ruby19 do
-          klass = Class.new do
-            def to_s
-              raise "foo" # Cause a deliberate error
-            end
-          end
-          transaction.set_sample_data("params", klass.new => 1)
-
-          expect(transaction.to_h["sample_data"]).to eq({})
-          expect(log_contents(log)).to contains_log :error,
-            "Error generating data (RuntimeError: foo). Can't inspect data."
-        end
       end
     end