appsignal 2.1.0.alpha.3 → 2.1.0.beta.1

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

@@ -2,8 +2,8 @@ describe Appsignal::Rack::JSExceptionCatcher do
   let(:app)            { double(:call => true) }
   let(:options)        { double }
   let(:active)         { true }
-  let(:config_options) { {:enable_frontend_error_catching => true} }
-  let(:config)         { project_fixture_config('production', config_options) }
+  let(:config_options) { { :enable_frontend_error_catching => true } }
+  let(:config)         { project_fixture_config("production", config_options) }
 
   before do
     Appsignal.stub(:config => config)
@@ -13,7 +13,7 @@ describe Appsignal::Rack::JSExceptionCatcher do
   describe "#initialize" do
     it "should log to the logger" do
       expect(Appsignal.logger).to receive(:debug)
-        .with('Initializing Appsignal::Rack::JSExceptionCatcher')
+        .with("Initializing Appsignal::Rack::JSExceptionCatcher")
 
       Appsignal::Rack::JSExceptionCatcher.new(app, options)
     end
@@ -23,7 +23,7 @@ describe Appsignal::Rack::JSExceptionCatcher do
     let(:catcher) { Appsignal::Rack::JSExceptionCatcher.new(app, options) }
 
     context "when path is not `/appsignal_error_catcher`" do
-      let(:env) { {'PATH_INFO' => '/foo'} }
+      let(:env) { { "PATH_INFO" => "/foo" } }
 
       it "should call the next middleware" do
         expect(app).to receive(:call).with(env)
@@ -34,21 +34,21 @@ describe Appsignal::Rack::JSExceptionCatcher do
       let(:transaction) { double(:complete! => true) }
       let(:env) do
         {
-          'PATH_INFO'  => '/appsignal_error_catcher',
-          'rack.input' => double(:read => '{"name": "error"}')
+          "PATH_INFO"  => "/appsignal_error_catcher",
+          "rack.input" => double(:read => '{"name": "error"}')
         }
       end
 
       it "should create a JSExceptionTransaction" do
         expect(Appsignal::JSExceptionTransaction).to receive(:new)
-          .with({'name' => 'error'})
+          .with("name" => "error")
           .and_return(transaction)
 
         expect(transaction).to receive(:complete!)
       end
 
       it "should return 200" do
-        allow( Appsignal::JSExceptionTransaction).to receive(:new)
+        allow(Appsignal::JSExceptionTransaction).to receive(:new)
           .and_return(transaction)
 
         expect(catcher.call(env)).to eql([200, {}, []])
@@ -57,7 +57,7 @@ describe Appsignal::Rack::JSExceptionCatcher do
       context "when `frontend_error_catching_path` is different" do
         let(:config_options) do
           {
-            :frontend_error_catching_path   => '/foo'
+            :frontend_error_catching_path => "/foo"
           }
         end
 
@@ -73,8 +73,8 @@ describe Appsignal::Rack::JSExceptionCatcher do
       context "when `name` is empty" do
         let(:env) do
           {
-            'PATH_INFO'  => '/appsignal_error_catcher',
-            'rack.input' => double(:read => '{"name": ""}')
+            "PATH_INFO"  => "/appsignal_error_catcher",
+            "rack.input" => double(:read => '{"name": ""}')
           }
         end
 
@@ -90,8 +90,8 @@ describe Appsignal::Rack::JSExceptionCatcher do
       context "when `name` doesn't exist" do
         let(:env) do
           {
-            'PATH_INFO'  => '/appsignal_error_catcher',
-            'rack.input' => double(:read => '{"foo": ""}')
+            "PATH_INFO"  => "/appsignal_error_catcher",
+            "rack.input" => double(:read => '{"foo": ""}')
           }
         end
 

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

@@ -9,10 +9,10 @@ if DependencyHelper.rails_present?
 
     let(:app) { double(:call => true) }
     let(:env) do
-      http_request_env_with_data('action_dispatch.request_id' => '1').tap do |request|
-        request['action_controller.instance'] = double(
+      http_request_env_with_data("action_dispatch.request_id" => "1").tap do |request|
+        request["action_controller.instance"] = double(
           :class => MockController,
-          :action_name => 'index'
+          :action_name => "index"
         )
       end
     end
@@ -27,7 +27,7 @@ if DependencyHelper.rails_present?
         before { Appsignal.stub(:active? => true) }
 
         it "should call with monitoring" do
-          expect( middleware ).to receive(:call_with_appsignal_monitoring).with(env)
+          expect(middleware).to receive(:call_with_appsignal_monitoring).with(env)
         end
       end
 
@@ -35,11 +35,11 @@ if DependencyHelper.rails_present?
         before { Appsignal.stub(:active? => false) }
 
         it "should not call with monitoring" do
-          expect( middleware ).to_not receive(:call_with_appsignal_monitoring)
+          expect(middleware).to_not receive(:call_with_appsignal_monitoring)
         end
 
         it "should call the app" do
-          expect( app ).to receive(:call).with(env)
+          expect(app).to receive(:call).with(env)
         end
       end
 
@@ -49,10 +49,10 @@ if DependencyHelper.rails_present?
     describe "#call_with_appsignal_monitoring" do
       it "should create a transaction" do
         Appsignal::Transaction.should_receive(:create).with(
-          '1',
+          "1",
           Appsignal::Transaction::HTTP_REQUEST,
           kind_of(ActionDispatch::Request),
-          :params_method=>:filtered_parameters
+          :params_method => :filtered_parameters
         ).and_return(
           double(
             :set_action => nil,
@@ -84,7 +84,7 @@ if DependencyHelper.rails_present?
       end
 
       it "should set the action and queue start" do
-        Appsignal::Transaction.any_instance.should_receive(:set_action).with('MockController#index')
+        Appsignal::Transaction.any_instance.should_receive(:set_action).with("MockController#index")
         Appsignal::Transaction.any_instance.should_receive(:set_http_or_background_queue_start)
       end
 
@@ -95,9 +95,9 @@ if DependencyHelper.rails_present?
       subject { middleware.request_id(env) }
 
       context "with request id set" do
-        let(:env) { {'action_dispatch.request_id' => 'id'} }
+        let(:env) { { "action_dispatch.request_id" => "id" } }
 
-        it { should eq 'id' }
+        it { should eq "id" }
       end
 
       context "with request id not set" do

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

@@ -1,10 +1,10 @@
 if DependencyHelper.sinatra_present?
-  require 'appsignal/integrations/sinatra'
+  require "appsignal/integrations/sinatra"
 
   describe Appsignal::Rack::SinatraInstrumentation do
     let(:settings) { double(:raise_errors => false) }
     let(:app) { double(:call => true, :settings => settings) }
-    let(:env) { {'sinatra.route' => 'GET /', :path => '/', :method => 'GET'} }
+    let(:env) { { "sinatra.route" => "GET /", :path => "/", :method => "GET" } }
     let(:middleware) { Appsignal::Rack::SinatraInstrumentation.new(app) }
 
     describe "#call" do
@@ -37,7 +37,7 @@ if DependencyHelper.sinatra_present?
 
     let(:settings) { double(:raise_errors => false) }
     let(:app) { double(:call => true, :settings => settings) }
-    let(:env) { {'sinatra.route' => 'GET /', :path => '/', :method => 'GET'} }
+    let(:env) { { "sinatra.route" => "GET /", :path => "/", :method => "GET" } }
     let(:options) { {} }
     let(:middleware) { Appsignal::Rack::SinatraBaseInstrumentation.new(app, options) }
 
@@ -46,7 +46,7 @@ if DependencyHelper.sinatra_present?
         let(:app) { double(:call => true) }
 
         it "should not raise errors" do
-          expect( middleware.raise_errors_on ).to be(false)
+          expect(middleware.raise_errors_on).to be(false)
         end
       end
 
@@ -54,7 +54,7 @@ if DependencyHelper.sinatra_present?
         let(:app) { double(:call => true, :settings => double) }
 
         it "should not raise errors" do
-          expect( middleware.raise_errors_on ).to be(false)
+          expect(middleware.raise_errors_on).to be(false)
         end
       end
 
@@ -62,7 +62,7 @@ if DependencyHelper.sinatra_present?
         let(:app) { double(:call => true, :settings => double(:raise_errors => false)) }
 
         it "should raise errors" do
-          expect( middleware.raise_errors_on ).to be(false)
+          expect(middleware.raise_errors_on).to be(false)
         end
       end
 
@@ -70,7 +70,7 @@ if DependencyHelper.sinatra_present?
         let(:app) { double(:call => true, :settings => double(:raise_errors => true)) }
 
         it "should raise errors" do
-          expect( middleware.raise_errors_on ).to be(true)
+          expect(middleware.raise_errors_on).to be(true)
         end
       end
     end
@@ -84,7 +84,7 @@ if DependencyHelper.sinatra_present?
         before { Appsignal.stub(:active? => true) }
 
         it "should call with monitoring" do
-          expect( middleware ).to receive(:call_with_appsignal_monitoring).with(env)
+          expect(middleware).to receive(:call_with_appsignal_monitoring).with(env)
         end
       end
 
@@ -92,11 +92,11 @@ if DependencyHelper.sinatra_present?
         before { Appsignal.stub(:active? => false) }
 
         it "should not call with monitoring" do
-          expect( middleware ).to_not receive(:call_with_appsignal_monitoring)
+          expect(middleware).to_not receive(:call_with_appsignal_monitoring)
         end
 
         it "should call the stack" do
-          expect( app ).to receive(:call).with(env)
+          expect(app).to receive(:call).with(env)
         end
       end
 
@@ -133,7 +133,7 @@ if DependencyHelper.sinatra_present?
 
       context "with an error in sinatra.error" do
         let(:error) { VerySpecificError.new }
-        let(:env) { {'sinatra.error' => error} }
+        let(:env) { { "sinatra.error" => error } }
 
         it "should set the error" do
           Appsignal::Transaction.any_instance.should_receive(:set_error).with(error)
@@ -148,7 +148,7 @@ if DependencyHelper.sinatra_present?
         end
 
         context "if sinatra.skip_appsignal_error is set" do
-          let(:env) { {'sinatra.error' => error, 'sinatra.skip_appsignal_error' => true} }
+          let(:env) { { "sinatra.error" => error, "sinatra.skip_appsignal_error" => true } }
 
           it "should not set the error" do
             Appsignal::Transaction.any_instance.should_not_receive(:set_error)
@@ -158,11 +158,11 @@ if DependencyHelper.sinatra_present?
 
       describe "action name" do
         it "should set the action" do
-          Appsignal::Transaction.any_instance.should_receive(:set_action).with('GET /')
+          Appsignal::Transaction.any_instance.should_receive(:set_action).with("GET /")
         end
 
         context "without 'sinatra.route' env" do
-          let(:env) { {:path => '/', :method => 'GET'} }
+          let(:env) { { :path => "/", :method => "GET" } }
 
           it "returns nil" do
             Appsignal::Transaction.any_instance.should_receive(:set_action).with(nil)
@@ -170,14 +170,14 @@ if DependencyHelper.sinatra_present?
         end
 
         context "with mounted modular application" do
-          before { env['SCRIPT_NAME'] = '/api' }
+          before { env["SCRIPT_NAME"] = "/api" }
 
           it "should call set_action with an application prefix path" do
             Appsignal::Transaction.any_instance.should_receive(:set_action).with("GET /api/")
           end
 
           context "without 'sinatra.route' env" do
-            let(:env) { {:path => '/', :method => 'GET'} }
+            let(:env) { { :path => "/", :method => "GET" } }
 
             it "returns nil" do
               Appsignal::Transaction.any_instance.should_receive(:set_action).with(nil)
@@ -195,14 +195,14 @@ if DependencyHelper.sinatra_present?
       end
 
       context "with overridden request class and params method" do
-        let(:options) { {:request_class => ::Rack::Request, :params_method => :filtered_params} }
+        let(:options) { { :request_class => ::Rack::Request, :params_method => :filtered_params } }
 
         it "should use the overridden request class and params method" do
           request = ::Rack::Request.new(env)
-          ::Rack::Request.should_receive(:new).
-                          with(env.merge(:params_method => :filtered_params)).
-                          at_least(:once).
-                          and_return(request)
+          ::Rack::Request.should_receive(:new)
+            .with(env.merge(:params_method => :filtered_params))
+            .at_least(:once)
+            .and_return(request)
         end
       end
 

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

@@ -1,16 +1,16 @@
-require 'appsignal/rack/streaming_listener'
+require "appsignal/rack/streaming_listener"
 
 describe Appsignal::Rack::StreamingListener do
-  let(:headers)  { {} }
+  let(:headers) { {} }
   let(:env) do
     {
-      'rack.input'     => StringIO.new,
-      'REQUEST_METHOD' => 'GET',
-      'PATH_INFO'      => '/homepage',
-      'QUERY_STRING'   => 'param=something'
+      "rack.input"     => StringIO.new,
+      "REQUEST_METHOD" => "GET",
+      "PATH_INFO"      => "/homepage",
+      "QUERY_STRING"   => "param=something"
     }
   end
-  let(:app)      { double(:call => [200, headers, 'body']) }
+  let(:app)      { double(:call => [200, headers, "body"]) }
   let(:listener) { Appsignal::Rack::StreamingListener.new(app, {}) }
 
   describe "#call" do
@@ -18,7 +18,7 @@ describe Appsignal::Rack::StreamingListener do
       before { Appsignal.stub(:active? => true) }
 
       it "should call `call_with_appsignal_monitoring`" do
-        expect( listener ).to receive(:call_with_appsignal_monitoring)
+        expect(listener).to receive(:call_with_appsignal_monitoring)
       end
     end
 
@@ -26,7 +26,7 @@ describe Appsignal::Rack::StreamingListener do
       before { Appsignal.stub(:active? => false) }
 
       it "should not call `call_with_appsignal_monitoring`" do
-        expect( listener ).to_not receive(:call_with_appsignal_monitoring)
+        expect(listener).to_not receive(:call_with_appsignal_monitoring)
       end
     end
 
@@ -41,69 +41,69 @@ describe Appsignal::Rack::StreamingListener do
         ::Rack::Request.new(env)
       )
     end
-    let(:wrapper)     { Appsignal::StreamWrapper.new('body', transaction) }
-    let(:raw_payload) { {:foo => :bar} }
+    let(:wrapper)     { Appsignal::StreamWrapper.new("body", transaction) }
+    let(:raw_payload) { { :foo => :bar } }
 
     before do
-      SecureRandom.stub(:uuid => '123')
+      SecureRandom.stub(:uuid => "123")
       listener.stub(:raw_payload => raw_payload)
       Appsignal::Transaction.stub(:create => transaction)
     end
 
     it "should create a transaction" do
-      expect( Appsignal::Transaction ).to receive(:create)
-        .with('123', Appsignal::Transaction::HTTP_REQUEST, instance_of(Rack::Request))
+      expect(Appsignal::Transaction).to receive(:create)
+        .with("123", Appsignal::Transaction::HTTP_REQUEST, instance_of(Rack::Request))
         .and_return(transaction)
 
       listener.call_with_appsignal_monitoring(env)
     end
 
     it "should instrument the call" do
-      expect( Appsignal ).to receive(:instrument)
-        .with('process_action.rack')
+      expect(Appsignal).to receive(:instrument)
+        .with("process_action.rack")
         .and_yield
 
       listener.call_with_appsignal_monitoring(env)
     end
 
     it "should add `appsignal.action` to the transaction" do
-      allow( Appsignal ).to receive(:instrument).and_yield
+      allow(Appsignal).to receive(:instrument).and_yield
 
-      env['appsignal.action'] = 'Action'
+      env["appsignal.action"] = "Action"
 
-      expect( transaction ).to receive(:set_action).with('Action')
+      expect(transaction).to receive(:set_action).with("Action")
 
       listener.call_with_appsignal_monitoring(env)
     end
 
     it "should add the path, method and queue start to the transaction" do
-      allow( Appsignal ).to receive(:instrument).and_yield
+      allow(Appsignal).to receive(:instrument).and_yield
 
-      expect( transaction ).to receive(:set_metadata).with('path', '/homepage')
-      expect( transaction ).to receive(:set_metadata).with('method', 'GET')
-      expect( transaction ).to receive(:set_http_or_background_queue_start)
+      expect(transaction).to receive(:set_metadata).with("path", "/homepage")
+      expect(transaction).to receive(:set_metadata).with("method", "GET")
+      expect(transaction).to receive(:set_http_or_background_queue_start)
 
       listener.call_with_appsignal_monitoring(env)
     end
 
     context "with an exception in the instrumentation call" do
       it "should add the exception to the transaction" do
-        allow( app ).to receive(:call).and_raise(VerySpecificError.new)
+        allow(app).to receive(:call).and_raise(VerySpecificError.new)
 
-        expect( transaction ).to receive(:set_error)
+        expect(transaction).to receive(:set_error)
 
         listener.call_with_appsignal_monitoring(env) rescue VerySpecificError
       end
     end
 
     it "should wrap the body in a wrapper" do
-      expect( Appsignal::StreamWrapper ).to receive(:new)
-        .with('body', transaction)
+      expect(Appsignal::StreamWrapper).to receive(:new)
+        .with("body", transaction)
         .and_return(wrapper)
 
       body = listener.call_with_appsignal_monitoring(env)[2]
 
-      expect( body ).to be_a(Appsignal::StreamWrapper)
+      expect(body).to be_a(Appsignal::StreamWrapper)
     end
   end
 end
@@ -115,17 +115,17 @@ describe Appsignal::StreamWrapper do
 
   describe "#each" do
     it "should call the original stream" do
-      expect( stream ).to receive(:each)
+      expect(stream).to receive(:each)
 
       wrapper.each
     end
 
     context "when each raises an error" do
       it "should add the exception to the transaction" do
-        allow( stream ).to receive(:each)
+        allow(stream).to receive(:each)
           .and_raise(VerySpecificError.new)
 
-        expect( transaction ).to receive(:set_error)
+        expect(transaction).to receive(:set_error)
 
         wrapper.send(:each) rescue VerySpecificError
       end
@@ -134,19 +134,19 @@ describe Appsignal::StreamWrapper do
 
   describe "#close" do
     it "should call the original stream and close the transaction" do
-      expect( stream ).to receive(:close)
-      expect( Appsignal::Transaction ).to receive(:complete_current!)
+      expect(stream).to receive(:close)
+      expect(Appsignal::Transaction).to receive(:complete_current!)
 
       wrapper.close
     end
 
     context "when each raises an error" do
       it "should add the exception to the transaction and close it" do
-        allow( stream ).to receive(:close)
+        allow(stream).to receive(:close)
           .and_raise(VerySpecificError.new)
 
-        expect( transaction ).to receive(:set_error)
-        expect( Appsignal::Transaction ).to receive(:complete_current!)
+        expect(transaction).to receive(:set_error)
+        expect(Appsignal::Transaction).to receive(:complete_current!)
 
         wrapper.send(:close) rescue VerySpecificError
       end