hoptoad_notifier 2.1.0

data/test/helper.rb

@@ -0,0 +1,237 @@
+require 'test/unit'
+require 'rubygems'
+
+gem 'jferris-mocha', '0.9.5.0.1241126838'
+
+require 'shoulda'
+require 'mocha'
+
+$LOAD_PATH << File.join(File.dirname(__FILE__), *%w[.. vendor ginger lib])
+require 'ginger'
+
+require 'action_controller'
+require 'action_controller/test_process'
+require 'active_record'
+require 'active_record/base'
+require 'active_support'
+require 'nokogiri'
+
+require File.join(File.dirname(__FILE__), "..", "lib", "hoptoad_notifier")
+
+begin require 'redgreen'; rescue LoadError; end
+
+module TestMethods
+  def rescue_action e
+    raise e
+  end
+
+  def do_raise
+    raise "Hoptoad"
+  end
+
+  def do_not_raise
+    render :text => "Success"
+  end
+
+  def do_raise_ignored
+    raise ActiveRecord::RecordNotFound.new("404")
+  end
+
+  def do_raise_not_ignored
+    raise ActiveRecord::StatementInvalid.new("Statement invalid")
+  end
+
+  def manual_notify
+    notify_hoptoad(Exception.new)
+    render :text => "Success"
+  end
+
+  def manual_notify_ignored
+    notify_hoptoad(ActiveRecord::RecordNotFound.new("404"))
+    render :text => "Success"
+  end
+end
+
+class HoptoadController < ActionController::Base
+  include TestMethods
+end
+
+class Test::Unit::TestCase
+  def request(action = nil, method = :get, user_agent = nil, params = {})
+    @request = ActionController::TestRequest.new
+    @request.action = action ? action.to_s : ""
+
+    if user_agent
+      if @request.respond_to?(:user_agent=)
+        @request.user_agent = user_agent
+      else
+        @request.env["HTTP_USER_AGENT"] = user_agent
+      end
+    end
+    @request.query_parameters = @request.query_parameters.merge(params)
+    @response = ActionController::TestResponse.new
+    @controller.process(@request, @response)
+  end
+
+  # Borrowed from ActiveSupport 2.3.2
+  def assert_difference(expression, difference = 1, message = nil, &block)
+    b = block.send(:binding)
+    exps = Array.wrap(expression)
+    before = exps.map { |e| eval(e, b) }
+
+    yield
+
+    exps.each_with_index do |e, i|
+      error = "#{e.inspect} didn't change by #{difference}"
+      error = "#{message}.\n#{error}" if message
+      assert_equal(before[i] + difference, eval(e, b), error)
+    end
+  end
+
+  def assert_no_difference(expression, message = nil, &block)
+    assert_difference expression, 0, message, &block
+  end
+
+  def stub_sender
+    stub('sender', :send_to_hoptoad => nil)
+  end
+
+  def stub_sender!
+    HoptoadNotifier.sender = stub_sender
+  end
+
+  def stub_notice
+    stub('notice', :to_xml => 'some yaml', :ignore? => false)
+  end
+
+  def stub_notice!
+    returning stub_notice do |notice|
+      HoptoadNotifier::Notice.stubs(:new => notice)
+    end
+  end
+
+  def create_dummy
+    HoptoadNotifier::DummySender.new
+  end
+
+  def reset_config
+    HoptoadNotifier.configuration = nil
+    HoptoadNotifier.configure do |config|
+      config.api_key = 'abc123'
+    end
+  end
+
+  def clear_backtrace_filters
+    HoptoadNotifier.configuration.backtrace_filters.clear
+  end
+
+  def build_exception
+    raise
+  rescue => caught_exception
+    caught_exception
+  end
+
+  def build_notice_data(exception = nil)
+    exception ||= build_exception
+    {
+      :api_key       => 'abc123',
+      :error_class   => exception.class.name,
+      :error_message => "#{exception.class.name}: #{exception.message}",
+      :backtrace     => exception.backtrace,
+      :environment   => { 'PATH' => '/bin', 'REQUEST_URI' => '/users/1' },
+      :request       => {
+        :params     => { 'controller' => 'users', 'action' => 'show', 'id' => '1' },
+        :rails_root => '/path/to/application',
+        :url        => "http://test.host/users/1"
+      },
+      :session       => {
+        :key  => '123abc',
+        :data => { 'user_id' => '5', 'flash' => { 'notice' => 'Logged in successfully' } }
+      }
+    }
+  end
+
+  def assert_caught_and_sent
+    assert !HoptoadNotifier.sender.collected.empty?
+  end
+
+  def assert_caught_and_not_sent
+    assert HoptoadNotifier.sender.collected.empty?
+  end
+
+  def assert_array_starts_with(expected, actual)
+    assert_respond_to actual, :to_ary
+    array = actual.to_ary.reverse
+    expected.reverse.each_with_index do |value, i|
+      assert_equal value, array[i]
+    end
+  end
+
+  def assert_valid_node(document, xpath, content)
+    nodes = document.xpath(xpath)
+    assert nodes.any?{|node| node.content == content },
+           "Expected xpath #{xpath} to have content #{content}, " +
+           "but found #{nodes.map { |n| n.content }} in #{nodes.size} matching nodes." +
+           "Document:\n#{document.to_s}"
+  end
+end
+
+module DefinesConstants
+  def setup
+    @defined_constants = []
+  end
+
+  def teardown
+    @defined_constants.each do |constant|
+      Object.__send__(:remove_const, constant)
+    end
+  end
+
+  def define_constant(name, value)
+    Object.const_set(name, value)
+    @defined_constants << name
+  end
+end
+
+# Also stolen from AS 2.3.2
+class Array
+  # Wraps the object in an Array unless it's an Array.  Converts the
+  # object to an Array using #to_ary if it implements that.
+  def self.wrap(object)
+    case object
+    when nil
+      []
+    when self
+      object
+    else
+      if object.respond_to?(:to_ary)
+        object.to_ary
+      else
+        [object]
+      end
+    end
+  end
+
+end
+
+class CollectingSender
+  attr_reader :collected
+
+  def initialize
+    @collected = []
+  end
+
+  def send_to_hoptoad(data)
+    @collected << data
+  end
+end
+
+class FakeLogger
+  def info(*args);  end
+  def debug(*args); end
+  def warn(*args);  end
+  def error(*args); end
+  def fatal(*args); end
+end
+
+RAILS_DEFAULT_LOGGER = FakeLogger.new

data/test/hoptoad_tasks_test.rb

@@ -0,0 +1,138 @@
+require File.dirname(__FILE__) + '/helper'
+require 'rubygems'
+
+require File.dirname(__FILE__) + '/../lib/hoptoad_tasks'
+require 'fakeweb'
+
+FakeWeb.allow_net_connect = false
+
+class HoptoadTasksTest < 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 { HoptoadTasks.stubs(:puts) }
+
+    context "in a configured project" do
+      setup { HoptoadNotifier.configure { |config| config.api_key = "1234123412341234" } }
+
+      context "on deploy({})" do
+        setup { @output = HoptoadTasks.deploy({}) }
+
+        before_should "complain about missing rails env" do
+          HoptoadTasks.expects(:puts).with(regexp_matches(/rails environment/i))
+        end
+
+        should "return false" do
+          assert !@output
+        end
+      end
+
+      context "given valid options" do
+        setup { @options = {:rails_env => "staging"} }
+
+        context "on deploy(options)" do
+          setup { @output = HoptoadTasks.deploy(@options) }
+
+          before_should "post to http://hoptoadapp.com/deploys.txt" do
+            URI.stubs(:parse).with('http://hoptoadapp.com/deploys.txt').returns(:uri)
+            Net::HTTP.expects(:post_form).with(:uri, kind_of(Hash)).returns(successful_response)
+          end
+
+          before_should "use the project api key" do
+            Net::HTTP.expects(:post_form).
+              with(kind_of(URI), has_entries('api_key' => "1234123412341234")).
+              returns(successful_response)
+          end
+
+          before_should "use send the rails_env param" do
+            Net::HTTP.expects(:post_form).
+              with(kind_of(URI), has_entries("deploy[rails_env]" => "staging")).
+              returns(successful_response)
+          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"
+              Net::HTTP.expects(:post_form).
+                with(kind_of(URI), has_entries("deploy[#{key}]" => "value")).
+                returns(successful_response)
+            end
+          end
+
+          before_should "use the :api_key param if it's passed in." do
+            @options[:api_key] = "value"
+            Net::HTTP.expects(:post_form).
+              with(kind_of(URI), has_entries("api_key" => "value")).
+              returns(successful_response)
+          end
+
+          before_should "puts the response body on success" do
+            HoptoadTasks.expects(:puts).with("body")
+            Net::HTTP.expects(:post_form).with(any_parameters).returns(successful_response('body'))
+          end
+
+          before_should "puts the response body on failure" do
+            HoptoadTasks.expects(:puts).with("body")
+            Net::HTTP.expects(:post_form).with(any_parameters).returns(unsuccessful_response('body'))
+          end
+
+          should "return false on failure", :before => lambda {
+            Net::HTTP.expects(:post_form).with(any_parameters).returns(unsuccessful_response('body'))
+          } do
+            assert !@output
+          end
+
+          should "return true on success", :before => lambda {
+            Net::HTTP.expects(:post_form).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
+        HoptoadNotifier.configure do |config| 
+          config.api_key = "1234123412341234"
+          config.host = "custom.host"
+        end
+      end
+
+      context "on deploy(:rails_env => 'staging')" do
+        setup { @output = HoptoadTasks.deploy(:rails_env => "staging") }
+
+        before_should "post to the custom host" do
+          URI.stubs(:parse).with('http://custom.host/deploys.txt').returns(:uri)
+          Net::HTTP.expects(:post_form).with(:uri, kind_of(Hash)).returns(successful_response)
+        end
+      end
+    end
+
+    context "when not configured" do
+      setup { HoptoadNotifier.configure { |config| config.api_key = "" } }
+
+      context "on deploy(:rails_env => 'staging')" do
+        setup { @output = HoptoadTasks.deploy(:rails_env => "staging") }
+
+        before_should "complain about missing api key" do
+          HoptoadTasks.expects(:puts).with(regexp_matches(/api key/i))
+        end
+
+        should "return false" do
+          assert !@output
+        end
+      end
+    end
+  end
+end

data/test/logger_test.rb

@@ -0,0 +1,85 @@
+require File.dirname(__FILE__) + '/helper'
+
+class LoggerTest < Test::Unit::TestCase
+  def stub_http(response, body = nil)
+    response.stubs(:body => body) if body
+    @http = stub(:post => response,
+                 :read_timeout= => nil,
+                 :open_timeout= => nil,
+                 :use_ssl= => nil)
+    Net::HTTP.stubs(:new).returns(@http)
+  end
+
+  def send_notice
+    HoptoadNotifier.sender.send_to_hoptoad('data')
+  end
+
+  def stub_verbose_log
+    HoptoadNotifier.stubs(:write_verbose_log)
+  end
+
+  def assert_logged(expected)
+    assert_received(HoptoadNotifier, :write_verbose_log) do |expect|
+      expect.with {|actual| actual =~ expected }
+    end
+  end
+
+  def assert_not_logged(expected)
+    assert_received(HoptoadNotifier, :write_verbose_log) do |expect|
+      expect.with {|actual| actual =~ expected }.never
+    end
+  end
+
+  def configure
+    HoptoadNotifier.configure { |config| }
+  end
+
+  should "report that notifier is ready when configured" do
+    stub_verbose_log
+    configure
+    assert_logged /Notifier (.*) ready/
+  end
+
+  should "not report that notifier is ready when internally configured" do
+    stub_verbose_log
+    HoptoadNotifier.configure(true) { |config| }
+    assert_not_logged /.*/
+  end
+
+  should "print environment info a successful notification without a body" do
+    reset_config
+    stub_verbose_log
+    stub_http(Net::HTTPSuccess)
+    send_notice
+    assert_logged /Environment Info:/
+    assert_not_logged /Response from Hoptoad:/
+  end
+
+  should "print environment info on a failed notification without a body" do
+    reset_config
+    stub_verbose_log
+    stub_http(Net::HTTPError)
+    send_notice
+    assert_logged /Environment Info:/
+    assert_not_logged /Response from Hoptoad:/
+  end
+
+  should "print environment info and response on a success with a body" do
+    reset_config
+    stub_verbose_log
+    stub_http(Net::HTTPSuccess, 'test')
+    send_notice
+    assert_logged /Environment Info:/
+    assert_logged /Response from Hoptoad:/
+  end
+
+  should "print environment info and response on a failure with a body" do
+    reset_config
+    stub_verbose_log
+    stub_http(Net::HTTPError, 'test')
+    send_notice
+    assert_logged /Environment Info:/
+    assert_logged /Response from Hoptoad:/
+  end
+
+end