captivus 0.0.3 → 0.0.5

data/spec/captivus/notifier_spec.rb

@@ -0,0 +1,73 @@
+require 'spec_helper'
+require 'captivus/notifier'
+
+describe Captivus::Notifier do
+  describe "notify" do
+    before do
+      Timecop.freeze Time.utc(2012, 11, 28, 2, 46, 4)
+      @config = double 'config',
+        :scheme => 'http',
+        :host => 'api.captiv.us',
+        :api_key => 'api-key',
+        :api_secret_key => 'secret',
+        :environment => 'production',
+        :development_environments => %w[development test]
+    end
+    after { Timecop.return }
+
+    context "when the environment is a development environment" do
+      it "doesn't post" do
+        @config.stub(:environment) { 'development' }
+        Captivus::Notifier.new(@config).notify({})
+        expect(captivus_api.requests.size).to eq 0
+
+        @config.stub(:environment) { 'test' }
+        Captivus::Notifier.new(@config).notify({})
+        expect(captivus_api.requests.size).to eq 0
+      end
+    end
+
+    it "posts the given payload to the endpoint in the config" do
+      Captivus::Notifier.new(@config).notify({:a => 1, :b => '2'})
+
+      expect(captivus_api.requests.size).to eq 1
+
+      headers = {
+        "CONTENT_TYPE"=>"application/json; charset=UTF-8",
+        "HTTP_ACCEPT" => "*/*",
+        "HTTP_USER_AGENT" => "Ruby",
+        "HTTP_DATE" => "Wed, 28 Nov 2012 02:46:04 GMT",
+        "HTTP_AUTHORIZATION" => "Captivus api-key:IgBW675pSKkCuD4McYnX9QQMI5g=",
+        "PATH_INFO" => "/events",
+        "QUERY_STRING" => "",
+        "REQUEST_METHOD"=>"POST",
+        "SCRIPT_NAME" => "",
+        "SERVER_NAME" => "api.captiv.us",
+        "SERVER_PORT" => "80",
+        "rack.url_scheme" => "http"
+      }
+
+      last_request = captivus_api.requests[0]
+
+      expect(last_request.values_at(*headers.keys)).to eq headers.values
+
+      expect(last_request['rack.input'].read).to eq '{"a":1,"b":"2"}'
+    end
+  end
+
+  describe "#==" do
+    it "is true given another notifier with the same config" do
+      config = double 'config'
+      expect(Captivus::Notifier.new(config) == Captivus::Notifier.new(config)).to be_true
+    end
+
+    it "is false given another notifier with different config" do
+      expect(Captivus::Notifier.new(double('config')) == Captivus::Notifier.new(double('config'))).to be_false
+    end
+
+    it "is false given a non notifier" do
+      config = double 'config'
+      expect(Captivus::Notifier.new(config) == double('other', :config => config)).to be_false
+    end
+  end
+end

data/spec/captivus/payload_spec.rb

@@ -2,47 +2,312 @@ require 'spec_helper'
 require 'captivus/payload'
 
 describe Captivus::Payload do
+  def valid_hash
+    {
+      'notifier' => {'name' => 'captivus-gem', 'version' => '1.2.3', 'language' => 'ruby'},
+      'event' => {'type' => 'SomeEvent', 'message' => "Some message.", 'timestamp' => '2012-10-22T02:25:42Z'},
+      'backtrace' => [
+        {'file' => '/Users/austin/go.rb', 'number' => 10, 'method' => 'go'},
+        {'file' => '/Users/austin/go.rb', 'number' => 5}
+      ],
+      'environment' => {'name' => 'production'}
+    }
+  end
+
   describe ".new" do
-    context "when argument doesn't behave like an exception" do
-      it "raises an argument error" do
-        [
-          double('exception'),
-          double('exception', :class => double('class')),
-          double('exception', :class => double('class', :name => 'X')),
-          double('exception', :class => double('class'), :message => 'x')
-        ].each do |exception|
-          expect {
-            Captivus::Payload.new exception
-          }.to raise_error(ArgumentError, "Unexpected exception: #{exception.inspect}")
+    before do
+      @exception = JSON::Schema::ValidationError
+      @json = {
+        :notifier => {
+          :name => 'captivus-gem',
+          :version => '1.2.3',
+          :language => 'ruby'
+        },
+        :event => {
+          :type => 'SomeEvent',
+          :message => "Some message.",
+          :timestamp => '2012-10-22T02:25:42Z'
+        },
+        :backtrace => [
+          {:file => '/Users/austin/go.rb', :number => 10, :method => 'go'},
+          {:file => '/Users/austin/go.rb', :number => 5}
+        ],
+        :environment => {:name => 'production'}
+      }
+    end
+
+    it "does not raise an error with valid payload JSON" do
+      expect { Captivus::Payload.new hash_to_json(@json) }.to_not raise_error
+
+      @json[:backtrace] = []
+      expect { Captivus::Payload.new hash_to_json(@json) }.to_not raise_error
+
+      @json[:context] = {:controller => 'widgets', :action => 'show'}
+      expect { Captivus::Payload.new hash_to_json(@json) }.to_not raise_error
+    end
+
+    context "payload JSON" do
+      it "must be a string" do
+        expect { Captivus::Payload.new nil }.to raise_error(@exception)
+        expect { Captivus::Payload.new Object.new }.to raise_error(@exception)
+      end
+
+      it "must be valid JSON" do
+        expect { Captivus::Payload.new '{"not" => ["valid json"]' }.to raise_error(@exception)
+      end
+    end
+
+    context "notifier" do
+      it "is required" do
+        @json.delete :notifier
+        expect { Captivus::Payload.new hash_to_json(@json) }.to raise_error(@exception)
+      end
+
+      it "must be an object" do
+        @json[:notifier] = ''
+        expect { Captivus::Payload.new hash_to_json(@json) }.to raise_error(@exception)
+      end
+
+      context "name" do
+        it "is required" do
+          @json[:notifier].delete :name
+          expect { Captivus::Payload.new hash_to_json(@json) }.to raise_error(@exception)
+        end
+
+        it "must be a string" do
+          @json[:notifier][:name] = {}
+          expect { Captivus::Payload.new hash_to_json(@json) }.to raise_error(@exception)
+        end
+      end
+
+      context "version" do
+        it "is required" do
+          @json[:notifier].delete :version
+          expect { Captivus::Payload.new hash_to_json(@json) }.to raise_error(@exception)
+        end
+
+        it "must be a string" do
+          @json[:notifier][:version] = {}
+          expect { Captivus::Payload.new hash_to_json(@json) }.to raise_error(@exception)
+        end
+      end
+
+      context "language" do
+        it "is required" do
+          @json[:notifier].delete :language
+          expect { Captivus::Payload.new hash_to_json(@json) }.to raise_error(@exception)
+        end
+
+        it "must be a string" do
+          @json[:notifier][:language] = {}
+          expect { Captivus::Payload.new hash_to_json(@json) }.to raise_error(@exception)
         end
       end
     end
-  end
 
-  describe "as_json" do
-    it "returns a hash of event and backtrace info" do
-      Timecop.freeze Time.utc(2012, 8, 23, 16, 34, 19)
+    context "event" do
+      it "is required" do
+        @json.delete :event
+        expect { Captivus::Payload.new hash_to_json(@json) }.to raise_error(@exception)
+      end
+
+      it "must be an object" do
+        @json[:event] = "some event"
+        expect { Captivus::Payload.new hash_to_json(@json) }.to raise_error(@exception)
+      end
+
+      context "type" do
+        it "is required" do
+          @json[:event].delete :type
+          expect { Captivus::Payload.new hash_to_json(@json) }.to raise_error(@exception)
+        end
+
+        it "must be a string" do
+          @json[:event][:type] = {:foo => 'bar'}
+          expect { Captivus::Payload.new hash_to_json(@json) }.to raise_error(@exception)
+        end
+      end
+
+      context "message" do
+        it "is required" do
+          @json[:event].delete :message
+          expect { Captivus::Payload.new hash_to_json(@json) }.to raise_error(@exception)
+        end
+
+        it "must be a string" do
+          @json[:event][:message] = {:foo => 'bar'}
+          expect { Captivus::Payload.new hash_to_json(@json) }.to raise_error(@exception)
+        end
+      end
+
+      context "timestamp" do
+        it "is required" do
+          @json[:event].delete :timestamp
+          expect { Captivus::Payload.new hash_to_json(@json) }.to raise_error(@exception)
+        end
+
+        it "must be a date-time" do
+          @json[:event][:timestamp] = "2012-12-22"
+          expect { Captivus::Payload.new hash_to_json(@json) }.to raise_error(@exception)
+        end
+      end
+    end
+
+    context "backtrace" do
+      it "is required" do
+        @json.delete :backtrace
+        expect { Captivus::Payload.new hash_to_json(@json) }.to raise_error(@exception)
+      end
+
+      it "must be an array" do
+        @json[:backtrace] = {:foo => 'bar'}
+        expect { Captivus::Payload.new hash_to_json(@json) }.to raise_error(@exception)
+      end
+
+      it "all items must be an object" do
+        @json[:backtrace][0] = "some string"
+        expect { Captivus::Payload.new hash_to_json(@json) }.to raise_error(@exception)
+      end
 
-      exception = double 'exception',
-        :class => double('class', :name => 'ExceptionType'),
-        :message => 'The exception message.',
-        :backtrace => ['/Users/x.rb:1', '/Users/x.rb:2', '/Users/x.rb:3']
+      context "file" do
+        it "is required" do
+          @json[:backtrace][0].delete :file
+          expect { Captivus::Payload.new hash_to_json(@json) }.to raise_error(@exception)
+        end
 
-      Captivus::Payload.new(exception).as_json.tap do |hash|
-        expect(hash.keys).to match_array ['event', 'backtrace']
+        it "must be a string" do
+          @json[:backtrace][0][:file] = {:foo => 'bar'}
+          expect { Captivus::Payload.new hash_to_json(@json) }.to raise_error(@exception)
+        end
+      end
+
+      context "number" do
+        it "is required" do
+          @json[:backtrace][0].delete :number
+          expect { Captivus::Payload.new hash_to_json(@json) }.to raise_error(@exception)
+        end
 
-        hash['event'].tap do |event|
-          expect(event.keys).to match_array ['type', 'message', 'timestamp']
+        it "must be an integer" do
+          @json[:backtrace][0][:number] = "10"
+          expect { Captivus::Payload.new hash_to_json(@json) }.to raise_error(@exception)
+        end
+      end
 
-          expect(event['type']).to eq 'ExceptionType'
-          expect(event['message']).to eq 'The exception message.'
-          expect(event['timestamp']).to eq '2012-08-23 16:34:19 UTC'
+      context "method" do
+        it "must be a string" do
+          @json[:backtrace][0][:method] = {:foo => 'bar'}
+          expect { Captivus::Payload.new hash_to_json(@json) }.to raise_error(@exception)
         end
+      end
+    end
+
+    context "context" do
+      before { @json[:context] = {} }
+
+      it "is not required" do
+        @json.delete :context
+        expect { Captivus::Payload.new hash_to_json(@json) }.to_not raise_error
+      end
 
-        hash['backtrace'].should == Captivus::Backtrace.new(exception).as_json
+      it "must be an object when present" do
+        expect { Captivus::Payload.new hash_to_json(@json) }.to_not raise_error
+
+        @json[:context] = 1
+        expect { Captivus::Payload.new hash_to_json(@json) }.to raise_error(@exception)
+      end
+
+      context "controller" do
+        it "must be a string when present" do
+          @json[:context][:controller] = 1
+          expect { Captivus::Payload.new hash_to_json(@json) }.to raise_error(@exception)
+
+          @json[:context][:controller] = 'widgets'
+          expect { Captivus::Payload.new hash_to_json(@json) }.to_not raise_error
+        end
+      end
+
+      context "action" do
+        it "must be a string when present" do
+          @json[:context][:action] = 1
+          expect { Captivus::Payload.new hash_to_json(@json) }.to raise_error(@exception)
+
+          @json[:context][:action] = 'show'
+          expect { Captivus::Payload.new hash_to_json(@json) }.to_not raise_error
+        end
+      end
+
+      context "params" do
+        it "must be an object when present" do
+          @json[:context][:params] = 1
+          expect { Captivus::Payload.new hash_to_json(@json) }.to raise_error(@exception)
+
+          @json[:context][:params] = {'a' => 'b'}
+          expect { Captivus::Payload.new hash_to_json(@json) }.to_not raise_error
+        end
       end
+    end
+
+    context "environment" do
+      it "is required" do
+        @json.delete :environment
+        expect { Captivus::Payload.new hash_to_json(@json) }.to raise_error(@exception)
+      end
+
+      it "must be an object" do
+        @json[:environment] = 'foo'
+        expect { Captivus::Payload.new hash_to_json(@json) }.to raise_error(@exception)
+      end
+
+      context "name" do
+        it "is required" do
+          @json[:environment].delete :name
+          expect { Captivus::Payload.new hash_to_json(@json) }.to raise_error(@exception)
+        end
+
+        it "must be an string" do
+          @json[:environment][:name] = 3495
+          expect { Captivus::Payload.new hash_to_json(@json) }.to raise_error(@exception)
+        end
+      end
+    end
+  end
+
+  describe "#as_json" do
+    it "is the JSON converted to a hash" do
+      hash = valid_hash
+      expect(Captivus::Payload.new(hash_to_json(hash)).as_json).to eq hash
+    end
+  end
+
+  describe "#to_json" do
+    before { @json = hash_to_json valid_hash }
+
+    it "is the given JSON" do
+      expect(Captivus::Payload.new(@json).to_json).to eq @json
+    end
+
+    it "never returns the same instance" do
+      payload = Captivus::Payload.new @json
+      expect(payload.to_json).to_not equal payload.to_json
+    end
+  end
+
+  describe "#==" do
+    before { @hash = valid_hash }
+
+    it "is true given another payload with the same JSON" do
+      json = hash_to_json(@hash)
+      expect(Captivus::Payload.new json).to eq Captivus::Payload.new(json)
+    end
+
+    it "is false given another payload with different JSON" do
+      other = Captivus::Payload.new hash_to_json(@hash.merge('environment' => {'name' => 'staging'}))
+      expect(Captivus::Payload.new hash_to_json(@hash)).to_not eq other
+    end
 
-      Timecop.return
+    it "is false given a non payload" do
+      json = hash_to_json @hash
+      expect(Captivus::Payload.new json).to_not eq double('other', :json => json)
     end
   end
 end

data/spec/captivus/rack_capturer_spec.rb

@@ -8,33 +8,50 @@ describe Captivus::RackCapturer do
       @rack_capturer = Captivus::RackCapturer.new @app
     end
 
-    it "is delegated to the given app, passing the env along" do
-      env = double 'env'
+    def env_double(hash = {})
+      {'rack.input' => StringIO.new, 'QUERY_STRING' => ''}.merge(hash)
+    end
+
+    it "calls the app with the given env" do
+      env = env_double
       result = double 'result'
       @app.stub(:call).with(env) { result }
       expect(@rack_capturer.call(env)).to eq result
     end
 
     context "when calling the app raises an error" do
-      before { @app.stub(:call) { raise StandardError, 'Error raised' } }
+      before { @app.stub(:call) { raise Exception, 'Error raised' } }
 
-      it "raises the error" do
-        expect { @rack_capturer.call double('env') }.to raise_error StandardError, "Error raised"
+      context "when the env contains a query string" do
+        it "tells Captivus to notify" do
+          Captivus.should_receive(:notify).with kind_of(Exception),
+            :context => {:params => {'username' => 'austin', 'password' => 'secret'}}
+          begin
+            @rack_capturer.call(env_double('QUERY_STRING' => 'username=austin&password=secret'))
+          rescue Exception
+          end
+        end
       end
 
-      it "notifies the Captivus API" do
-        Captivus.should_receive(:notify).with kind_of(StandardError)
-        @rack_capturer.call double('env') rescue nil
+      context "when the env doesn't contain a query string" do
+        it "tells Captivus to notify" do
+          Captivus.should_receive(:notify).with kind_of(Exception), :context => {:params => {}}
+          begin
+            @rack_capturer.call(env_double)
+          rescue Exception
+          end
+        end
       end
-    end
 
-    context "when calling the app does not raise an error" do
-      before { @app.stub :call }
-
-      it "does not notify the Captivus API" do
-        @rack_capturer.call double('env')
-        expect(captivus_api.requests.size).to eq 0
+      it "raises the error" do
+        expect { @rack_capturer.call(env_double) }.to raise_error Exception, "Error raised"
       end
     end
+
+    it "does not notify the Captivus API when calling the app does not raise an error" do
+      @app.stub :call
+      @rack_capturer.call env_double
+      expect(captivus_api.requests.size).to eq 0
+    end
   end
 end

data/spec/captivus/rails_capturer_spec.rb

@@ -0,0 +1,59 @@
+require 'spec_helper'
+require 'captivus/rails_capturer'
+
+describe Captivus::RailsCapturer do
+  describe "call" do
+    before do
+      @app = double 'app'
+      @rails_capturer = Captivus::RailsCapturer.new @app
+    end
+
+    it "calls the app with the given env" do
+      env = double 'env'
+      result = double 'result'
+      @app.stub(:call).with(env) { result }
+      expect(@rails_capturer.call(env)).to eq result
+    end
+
+    context "when calling the app raises an error" do
+      before do
+        @app.stub(:call) { raise Exception, 'Error raised' }
+        @env = {'action_controller.instance' => double('controller',
+          :controller_name => 'widgets',
+          :action_name => 'show',
+          :request => double('request', :filtered_parameters => {
+            'controller' => 'widgets',
+            'action' => 'show',
+            'p1' => 'v1',
+            'p2' => 'v2'
+          })
+        )}
+      end
+
+      it "tells Captivus to notify of the exception" do
+        Captivus.should_receive(:notify).with kind_of(Exception), 'context' => {
+          'controller' => 'widgets',
+          'action' => 'show',
+          'params' => {'p1' => 'v1', 'p2' => 'v2'}
+        }
+        begin
+          @rails_capturer.call @env
+        rescue Exception
+        end
+      end
+
+      it "raises the error" do
+        expect { @rails_capturer.call @env }.to raise_error Exception, "Error raised"
+      end
+    end
+
+    context "when calling the app does not raise an error" do
+      before { @app.stub :call }
+
+      it "does not notify the Captivus API" do
+        @rails_capturer.call double('env')
+        expect(captivus_api.requests.size).to eq 0
+      end
+    end
+  end
+end

data/spec/captivus_spec.rb

@@ -21,43 +21,64 @@ describe Captivus do
     end
   end
 
+  describe ".notifier" do
+    it "is a notifier" do
+      expect(Captivus.notifier).to eq Captivus::Notifier.new(Captivus.config)
+    end
+
+    it "always returns the same notifier" do
+      expect(Captivus.notifier).to equal Captivus.notifier
+    end
+  end
+
   describe ".notify" do
-    it "sends a notice to the Captivus API" do
-      Timecop.freeze Time.utc(2012, 11, 28, 2, 46, 4)
+    before { Timecop.freeze Time.utc(2012, 8, 23, 16, 34, 19) }
+    after { Timecop.return }
 
-      exception = StandardError.new('Error raised')
+    it "tells the notifier to notify" do
+      Captivus.config.environment = 'the-environment'
 
-      Captivus.configure do |config|
-        config.api_key = 'api-key'
-        config.api_secret_key = 'secret'
-      end
+      exception = double 'exception',
+        :class => double('class', :name => 'ExceptionType'),
+        :message => 'The exception message.',
+        :backtrace => ['/Users/x.rb:1', '/Users/x.rb:2', '/Users/x.rb:3']
 
-      Captivus.notify exception
-
-      expect(captivus_api.requests.size).to eq 1
-
-      headers = {
-        "CONTENT_TYPE"=>"application/json; charset=UTF-8",
-        "HTTP_ACCEPT" => "*/*",
-        "HTTP_USER_AGENT" => "Ruby",
-        "HTTP_DATE" => "Wed, 28 Nov 2012 02:46:04 GMT",
-        "HTTP_AUTHORIZATION" => "Captivus api-key:IgBW675pSKkCuD4McYnX9QQMI5g=",
-        "PATH_INFO" => "/events",
-        "QUERY_STRING" => "",
-        "REQUEST_METHOD"=>"POST",
-        "SCRIPT_NAME" => "",
-        "SERVER_NAME" => "api.captiv.us",
-        "SERVER_PORT" => "80",
-        "rack.url_scheme" => "http"
+      hash = {
+        'notifier' => {
+          'name' => 'captivus',
+          'version' => Captivus::VERSION,
+          'language' => 'Ruby'
+        },
+        'event' => {
+          'type' => 'ExceptionType',
+          'message' => 'The exception message.',
+          'timestamp' => '2012-08-23T16:34:19Z'
+        },
+        'backtrace' => Captivus::Backtrace.new(exception).as_json,
+        'environment' => {'name' => 'the-environment'}
       }
 
-      last_request = captivus_api.requests[0]
-
-      expect(last_request.values_at(*headers.keys)).to eq headers.values
+      Captivus.notifier.should_receive(:notify).with(Captivus::Payload.new(hash_to_json(hash)))
+      Captivus.notify exception, {}
 
-      expect(last_request['rack.input'].read).to eq MultiJson.dump(Captivus::Payload.new(exception).as_json)
+      hash.merge!('extra' => 'data', 'goes' => 'here')
+      Captivus.notifier.should_receive(:notify).with(Captivus::Payload.new(hash_to_json(hash)))
+      Captivus.notify exception, {'extra' => 'data', 'goes' => 'here'}
+    end
 
-      Timecop.return
+    context "when the exception doesn't behave like an one" do
+      it "raises an argument error" do
+        [
+          double('exception'),
+          double('exception', :class => double('class')),
+          double('exception', :class => double('class', :name => 'X')),
+          double('exception', :class => double('class'), :message => 'x')
+        ].each do |exception|
+          expect {
+            Captivus.notify exception
+          }.to raise_error(ArgumentError, "Unexpected exception: #{exception.inspect}")
+        end
+      end
     end
   end
 end