appsignal 1.4.0.beta.1 → 2.0.0.beta.1

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

@@ -1,92 +1,201 @@
 if DependencyHelper.grape_present?
-  require 'appsignal/integrations/grape'
+  require "appsignal/integrations/grape"
 
   describe Appsignal::Grape::Middleware do
-
-    before :all do
-      start_agent
+    let(:app) do
+      Class.new(::Grape::API) do
+        format :json
+        post :ping do
+          { :message => "Hello world!" }
+        end
+      end
     end
-
-    let(:app)          { double(:call => true) }
-    let(:api_endpoint) { double(:options => options) }
-    let(:options)      { {
-      :for    => 'Api::PostPut',
-      :method => ['POST'],
-      :path   => ['ping']
-    }}
+    let(:api_endpoint) { app.endpoints.first }
     let(:env) do
-      http_request_env_with_data('api.endpoint' => api_endpoint)
+      http_request_env_with_data \
+        "api.endpoint" => api_endpoint,
+        "REQUEST_METHOD" => "POST",
+        :path => "/ping"
+    end
+    let(:middleware) { Appsignal::Grape::Middleware.new(api_endpoint) }
+    around do |example|
+      GrapeExample = Module.new
+      GrapeExample.send(:const_set, :Api, app)
+      example.run
+      Object.send(:remove_const, :GrapeExample)
     end
-    let(:middleware) { Appsignal::Grape::Middleware.new(app) }
 
     describe "#call" do
-      context "when appsignal is active" do
-        before { Appsignal.stub(:active? => true) }
+      context "when AppSignal is not active" do
+        before(:all) do
+          Appsignal.config = nil
+          Appsignal::Hooks.load_hooks
+        end
 
-        it "should call with monitoring" do
-          expect( middleware ).to receive(:call_with_appsignal_monitoring).with(env)
+        it "creates no transaction" do
+          expect(Appsignal::Transaction).to_not receive(:create)
         end
-      end
 
-      context "when appsignal is not active" do
-        before { Appsignal.stub(:active? => false) }
+        it "calls the endpoint normally" do
+          expect(api_endpoint).to receive(:call).with(env)
+        end
 
-        it "should not call with monitoring" do
-          expect( middleware ).to_not receive(:call_with_appsignal_monitoring)
+        after { middleware.call(env) }
+      end
+
+      context "when AppSignal is active" do
+        let(:transaction) { http_request_transaction }
+        before :all do
+          Appsignal.config = project_fixture_config
+          expect(Appsignal.active?).to be_true
+        end
+        before do
+          expect(Appsignal::Transaction).to receive(:create).with(
+            kind_of(String),
+            Appsignal::Transaction::HTTP_REQUEST,
+            kind_of(::Rack::Request)
+          ).and_return(transaction)
         end
 
-        it "should call the app" do
-          expect( app ).to receive(:call).with(env)
+        context "without error" do
+          it "calls the endpoint" do
+            expect(api_endpoint).to receive(:call).with(env)
+          end
+
+          it "sets metadata" do
+            expect(transaction).to receive(:set_http_or_background_queue_start)
+            expect(transaction).to receive(:set_action).with("POST::GrapeExample::Api#/ping")
+            expect(transaction).to receive(:set_metadata).with("path", "/ping")
+            expect(transaction).to receive(:set_metadata).with("method", "POST")
+          end
+
+          after { middleware.call(env) }
         end
-      end
 
-      after { middleware.call(env) }
-    end
+        context "with error" do
+          let(:app) do
+            Class.new(::Grape::API) do
+              format :json
+              post :ping do
+                raise VerySpecificError
+              end
+            end
+          end
 
-    describe "#call_with_appsignal_monitoring" do
-      before { SecureRandom.stub(:uuid => '1') }
-
-      it "should create a transaction" do
-        Appsignal::Transaction.should_receive(:create).with(
-          '1',
-          Appsignal::Transaction::HTTP_REQUEST,
-          kind_of(::Rack::Request)
-        ).and_return(
-          double(
-            :set_action                         => nil,
-            :set_http_or_background_queue_start => nil,
-            :set_metadata                       => nil
-          )
-        )
-      end
+          it "sets metadata" do
+            expect(transaction).to receive(:set_http_or_background_queue_start)
+            expect(transaction).to receive(:set_action).with("POST::GrapeExample::Api#/ping")
+            expect(transaction).to receive(:set_metadata).with("path", "/ping")
+            expect(transaction).to receive(:set_metadata).with("method", "POST")
+          end
 
-      it "should call the app" do
-        app.should_receive(:call).with(env)
-      end
+          it "sets the error" do
+            expect(transaction).to receive(:set_error).with(kind_of(VerySpecificError))
+          end
 
-      context "with an error" do
-        let(:error) { VerySpecificError.new }
-        let(:app) do
-          double.tap do |d|
-            d.stub(:call).and_raise(error)
+          after do
+            expect { middleware.call(env) }.to raise_error VerySpecificError
           end
         end
 
-        it "should set the error" do
-          Appsignal::Transaction.any_instance.should_receive(:set_error).with(error)
+        context "with route_param" do
+          let(:app) do
+            Class.new(::Grape::API) do
+              format :json
+              resource :users do
+                route_param :id do
+                  get do
+                    { :name => "Tom" }
+                  end
+                end
+              end
+            end
+          end
+          let(:env) do
+            http_request_env_with_data \
+              "api.endpoint" => api_endpoint,
+              "REQUEST_METHOD" => "GET",
+              :path => ""
+          end
+
+          it "sets non-unique route_param path" do
+            expect(transaction).to receive(:set_action).with("GET::GrapeExample::Api#/users/:id/")
+            expect(transaction).to receive(:set_metadata).with("path", "/users/:id/")
+            expect(transaction).to receive(:set_metadata).with("method", "GET")
+          end
+
+          after { middleware.call(env) }
         end
-      end
 
-      it "should set metadata" do
-        Appsignal::Transaction.any_instance.should_receive(:set_metadata).twice
-      end
+        context "with namespaced path" do
+          context "with symbols" do
+            let(:app) do
+              Class.new(::Grape::API) do
+                format :json
+                namespace :v1 do
+                  namespace :beta do
+                    post :ping do
+                      { :message => "Hello namespaced world!" }
+                    end
+                  end
+                end
+              end
+            end
+
+            it "sets namespaced path" do
+              expect(transaction).to receive(:set_action).with("POST::GrapeExample::Api#/v1/beta/ping")
+              expect(transaction).to receive(:set_metadata).with("path", "/v1/beta/ping")
+              expect(transaction).to receive(:set_metadata).with("method", "POST")
+            end
+          end
 
-      it "should set the action and queue start" do
-        Appsignal::Transaction.any_instance.should_receive(:set_action).with('POST::Api::PostPut#ping')
-        Appsignal::Transaction.any_instance.should_receive(:set_http_or_background_queue_start)
-      end
+          context "with strings" do
+            context "without / prefix" do
+              let(:app) do
+                Class.new(::Grape::API) do
+                  format :json
+                  namespace "v1" do
+                    namespace "beta" do
+                      post "ping" do
+                        { :message => "Hello namespaced world!" }
+                      end
+                    end
+                  end
+                end
+              end
+
+              it "sets namespaced path" do
+                expect(transaction).to receive(:set_action).with("POST::GrapeExample::Api#/v1/beta/ping")
+                expect(transaction).to receive(:set_metadata).with("path", "/v1/beta/ping")
+                expect(transaction).to receive(:set_metadata).with("method", "POST")
+              end
+            end
+
+            context "with / prefix" do
+              let(:app) do
+                Class.new(::Grape::API) do
+                  format :json
+                  namespace "/v1" do
+                    namespace "/beta" do
+                      post "/ping" do
+                        { :message => "Hello namespaced world!" }
+                      end
+                    end
+                  end
+                end
+              end
+
+              it "sets namespaced path" do
+                expect(transaction).to receive(:set_action).with("POST::GrapeExample::Api#/v1/beta/ping")
+                expect(transaction).to receive(:set_metadata).with("path", "/v1/beta/ping")
+                expect(transaction).to receive(:set_metadata).with("method", "POST")
+              end
+            end
+          end
 
-      after { middleware.call(env) rescue VerySpecificError }
+          after { middleware.call(env) }
+        end
+      end
     end
   end
 end

data/spec/lib/appsignal/js_exception_transaction_spec.rb

@@ -21,22 +21,22 @@ describe Appsignal::JSExceptionTransaction do
 
   describe "#initialize" do
     it "should call all required methods" do
-      expect( Appsignal::Extension ).to receive(:start_transaction).with('123abc', 'frontend', 0).and_return(1)
+      expect(Appsignal::Extension).to receive(:start_transaction).with('123abc', 'frontend', 0).and_return(1)
 
-      expect( transaction ).to receive(:set_action)
-      expect( transaction ).to receive(:set_metadata)
-      expect( transaction ).to receive(:set_error)
-      expect( transaction ).to receive(:set_sample_data)
+      expect(transaction).to receive(:set_action)
+      expect(transaction).to receive(:set_metadata)
+      expect(transaction).to receive(:set_error)
+      expect(transaction).to receive(:set_sample_data)
 
       transaction.send :initialize, data
 
-      expect( transaction.ext ).not_to be_nil
+      expect(transaction.ext).to_not be_nil
     end
   end
 
-  describe "#set_base_data" do
-    it "should call `Appsignal::Extension.set_transaction_basedata`" do
-      expect( transaction.ext ).to receive(:set_action).with(
+  describe "#set_action" do
+    it "should call `Appsignal::Extension.set_action`" do
+      expect(transaction.ext).to receive(:set_action).with(
         'ExceptionIncidentComponent'
       )
 
@@ -45,43 +45,83 @@ describe Appsignal::JSExceptionTransaction do
   end
 
   describe "#set_metadata" do
-   it "should call `Appsignal::Extension.set_transaction_metadata`" do
-     expect( transaction.ext ).to receive(:set_metadata).with(
-       'path',
-       'foo.bar/moo'
-     )
-
-     transaction.set_metadata
-   end
+    it "should call `Appsignal::Extension.set_transaction_metadata`" do
+      expect(transaction.ext).to receive(:set_metadata).with(
+        'path',
+        'foo.bar/moo'
+      )
+
+      transaction.set_metadata
+    end
   end
 
   describe "#set_error" do
-   it "should call `Appsignal::Extension.set_transaction_error`" do
-     expect( transaction.ext ).to receive(:set_error).with(
-       'TypeError',
-       'foo is not a valid method',
-       Appsignal::Utils.data_generate(['foo.bar/js:11:1', 'foo.bar/js:22:2'])
-     )
-
-     transaction.set_error
-   end
+    it "should call `Appsignal::Extension.set_transaction_error`" do
+      expect(transaction.ext).to receive(:set_error).with(
+        'TypeError',
+        'foo is not a valid method',
+        Appsignal::Utils.data_generate(['foo.bar/js:11:1', 'foo.bar/js:22:2'])
+      )
+
+      transaction.set_error
+    end
   end
 
   describe "#set_sample_data" do
-   it "should call `Appsignal::Extension.set_transaction_error_data`" do
-     expect( transaction.ext ).to receive(:set_sample_data).with(
-      'tags',
-      Appsignal::Utils.data_generate(['tag1'])
-     )
-
-     transaction.set_sample_data
-   end
+    it "should call `Appsignal::Extension.set_transaction_error_data`" do
+      expect(transaction.ext).to receive(:set_sample_data).with(
+        'tags',
+        Appsignal::Utils.data_generate(['tag1'])
+      )
+
+      transaction.set_sample_data
+    end
+  end
+
+  context "when sending just the name" do
+    let(:data) { {'name' => 'TypeError'} }
+
+    describe "#set_action" do
+      it "should not call `Appsignal::Extension.set_action`" do
+        expect(transaction.ext).to_not receive(:set_action)
+
+        transaction.set_action
+      end
+    end
+
+    describe "#set_metadata" do
+      it "should not call `Appsignal::Extension.set_transaction_metadata`" do
+        expect(transaction.ext).to_not receive(:set_metadata)
+
+        transaction.set_metadata
+      end
+    end
+
+    describe "#set_error" do
+      it "should call `Appsignal::Extension.set_transaction_error` with just the name" do
+        expect(transaction.ext).to receive(:set_error).with(
+          'TypeError',
+          '',
+          Appsignal::Utils.data_generate([])
+        )
+
+        transaction.set_error
+      end
+    end
+
+    describe "#set_sample_data" do
+      it "should not call `Appsignal::Extension.set_transaction_error_data`" do
+        expect(transaction.ext).to_not receive(:set_sample_data)
+
+        transaction.set_sample_data
+      end
+    end
   end
 
   describe "#complete!" do
     it "should call all required methods" do
-      expect( transaction.ext ).to receive(:finish)
-      expect( transaction.ext ).to receive(:complete)
+      expect(transaction.ext).to receive(:finish)
+      expect(transaction.ext).to receive(:complete)
       transaction.complete!
     end
   end

data/spec/lib/appsignal/marker_spec.rb

@@ -30,8 +30,8 @@ describe Appsignal::Marker do
       it "outputs success" do
         output = out_stream.string
         expect(output).to include \
-          'Notifying Appsignal of deploy with: revision: 503ce0923ed177a3ce000005, user: batman',
-          'Appsignal has been notified of this deploy!'
+          'Notifying AppSignal of deploy with: revision: 503ce0923ed177a3ce000005, user: batman',
+          'AppSignal has been notified of this deploy!'
       end
     end
 
@@ -44,11 +44,11 @@ describe Appsignal::Marker do
       it "outputs failure" do
         output = out_stream.string
         expect(output).to include \
-          'Notifying Appsignal of deploy with: revision: 503ce0923ed177a3ce000005, user: batman',
-          "Something went wrong while trying to notify Appsignal: 500 at "\
+          'Notifying AppSignal of deploy with: revision: 503ce0923ed177a3ce000005, user: batman',
+          "Something went wrong while trying to notify AppSignal: 500 at "\
           "#{config[:endpoint]}/1/markers"
         expect(output).to_not include \
-          'Appsignal has been notified of this deploy!'
+          'AppSignal has been notified of this deploy!'
       end
     end
   end

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

@@ -12,7 +12,7 @@ describe Appsignal::Rack::JSExceptionCatcher do
 
   describe "#initialize" do
     it "should log to the logger" do
-      expect( Appsignal.logger ).to receive(:debug)
+      expect(Appsignal.logger).to receive(:debug)
         .with('Initializing Appsignal::Rack::JSExceptionCatcher')
 
       Appsignal::Rack::JSExceptionCatcher.new(app, options)
@@ -26,7 +26,7 @@ describe Appsignal::Rack::JSExceptionCatcher do
       let(:env) { {'PATH_INFO' => '/foo'} }
 
       it "should call the next middleware" do
-        expect( app ).to receive(:call).with(env)
+        expect(app).to receive(:call).with(env)
       end
     end
 
@@ -35,16 +35,23 @@ describe Appsignal::Rack::JSExceptionCatcher do
       let(:env) do
         {
           'PATH_INFO'  => '/appsignal_error_catcher',
-          'rack.input' => double(:read => '{"foo": "bar"}')
+          'rack.input' => double(:read => '{"name": "error"}')
         }
       end
 
       it "should create a JSExceptionTransaction" do
-        expect( Appsignal::JSExceptionTransaction ).to receive(:new)
-          .with({'foo' => 'bar'})
+        expect(Appsignal::JSExceptionTransaction).to receive(:new)
+          .with({'name' => 'error'})
           .and_return(transaction)
 
-        expect( transaction ).to receive(:complete!)
+        expect(transaction).to receive(:complete!)
+      end
+
+      it "should return 200" do
+        allow( Appsignal::JSExceptionTransaction).to receive(:new)
+          .and_return(transaction)
+
+        expect(catcher.call(env)).to eql([200, {}, []])
       end
 
       context "when `frontend_error_catching_path` is different" do
@@ -55,16 +62,49 @@ describe Appsignal::Rack::JSExceptionCatcher do
         end
 
         it "should not create a transaction" do
-          expect( Appsignal::JSExceptionTransaction ).to_not receive(:new)
+          expect(Appsignal::JSExceptionTransaction).to_not receive(:new)
         end
 
         it "should call the next middleware" do
-          expect( app ).to receive(:call).with(env)
+          expect(app).to receive(:call).with(env)
+        end
+      end
+
+      context "when `name` is empty" do
+        let(:env) do
+          {
+            'PATH_INFO'  => '/appsignal_error_catcher',
+            'rack.input' => double(:read => '{"name": ""}')
+          }
+        end
+
+        it "should not create a transaction" do
+          expect(Appsignal::JSExceptionTransaction).to_not receive(:new)
+        end
+
+        it "should return 422" do
+          expect(catcher.call(env)).to eql([422, {}, []])
+        end
+      end
+
+      context "when `name` doesn't exist" do
+        let(:env) do
+          {
+            'PATH_INFO'  => '/appsignal_error_catcher',
+            'rack.input' => double(:read => '{"foo": ""}')
+          }
+        end
+
+        it "should not create a transaction" do
+          expect(Appsignal::JSExceptionTransaction).to_not receive(:new)
+        end
+
+        it "should return 422" do
+          expect(catcher.call(env)).to eql([422, {}, []])
         end
       end
     end
 
     after { catcher.call(env) }
   end
-
 end