appsignal 2.1.0.beta.1 → 2.1.0

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

@@ -15,13 +15,13 @@ describe Appsignal::Hooks::SidekiqPlugin do
   let(:plugin) { Appsignal::Hooks::SidekiqPlugin.new }
 
   before do
-    Appsignal::Transaction.stub(:current => current_transaction)
+    allow(Appsignal::Transaction).to receive(:current).and_return(current_transaction)
     start_agent
   end
 
   context "with a performance call" do
     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.sidekiq",
         :class    => "TestClass",
         :method   => "perform",
@@ -56,7 +56,7 @@ describe Appsignal::Hooks::SidekiqPlugin do
       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.sidekiq",
           :class    => "TestClass",
           :method   => "perform",
@@ -83,7 +83,7 @@ describe Appsignal::Hooks::SidekiqPlugin do
     let(:error) { VerySpecificError.new }
 
     it "should add the exception to appsignal" do
-      Appsignal::Transaction.any_instance.should_receive(:set_error).with(error)
+      expect_any_instance_of(Appsignal::Transaction).to receive(:set_error).with(error)
     end
 
     after do
@@ -107,26 +107,34 @@ describe Appsignal::Hooks::SidekiqPlugin do
     end
 
     it "should only add items to the hash that do not appear in JOB_KEYS" do
-      plugin.formatted_metadata(item).should eq("foo" => "bar")
+      expect(plugin.formatted_metadata(item)).to eq("foo" => "bar")
     end
   end
 end
 
 describe Appsignal::Hooks::SidekiqHook do
   context "with sidekiq" do
-    before :all do
+    before :context do
       module Sidekiq
         def self.configure_server
         end
       end
       Appsignal::Hooks::SidekiqHook.new.install
     end
-    after(:all) { Object.send(:remove_const, :Sidekiq) }
+    after(:context) { Object.send(:remove_const, :Sidekiq) }
 
-    its(:dependencies_present?) { should be_true }
+    describe "#dependencies_present?" do
+      subject { described_class.new.dependencies_present? }
+
+      it { is_expected.to be_truthy }
+    end
   end
 
   context "without sidekiq" do
-    its(:dependencies_present?) { should be_false }
+    describe "#dependencies_present?" do
+      subject { described_class.new.dependencies_present? }
+
+      it { is_expected.to be_falsy }
+    end
   end
 end

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

@@ -1,6 +1,6 @@
 describe Appsignal::Hooks::UnicornHook do
   context "with unicorn" do
-    before :all do
+    before :context do
       module Unicorn
         class HttpServer
           def worker_loop(worker)
@@ -14,16 +14,20 @@ describe Appsignal::Hooks::UnicornHook do
       end
       Appsignal::Hooks::UnicornHook.new.install
     end
-    after(:all) { Object.send(:remove_const, :Unicorn) }
+    after(:context) { Object.send(:remove_const, :Unicorn) }
 
-    its(:dependencies_present?) { should be_true }
+    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
 
-      Appsignal.should_receive(:forked)
-      server.should_receive(:worker_loop_without_appsignal).with(worker)
+      expect(Appsignal).to receive(:forked)
+      expect(server).to receive(:worker_loop_without_appsignal).with(worker)
 
       server.worker_loop(worker)
     end
@@ -31,14 +35,18 @@ describe Appsignal::Hooks::UnicornHook do
     it "adds behavior to Unicorn::Worker#close" do
       worker = Unicorn::Worker.new
 
-      Appsignal.should_receive(:stop)
-      worker.should_receive(:close_without_appsignal)
+      expect(Appsignal).to receive(:stop)
+      expect(worker).to receive(:close_without_appsignal)
 
       worker.close
     end
   end
 
   context "without unicorn" do
-    its(:dependencies_present?) { should be_false }
+    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

@@ -2,9 +2,13 @@ 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(:all) { start_agent }
+      before(:context) { start_agent }
 
-      its(:dependencies_present?) { should be_true }
+      describe "#dependencies_present?" do
+        subject { described_class.new.dependencies_present? }
+
+        it { is_expected.to be_truthy }
+      end
 
       it "should include the run alias methods" do
         expect(fsm).to respond_to(:run_with_appsignal)
@@ -14,12 +18,18 @@ describe Appsignal::Hooks::WebmachineHook do
       it "should include the handle_exceptions alias methods" do
         expect(
           fsm.respond_to?(:handle_exceptions_with_appsignal, true)
-        ).to be_true
+        ).to be_truthy
 
         expect(
           fsm.respond_to?(:handle_exceptions_without_appsignal, true)
-        ).to be_true
+        ).to be_truthy
       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

@@ -35,43 +35,43 @@ describe Appsignal::Hooks do
   it "should register and install a hook once" do
     Appsignal::Hooks::Hook.register(:mock_present_hook, MockPresentHook)
 
-    Appsignal::Hooks.hooks[:mock_present_hook].should be_instance_of(MockPresentHook)
-    Appsignal::Hooks.hooks[:mock_present_hook].installed?.should be_false
+    expect(Appsignal::Hooks.hooks[:mock_present_hook]).to be_instance_of(MockPresentHook)
+    expect(Appsignal::Hooks.hooks[:mock_present_hook].installed?).to be_falsy
 
-    MockPresentHook.should_receive(:call_something).once
+    expect(MockPresentHook).to receive(:call_something).once
 
     Appsignal::Hooks.load_hooks
     Appsignal::Hooks.load_hooks
     Appsignal::Hooks.load_hooks
-    Appsignal::Hooks.hooks[:mock_present_hook].installed?.should be_true
+    expect(Appsignal::Hooks.hooks[:mock_present_hook].installed?).to be_truthy
     Appsignal::Hooks.hooks.delete(:mock_present_hook)
   end
 
   it "should not install if depencies are not present" do
     Appsignal::Hooks::Hook.register(:mock_not_present_hook, MockNotPresentHook)
 
-    Appsignal::Hooks.hooks[:mock_not_present_hook].should be_instance_of(MockNotPresentHook)
-    Appsignal::Hooks.hooks[:mock_not_present_hook].installed?.should be_false
+    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
 
-    MockPresentHook.should_not_receive(:call_something)
+    expect(MockPresentHook).to_not receive(:call_something)
 
     Appsignal::Hooks.load_hooks
 
-    Appsignal::Hooks.hooks[:mock_not_present_hook].installed?.should be_false
+    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)
 
-    Appsignal::Hooks.hooks[:mock_error_hook].should be_instance_of(MockErrorHook)
-    Appsignal::Hooks.hooks[:mock_error_hook].installed?.should be_false
+    expect(Appsignal::Hooks.hooks[:mock_error_hook]).to be_instance_of(MockErrorHook)
+    expect(Appsignal::Hooks.hooks[:mock_error_hook].installed?).to be_falsy
 
-    Appsignal.logger.should_receive(:error).with("Error while installing mock_error_hook hook: error").once
+    expect(Appsignal.logger).to receive(:error).with("Error while installing mock_error_hook hook: error").once
 
     Appsignal::Hooks.load_hooks
 
-    Appsignal::Hooks.hooks[:mock_error_hook].installed?.should be_false
+    expect(Appsignal::Hooks.hooks[:mock_error_hook].installed?).to be_falsy
     Appsignal::Hooks.hooks.delete(:mock_error_hook)
   end
 end
@@ -88,20 +88,20 @@ describe Appsignal::Hooks::Helpers do
     end
 
     it "should truncate the text to 200 chars max" do
-      with_helpers.truncate(very_long_text).should eq "#{"a" * 197}..."
+      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
-        with_helpers.string_or_inspect("foo").should eq "foo"
+        expect(with_helpers.string_or_inspect("foo")).to eq "foo"
       end
     end
 
     context "when integer" do
       it "should return the string" do
-        with_helpers.string_or_inspect(1).should eq "1"
+        expect(with_helpers.string_or_inspect(1)).to eq "1"
       end
     end
 
@@ -109,7 +109,7 @@ describe Appsignal::Hooks::Helpers do
       let(:object) { Object.new }
 
       it "should return the string" do
-        with_helpers.string_or_inspect(object).should eq object.inspect
+        expect(with_helpers.string_or_inspect(object)).to eq object.inspect
       end
     end
   end
@@ -121,24 +121,24 @@ describe Appsignal::Hooks::Helpers do
       context "when the key exists" do
         subject { with_helpers.extract_value(hash, :key) }
 
-        it { should eq "value" }
+        it { is_expected.to eq "value" }
       end
 
       context "when the key does not exist" do
         subject { with_helpers.extract_value(hash, :nonexistent_key) }
 
-        it { should be_nil }
+        it { is_expected.to be_nil }
 
         context "with a default value" do
           subject { with_helpers.extract_value(hash, :nonexistent_key, 1) }
 
-          it { should eq 1 }
+          it { is_expected.to eq 1 }
         end
       end
     end
 
     context "for a struct" do
-      before :all do
+      before :context do
         TestStruct = Struct.new(:key)
       end
       let(:struct) { TestStruct.new("value") }
@@ -146,18 +146,18 @@ describe Appsignal::Hooks::Helpers do
       context "when the key exists" do
         subject { with_helpers.extract_value(struct, :key) }
 
-        it { should eq "value" }
+        it { is_expected.to eq "value" }
       end
 
       context "when the key does not exist" do
         subject { with_helpers.extract_value(struct, :nonexistent_key) }
 
-        it { should be_nil }
+        it { is_expected.to be_nil }
 
         context "with a default value" do
           subject { with_helpers.extract_value(struct, :nonexistent_key, 1) }
 
-          it { should eq 1 }
+          it { is_expected.to eq 1 }
         end
       end
     end
@@ -168,18 +168,18 @@ describe Appsignal::Hooks::Helpers do
       context "when the method exists" do
         subject { with_helpers.extract_value(object, :existing_method) }
 
-        it { should eq "value" }
+        it { is_expected.to eq "value" }
       end
 
       context "when the method does not exist" do
         subject { with_helpers.extract_value(object, :nonexistent_method) }
 
-        it { should be_nil }
+        it { is_expected.to be_nil }
 
         context "and there is a default value" do
           subject { with_helpers.extract_value(object, :nonexistent_method, 1) }
 
-          it { should eq 1 }
+          it { is_expected.to eq 1 }
         end
       end
     end
@@ -189,7 +189,7 @@ describe Appsignal::Hooks::Helpers do
 
       subject { with_helpers.extract_value(object, :existing_method, nil, true) }
 
-      it { should eq "1" }
+      it { is_expected.to eq "1" }
     end
   end
 
@@ -205,7 +205,7 @@ describe Appsignal::Hooks::Helpers do
     end
 
     it "should format the arguments" do
-      with_helpers.format_args(args).should eq([
+      expect(with_helpers.format_args(args)).to eq([
         "Model",
         "1",
         object.inspect,

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

@@ -25,7 +25,7 @@ describe Appsignal::Hooks::DataMapperLogListener do
       end
     end
 
-    before { Appsignal::Transaction.stub(:current) { transaction } }
+    before { allow(Appsignal::Transaction).to receive(:current) { transaction } }
 
     it "should record the log entry in an event" do
       expect(transaction).to receive(:record_event).with(

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

@@ -27,7 +27,7 @@ if DependencyHelper.grape_present?
 
     describe "#call" do
       context "when AppSignal is not active" do
-        before(:all) do
+        before(:context) do
           Appsignal.config = nil
           Appsignal::Hooks.load_hooks
         end
@@ -45,9 +45,9 @@ if DependencyHelper.grape_present?
 
       context "when AppSignal is active" do
         let(:transaction) { http_request_transaction }
-        before :all do
+        before :context do
           Appsignal.config = project_fixture_config
-          expect(Appsignal.active?).to be_true
+          expect(Appsignal.active?).to be_truthy
         end
         before do
           expect(Appsignal::Transaction).to receive(:create).with(

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

@@ -17,8 +17,8 @@ describe Appsignal::Hooks::MongoMonitorSubscriber do
       end
 
       it "should sanitize command" do
-        Appsignal::EventFormatter::MongoRubyDriver::QueryFormatter
-          .should receive(:format).with("find", "foo" => "bar")
+        expect(Appsignal::EventFormatter::MongoRubyDriver::QueryFormatter)
+          .to receive(:format).with("find", "foo" => "bar")
 
         subscriber.started(event)
       end
@@ -26,11 +26,11 @@ describe Appsignal::Hooks::MongoMonitorSubscriber do
       it "should store command on the transaction" do
         subscriber.started(event)
 
-        transaction.store("mongo_driver").should eq(1 => { "foo" => "?" })
+        expect(transaction.store("mongo_driver")).to eq(1 => { "foo" => "?" })
       end
 
       it "should start an event in the extension" do
-        transaction.should receive(:start_event)
+        expect(transaction).to receive(:start_event)
 
         subscriber.started(event)
       end
@@ -40,7 +40,7 @@ describe Appsignal::Hooks::MongoMonitorSubscriber do
       let(:event) { double }
 
       it "should finish the event" do
-        subscriber.should receive(:finish).with("SUCCEEDED", event)
+        expect(subscriber).to receive(:finish).with("SUCCEEDED", event)
 
         subscriber.succeeded(event)
       end
@@ -50,7 +50,7 @@ describe Appsignal::Hooks::MongoMonitorSubscriber do
       let(:event) { double }
 
       it "should finish the event" do
-        subscriber.should receive(:finish).with("FAILED", event)
+        expect(subscriber).to receive(:finish).with("FAILED", event)
 
         subscriber.failed(event)
       end
@@ -72,13 +72,13 @@ describe Appsignal::Hooks::MongoMonitorSubscriber do
       end
 
       it "should get the query from the store" do
-        transaction.should receive(:store).with("mongo_driver").and_return(command)
+        expect(transaction).to receive(:store).with("mongo_driver").and_return(command)
 
         subscriber.finish("SUCCEEDED", event)
       end
 
       it "should finish the transaction in the extension" do
-        transaction.should receive(:finish_event).with(
+        expect(transaction).to receive(:finish_event).with(
           "query.mongodb",
           "find | test | SUCCEEDED",
           Appsignal::Utils.data_generate("foo" => "?"),
@@ -92,19 +92,17 @@ describe Appsignal::Hooks::MongoMonitorSubscriber do
 
   context "without transaction" do
     before do
-      Appsignal::Transaction.stub(
-        :current => Appsignal::Transaction::NilTransaction.new
-      )
+      allow(Appsignal::Transaction).to receive(:current).and_return(Appsignal::Transaction::NilTransaction.new)
     end
 
     it "should not attempt to start an event" do
-      Appsignal::Extension.should_not receive(:start_event)
+      expect(Appsignal::Extension).to_not receive(:start_event)
 
       subscriber.started(double)
     end
 
     it "should not attempt to finish an event" do
-      Appsignal::Extension.should_not receive(:finish_event)
+      expect(Appsignal::Extension).to_not receive(:finish_event)
 
       subscriber.finish("SUCCEEDED", double)
     end
@@ -112,16 +110,16 @@ describe Appsignal::Hooks::MongoMonitorSubscriber do
 
   context "when appsignal is paused" do
     let(:transaction) { double(:paused? => true, :nil_transaction? => false) }
-    before { Appsignal::Transaction.stub(:current => transaction) }
+    before { allow(Appsignal::Transaction).to receive(:current).and_return(transaction) }
 
     it "should not attempt to start an event" do
-      Appsignal::Extension.should_not receive(:start_event)
+      expect(Appsignal::Extension).to_not receive(:start_event)
 
       subscriber.started(double)
     end
 
     it "should not attempt to finish an event" do
-      Appsignal::Extension.should_not receive(:finish_event)
+      expect(Appsignal::Extension).to_not receive(:finish_event)
 
       subscriber.finish("SUCCEEDED", double)
     end