chillout 0.2.0

data/test/dispatcher_test.rb

@@ -0,0 +1,68 @@
+require 'test_helper'
+
+class DispatcherTest < ChilloutTestCase
+
+  def test_error_dispatch
+    exception = build_exception(NameError)
+    env = {
+      "HTTP_USER_AGENT" => "Mozzila/4.0",
+      "rack.session" => {}
+    }
+    error = Chillout::Error.new(exception, env)
+
+    filter = mock("Filter")
+    filter.expects(:deliver_error?).with(error).returns(true)
+
+    server_side = mock("ServerSide")
+    server_side.expects(:send_error).with(error)
+
+    dispatcher = Chillout::Dispatcher.new(filter, server_side)
+    dispatcher.dispatch_error(error)
+  end
+
+  def test_ignored_error_dispatch
+    exception = build_exception(NameError)
+    env = {
+      "HTTP_USER_AGENT" => "Mozzila/4.0",
+      "rack.session" => {}
+    }
+    error = Chillout::Error.new(exception, env)
+
+    filter = mock("Filter")
+    filter.expects(:deliver_error?).with(error).returns(false)
+
+    server_side = mock("ServerSide")
+
+    dispatcher = Chillout::Dispatcher.new(filter, server_side)
+    dispatcher.dispatch_error(error)
+  end
+
+  def test_send_error_ignore_not_sent_exception
+    server_side = stub()
+    server_side.stubs(:send_error).raises(Chillout::HttpClient::NotSent.new(:http_error))
+
+    dispatcher = Chillout::Dispatcher.new(mock, server_side)
+
+    assert_nil dispatcher.send_error(:error)
+  end
+
+  def test_send_creations
+    filter = mock("Filter")
+
+    server_side = mock("ServerSide")
+    server_side.expects(:send_creations).with(:creations)
+
+    dispatcher = Chillout::Dispatcher.new(filter, server_side)
+    dispatcher.send_creations(:creations)
+  end
+
+  def test_send_creations_ignore_not_sent_exception
+    server_side = stub()
+    server_side.stubs(:send_creations).raises(Chillout::HttpClient::NotSent.new(:http_error))
+
+    dispatcher = Chillout::Dispatcher.new(mock, server_side)
+
+    assert_nil dispatcher.send_creations(:creations)
+  end
+
+end

data/test/error_test.rb

@@ -0,0 +1,115 @@
+require 'test_helper'
+
+class ErrorTest < ChilloutTestCase
+
+  def setup
+    @exception = build_exception(ArgumentError)
+    @env = { 'charset' => 'utf-8' }
+    @error = Chillout::Error.new(@exception, @env)
+  end
+
+  def test_exception_class
+    assert_equal "ArgumentError", @error.exception_class
+  end
+
+  def test_backtrace
+    assert_kind_of Array, @error.backtrace
+  end
+
+  def test_file
+    file = File.expand_path('../test_helper.rb', __FILE__)
+    assert_equal file, @error.file
+  end
+
+  context "controller is not given" do
+
+    def test_controller_name
+      assert_nil @error.controller_name
+    end
+
+    def test_controller_action
+      assert_nil @error.controller_action
+    end
+
+  end
+
+  context "controller is given" do
+
+    setup do
+      @controller = mock("controller")
+      @env['action_controller.instance'] = @controller
+    end
+
+    def test_controller_action_when_controller_is_set
+      @controller.expects(:action_name).returns("index")
+      assert_equal "index", @error.controller_action
+    end
+
+    def test_controller_name_when_controller_is_set
+      @controller.expects(:controller_name).returns("ApplicationController")
+      assert_equal "ApplicationController", @error.controller_name
+    end
+
+  end
+
+  context "current user is not given" do
+
+    def test_current_user_id
+      assert_nil @error.current_user_id
+    end
+
+    def test_current_user_email
+      assert_nil @error.current_user_email
+    end
+
+    def test_current_user_full_name
+      assert_nil @error.current_user_full_name
+    end
+
+  end
+
+  context "current user is given" do
+
+    setup do
+      @user = mock("user")
+      @env['current_user'] = @user
+    end
+
+    def test_current_user_id
+      @user.expects(:id).returns(123)
+      assert_equal 123, @error.current_user_id
+    end
+
+    def test_current_user_email
+      @user.expects(:email).returns("john@example.net")
+      assert_equal "john@example.net", @error.current_user_email
+    end
+
+    def test_current_user_full_name
+      @user.expects(:full_name).returns("john doe")
+      assert_equal "john doe", @error.current_user_full_name
+    end
+  end
+
+  context "current user is given but does not respond to expected methods" do
+
+    setup do
+      @user = mock("user")
+      @env['current_user'] = @user
+    end
+
+    def test_current_user_id
+      assert_nil @error.current_user_id
+    end
+
+    def test_current_user_email
+      assert_nil @error.current_user_email
+    end
+
+    def test_current_user_full_name
+      assert_nil @error.current_user_full_name
+    end
+
+  end
+
+end

data/test/event_data_builder_test.rb

@@ -0,0 +1,190 @@
+require 'test_helper'
+require 'chillout/event_data_builder'
+require 'chillout/creations_container'
+
+module Chillout
+  class EventDataBuilderTest < ChilloutTestCase
+    setup do
+      @shell_env = { 'PATH' => '/bin:/usr/bin' }
+      @api_key = "s3cr3t"
+
+      @config = Config.new(@api_key)
+      @config.shell_environment = @shell_env
+      @config.platform = "rails"
+      @config.environment = "development"
+      @config.notifier_name = "chillout"
+      @config.version = "0.1"
+      @config.notifier_url = "http://github.com/arkency/chillout"
+
+      @timestamp = Time.now.iso8601
+    end
+
+    context "build from error" do
+      setup do
+        @event_data_builder = EventDataBuilder.new(@config)
+
+        @controller = mock("Controller")
+        @controller.stubs(:controller_name).returns("UsersController")
+        @controller.stubs(:action_name).returns("index")
+
+        @current_user = mock("User")
+        @current_user.stubs(:id).returns(123)
+        @current_user.stubs(:email).returns("john@example.com")
+        @current_user.stubs(:full_name).returns("john doe")
+
+        @exception = build_exception(NameError, "FooBar does not exists")
+        @env = {
+          'HTTP_USER_AGENT' => 'Mozilla/4.0',
+          'action_controller.instance' => @controller,
+          'current_user' => @current_user
+        }
+        @error = Chillout::Error.new(@exception, @env)
+        @event_data = @event_data_builder.build_from_error(@error, @timestamp)
+      end
+
+      def test_event_type
+        assert_param :event, 'exception'
+      end
+
+      def test_timestamp
+        assert_param :timestamp, @timestamp
+      end
+
+      def test_exception_class
+        assert_content :class, 'NameError'
+      end
+
+      def test_exception_message
+        assert_content :message, 'FooBar does not exists'
+      end
+
+      def test_backtrace
+        assert_content :backtrace, @exception.backtrace
+      end
+
+      def test_file
+        assert_content :file, @error.file
+      end
+
+      def test_environment
+        assert_content :environment, "development"
+      end
+
+      def test_platform
+        assert_context :platform, "rails"
+      end
+
+      def test_controller
+        assert_context :controller, "UsersController"
+      end
+
+      def test_action
+        assert_context :controller, "UsersController"
+      end
+
+      def test_current_user_id
+        assert_current_user :id, 123
+      end
+
+      def test_current_user_email
+        assert_current_user :email, "john@example.com"
+      end
+
+      def test_current_user_full_name
+        assert_current_user :full_name, "john doe"
+      end
+
+      def test_rack_environment
+        expected_value = Hash[@env.collect { |k,v| [k, v.to_s] }]
+        assert_content :rack_environment, expected_value
+      end
+
+      def test_shell_environment
+        assert_content :shell_environment, @shell_env
+      end
+
+      def test_notifier_name
+        assert_notifier :name, "chillout"
+      end
+
+      def test_notifier_version
+        assert_notifier :version, "0.1"
+      end
+
+      def test_notifier_url
+        assert_notifier :url, "http://github.com/arkency/chillout"
+      end
+    end
+
+    context "build from creations container" do
+      setup do
+        @creations_container = CreationsContainer.new
+        5.times { @creations_container.increment!("User") }
+        3.times { @creations_container.increment!("Cart") }
+        8.times { @creations_container.increment!("CartItem") }
+
+        @event_data_builder = EventDataBuilder.new(@config)
+        @event_data = @event_data_builder.build_from_creations_container(@creations_container, @timestamp)
+      end
+
+      def test_metric_type
+        assert_param :metric, "creations"
+      end
+
+      def test_timestamp
+        assert_param :timestamp, @timestamp
+      end
+
+      def test_each_counter
+        assert_creations :User, 5
+        assert_creations :Cart, 3
+        assert_creations :CartItem, 8
+      end
+
+      def test_environment
+        assert_content :environment, "development"
+      end
+
+      def test_notifier_name
+        assert_notifier :name, "chillout"
+      end
+
+      def test_notifier_version
+        assert_notifier :version, "0.1"
+      end
+
+      def test_notifier_url
+        assert_notifier :url, "http://github.com/arkency/chillout"
+      end
+    end
+
+    private
+    def event_data
+      @event_data
+    end
+
+    def assert_param(key, value)
+      assert_equal value, event_data[key]
+    end
+
+    def assert_content(key, value)
+      assert_equal value, event_data[:content][key]
+    end
+
+    def assert_context(key, value)
+      assert_equal value, event_data[:content][:context][key]
+    end
+
+    def assert_creations(key, value)
+      assert_equal value, event_data[:content][:creations][key]
+    end
+
+    def assert_current_user(key, value)
+      assert_equal value, event_data[:content][:context][:current_user][key]
+    end
+
+    def assert_notifier(key, value)
+      assert_equal value, event_data[:notifier][key]
+    end
+  end
+end

data/test/http_client_test.rb

@@ -0,0 +1,13 @@
+require 'test_helper'
+
+module Chillout
+  class HttpClientTest < ChilloutTestCase
+    def test_post_raises_not_sent_exception_when_get_any_error
+      logger = stub(error: nil)
+      http_client = HttpClient.new(:wrong_config, logger)
+      assert_raises HttpClient::NotSent do
+        http_client.post("/events", {fake_data: "client"})
+      end
+    end
+  end
+end

data/test/integration/creations_monitor_rack_test.rb

@@ -0,0 +1,41 @@
+require 'test_helper'
+require 'chillout/creations_container'
+
+module Chillout
+  class CreationsMonitorRackTest < ChilloutTestCase
+    include Rack::Test::Methods
+
+    def setup
+      api_key = "xyz123"
+      stub_api_request(api_key, "metrics")
+      @config = Chillout::Config.new(api_key)
+      @config.ssl = false
+      @client = Chillout::Client.new(@config)
+    end
+
+    def app
+      client = @client
+      deepest_level = lambda do |env|
+        Thread.current[:creations] = CreationsContainer.new
+        2.times { Thread.current[:creations].increment!("User") }
+        3.times { Thread.current[:creations].increment!("Cart") }
+        [200, env, ['hello']]
+      end
+      Rack::Builder.new do
+        use Middleware::CreationsMonitor, client
+        run(deepest_level)
+      end
+    end
+
+    def test_creations_values
+      get "/"
+      assert_equal 2, request_body["content"]["creations"]["User"]
+      assert_equal 3, request_body["content"]["creations"]["Cart"]
+    end
+
+    private
+      def request_body
+        assert_request_body("metrics") { |body| return body }
+      end
+  end
+end

data/test/integration/exception_monitor_rack_test.rb

@@ -0,0 +1,51 @@
+require 'test_helper'
+
+class ExceptionMonitorRackTest < ChilloutTestCase
+  include Rack::Test::Methods
+
+  def setup
+    api_key = "xyz123"
+    stub_api_request(api_key, "events")
+    @config = Chillout::Config.new(api_key)
+    @config.ssl = false
+    @client = Chillout::Client.new(@config)
+  end
+
+  def app
+    client = @client # Only local variable can be passed to the block below
+    Rack::Builder.new do
+      use Chillout::Middleware::ExceptionMonitor, client
+      run(lambda { |env| raise ChilloutTestException.new("Something went wrong") })
+    end
+  end
+
+  def test_exception_class
+    trigger_error
+    assert_equal "ChilloutTestException", request_body["content"]["class"]
+  end
+
+  def test_exception_message
+    trigger_error
+    assert_equal "Something went wrong", request_body["content"]["message"]
+  end
+
+  def test_rack_environment
+    trigger_error
+    assert_request_body "events" do |body|
+      assert_equal last_request.env.keys, body["content"]["rack_environment"].keys
+    end
+  end
+
+  private
+  def trigger_error
+    begin
+      get "/"
+    rescue ChilloutTestException
+    end
+  end
+
+  def request_body
+    assert_request_body("events"){ |body| return body }
+  end
+
+end

data/test/integration/standalone_client_test.rb

@@ -0,0 +1,66 @@
+require 'test_helper'
+require 'webmock/minitest'
+
+class StandaloneClientTest < ChilloutTestCase
+
+  def setup
+    api_key = "xyz123"
+    stub_api_request(api_key, "events")
+    config  = Chillout::Config.new(api_key)
+    config.ssl = false
+    @client = Chillout::Client.new(config)
+    @error  = build_error(NameError, "FooBar is not defined")
+  end
+
+  def test_request_headers_contain_content_type
+    send_error
+    assert_request_headers 'events', 'Content-Type' => 'application/vnd.chillout.v1+json'
+  end
+
+  def test_request_body_contains_exception_class
+    send_error
+    assert_equal "NameError", request_body["content"]["class"]
+  end
+
+  def test_request_body_contains_exception_message
+    send_error
+    assert_equal "FooBar is not defined", request_body["content"]["message"]
+  end
+
+  def test_request_body_contains_event_type
+    send_error
+    assert_equal "exception", request_body["event"]
+  end
+
+  def test_request_body_contains_shell_environment
+    send_error
+    assert_equal ENV.to_hash, request_body["content"]["shell_environment"]
+  end
+
+  def test_request_body_contains_notifier_name
+    send_error
+    assert_equal "Chillout", request_body["notifier"]["name"]
+  end
+
+  def test_request_body_contains_notifier_version
+    send_error
+    assert_equal Chillout::VERSION, request_body["notifier"]["version"]
+  end
+
+  def test_allows_to_send_exceptions
+    exception = build_exception(ArgumentError, "wrong number of arguments")
+    @client.send_exception(exception)
+    assert_equal "ArgumentError", request_body["content"]["class"]
+    assert_equal "wrong number of arguments", request_body["content"]["message"]
+  end
+
+  private
+  def send_error
+    @client.send_error(@error)
+  end
+
+  def request_body
+    assert_request_body("events") { |body| return body }
+  end
+
+end

data/test/middleware/creations_monitor_test.rb

@@ -0,0 +1,50 @@
+require 'test_helper'
+
+module Chillout
+  module Middleware
+    class CreationsMonitorTest < ChilloutTestCase
+      setup do
+        @env = { 'HOST' => 'example.net' }
+        @client = mock()
+      end
+
+      context "for call with model creation" do
+        setup do
+          @app = lambda do |env|
+            Thread.current[:creations] = :creations
+            [200, env, ['hello']]
+          end
+          @middleware = CreationsMonitor.new(@app, @client)
+        end
+
+        def test_behaves_like_rack_middleware
+          @client.stubs(:send_creations)
+          response = @middleware.call(@env)
+
+          assert_equal [200, @env, ['hello']], response
+        end
+
+        def test_dispatch_creations_from_thread_current
+          @client.expects(:send_creations).with(:creations)
+
+          @middleware.call(@env)
+        end
+      end
+
+      context "for call without model creation" do
+        setup do
+          @app = lambda do |env|
+            [200, env, ['hello']]
+          end
+          @middleware = CreationsMonitor.new(@app, @client)
+        end
+
+        def test_behaves_like_rack_middleware
+          response = @middleware.call(@env)
+
+          assert_equal [200, @env, ['hello']], response
+        end
+      end
+    end
+  end
+end

data/test/middleware/exception_monitor_test.rb

@@ -0,0 +1,54 @@
+require 'test_helper'
+
+module Chillout
+  module Middleware
+    class ExceptionMonitorTest < ChilloutTestCase
+
+      class DummyError < StandardError; end
+
+      def test_behaves_like_rack_middleware
+        env        = { 'HOST' => 'example.net' }
+        app        = lambda { |env| [200, env, ['hello']] }
+        middleware = ExceptionMonitor.new(app, mock)
+
+        response = middleware.call(env)
+
+        assert_equal [200, env, ['hello']], response
+      end
+
+      def test_exception_is_raised
+        exception = build_exception(DummyError)
+        env = { 'HOST' => 'example.net' }
+        app = lambda do |env|
+          raise exception
+        end
+        dispatcher = mock("Dispatcher")
+        dispatcher.expects(:dispatch_error).with do |error|
+          error.exception == exception && error.environment == env
+        end
+
+        middleware = ExceptionMonitor.new(app, dispatcher)
+        assert_raises DummyError do
+          middleware.call(env)
+        end
+      end
+
+      def test_exception_is_found_in_rack_environment
+        exception = build_exception(DummyError)
+        env = { 'HOST' => 'example.net' }
+        app = lambda do |env|
+          env['rack.exception'] = exception
+          [200, env, ['hello']]
+        end
+        dispatcher = mock("Dispatcher")
+        dispatcher.expects(:dispatch_error).with do |error|
+          error.exception == exception && error.environment == env
+        end
+
+        middleware = ExceptionMonitor.new(app, dispatcher)
+        middleware.call(env)
+      end
+
+    end
+  end
+end

data/test/prefixed_logger_test.rb

@@ -0,0 +1,13 @@
+require 'test_helper'
+
+module Chillout
+  class PrefixedLoggerTest < ChilloutTestCase
+    def test_error_message_is_prefixed
+      output = StringIO.new
+      logger = Logger.new(output)
+      prefixed_logger = PrefixedLogger.new("[Chillout]", logger)
+      prefixed_logger.error "Someone is wrong on the internet"
+      assert_includes output.string, "[Chillout] Someone is wrong on the internet"
+    end
+  end
+end

data/test/server_side_test.rb

@@ -0,0 +1,35 @@
+require 'test_helper'
+require 'time'
+
+class ServerSideTest < ChilloutTestCase
+
+  def setup
+    @event_data_builder = mock("EventDataBuilder")
+    @http_client = mock("HttpClient")
+    @server_side = Chillout::ServerSide.new(@event_data_builder, @http_client)
+  end
+
+  def test_send_error_use_event_data_builder
+    @event_data_builder.expects(:build_from_error).with(:error, anything).returns(:event_data_from_builder)
+    @http_client.stubs(:post)
+    @server_side.send_error(:error)
+  end
+
+  def test_send_error_use_http_client
+    @event_data_builder.stubs(:build_from_error).returns(:event_data_from_builder)
+    @http_client.expects(:post).with('/events', :event_data_from_builder)
+    @server_side.send_error(:error)
+  end
+
+  def test_send_creations_use_event_data_builder
+    @event_data_builder.expects(:build_from_creations_container).with(:creations_container, anything).returns(:event_data_from_builder)
+    @http_client.stubs(:post)
+    @server_side.send_creations(:creations_container)
+  end
+
+  def test_send_creations_use_http_client
+    @event_data_builder.stubs(:build_from_creations_container).returns(:event_data_from_builder)
+    @http_client.expects(:post).with('/metrics', :event_data_from_builder)
+    @server_side.send_creations(:creations_container)
+  end
+end