riscfuture-hoptoad_notifier 2.3.6

data/test/configuration_test.rb

@@ -0,0 +1,209 @@
+require File.dirname(__FILE__) + '/helper'
+
+class ConfigurationTest < Test::Unit::TestCase
+
+  include DefinesConstants
+
+  should "provide default values" do
+    assert_config_default :proxy_host,          nil
+    assert_config_default :proxy_port,          nil
+    assert_config_default :proxy_user,          nil
+    assert_config_default :proxy_pass,          nil
+    assert_config_default :project_root,        nil
+    assert_config_default :environment_name,    nil
+    assert_config_default :logger,              nil
+    assert_config_default :notifier_version,    HoptoadNotifier::VERSION
+    assert_config_default :notifier_name,       'Hoptoad Notifier'
+    assert_config_default :notifier_url,        'http://hoptoadapp.com'
+    assert_config_default :secure,              false
+    assert_config_default :host,                'hoptoadapp.com'
+    assert_config_default :http_open_timeout,   2
+    assert_config_default :http_read_timeout,   5
+    assert_config_default :ignore_by_filters,   []
+    assert_config_default :ignore_user_agent,   []
+    assert_config_default :params_filters,
+                          HoptoadNotifier::Configuration::DEFAULT_PARAMS_FILTERS
+    assert_config_default :backtrace_filters,
+                          HoptoadNotifier::Configuration::DEFAULT_BACKTRACE_FILTERS
+    assert_config_default :ignore,
+                          HoptoadNotifier::Configuration::IGNORE_DEFAULT
+    assert_config_default :development_lookup, true
+    assert_config_default :framework, 'Standalone'
+    assert_config_default :js_notifier, false
+  end
+
+  should "provide default values for secure connections" do
+    config = HoptoadNotifier::Configuration.new
+    config.secure = true
+    assert_equal 443, config.port
+    assert_equal 'https', config.protocol
+  end
+
+  should "provide default values for insecure connections" do
+    config = HoptoadNotifier::Configuration.new
+    config.secure = false
+    assert_equal 80, config.port
+    assert_equal 'http', config.protocol
+  end
+
+  should "not cache inferred ports" do
+    config = HoptoadNotifier::Configuration.new
+    config.secure = false
+    config.port
+    config.secure = true
+    assert_equal 443, config.port
+  end
+
+  should "allow values to be overwritten" do
+    assert_config_overridable :proxy_host
+    assert_config_overridable :proxy_port
+    assert_config_overridable :proxy_user
+    assert_config_overridable :proxy_pass
+    assert_config_overridable :secure
+    assert_config_overridable :host
+    assert_config_overridable :port
+    assert_config_overridable :http_open_timeout
+    assert_config_overridable :http_read_timeout
+    assert_config_overridable :project_root
+    assert_config_overridable :notifier_version
+    assert_config_overridable :notifier_name
+    assert_config_overridable :notifier_url
+    assert_config_overridable :environment_name
+    assert_config_overridable :development_lookup
+    assert_config_overridable :logger
+  end
+
+  should "have an api key" do
+    assert_config_overridable :api_key
+  end
+
+  should "act like a hash" do
+    config = HoptoadNotifier::Configuration.new
+    hash = config.to_hash
+    [:api_key, :backtrace_filters, :development_environments,
+     :environment_name, :host, :http_open_timeout,
+     :http_read_timeout, :ignore, :ignore_by_filters, :ignore_user_agent,
+     :notifier_name, :notifier_url, :notifier_version, :params_filters,
+     :project_root, :port, :protocol, :proxy_host, :proxy_pass, :proxy_port,
+     :proxy_user, :secure, :development_lookup, :js_notifier].each do |option|
+      assert_equal config[option], hash[option], "Wrong value for #{option}"
+    end
+  end
+
+  should "be mergable" do
+    config = HoptoadNotifier::Configuration.new
+    hash = config.to_hash
+    assert_equal hash.merge(:key => 'value'), config.merge(:key => 'value')
+  end
+
+  should "allow param filters to be appended" do
+    assert_appends_value :params_filters
+  end
+
+  should "warn when attempting to read environment filters" do
+    config = HoptoadNotifier::Configuration.new
+    config.
+      expects(:warn).
+      with(regexp_matches(/deprecated/i))
+    assert_equal [], config.environment_filters
+  end
+
+  should "allow ignored user agents to be appended" do
+    assert_appends_value :ignore_user_agent
+  end
+
+  should "allow backtrace filters to be appended" do
+    assert_appends_value(:backtrace_filters) do |config|
+      new_filter = lambda {}
+      config.filter_backtrace(&new_filter)
+      new_filter
+    end
+  end
+
+  should "allow ignore by filters to be appended" do
+    assert_appends_value(:ignore_by_filters) do |config|
+      new_filter = lambda {}
+      config.ignore_by_filter(&new_filter)
+      new_filter
+    end
+  end
+
+  should "allow ignored exceptions to be appended" do
+    config = HoptoadNotifier::Configuration.new
+    original_filters = config.ignore.dup
+    new_filter = 'hello'
+    config.ignore << new_filter
+    assert_same_elements original_filters + [new_filter], config.ignore
+  end
+
+  should "allow ignored exceptions to be replaced" do
+    assert_replaces(:ignore, :ignore_only=)
+  end
+
+  should "allow ignored user agents to be replaced" do
+    assert_replaces(:ignore_user_agent, :ignore_user_agent_only=)
+  end
+
+  should "use development and test as development environments by default" do
+    config = HoptoadNotifier::Configuration.new
+    assert_same_elements %w(development test cucumber), config.development_environments
+  end
+
+  should "be public in a public environment" do
+    config = HoptoadNotifier::Configuration.new
+    config.development_environments = %w(development)
+    config.environment_name = 'production'
+    assert config.public?
+  end
+
+  should "not be public in a development environment" do
+    config = HoptoadNotifier::Configuration.new
+    config.development_environments = %w(staging)
+    config.environment_name = 'staging'
+    assert !config.public?
+  end
+
+  should "be public without an environment name" do
+    config = HoptoadNotifier::Configuration.new
+    assert config.public?
+  end
+
+  should "use the assigned logger if set" do
+    config = HoptoadNotifier::Configuration.new
+    config.logger = "CUSTOM LOGGER"
+    assert_equal "CUSTOM LOGGER", config.logger
+  end
+
+  def assert_config_default(option, default_value, config = nil)
+    config ||= HoptoadNotifier::Configuration.new
+    assert_equal default_value, config.send(option)
+  end
+
+  def assert_config_overridable(option, value = 'a value')
+    config = HoptoadNotifier::Configuration.new
+    config.send(:"#{option}=", value)
+    assert_equal value, config.send(option)
+  end
+
+  def assert_appends_value(option, &block)
+    config = HoptoadNotifier::Configuration.new
+    original_values = config.send(option).dup
+    block ||= lambda do |config|
+      new_value = 'hello'
+      config.send(option) << new_value
+      new_value
+    end
+    new_value = block.call(config)
+    assert_same_elements original_values + [new_value], config.send(option)
+  end
+
+  def assert_replaces(option, setter)
+    config = HoptoadNotifier::Configuration.new
+    new_value = 'hello'
+    config.send(setter, [new_value])
+    assert_equal [new_value], config.send(option)
+    config.send(setter, new_value)
+    assert_equal [new_value], config.send(option)
+  end
+
+end

data/test/helper.rb

@@ -0,0 +1,239 @@
+require 'test/unit'
+require 'rubygems'
+
+gem 'jferris-mocha', '>= 0.9.5.0.1241126838'
+
+$LOAD_PATH << File.join(File.dirname(__FILE__), *%w[.. vendor ginger lib])
+$LOAD_PATH << File.expand_path(File.join(File.dirname(__FILE__), "..", "lib"))
+
+require 'shoulda'
+require 'mocha'
+
+require 'ginger'
+
+require 'action_controller'
+require 'action_controller/test_process'
+require 'active_record'
+require 'active_record/base'
+require 'active_support'
+require 'nokogiri'
+require 'rack'
+
+require "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
+

data/test/hoptoad_tasks_test.rb

@@ -0,0 +1,152 @@
+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 an optional HTTP proxy and valid options" do
+        setup do
+          @response   = stub("response", :body => "stub body")
+          @http_proxy = stub("proxy", :post_form => @response)
+
+          Net::HTTP.expects(:Proxy).
+            with(HoptoadNotifier.configuration.proxy_host,
+                 HoptoadNotifier.configuration.proxy_port,
+                 HoptoadNotifier.configuration.proxy_user,
+                 HoptoadNotifier.configuration.proxy_pass).
+            returns(@http_proxy)
+
+          @options    = { :rails_env => "staging" }
+        end
+
+        context "on deploy(options)" do
+          setup do
+            @output = HoptoadTasks.deploy(@options)
+          end
+
+          before_should "post to http://hoptoadapp.com/deploys.txt" do
+            URI.stubs(:parse).with('http://hoptoadapp.com/deploys.txt').returns(:uri)
+            @http_proxy.expects(:post_form).with(:uri, kind_of(Hash)).returns(successful_response)
+          end
+
+          before_should "use the project api key" do
+            @http_proxy.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
+            @http_proxy.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"
+              @http_proxy.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"
+            @http_proxy.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")
+            @http_proxy.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")
+            @http_proxy.expects(:post_form).with(any_parameters).returns(unsuccessful_response('body'))
+          end
+
+          should "return false on failure", :before => lambda {
+            @http_proxy.expects(:post_form).with(any_parameters).returns(unsuccessful_response('body'))
+          } do
+            assert !@output
+          end
+
+          should "return true on success", :before => lambda {
+            @http_proxy.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