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

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
@@ -30,57 +26,12 @@ describe Object do
         before do
           Appsignal.config = project_fixture_config
           expect(Appsignal::Transaction).to receive(:current).at_least(:once).and_return(transaction)
-          expect(Appsignal.active?).to be_truthy
         end
         after { Appsignal.config = nil }
 
-        context "with different kind of arguments" do
-          let(:klass) do
-            Class.new do
-              def positional_arguments(param1, param2)
-                [param1, param2]
-              end
-              appsignal_instrument_method :positional_arguments
-
-              def positional_arguments_splat(*params)
-                params
-              end
-              appsignal_instrument_method :positional_arguments_splat
-
-              def keyword_arguments(a: nil, b: nil)
-                [a, b]
-              end
-              appsignal_instrument_method :keyword_arguments
-
-              def keyword_arguments_splat(**kwargs)
-                kwargs
-              end
-              appsignal_instrument_method :keyword_arguments_splat
-
-              def splat(*args, **kwargs)
-                [args, kwargs]
-              end
-              appsignal_instrument_method :splat
-            end
-          end
-
-          it "instruments the method and calls it" do
-            expect(instance.positional_arguments("abc", "def")).to eq(["abc", "def"])
-            expect(instance.positional_arguments_splat("abc", "def")).to eq(["abc", "def"])
-            expect(instance.keyword_arguments(:a => "a", :b => "b")).to eq(["a", "b"])
-            expect(instance.keyword_arguments_splat(:a => "a", :b => "b"))
-              .to eq(:a => "a", :b => "b")
-
-            expect(instance.splat).to eq([[], {}])
-            expect(instance.splat(:a => "a", :b => "b")).to eq([[], { :a => "a", :b => "b" }])
-            expect(instance.splat("abc", "def")).to eq([["abc", "def"], {}])
-            expect(instance.splat("abc", "def", :a => "a", :b => "b"))
-              .to eq([["abc", "def"], { :a => "a", :b => "b" }])
-          end
-        end
-
         context "with anonymous class" do
           it "instruments the method and calls it" do
+            expect(Appsignal.active?).to be_truthy
             expect(transaction).to receive(:start_event)
             expect(transaction).to receive(:finish_event).with \
               "foo.AnonymousClass.other", nil, nil, Appsignal::EventFormatter::DEFAULT
@@ -101,6 +52,7 @@ describe Object do
           let(:klass) { NamedClass }
 
           it "instruments the method and calls it" do
+            expect(Appsignal.active?).to be_truthy
             expect(transaction).to receive(:start_event)
             expect(transaction).to receive(:finish_event).with \
               "foo.NamedClass.other", nil, nil, Appsignal::EventFormatter::DEFAULT
@@ -125,6 +77,7 @@ describe Object do
           let(:klass) { MyModule::NestedModule::NamedClass }
 
           it "instruments the method and calls it" do
+            expect(Appsignal.active?).to be_truthy
             expect(transaction).to receive(:start_event)
             expect(transaction).to receive(:finish_event).with \
               "bar.NamedClass.NestedModule.MyModule.other", nil, nil,
@@ -144,6 +97,7 @@ describe Object do
           end
 
           it "instruments with custom name" do
+            expect(Appsignal.active?).to be_truthy
             expect(transaction).to receive(:start_event)
             expect(transaction).to receive(:finish_event).with \
               "my_method.group", nil, nil, Appsignal::EventFormatter::DEFAULT
@@ -204,51 +158,6 @@ describe Object do
         end
         after { Appsignal.config = nil }
 
-        context "with different kind of arguments" do
-          let(:klass) do
-            Class.new do
-              def self.positional_arguments(param1, param2)
-                [param1, param2]
-              end
-              appsignal_instrument_class_method :positional_arguments
-
-              def self.positional_arguments_splat(*params)
-                params
-              end
-              appsignal_instrument_class_method :positional_arguments_splat
-
-              def self.keyword_arguments(a: nil, b: nil)
-                [a, b]
-              end
-              appsignal_instrument_class_method :keyword_arguments
-
-              def self.keyword_arguments_splat(**kwargs)
-                kwargs
-              end
-              appsignal_instrument_class_method :keyword_arguments_splat
-
-              def self.splat(*args, **kwargs)
-                [args, kwargs]
-              end
-              appsignal_instrument_class_method :splat
-            end
-          end
-
-          it "instruments the method and calls it" do
-            expect(klass.positional_arguments("abc", "def")).to eq(["abc", "def"])
-            expect(klass.positional_arguments_splat("abc", "def")).to eq(["abc", "def"])
-            expect(klass.keyword_arguments(:a => "a", :b => "b")).to eq(["a", "b"])
-            expect(klass.keyword_arguments_splat(:a => "a", :b => "b"))
-              .to eq(:a => "a", :b => "b")
-
-            expect(klass.splat).to eq([[], {}])
-            expect(klass.splat(:a => "a", :b => "b")).to eq([[], { :a => "a", :b => "b" }])
-            expect(klass.splat("abc", "def")).to eq([["abc", "def"], {}])
-            expect(klass.splat("abc", "def", :a => "a", :b => "b"))
-              .to eq([["abc", "def"], { :a => "a", :b => "b" }])
-          end
-        end
-
         context "with anonymous class" do
           it "instruments the method and calls it" do
             expect(Appsignal.active?).to be_truthy

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