appsignal 2.1.0.beta.1 → 2.1.0

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

@@ -23,7 +23,7 @@ describe Object do
 
         context "with anonymous class" do
           it "instruments the method and calls it" do
-            expect(Appsignal.active?).to be_true
+            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
@@ -44,7 +44,7 @@ describe Object do
           let(:klass) { NamedClass }
 
           it "instruments the method and calls it" do
-            expect(Appsignal.active?).to be_true
+            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
@@ -69,7 +69,7 @@ describe Object do
           let(:klass) { MyModule::NestedModule::NamedClass }
 
           it "instruments the method and calls it" do
-            expect(Appsignal.active?).to be_true
+            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,
@@ -89,7 +89,7 @@ describe Object do
           end
 
           it "instruments with custom name" do
-            expect(Appsignal.active?).to be_true
+            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
@@ -117,7 +117,7 @@ describe Object do
         let(:transaction) { Appsignal::Transaction.current }
 
         it "should not instrument, but still call the method" do
-          expect(Appsignal.active?).to be_false
+          expect(Appsignal.active?).to be_falsy
           expect(transaction).to_not receive(:start_event)
           expect(instance.foo).to eq(1)
         end
@@ -145,7 +145,7 @@ describe Object do
 
         context "with anonymous class" do
           it "instruments the method and calls it" do
-            expect(Appsignal.active?).to be_true
+            expect(Appsignal.active?).to be_truthy
             expect(transaction).to receive(:start_event)
             expect(transaction).to receive(:finish_event).with \
               "bar.class_method.AnonymousClass.other", nil, nil, Appsignal::EventFormatter::DEFAULT
@@ -166,7 +166,7 @@ describe Object do
           let(:klass) { NamedClass }
 
           it "instruments the method and calls it" do
-            expect(Appsignal.active?).to be_true
+            expect(Appsignal.active?).to be_truthy
             expect(transaction).to receive(:start_event)
             expect(transaction).to receive(:finish_event).with \
               "bar.class_method.NamedClass.other", nil, nil, Appsignal::EventFormatter::DEFAULT
@@ -190,7 +190,7 @@ describe Object do
             let(:klass) { MyModule::NestedModule::NamedClass }
 
             it "instruments the method and calls it" do
-              expect(Appsignal.active?).to be_true
+              expect(Appsignal.active?).to be_truthy
               expect(transaction).to receive(:start_event)
               expect(transaction).to receive(:finish_event).with \
                 "bar.class_method.NamedClass.NestedModule.MyModule.other", nil, nil,
@@ -211,7 +211,7 @@ describe Object do
           end
 
           it "instruments with custom name" do
-            expect(Appsignal.active?).to be_true
+            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
@@ -239,7 +239,7 @@ describe Object do
         let(:transaction) { Appsignal::Transaction.current }
 
         it "should not instrument, but still call the method" do
-          expect(Appsignal.active?).to be_false
+          expect(Appsignal.active?).to be_falsy
           expect(transaction).to_not receive(:start_event)
           expect(klass.bar).to eq(2)
         end

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

@@ -7,11 +7,9 @@ if DependencyHelper.padrino_present?
     end
 
     before do
-      Appsignal.stub(
-        :active?      => true,
-        :start        => true,
-        :start_logger => true
-      )
+      allow(Appsignal).to receive(:active?).and_return(true)
+      allow(Appsignal).to receive(:start).and_return(true)
+      allow(Appsignal).to receive(:start_logger).and_return(true)
     end
 
     describe "Appsignal::Integrations::PadrinoPlugin" do
@@ -24,7 +22,7 @@ if DependencyHelper.padrino_present?
       end
 
       context "when not active" do
-        before { Appsignal.stub(:active? => false) }
+        before { allow(Appsignal).to receive(:active?).and_return(false) }
 
         it "should not add the Listener middleware to the stack" do
           expect(Padrino).to_not receive(:use)
@@ -76,13 +74,11 @@ if DependencyHelper.padrino_present?
         end
 
         before do
-          router.stub(
-            :route_without_appsignal => true,
-            :request                 => request,
-            :env                     => env,
-            :settings                => settings,
-            :get_payload_action      => "controller#action"
-          )
+          allow(router).to receive(:route_without_appsignal).and_return(true)
+          allow(router).to receive(:request).and_return(request)
+          allow(router).to receive(:env).and_return(env)
+          allow(router).to receive(:settings).and_return(settings)
+          allow(router).to receive(:get_payload_action).and_return("controller#action")
         end
 
         context "when Sinatra tells us it's a static file" do
@@ -100,7 +96,7 @@ if DependencyHelper.padrino_present?
         end
 
         context "when appsignal is not active" do
-          before { Appsignal.stub(:active? => false) }
+          before { allow(Appsignal).to receive(:active?).and_return(false) }
 
           it "should call the original method" do
             expect(router).to receive(:route_without_appsignal)
@@ -123,7 +119,7 @@ if DependencyHelper.padrino_present?
               :set_error => nil
             )
           end
-          before { Appsignal::Transaction.stub(:create => transaction) }
+          before { allow(Appsignal::Transaction).to receive(:create).and_return(transaction) }
 
           context "without an error" do
             it "should create a transaction" do
@@ -155,7 +151,7 @@ if DependencyHelper.padrino_present?
 
           context "with an error" do
             let(:error) { VerySpecificError.new }
-            before { router.stub(:route_without_appsignal).and_raise(error) }
+            before { allow(router).to receive(:route_without_appsignal).and_raise(error) }
 
             it "should add the exception to the current transaction" do
               expect(transaction).to receive(:set_error).with(error)
@@ -167,7 +163,7 @@ if DependencyHelper.padrino_present?
       end
 
       describe "#get_payload_action" do
-        before { router.stub(:settings => settings) }
+        before { allow(router).to receive(:settings).and_return(settings) }
 
         context "when request is nil" do
           it "should return the site" do
@@ -194,7 +190,7 @@ if DependencyHelper.padrino_present?
         context "when request has a route object" do
           let(:request)      { double }
           let(:route_object) { double(:original_path => "/accounts/edit/:id") }
-          before             { request.stub(:route_obj => route_object) }
+          before             { allow(request).to receive(:route_obj).and_return(route_object) }
 
           it "should return the original path" do
             expect(router.get_payload_action(request)).to eql("TestApp:/accounts/edit/:id")

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

@@ -11,42 +11,58 @@ if DependencyHelper.rails_present?
 
     describe "#initialize_appsignal" do
       let(:app) { MyApp::Application }
-      before { app.middleware.stub(:insert_before => true) }
+      before { allow(app.middleware).to receive(:insert_before).and_return(true) }
 
-      context "logger" do
+      describe ".logger" do
         before  { Appsignal::Integrations::Railtie.initialize_appsignal(app) }
         subject { Appsignal.logger }
 
-        it { should be_a Logger }
+        it { is_expected.to be_a Logger }
       end
 
-      context "config" do
-        subject { Appsignal.config }
-        context "basics" do
+      describe ".config" do
+        let(:config) { Appsignal.config }
+
+        describe "basic configuration" do
           before { Appsignal::Integrations::Railtie.initialize_appsignal(app) }
 
-          it { should be_a(Appsignal::Config) }
+          it { expect(config).to be_a(Appsignal::Config) }
 
-          its(:root_path)  { should eq Pathname.new(project_fixture_path) }
-          its(:env)        { should eq "test" }
-          its([:name])     { should eq "TestApp" }
-          its([:log_path]) { should eq Pathname.new(File.join(project_fixture_path, "log")) }
-        end
+          it "sets the root_path" do
+            expect(config.root_path).to eq Pathname.new(project_fixture_path)
+          end
 
-        context "initial config" do
-          before  { Appsignal::Integrations::Railtie.initialize_appsignal(app) }
-          subject { Appsignal.config.initial_config }
+          it "sets the detected environment" do
+            expect(config.env).to eq "test"
+          end
+
+          it "loads the app name" do
+            expect(config[:name]).to eq "TestApp"
+          end
 
-          its([:name]) { should eq "MyApp" }
+          it "sets the log_path based on the root_path" do
+            expect(config[:log_path]).to eq Pathname.new(File.join(project_fixture_path, "log"))
+          end
         end
 
         context "with APPSIGNAL_APP_ENV ENV var set" do
           before do
-            ENV.should_receive(:fetch).with("APPSIGNAL_APP_ENV", "test").and_return("env_test")
+            ENV["APPSIGNAL_APP_ENV"] = "env_test"
             Appsignal::Integrations::Railtie.initialize_appsignal(app)
           end
 
-          its(:env) { should eq "env_test" }
+          it "uses the environment variable value as the environment" do
+            expect(config.env).to eq "env_test"
+          end
+        end
+      end
+
+      describe ".initial_config" do
+        before { Appsignal::Integrations::Railtie.initialize_appsignal(app) }
+        let(:config) { Appsignal.config.initial_config }
+
+        it "returns the initial config" do
+          expect(config[:name]).to eq "MyApp"
         end
       end
 
@@ -69,7 +85,7 @@ if DependencyHelper.rails_present?
           end
 
           before do
-            Appsignal.stub(:config => config)
+            allow(Appsignal).to receive(:config).and_return(config)
           end
 
           it "should have added the listener and JSExceptionCatcher middleware" do

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

@@ -16,11 +16,11 @@ if DependencyHelper.resque_present? && DependencyHelper.active_job_present?
       end
 
       describe :around_perform_plugin do
-        before    { SecureRandom.stub(:uuid => 123) }
+        before    { allow(SecureRandom).to receive(:uuid).and_return(123) }
         let(:job) { TestActiveJob.new("moo") }
 
         it "should wrap in a transaction with the correct params" do
-          Appsignal.should_receive(:monitor_single_transaction).with(
+          expect(Appsignal).to receive(:monitor_single_transaction).with(
             "perform_job.resque",
             :class  => "TestActiveJob",
             :method => "perform",

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

@@ -27,18 +27,18 @@ if DependencyHelper.resque_present?
         let(:transaction) { Appsignal::Transaction.new("1", "background", {}, {}) }
         let(:job) { ::Resque::Job.new("default", "class" => "TestJob") }
         before do
-          transaction.stub(:complete => true)
-          Appsignal::Transaction.stub(:current => transaction)
-          Appsignal.should_receive(:stop)
+          allow(transaction).to receive(:complete).and_return(true)
+          allow(Appsignal::Transaction).to receive(:current).and_return(transaction)
+          expect(Appsignal).to receive(:stop)
         end
 
         context "without exception" do
           it "should create a new transaction" do
-            Appsignal::Transaction.should_receive(:create).and_return(transaction)
+            expect(Appsignal::Transaction).to receive(:create).and_return(transaction)
           end
 
           it "should wrap in a transaction with the correct params" do
-            Appsignal.should_receive(:monitor_transaction).with(
+            expect(Appsignal).to receive(:monitor_transaction).with(
               "perform_job.resque",
               :class => "TestJob",
               :method => "perform"
@@ -46,7 +46,7 @@ if DependencyHelper.resque_present?
           end
 
           it "should close the transaction" do
-            transaction.should_receive(:complete)
+            expect(transaction).to receive(:complete)
           end
 
           after { job.perform }
@@ -56,7 +56,7 @@ if DependencyHelper.resque_present?
           let(:job) { ::Resque::Job.new("default", "class" => "BrokenTestJob") }
 
           it "should set the exception" do
-            Appsignal::Transaction.any_instance.should_receive(:set_error)
+            expect_any_instance_of(Appsignal::Transaction).to receive(:set_error)
           end
 
           after do
@@ -71,7 +71,7 @@ if DependencyHelper.resque_present?
     end
 
     context "without resque" do
-      before(:all) { Object.send(:remove_const, :Resque) }
+      before(:context) { Object.send(:remove_const, :Resque) }
 
       specify { expect { ::Resque }.to raise_error(NameError) }
       specify { expect { load file }.to_not raise_error }

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

@@ -6,12 +6,12 @@ if DependencyHelper.sinatra_present?
     context "Appsignal.logger" do
       subject { Appsignal.logger }
 
-      it { should be_a Logger }
+      it { is_expected.to be_a Logger }
     end
 
     describe "middleware" do
       it "adds the instrumentation middleware to Sinatra::Base" do
-        Sinatra::Base.middleware.to_a.should include(
+        expect(Sinatra::Base.middleware.to_a).to include(
           [Appsignal::Rack::SinatraBaseInstrumentation, [], nil]
         )
       end

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

@@ -9,7 +9,7 @@ if DependencyHelper.webmachine_present?
     let(:response)    { double }
     let(:transaction) { double(:set_action => true) }
     let(:fsm) { Webmachine::Decision::FSM.new(resource, request, response) }
-    before(:all) { start_agent }
+    before(:context) { start_agent }
 
     # Make sure the request responds to the method we need to get query params.
     describe "request" do

data/spec/lib/appsignal/js_exception_transaction_spec.rb

@@ -1,5 +1,5 @@
 describe Appsignal::JSExceptionTransaction do
-  before { SecureRandom.stub(:uuid => "123abc") }
+  before { allow(SecureRandom).to receive(:uuid).and_return("123abc") }
 
   let!(:transaction) { Appsignal::JSExceptionTransaction.new(data) }
   let(:data) do

data/spec/lib/appsignal/minutely_spec.rb

@@ -12,7 +12,7 @@ describe Appsignal::Minutely do
       probe = double
       expect(probe).to receive(:call).at_least(:twice)
       Appsignal::Minutely.probes << probe
-      Appsignal::Minutely.stub(:wait_time => 0.1)
+      allow(Appsignal::Minutely).to receive(:wait_time).and_return(0.1)
 
       Appsignal::Minutely.start
 
@@ -22,7 +22,7 @@ describe Appsignal::Minutely do
 
   describe ".wait_time" do
     it "should get the time to the next minute" do
-      Time.any_instance.stub(:sec => 30)
+      allow_any_instance_of(Time).to receive(:sec).and_return(30)
       expect(Appsignal::Minutely.wait_time).to eq 30
     end
   end
@@ -33,7 +33,7 @@ describe Appsignal::Minutely do
 
       Appsignal::Minutely.add_gc_probe
 
-      expect(Appsignal::Minutely.probes).to have(1).item
+      expect(Appsignal::Minutely.probes.size).to eq(1)
       expect(Appsignal::Minutely.probes[0]).to be_instance_of(Appsignal::Minutely::GCProbe)
     end
   end

data/spec/lib/appsignal/rack/generic_instrumentation_spec.rb

@@ -1,5 +1,5 @@
 describe Appsignal::Rack::GenericInstrumentation do
-  before :all do
+  before :context do
     start_agent
   end
 
@@ -10,11 +10,11 @@ describe Appsignal::Rack::GenericInstrumentation do
 
   describe "#call" do
     before do
-      middleware.stub(:raw_payload => {})
+      allow(middleware).to receive(:raw_payload).and_return({})
     end
 
     context "when appsignal is active" do
-      before { Appsignal.stub(:active? => true) }
+      before { allow(Appsignal).to receive(:active?).and_return(true) }
 
       it "should call with monitoring" do
         expect(middleware).to receive(:call_with_appsignal_monitoring).with(env)
@@ -22,7 +22,7 @@ describe Appsignal::Rack::GenericInstrumentation do
     end
 
     context "when appsignal is not active" do
-      before { Appsignal.stub(:active? => false) }
+      before { allow(Appsignal).to receive(:active?).and_return(false) }
 
       it "should not call with monitoring" do
         expect(middleware).to_not receive(:call_with_appsignal_monitoring)
@@ -38,7 +38,7 @@ describe Appsignal::Rack::GenericInstrumentation do
 
   describe "#call_with_appsignal_monitoring" do
     it "should create a transaction" do
-      Appsignal::Transaction.should_receive(:create).with(
+      expect(Appsignal::Transaction).to receive(:create).with(
         kind_of(String),
         Appsignal::Transaction::HTTP_REQUEST,
         kind_of(Rack::Request)
@@ -46,24 +46,24 @@ describe Appsignal::Rack::GenericInstrumentation do
     end
 
     it "should call the app" do
-      app.should_receive(:call).with(env)
+      expect(app).to receive(:call).with(env)
     end
 
     context "with an error" do
       let(:error) { VerySpecificError.new }
       let(:app) do
         double.tap do |d|
-          d.stub(:call).and_raise(error)
+          allow(d).to receive(:call).and_raise(error)
         end
       end
 
       it "should set the error" do
-        Appsignal::Transaction.any_instance.should_receive(:set_error).with(error)
+        expect_any_instance_of(Appsignal::Transaction).to receive(:set_error).with(error)
       end
     end
 
     it "should set the action to unknown" do
-      Appsignal::Transaction.any_instance.should_receive(:set_action).with("unknown")
+      expect_any_instance_of(Appsignal::Transaction).to receive(:set_action).with("unknown")
     end
 
     context "with a route specified in the env" do
@@ -72,16 +72,16 @@ describe Appsignal::Rack::GenericInstrumentation do
       end
 
       it "should set the action" do
-        Appsignal::Transaction.any_instance.should_receive(:set_action).with("GET /")
+        expect_any_instance_of(Appsignal::Transaction).to receive(:set_action).with("GET /")
       end
     end
 
     it "should set metadata" do
-      Appsignal::Transaction.any_instance.should_receive(:set_metadata).twice
+      expect_any_instance_of(Appsignal::Transaction).to receive(:set_metadata).twice
     end
 
     it "should set the queue start" do
-      Appsignal::Transaction.any_instance.should_receive(:set_http_or_background_queue_start)
+      expect_any_instance_of(Appsignal::Transaction).to receive(:set_http_or_background_queue_start)
     end
 
     after { middleware.call(env) rescue VerySpecificError }