projectlocker_pulse 0.2.1

data/test/notifier_test.rb

@@ -0,0 +1,276 @@
+require File.expand_path '../helper', __FILE__
+
+class NotifierTest < Test::Unit::TestCase
+
+  class OriginalException < Exception
+  end
+
+  class ContinuedException < Exception
+  end
+
+  include DefinesConstants
+
+  def setup
+    super
+    reset_config
+  end
+
+  def assert_sent(notice, notice_args)
+    assert_received(Pulse::Notice, :new) {|expect| expect.with(has_entries(notice_args)) }
+    assert_received(Pulse.sender, :send_to_pulse) {|expect| expect.with(notice) }
+  end
+
+  def set_public_env
+    Pulse.configure { |config| config.environment_name = 'production' }
+  end
+
+  def set_development_env
+    Pulse.configure { |config| config.environment_name = 'development' }
+  end
+
+  should "yield and save a configuration when configuring" do
+    yielded_configuration = nil
+    Pulse.configure do |config|
+      yielded_configuration = config
+    end
+
+    assert_kind_of Pulse::Configuration, yielded_configuration
+    assert_equal yielded_configuration, Pulse.configuration
+  end
+
+  should "not remove existing config options when configuring twice" do
+    first_config = nil
+    Pulse.configure do |config|
+      first_config = config
+    end
+    Pulse.configure do |config|
+      assert_equal first_config, config
+    end
+  end
+
+  should "configure the sender" do
+    sender = stub_sender
+    Pulse::Sender.stubs(:new => sender)
+    configuration = nil
+
+    Pulse.configure { |yielded_config| configuration = yielded_config }
+
+    assert_received(Pulse::Sender, :new) { |expect| expect.with(configuration) }
+    assert_equal sender, Pulse.sender
+  end
+
+  should "create and send a notice for an exception" do
+    set_public_env
+    exception = build_exception
+    stub_sender!
+    notice = stub_notice!
+
+    Pulse.notify(exception)
+
+    assert_sent notice, :exception => exception
+  end
+
+  should "create and send a notice for a hash" do
+    set_public_env
+    notice = stub_notice!
+    notice_args = { :error_message => 'uh oh' }
+    stub_sender!
+
+    Pulse.notify(notice_args)
+
+    assert_sent(notice, notice_args)
+  end
+
+  should "not pass the hash as an exception when sending a notice for it" do
+    set_public_env
+    notice = stub_notice!
+    notice_args = { :error_message => 'uh oh' }
+    stub_sender!
+
+    Pulse.notify(notice_args)
+
+    assert_received(Pulse::Notice, :new) {|expect| expect.with(Not(has_key(:exception))) }
+  end
+
+  should "create and send a notice for an exception that responds to to_hash" do
+    set_public_env
+    exception = build_exception
+    notice = stub_notice!
+    notice_args = { :error_message => 'uh oh' }
+    exception.stubs(:to_hash).returns(notice_args)
+    stub_sender!
+
+    Pulse.notify(exception)
+
+    assert_sent(notice, notice_args.merge(:exception => exception))
+  end
+
+  should "create and sent a notice for an exception and hash" do
+    set_public_env
+    exception = build_exception
+    notice = stub_notice!
+    notice_args = { :error_message => 'uh oh' }
+    stub_sender!
+
+    Pulse.notify(exception, notice_args)
+
+    assert_sent(notice, notice_args.merge(:exception => exception))
+  end
+
+  should "not create a notice in a development environment" do
+    set_development_env
+    sender = stub_sender!
+
+    Pulse.notify(build_exception)
+    Pulse.notify_or_ignore(build_exception)
+
+    assert_received(sender, :send_to_pulse) {|expect| expect.never }
+  end
+
+  should "not deliver an ignored exception when notifying implicitly" do
+    set_public_env
+    exception = build_exception
+    sender = stub_sender!
+    notice = stub_notice!
+    notice.stubs(:ignore? => true)
+
+    Pulse.notify_or_ignore(exception)
+
+    assert_received(sender, :send_to_pulse) {|expect| expect.never }
+  end
+
+  should "deliver exception in async-mode" do
+    Pulse.configure do |config|
+      config.environment_name = 'production'
+      config.async do |notice|
+        Pulse.sender.send_to_pulse(notice)
+      end
+    end
+    exception = build_exception
+    sender = stub_sender!
+    notice = stub_notice!
+
+    Pulse.notify(exception)
+
+    assert_sent(notice, :exception => exception)
+  end
+
+  should "pass notice in async-mode" do
+    received_notice = nil
+    Pulse.configure do |config|
+      config.environment_name = 'production'
+      config.async {|notice| received_notice = notice}
+    end
+    exception = build_exception
+    sender = stub_sender!
+    notice = stub_notice!
+
+    Pulse.notify(exception)
+
+    assert_equal received_notice, notice
+  end
+
+  should "deliver an ignored exception when notifying manually" do
+    set_public_env
+    exception = build_exception
+    sender = stub_sender!
+    notice = stub_notice!
+    notice.stubs(:ignore? => true)
+
+    Pulse.notify(exception)
+
+    assert_sent(notice, :exception => exception)
+  end
+
+  should "pass config to created notices" do
+    exception = build_exception
+    config_opts = { 'one' => 'two', 'three' => 'four' }
+    notice = stub_notice!
+    stub_sender!
+    Pulse.configuration = stub('config', :merge => config_opts, :public? => true,:async? => nil)
+
+    Pulse.notify(exception)
+
+    assert_received(Pulse::Notice, :new) do |expect|
+      expect.with(has_entries(config_opts))
+    end
+  end
+
+  context "building notice JSON for an exception" do
+    setup do
+      @params    = { :controller => "users", :action => "create" }
+      @exception = build_exception
+      @hash      = Pulse.build_lookup_hash_for(@exception, @params)
+    end
+
+    should "set action" do
+      assert_equal @params[:action], @hash[:action]
+    end
+
+    should "set controller" do
+      assert_equal @params[:controller], @hash[:component]
+    end
+
+    should "set line number" do
+      assert @hash[:line_number] =~ /\d+/
+    end
+
+    should "set file" do
+      assert_match /test\/helper\.rb$/, @hash[:file]
+    end
+
+    should "set rails_env to production" do
+      assert_equal 'production', @hash[:environment_name]
+    end
+
+    should "set error class" do
+      assert_equal @exception.class.to_s, @hash[:error_class]
+    end
+
+    should "not set file or line number with no backtrace" do
+      @exception.stubs(:backtrace).returns([])
+
+      @hash = Pulse.build_lookup_hash_for(@exception)
+
+      assert_nil @hash[:line_number]
+      assert_nil @hash[:file]
+    end
+
+    should "not set action or controller when not provided" do
+      @hash = Pulse.build_lookup_hash_for(@exception)
+
+      assert_nil @hash[:action]
+      assert_nil @hash[:controller]
+    end
+
+    context "when an exception that provides #original_exception is raised" do
+      setup do
+        @exception.stubs(:original_exception).returns(begin
+          raise NotifierTest::OriginalException.new
+        rescue Exception => e
+          e
+        end)
+      end
+
+      should "unwrap exceptions that provide #original_exception" do
+        @hash = Pulse.build_lookup_hash_for(@exception)
+        assert_equal "NotifierTest::OriginalException", @hash[:error_class]
+      end
+    end
+
+    context "when an exception that provides #continued_exception is raised" do
+      setup do
+        @exception.stubs(:continued_exception).returns(begin
+          raise NotifierTest::ContinuedException.new
+        rescue Exception => e
+          e
+        end)
+      end
+
+      should "unwrap exceptions that provide #continued_exception" do
+        @hash = Pulse.build_lookup_hash_for(@exception)
+        assert_equal "NotifierTest::ContinuedException", @hash[:error_class]
+      end
+    end
+  end
+end

data/test/projectlocker_pulse_tasks_test.rb

@@ -0,0 +1,170 @@
+require File.expand_path '../helper', __FILE__
+require 'rubygems'
+
+require File.dirname(__FILE__) + '/../lib/pulse_tasks'
+require 'fakeweb'
+
+FakeWeb.allow_net_connect = false
+
+class PulseTasksTest < Test::Unit::TestCase
+  def successful_response(body = "")
+    response = Net::HTTPSuccess.new('1.2', '200', 'OK')
+    response.stubs(:body).returns(body)
+    return response
+  end
+
+  def unsuccessful_response(body = "")
+    response = Net::HTTPClientError.new('1.2', '200', 'OK')
+    response.stubs(:body).returns(body)
+    return response
+  end
+
+  context "being quiet" do
+    setup { PulseTasks.stubs(:puts) }
+
+    context "in a configured project" do
+      setup { Pulse.configure { |config| config.api_key = "1234123412341234" } }
+
+      context "on deploy({})" do
+        setup { @output = PulseTasks.deploy({}) }
+
+        before_should "complain about missing rails env" do
+          PulseTasks.expects(:puts).with(regexp_matches(/rails environment/i))
+        end
+
+        should "return false" do
+          assert !@output
+        end
+      end
+
+      context "given an optional HTTP proxy and valid options" do
+        setup do
+          @response         = stub("response",    :body => "stub body")
+          @http_proxy       = stub("proxy",       :request => @response)
+          @http_proxy_class = stub("proxy_class", :new => @http_proxy)
+          @post             = stub("post",        :set_form_data => nil)
+
+          Net::HTTP.expects(:Proxy).
+            with(Pulse.configuration.proxy_host,
+                 Pulse.configuration.proxy_port,
+                 Pulse.configuration.proxy_user,
+                 Pulse.configuration.proxy_pass).
+            returns(@http_proxy_class)
+          Net::HTTP::Post.expects(:new).with("/deploys.txt").returns(@post)
+
+          @options    = { :rails_env => "staging", :dry_run => false }
+        end
+
+        context "performing a dry run" do
+          setup { @output = PulseTasks.deploy(@options.merge(:dry_run => true)) }
+
+          should "return true without performing any actual request" do
+            assert_equal true, @output
+            assert_received(@http_proxy, :request) do |expects|
+              expects.never
+            end
+          end
+        end
+
+        context "on deploy(options)" do
+          setup do
+            @output = PulseTasks.deploy(@options)
+          end
+
+          before_should "post to http://errors.projectlocker.com:80/deploys.txt" do
+            @http_proxy_class.expects(:new).with("errors.projectlocker.com", 80).returns(@http_proxy)
+            @post.expects(:set_form_data).with(kind_of(Hash))
+            @http_proxy.expects(:request).with(any_parameters).returns(successful_response)
+          end
+
+          before_should "use the project api key" do
+            @post.expects(:set_form_data).
+              with(has_entries('api_key' => "1234123412341234"))
+          end
+
+          before_should "use send the rails_env param" do
+            @post.expects(:set_form_data).
+              with(has_entries("deploy[rails_env]" => "staging"))
+          end
+
+          [:local_username, :scm_repository, :scm_revision].each do |key|
+            before_should "use send the #{key} param if it's passed in." do
+              @options[key] = "value"
+              @post.expects(:set_form_data).
+                with(has_entries("deploy[#{key}]" => "value"))
+            end
+          end
+
+          before_should "use the :api_key param if it's passed in." do
+            @options[:api_key] = "value"
+            @post.expects(:set_form_data).
+              with(has_entries("api_key" => "value"))
+          end
+
+          before_should "puts the response body on success" do
+            PulseTasks.expects(:puts).with("body")
+            @http_proxy.expects(:request).with(any_parameters).returns(successful_response('body'))
+          end
+
+          before_should "puts the response body on failure" do
+            PulseTasks.expects(:puts).with("body")
+            @http_proxy.expects(:request).with(any_parameters).returns(unsuccessful_response('body'))
+          end
+
+          should "return false on failure", :before => lambda {
+            @http_proxy.expects(:request).with(any_parameters).returns(unsuccessful_response('body'))
+          } do
+            assert !@output
+          end
+
+          should "return true on success", :before => lambda {
+            @http_proxy.expects(:request).with(any_parameters).returns(successful_response('body'))
+          } do
+            assert @output
+          end
+        end
+      end
+    end
+
+    context "in a configured project with custom host" do
+      setup do
+        Pulse.configure do |config| 
+          config.api_key = "1234123412341234"
+          config.host = "custom.host"
+        end
+      end
+
+      context "on deploy(:rails_env => 'staging')" do
+        setup { @output = PulseTasks.deploy(:rails_env => "staging") }
+
+        before_should "post to the custom host" do
+          @post             = stub("post",     :set_form_data => nil)
+          @http_proxy       = stub("proxy",    :request => @response)
+
+          @http_proxy_class = stub("proxy_class", :new => @http_proxy)
+          @http_proxy_class.expects(:new).with("custom.host", 80).returns(@http_proxy)
+          Net::HTTP.expects(:Proxy).with(any_parameters).returns(@http_proxy_class)
+          Net::HTTP::Post.expects(:new).with("/deploys.txt").returns(@post)
+          @post.expects(:set_form_data).with(kind_of(Hash))
+          @http_proxy.expects(:request).with(any_parameters).returns(successful_response)
+        end
+      end
+    end
+
+    context "when not configured" do
+      setup { Pulse.configure { |config| config.api_key = "" } }
+
+      context "on deploy(:rails_env => 'staging')" do
+        setup { @output = PulseTasks.deploy(:rails_env => "staging") }
+
+        before_should "complain about missing api key" do
+          PulseTasks.expects(:puts).with(regexp_matches(/api key/i))
+        end
+
+        should "return false" do
+          assert !@output
+        end
+      end
+    end
+  end
+end

data/test/pulse.xsd

@@ -0,0 +1,88 @@
+<?xml version="1.0"?>
+<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
+
+  <xs:element name="notice">
+    <xs:complexType>
+      <xs:all>
+        <xs:element name="api-key" type="xs:string"/>
+        <xs:element name="notifier" type="notifier"/>
+        <xs:element name="error" type="error"/>
+        <xs:element name="request" type="request" minOccurs="0"/>
+        <xs:element name="server-environment" type="serverEnvironment"/>
+        <xs:element name="current-user" type="current-user" minOccurs="0"/>
+      </xs:all>
+      <xs:attribute name="version" type="xs:string" use="required"/>
+    </xs:complexType>
+  </xs:element>
+
+  <xs:complexType name="notifier">
+    <xs:all>
+      <xs:element name="name" type="xs:string"/>
+      <xs:element name="version" type="xs:string"/>
+      <xs:element name="url" type="xs:string"/>
+    </xs:all>
+  </xs:complexType>
+
+  <xs:complexType name="error">
+    <xs:all>
+      <xs:element name="class" type="xs:string"/>
+      <xs:element name="message" type="xs:string" minOccurs="0"/>
+      <xs:element name="backtrace" type="backtrace"/>
+    </xs:all>
+  </xs:complexType>
+
+  <xs:complexType name="backtrace">
+    <xs:sequence>
+      <xs:element name="line" maxOccurs="unbounded" minOccurs="0">
+        <xs:complexType>
+          <xs:attribute name="file" type="xs:string" use="required"/>
+          <xs:attribute name="number" type="xs:string" use="required"/>
+          <xs:attribute name="method" type="xs:string" use="optional"/>
+        </xs:complexType>
+      </xs:element>
+    </xs:sequence>
+  </xs:complexType>
+
+  <xs:complexType name="request">
+    <xs:all>
+      <xs:element name="url" type="xs:string"/>
+      <xs:element name="component" type="xs:string"/>
+      <xs:element name="action" type="xs:string" minOccurs="0"/>
+      <xs:element name="params" type="varList" minOccurs="0"/>
+      <xs:element name="session" type="varList" minOccurs="0"/>
+      <xs:element name="cgi-data" type="varList" minOccurs="0"/>
+    </xs:all>
+  </xs:complexType>
+
+  <xs:complexType name="varList">
+    <xs:sequence>
+      <xs:element name="var" type="var" maxOccurs="unbounded"/>
+    </xs:sequence>
+  </xs:complexType>
+
+  <xs:complexType name="var" mixed="true">
+    <xs:sequence>
+      <xs:element name="var" type="var" minOccurs="0" maxOccurs="unbounded"/>
+    </xs:sequence>
+    <xs:attribute name="key" type="xs:string" use="required"/>
+  </xs:complexType>
+
+  <xs:complexType name="serverEnvironment">
+    <xs:sequence>
+      <xs:element name="project-root" type="xs:string" minOccurs="0"/>
+      <xs:element name="environment-name" type="xs:string"/>
+      <xs:element name="app-version" type="xs:string" minOccurs="0"/>
+      <xs:element name="hostname" type="xs:string" minOccurs="0"/>
+    </xs:sequence>
+  </xs:complexType>
+
+  <xs:complexType name="current-user">
+    <xs:all>
+      <xs:element name="id" type="xs:string"/>
+      <xs:element name="name" type="xs:string" minOccurs="0"/>
+      <xs:element name="email" type="xs:string" minOccurs="0"/>
+      <xs:element name="username" type="xs:string" minOccurs="0"/>
+    </xs:all>
+  </xs:complexType>
+
+</xs:schema>

data/test/rack_test.rb

@@ -0,0 +1,58 @@
+require File.expand_path '../helper', __FILE__
+
+class RackTest < Test::Unit::TestCase
+
+  should "call the upstream app with the environment" do
+    environment = { 'key' => 'value' }
+    app = lambda { |env| ['response', {}, env] }
+    stack = Pulse::Rack.new(app)
+
+    response = stack.call(environment)
+
+    assert_equal ['response', {}, environment], response
+  end
+
+  should "deliver an exception raised while calling an upstream app" do
+    Pulse.stubs(:notify_or_ignore)
+
+    exception = build_exception
+    environment = { 'key' => 'value' }
+    app = lambda do |env|
+      raise exception
+    end
+
+    begin
+      stack = Pulse::Rack.new(app)
+      stack.call(environment)
+    rescue Exception => raised
+      assert_equal exception, raised
+    else
+      flunk "Didn't raise an exception"
+    end
+
+    assert_received(Pulse, :notify_or_ignore) do |expect|
+      expect.with(exception, :rack_env => environment)
+    end
+  end
+
+  should "deliver an exception in rack.exception" do
+    Pulse.stubs(:notify_or_ignore)
+    exception = build_exception
+    environment = { 'key' => 'value' }
+
+    response = [200, {}, ['okay']]
+    app = lambda do |env|
+      env['rack.exception'] = exception
+      response
+    end
+    stack = Pulse::Rack.new(app)
+
+    actual_response = stack.call(environment)
+
+    assert_equal response, actual_response
+    assert_received(Pulse, :notify_or_ignore) do |expect|
+      expect.with(exception, :rack_env => environment)
+    end
+  end
+
+end

data/test/rails_initializer_test.rb

@@ -0,0 +1,36 @@
+require File.expand_path '../helper', __FILE__
+
+require 'pulse/rails'
+
+class RailsInitializerTest < Test::Unit::TestCase
+  include DefinesConstants
+
+  should "trigger use of Rails' logger if logger isn't set and Rails' logger exists" do
+    rails = Module.new do
+      def self.logger
+        "RAILS LOGGER"
+      end
+    end
+    define_constant("Rails", rails)
+    Pulse::Rails.initialize
+    assert_equal "RAILS LOGGER", Pulse.logger
+  end
+
+  should "trigger use of Rails' default logger if logger isn't set and Rails.logger doesn't exist" do
+    define_constant("RAILS_DEFAULT_LOGGER", "RAILS DEFAULT LOGGER")
+
+    Pulse::Rails.initialize
+    assert_equal "RAILS DEFAULT LOGGER", Pulse.logger
+  end
+
+  should "allow overriding of the logger if already assigned" do
+    define_constant("RAILS_DEFAULT_LOGGER", "RAILS DEFAULT LOGGER")
+    Pulse::Rails.initialize
+
+    Pulse.configure(true) do |config|
+      config.logger = "OVERRIDDEN LOGGER"
+    end
+
+    assert_equal "OVERRIDDEN LOGGER", Pulse.logger
+  end
+end

data/test/recursion_test.rb

@@ -0,0 +1,10 @@
+require File.expand_path '../helper', __FILE__
+
+class RecursionTest < Test::Unit::TestCase
+  should "not allow infinite recursion" do
+    hash = {:a => :a}
+    hash[:hash] = hash
+    notice = Pulse::Notice.new(:parameters => hash)
+    assert_equal "[possible infinite recursion halted]", notice.parameters[:hash]
+  end
+end