airbrake 3.1.6 → 3.1.7

data/test/configuration_test.rb

@@ -31,6 +31,7 @@ class ConfigurationTest < Test::Unit::TestCase
     assert_config_default :development_lookup, true
     assert_config_default :framework, 'Standalone'
     assert_config_default :async, nil
+    assert_config_default :project_id, nil
   end
 
   should "set GirlFriday-callable for async=true" do
@@ -86,6 +87,7 @@ class ConfigurationTest < Test::Unit::TestCase
     assert_config_overridable :development_lookup
     assert_config_overridable :logger
     assert_config_overridable :async
+    assert_config_overridable :project_id
   end
 
   should "have an api key" do

data/test/helper.rb

@@ -1,5 +1,3 @@
-require 'simplecov'
-SimpleCov.start
 require 'test/unit'
 require 'rubygems'
 
@@ -10,19 +8,140 @@ require 'thread'
 require 'shoulda'
 require 'mocha'
 
+require 'abstract_controller'
 require 'action_controller'
-require 'action_controller/test_process'
+require 'action_dispatch'
+require 'active_support/dependencies'
+require 'active_model'
 require 'active_record'
-require 'active_support'
+require 'active_support/core_ext/kernel/reporting'
+
 require 'nokogiri'
 require 'rack'
 require 'bourne'
 require 'sham_rack'
+require 'json-schema'
 
 require "airbrake"
 
 begin require 'redgreen'; rescue LoadError; end
 
+# Show backtraces for deprecated behavior for quicker cleanup.
+ActiveSupport::Deprecation.debug = true
+
+FIXTURE_LOAD_PATH = File.join(File.dirname(__FILE__), 'fixtures')
+FIXTURES = Pathname.new(FIXTURE_LOAD_PATH)
+
+SharedTestRoutes = ActionDispatch::Routing::RouteSet.new
+
+class RoutedRackApp
+  attr_reader :routes
+
+  def initialize(routes, &blk)
+    @routes = routes
+    @stack = ActionDispatch::MiddlewareStack.new(&blk).build(@routes)
+  end
+
+  def call(env)
+    @stack.call(env)
+  end
+end
+
+class ActionDispatch::IntegrationTest < ActiveSupport::TestCase
+  setup do
+    @routes = SharedTestRoutes
+  end
+end
+
+class ActionController::IntegrationTest < ActiveSupport::TestCase
+  def self.build_app(routes = nil)
+    RoutedRackApp.new(routes || ActionDispatch::Routing::RouteSet.new) do |middleware|
+      middleware.use "ActionDispatch::Callbacks"
+      middleware.use "ActionDispatch::ParamsParser"
+      middleware.use "ActionDispatch::Cookies"
+      middleware.use "ActionDispatch::Flash"
+      middleware.use "ActionDispatch::Head"
+      yield(middleware) if block_given?
+    end
+  end
+
+  self.app = build_app
+
+  # Stub Rails dispatcher so it does not get controller references and
+  # simply return the controller#action as Rack::Body.
+  class StubDispatcher < ::ActionDispatch::Routing::RouteSet::Dispatcher
+    protected
+    def controller_reference(controller_param)
+      controller_param
+    end
+
+    def dispatch(controller, action, env)
+      [200, {'Content-Type' => 'text/html'}, ["#{controller}##{action}"]]
+    end
+  end
+
+  def self.stub_controllers
+    old_dispatcher = ActionDispatch::Routing::RouteSet::Dispatcher
+    ActionDispatch::Routing::RouteSet.module_eval { remove_const :Dispatcher }
+    ActionDispatch::Routing::RouteSet.module_eval { const_set :Dispatcher, StubDispatcher }
+    yield ActionDispatch::Routing::RouteSet.new
+  ensure
+    ActionDispatch::Routing::RouteSet.module_eval { remove_const :Dispatcher }
+    ActionDispatch::Routing::RouteSet.module_eval { const_set :Dispatcher, old_dispatcher }
+  end
+
+  def with_routing(&block)
+    temporary_routes = ActionDispatch::Routing::RouteSet.new
+    old_app, self.class.app = self.class.app, self.class.build_app(temporary_routes)
+    old_routes = SharedTestRoutes
+    silence_warnings { Object.const_set(:SharedTestRoutes, temporary_routes) }
+
+    yield temporary_routes
+  ensure
+    self.class.app = old_app
+    silence_warnings { Object.const_set(:SharedTestRoutes, old_routes) }
+  end
+
+  def with_autoload_path(path)
+    path = File.join(File.dirname(__FILE__), "fixtures", path)
+    if ActiveSupport::Dependencies.autoload_paths.include?(path)
+      yield
+    else
+      begin
+        ActiveSupport::Dependencies.autoload_paths << path
+        yield
+      ensure
+        ActiveSupport::Dependencies.autoload_paths.reject! {|p| p == path}
+        ActiveSupport::Dependencies.clear
+      end
+    end
+  end
+end
+
+module ActionController
+  class Base
+    include ActionController::Testing
+  end
+
+  Base.view_paths = FIXTURE_LOAD_PATH
+
+  class TestCase
+    include ActionDispatch::TestProcess
+
+    setup do
+      @routes = SharedTestRoutes
+    end
+  end
+end
+
+# This stub emulates the Railtie including the URL helpers from a Rails application
+module ActionController
+  class Base
+    include SharedTestRoutes.url_helpers
+  end
+end
+
+
 module TestMethods
   def rescue_action e
     raise e
@@ -56,41 +175,6 @@ module 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_airbrake => nil)
   end
@@ -109,10 +193,6 @@ class Test::Unit::TestCase
     end
   end
 
-  def create_dummy
-    Airbrake::DummySender.new
-  end
-
   def reset_config
     Airbrake.configuration = nil
     Airbrake.configure do |config|
@@ -187,8 +267,6 @@ class Test::Unit::TestCase
       expect.with {|actual| actual =~ expected }.never
     end
   end
-
-
 end
 
 module DefinesConstants
@@ -241,14 +319,6 @@ class CollectingSender
   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
-
 class BacktracedException < Exception
   attr_accessor :backtrace
   def initialize(opts)

data/test/notice_test.rb

@@ -61,12 +61,18 @@ class NoticeTest < Test::Unit::TestCase
   end
 
   def assert_valid_notice_document(document)
-    xsd_path = File.join(File.dirname(__FILE__), "airbrake_2_3.xsd")
+    xsd_path = File.expand_path(File.join(File.dirname(__FILE__),"..", "resources", "airbrake_2_4.xsd"))
     schema = Nokogiri::XML::Schema.new(IO.read(xsd_path))
     errors = schema.validate(document)
     assert errors.empty?, errors.collect{|e| e.message }.join
   end
 
+  def assert_valid_json(notice)
+    json_schema = File.expand_path(File.join(File.dirname(__FILE__),"..", "resources", "airbrake_3_0.json"))
+    errors = JSON::Validator.fully_validate(json_schema, notice)
+    assert errors.empty?, errors.join
+  end
+
   def assert_filters_hash(attribute)
     filters  = ["abc", :def]
     original = { 'abc' => "123", 'def' => "456", 'ghi' => "789", 'nested' => { 'abc' => '100' },
@@ -251,6 +257,15 @@ class NoticeTest < Test::Unit::TestCase
   should "filter session" do
     assert_filters_hash(:session_data)
   end
+  
+  should "should always remove a Rails application's secret token" do
+    original = {
+      "action_dispatch.secret_token" => "abc123xyz456",
+      "abc" => "123"
+    }
+    notice = build_notice(:cgi_data => original)
+    assert_equal({"abc" => "123"}, notice.cgi_data)
+  end
 
   should "remove rack.request.form_vars" do
     original = {
@@ -262,6 +277,34 @@ class NoticeTest < Test::Unit::TestCase
     assert_equal({"abc" => "123"}, notice.cgi_data)
   end
 
+  context "a Notice turned into JSON" do
+    setup do
+      @exception = build_exception
+
+      @notice = build_notice({
+        :notifier_name    => 'a name',
+        :notifier_version => '1.2.3',
+        :notifier_url     => 'http://some.url/path',
+        :exception        => @exception,
+        :controller       => "controller",
+        :action           => "action",
+        :url              => "http://url.com",
+        :parameters       => { "paramskey"     => "paramsvalue",
+                               "nestparentkey" => { "nestkey" => "nestvalue" } },
+        :session_data     => { "sessionkey" => "sessionvalue" },
+        :cgi_data         => { "cgikey" => "cgivalue" },
+        :project_root     => "RAILS_ROOT",
+        :environment_name => "RAILS_ENV"
+      })
+
+      @json = @notice.to_json
+    end
+
+    should "validate against the JSON schema" do
+      assert_valid_json @json
+    end
+  end
+
   context "a Notice turned into XML" do
     setup do
       Airbrake.configure do |config|
@@ -295,6 +338,7 @@ class NoticeTest < Test::Unit::TestCase
       assert_valid_notice_document @document
     end
 
+
     should "serialize a Notice to XML when sent #to_xml" do
       assert_valid_node(@document, "//api-key", @notice.api_key)
 

data/test/sender_test.rb

@@ -31,32 +31,6 @@ class SenderTest < Test::Unit::TestCase
     http
   end
 
-  should "post to Airbrake with XML passed" do
-    xml_notice = Airbrake::Notice.new(:error_class => "FooBar", :error_message => "Foo Bar").to_xml
-
-    http = stub_http
-
-    sender = build_sender
-    sender.send_to_airbrake(xml_notice)
-
-    assert_received(http, :post) do |expect|
-      expect.with(anything, xml_notice, Airbrake::HEADERS)
-    end
-  end
-
-  should "post to Airbrake with a Notice instance passed" do
-    notice = Airbrake::Notice.new(:error_class => "FooBar", :error_message => "Foo Bar")
-
-    http = stub_http
-
-    sender = build_sender
-    sender.send_to_airbrake(notice)
-
-    assert_received(http, :post) do |expect|
-      expect.with(anything, notice.to_xml, Airbrake::HEADERS)
-    end
-  end
-
   should "post to Airbrake when using an HTTP proxy" do
     response = stub(:body => 'body')
     http     = stub(:post          => response,
@@ -79,7 +53,7 @@ class SenderTest < Test::Unit::TestCase
                    :proxy_user => proxy_user,
                    :proxy_pass => proxy_pass)
     assert_received(http, :post) do |expect|
-      expect.with(uri.path, anything, Airbrake::HEADERS)
+      expect.with(uri.path, anything, Airbrake::Sender::HEADERS[:xml])
     end
     assert_received(Net::HTTP, :Proxy) do |expect|
       expect.with(proxy_host, proxy_port, proxy_user, proxy_pass)
@@ -91,6 +65,66 @@ class SenderTest < Test::Unit::TestCase
     assert_equal "3799307", send_exception(:secure => false)
   end
 
+  context "when using the XML API" do
+
+    should "post to Airbrake with XML passed" do
+      xml_notice = Airbrake::Notice.new(:error_class => "FooBar", :error_message => "Foo Bar").to_xml
+
+      http = stub_http
+
+      sender = build_sender
+      sender.send_to_airbrake(xml_notice)
+
+      assert_received(http, :post) do |expect|
+        expect.with(anything, xml_notice, Airbrake::Sender::HEADERS[:xml])
+      end
+    end
+
+    should "post to Airbrake with a Notice instance passed" do
+      notice = Airbrake::Notice.new(:error_class => "FooBar", :error_message => "Foo Bar")
+
+      http = stub_http
+
+      sender = build_sender
+      sender.send_to_airbrake(notice)
+
+      assert_received(http, :post) do |expect|
+        expect.with(anything, notice.to_xml, Airbrake::Sender::HEADERS[:xml])
+      end
+    end
+
+  end
+
+  context "when using new JSON API" do
+    should "post to Airbrake with JSON passed" do
+      json_notice = Airbrake::Notice.new(:error_class => "FooBar", :error_message => "Foo Bar").to_json
+
+      http = stub_http
+
+      sender = build_sender(:project_id => "PROJECT_ID", :host => "collect.airbrake.io")
+      sender.send_to_airbrake(json_notice)
+
+      assert_received(http, :post) do |expect|
+        expect.with(anything, json_notice, Airbrake::Sender::HEADERS[:json])
+      end
+
+    end
+
+    should "post to Airbrake with notice passed" do
+      notice = Airbrake::Notice.new(:error_class => "FooBar", :error_message => "Foo Bar")
+
+      http = stub_http
+
+      sender = build_sender(:project_id => "PROJECT_ID", :host => "collect.airbrake.io")
+      sender.send_to_airbrake(notice)
+
+      assert_received(http, :post) do |expect|
+        expect.with(anything, notice.to_json, Airbrake::Sender::HEADERS[:json])
+      end
+
+    end
+  end
+
   context "when encountering exceptions: " do
     context "HTTP connection setup problems" do
       should "not be rescued" do
@@ -176,13 +210,13 @@ class SenderTest < Test::Unit::TestCase
       url = "http://api.airbrake.io:80#{Airbrake::Sender::NOTICES_URI}"
       uri = URI.parse(url)
       send_exception(:secure => false)
-      assert_received(http, :post) {|expect| expect.with(uri.path, anything, Airbrake::HEADERS) }
+      assert_received(http, :post) {|expect| expect.with(uri.path, anything, Airbrake::Sender::HEADERS[:xml]) }
     end
 
     should "post to the right path for ssl" do
       http = stub_http
       send_exception(:secure => true)
-      assert_received(http, :post) {|expect| expect.with(Airbrake::Sender::NOTICES_URI, anything, Airbrake::HEADERS) }
+      assert_received(http, :post) {|expect| expect.with(Airbrake::Sender::NOTICES_URI, anything, Airbrake::Sender::HEADERS[:xml]) }
     end
 
     should "verify the SSL peer when the use_ssl option is set to true" do
@@ -255,8 +289,6 @@ class SenderTest < Test::Unit::TestCase
       send_exception(:secure => false, :host => 'example.org')
       assert_received(Net::HTTP, :new) {|expect| expect.with('example.org', 80) }
     end
-
-
   end
 
   context "network timeouts" do
@@ -284,5 +316,4 @@ class SenderTest < Test::Unit::TestCase
       assert_received(http, :read_timeout=) {|expect| expect.with(10) }
     end
   end
-
 end