messagebus_ruby_api 0.4.0 → 0.4.4

data/spec/ruby/1.9.1/gems/fakeweb-1.3.0/test/vendor/samuel-0.2.1/LICENSE

@@ -0,0 +1,20 @@
+Copyright 2009 Chris Kampmeier
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/spec/ruby/1.9.1/gems/fakeweb-1.3.0/test/vendor/samuel-0.2.1/README.rdoc

@@ -0,0 +1,70 @@
+= Samuel
+
+Samuel is a gem for automatic logging of your Net::HTTP requests. It's named for
+the serial diarist Mr. Pepys, who was known to reliably record events both
+quotidian and remarkable.
+
+Should a Great Plague, Fire, or Whale befall an important external web service
+you use, you'll be sure to have a tidy record of it.
+
+== Usage:
+
+When Rails is loaded, Samuel configures a few things automatically. So all you
+need to do is this:
+
+  # config/environment.rb
+  config.gem "samuel"
+
+And Samuel will automatically use Rails's logger and an ActiveRecord-like format.
+
+For non-Rails projects, you'll have to manually configure logging, like this:
+
+  require 'samuel'
+  Samuel.logger = Logger.new('http_requests.log')
+
+If you don't assign a logger, Samuel will configure a default logger on +STDOUT+.
+
+== Configuration
+
+There are two ways to specify configuration options for Samuel: global and
+inline. Global configs look like this:
+
+  Samuel.config[:labels]          = {"example.com" => "Example API"}
+  Samuel.config[:filtered_params] = :password
+
+You should put global configuration somewhere early-on in your program. If
+you're using Rails, <tt>config/initializers/samuel.rb</tt> will do the trick.
+
+Alternatively, an inline configuration block temporarily overrides any global
+configuration for a set of HTTP requests:
+
+  Samuel.with_config :label => "Twitter API" do
+    Net::HTTP.start("twitter.com") { |http| http.get("/help/test") }
+  end
+
+Right now, there are three configuration changes you can make in either style:
+
+* +:labels+ - This is a hash with domain substrings as keys and log labels as
+  values. If a request domain includes one of the domain substrings, the
+  corresponding label will be used for the first part of that log entry. By
+  default this is set to <tt>\{"" => "HTTP"}</tt>, so that all requests are
+  labeled with <tt>"HTTP Request"</tt>.
+* +:label+ - As an alternative to the +:labels+ hash, this is simply a string.
+  If set, it takes precedence over any +:labels+ (by default, it's not set). It
+  gets <tt>"Request"</tt> appended to it as well -- so if you want your log to
+  always say +Twitter API Request+ instead of the default +HTTP Request+, you
+  can set this to <tt>"Twitter API"</tt>. I'd recommend using this setting
+  globally if you're only making requests to one service, or inline if you just
+  need to temporarily override the global +:labels+.
+* +:filtered_params+ - This works just like Rails's +filter_parameter_logging+
+  method. Set it to a symbol, string, or array of them, and Samuel will filter
+  the value of query parameters that have any of these patterns as a substring
+  by replacing the value with <tt>[FILTERED]</tt> in your logs. By default, no
+  filtering is enabled.
+
+Samuel logs successful HTTP requests at the +INFO+ level; Failed requests log at
+the +WARN+ level. This isn't currently configurable, but it's on the list.
+
+== License
+
+Copyright 2009 Chris Kampmeier. See +LICENSE+ for details.

data/spec/ruby/1.9.1/gems/fakeweb-1.3.0/test/vendor/samuel-0.2.1/Rakefile

@@ -0,0 +1,62 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "samuel"
+    gem.summary = %Q{An automatic logger for HTTP requests in Ruby}
+    gem.description = %Q{An automatic logger for HTTP requests in Ruby. Adds Net::HTTP request logging to your Rails logs, and more.}
+    gem.email = "chris@kampers.net"
+    gem.homepage = "http://github.com/chrisk/samuel"
+    gem.authors = ["Chris Kampmeier"]
+    gem.rubyforge_project = "samuel"
+    gem.add_development_dependency "thoughtbot-shoulda"
+    gem.add_development_dependency "yard"
+    gem.add_development_dependency "mocha"
+    gem.add_development_dependency "fakeweb"
+  end
+  Jeweler::GemcutterTasks.new
+  Jeweler::RubyforgeTasks.new do |rubyforge|
+    rubyforge.doc_task = "yardoc"
+  end
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: sudo gem install jeweler"
+end
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/*_test.rb'
+  test.verbose = false
+  test.warning = true
+end
+
+begin
+  require 'rcov/rcovtask'
+  Rcov::RcovTask.new do |test|
+    test.libs << 'test'
+    test.pattern = 'test/**/*_test.rb'
+    test.rcov_opts << "--sort coverage"
+    test.rcov_opts << "--exclude gems"
+    test.verbose = false
+    test.warning = true
+  end
+rescue LoadError
+  task :rcov do
+    abort "RCov is not available. In order to run rcov, you must: sudo gem install spicycode-rcov"
+  end
+end
+
+task :test => :check_dependencies
+
+task :default => :test
+
+begin
+  require 'yard'
+  YARD::Rake::YardocTask.new
+rescue LoadError
+  task :yardoc do
+    abort "YARD is not available. In order to run yardoc, you must: sudo gem install yard"
+  end
+end

data/spec/ruby/1.9.1/gems/fakeweb-1.3.0/test/vendor/samuel-0.2.1/VERSION

@@ -0,0 +1 @@
+0.2.1

data/spec/ruby/1.9.1/gems/fakeweb-1.3.0/test/vendor/samuel-0.2.1/lib/samuel/net_http.rb

@@ -0,0 +1,10 @@
+class Net::HTTP
+
+  alias request_without_samuel request
+  def request(req, body = nil, &block)
+    Samuel.log_request(self, req) do
+      request_without_samuel(req, body, &block)
+    end
+  end
+
+end

data/spec/ruby/1.9.1/gems/fakeweb-1.3.0/test/vendor/samuel-0.2.1/lib/samuel/request.rb

@@ -0,0 +1,96 @@
+module Samuel
+  class Request
+
+    attr_accessor :response
+
+    def initialize(http, request, proc)
+      @http, @request, @proc = http, request, proc
+    end
+
+    def perform_and_log!
+      # If an exception is raised in the Benchmark block, it'll interrupt the
+      # benchmark. Instead, use an inner block to record it as the "response"
+      # for raising after the benchmark (and logging) is done.
+      @seconds = Benchmark.realtime do
+        begin; @response = @proc.call; rescue Exception => @response; end
+      end
+      Samuel.logger.add(log_level, log_message)
+      raise @response if @response.is_a?(Exception)
+    end
+
+    private
+
+    def log_message
+      bold      = "\e[1m"
+      blue      = "\e[34m"
+      underline = "\e[4m"
+      reset     = "\e[0m"
+      "  #{bold}#{blue}#{underline}#{label} request (#{milliseconds}ms) " +
+      "#{response_summary}#{reset}  #{method} #{uri}"
+    end
+
+    def milliseconds
+      (@seconds * 1000).round
+    end
+
+    def uri
+      "#{scheme}://#{@http.address}#{port_if_not_default}#{filtered_path}"
+    end
+
+    def filtered_path
+      path_without_query, query = @request.path.split("?")
+      if query
+        patterns = [Samuel.config[:filtered_params]].flatten
+        patterns.map { |pattern|
+          pattern_for_regex = Regexp.escape(pattern.to_s)
+          [/([^&]*#{pattern_for_regex}[^&=]*)=(?:[^&]+)/, '\1=[FILTERED]']
+        }.each { |filter| query.gsub!(*filter) }
+        "#{path_without_query}?#{query}"
+      else
+        @request.path
+      end
+    end
+
+    def scheme
+      @http.use_ssl? ? "https" : "http"
+    end
+
+    def port_if_not_default
+      ssl, port = @http.use_ssl?, @http.port
+      if (!ssl && port == 80) || (ssl && port == 443)
+        ""
+      else
+        ":#{port}"
+      end
+    end
+
+    def method
+      @request.method.to_s.upcase
+    end
+
+    def label
+      return Samuel.config[:label] if Samuel.config[:label]
+
+      pair = Samuel.config[:labels].detect { |domain, label| @http.address.include?(domain) }
+      pair[1] if pair
+    end
+
+    def response_summary
+      if response.is_a?(Exception)
+        response.class
+      else
+        "[#{response.code} #{response.message}]"
+      end
+    end
+
+    def log_level
+      error_classes = [Exception, Net::HTTPClientError, Net::HTTPServerError]
+      if error_classes.any? { |klass| response.is_a?(klass) }
+        level = Logger::WARN
+      else
+        level = Logger::INFO
+      end
+    end
+
+  end
+end

data/spec/ruby/1.9.1/gems/fakeweb-1.3.0/test/vendor/samuel-0.2.1/lib/samuel.rb

@@ -0,0 +1,52 @@
+require "logger"
+require "net/http"
+require "net/https"
+require "benchmark"
+
+require "samuel/net_http"
+require "samuel/request"
+
+
+module Samuel
+  extend self
+
+  attr_writer :config, :logger
+
+  def logger
+    @logger = nil if !defined?(@logger)
+    return @logger if !@logger.nil?
+
+    if defined?(RAILS_DEFAULT_LOGGER)
+      @logger = RAILS_DEFAULT_LOGGER
+    else
+      @logger = Logger.new(STDOUT)
+    end
+  end
+
+  def config
+    Thread.current[:__samuel_config] ? Thread.current[:__samuel_config] : @config
+  end
+
+  def log_request(http, request, &block)
+    request = Request.new(http, request, block)
+    request.perform_and_log!
+    request.response
+  end
+
+  def with_config(options = {})
+    original_config = config.dup
+    nested = !Thread.current[:__samuel_config].nil?
+
+    Thread.current[:__samuel_config] = original_config.merge(options)
+    yield
+    Thread.current[:__samuel_config] = nested ? original_config : nil
+  end
+
+  def reset_config
+    Thread.current[:__samuel_config] = nil
+    @config = {:label => nil, :labels => {"" => "HTTP"}, :filtered_params => []}
+  end
+
+end
+
+Samuel.reset_config

data/spec/ruby/1.9.1/gems/fakeweb-1.3.0/test/vendor/samuel-0.2.1/samuel.gemspec

@@ -0,0 +1,69 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE
+# Instead, edit Jeweler::Tasks in Rakefile, and run `rake gemspec`
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{samuel}
+  s.version = "0.2.1"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Chris Kampmeier"]
+  s.date = %q{2009-09-15}
+  s.description = %q{An automatic logger for HTTP requests in Ruby. Adds Net::HTTP request logging to your Rails logs, and more.}
+  s.email = %q{chris@kampers.net}
+  s.extra_rdoc_files = [
+    "LICENSE",
+     "README.rdoc"
+  ]
+  s.files = [
+    ".document",
+     ".gitignore",
+     "LICENSE",
+     "README.rdoc",
+     "Rakefile",
+     "VERSION",
+     "lib/samuel.rb",
+     "lib/samuel/net_http.rb",
+     "lib/samuel/request.rb",
+     "samuel.gemspec",
+     "test/request_test.rb",
+     "test/samuel_test.rb",
+     "test/test_helper.rb",
+     "test/thread_test.rb"
+  ]
+  s.homepage = %q{http://github.com/chrisk/samuel}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubyforge_project = %q{samuel}
+  s.rubygems_version = %q{1.3.5}
+  s.summary = %q{An automatic logger for HTTP requests in Ruby}
+  s.test_files = [
+    "test/request_test.rb",
+     "test/samuel_test.rb",
+     "test/test_helper.rb",
+     "test/thread_test.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+      s.add_development_dependency(%q<thoughtbot-shoulda>, [">= 0"])
+      s.add_development_dependency(%q<yard>, [">= 0"])
+      s.add_development_dependency(%q<mocha>, [">= 0"])
+      s.add_development_dependency(%q<fakeweb>, [">= 0"])
+    else
+      s.add_dependency(%q<thoughtbot-shoulda>, [">= 0"])
+      s.add_dependency(%q<yard>, [">= 0"])
+      s.add_dependency(%q<mocha>, [">= 0"])
+      s.add_dependency(%q<fakeweb>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<thoughtbot-shoulda>, [">= 0"])
+    s.add_dependency(%q<yard>, [">= 0"])
+    s.add_dependency(%q<mocha>, [">= 0"])
+    s.add_dependency(%q<fakeweb>, [">= 0"])
+  end
+end

data/spec/ruby/1.9.1/gems/fakeweb-1.3.0/test/vendor/samuel-0.2.1/test/request_test.rb

@@ -0,0 +1,193 @@
+require 'test_helper'
+
+class RequestTest < Test::Unit::TestCase
+
+  context "making an HTTP request" do
+    setup    { setup_test_logger
+               FakeWeb.clean_registry
+               Samuel.reset_config }
+    teardown { teardown_test_logger }
+
+    context "to GET http://example.com/test, responding with a 200 in 53ms" do
+      setup do
+        FakeWeb.register_uri(:get, "http://example.com/test", :status => [200, "OK"])
+        Benchmark.stubs(:realtime).yields.returns(0.053)
+        open "http://example.com/test"
+      end
+
+      should_log_lines     1
+      should_log_at_level  :info
+      should_log_including "HTTP request"
+      should_log_including "(53ms)"
+      should_log_including "[200 OK]"
+      should_log_including "GET http://example.com/test"
+    end
+
+    context "on a non-standard port" do
+      setup do
+        FakeWeb.register_uri(:get, "http://example.com:8080/test", :status => [200, "OK"])
+        open "http://example.com:8080/test"
+      end
+
+      should_log_including "GET http://example.com:8080/test"
+    end
+
+    context "with SSL" do
+      setup do
+        FakeWeb.register_uri(:get, "https://example.com/test", :status => [200, "OK"])
+        open "https://example.com/test"
+      end
+
+      should_log_including "HTTP request"
+      should_log_including "GET https://example.com/test"
+    end
+
+    context "with SSL on a non-standard port" do
+      setup do
+        FakeWeb.register_uri(:get, "https://example.com:80/test", :status => [200, "OK"])
+        open "https://example.com:80/test"
+      end
+
+      should_log_including "HTTP request"
+      should_log_including "GET https://example.com:80/test"
+    end
+
+    context "that raises" do
+      setup do
+        FakeWeb.register_uri(:get, "http://example.com/test", :exception => Errno::ECONNREFUSED)
+        begin
+          Net::HTTP.start("example.com") { |http| http.get("/test") }
+        rescue Errno::ECONNREFUSED => @exception
+        end
+      end
+
+      should_log_at_level    :warn
+      should_log_including   "HTTP request"
+      should_log_including   "GET http://example.com/test"
+      should_log_including   "Errno::ECONNREFUSED"
+      should_log_including   %r|\d+ms|
+      should_raise_exception Errno::ECONNREFUSED
+    end
+
+    context "that responds with a 500-level code" do
+      setup do
+        FakeWeb.register_uri(:get, "http://example.com/test", :status => [502, "Bad Gateway"])
+        Net::HTTP.start("example.com") { |http| http.get("/test") }
+      end
+
+      should_log_at_level :warn
+    end
+
+    context "that responds with a 400-level code" do
+      setup do
+        FakeWeb.register_uri(:get, "http://example.com/test", :status => [404, "Not Found"])
+        Net::HTTP.start("example.com") { |http| http.get("/test") }
+      end
+
+      should_log_at_level :warn
+    end
+
+    context "inside a configuration block with :label => 'Example'" do
+      setup do
+        FakeWeb.register_uri(:get, "http://example.com/test", :status => [200, "OK"])
+        Samuel.with_config :label => "Example" do
+          open "http://example.com/test"
+        end
+      end
+
+      should_log_including "Example request"
+      should_have_config_afterwards_including :labels => {"" => "HTTP"},
+                                              :label  => nil
+    end
+
+    context "inside a configuration block with :filter_params" do
+      setup do
+        FakeWeb.register_uri(:get, "http://example.com/test?password=secret&username=chrisk",
+                             :status => [200, "OK"])
+        @uri = "http://example.com/test?password=secret&username=chrisk"
+      end
+
+      context "=> :password" do
+        setup { Samuel.with_config(:filtered_params => :password) { open @uri } }
+        should_log_including "http://example.com/test?password=[FILTERED]&username=chrisk"
+      end
+
+      context "=> :as" do
+        setup { Samuel.with_config(:filtered_params => :ass) { open @uri } }
+        should_log_including "http://example.com/test?password=[FILTERED]&username=chrisk"
+      end
+
+      context "=> ['pass', 'name']" do
+        setup { Samuel.with_config(:filtered_params => %w(pass name)) { open @uri } }
+        should_log_including "http://example.com/test?password=[FILTERED]&username=[FILTERED]"
+      end
+    end
+
+    context "with a global config including :label => 'Example'" do
+      setup do
+        FakeWeb.register_uri(:get, "http://example.com/test", :status => [200, "OK"])
+        Samuel.config[:label] = "Example"
+        open "http://example.com/test"
+      end
+
+      should_log_including "Example request"
+      should_have_config_afterwards_including :labels => {"" => "HTTP"},
+                                              :label  => "Example"
+    end
+
+    context "with a global config including :label => 'Example' but inside config block that changes it to 'Example 2'" do
+      setup do
+        FakeWeb.register_uri(:get, "http://example.com/test", :status => [200, "OK"])
+        Samuel.config[:label] = "Example"
+        Samuel.with_config(:label => "Example 2") { open "http://example.com/test" }
+      end
+
+      should_log_including "Example 2 request"
+      should_have_config_afterwards_including :labels => {"" => "HTTP"},
+                                              :label  => "Example"
+    end
+
+    context "inside a config block of :label => 'Example 2' nested inside a config block of :label => 'Example'" do
+      setup do
+        FakeWeb.register_uri(:get, "http://example.com/test", :status => [200, "OK"])
+        Samuel.with_config :label => "Example" do
+          Samuel.with_config :label => "Example 2" do
+            open "http://example.com/test"
+          end
+        end
+      end
+
+      should_log_including "Example 2 request"
+      should_have_config_afterwards_including :labels => {"" => "HTTP"},
+                                              :label => nil
+    end
+
+    context "wth a global config including :labels => {'example.com' => 'Example'} but inside a config block of :label => 'Example 3' nested inside a config block of :label => 'Example 2'" do
+      setup do
+        FakeWeb.register_uri(:get, "http://example.com/test", :status => [200, "OK"])
+        Samuel.config[:labels] = {'example.com' => 'Example'}
+        Samuel.with_config :label => "Example 2" do
+          Samuel.with_config :label => "Example 3" do
+            open "http://example.com/test"
+          end
+        end
+      end
+
+      should_log_including "Example 3 request"
+      should_have_config_afterwards_including :labels => {'example.com' => 'Example'},
+                                              :label  => nil
+    end
+
+    context "with a global config including :labels => {'example.com' => 'Example API'}" do
+      setup do
+        FakeWeb.register_uri(:get, "http://example.com/test", :status => [200, "OK"])
+        Samuel.config[:labels] = {'example.com' => 'Example API'}
+        open "http://example.com/test"
+      end
+
+      should_log_including "Example API request"
+    end
+
+  end
+
+end

data/spec/ruby/1.9.1/gems/fakeweb-1.3.0/test/vendor/samuel-0.2.1/test/samuel_test.rb

@@ -0,0 +1,42 @@
+require 'test_helper'
+
+class SamuelTest < Test::Unit::TestCase
+
+  context "logger configuration" do
+    setup do
+      Samuel.logger = nil
+      if Object.const_defined?(:RAILS_DEFAULT_LOGGER)
+        Object.send(:remove_const, :RAILS_DEFAULT_LOGGER)
+      end
+    end
+
+    teardown do
+      Samuel.logger = nil
+    end
+
+    context "when Rails's logger is available" do
+      setup { Object.const_set(:RAILS_DEFAULT_LOGGER, :mock_logger) }
+
+      should "use the same logger" do
+        assert_equal :mock_logger, Samuel.logger
+      end
+    end
+
+    context "when Rails's logger is not available" do
+      should "use a new Logger instance pointed to STDOUT" do
+        assert_instance_of Logger, Samuel.logger
+        assert_equal STDOUT, Samuel.logger.instance_variable_get(:"@logdev").dev
+      end
+    end
+  end
+
+
+  context ".reset_config" do
+    should "reset the config to default vaules" do
+      Samuel.config = {:foo => "bar"}
+      Samuel.reset_config
+      assert_equal({:label => nil, :labels => {"" => "HTTP"}, :filtered_params => []}, Samuel.config)
+    end
+  end
+
+end

data/spec/ruby/1.9.1/gems/fakeweb-1.3.0/test/vendor/samuel-0.2.1/test/test_helper.rb

@@ -0,0 +1,66 @@
+require 'rubygems'
+require 'test/unit'
+require 'shoulda'
+require 'mocha'
+require 'open-uri'
+require 'fakeweb'
+
+FakeWeb.allow_net_connect = false
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'samuel'
+
+class Test::Unit::TestCase
+  TEST_LOG_PATH = File.join(File.dirname(__FILE__), 'test.log')
+
+  def self.should_log_lines(expected_count)
+    should "log #{expected_count} line#{'s' unless expected_count == 1}" do
+      lines = File.readlines(TEST_LOG_PATH)
+      assert_equal expected_count, lines.length
+    end
+  end
+
+  def self.should_log_including(what)
+    should "log a line including #{what.inspect}" do
+      contents = File.read(TEST_LOG_PATH)
+      if what.is_a?(Regexp)
+        assert_match what, contents
+      else
+        assert contents.include?(what),
+               "Expected #{contents.inspect} to include #{what.inspect}"
+      end
+    end
+  end
+
+  def self.should_log_at_level(level)
+    level = level.to_s.upcase
+    should "log at the #{level} level" do
+      assert File.read(TEST_LOG_PATH).include?("  #{level} -- :")
+    end
+  end
+
+  def self.should_raise_exception(klass)
+    should "raise an #{klass} exception" do
+      assert @exception.is_a?(klass)
+    end
+  end
+
+  def self.should_have_config_afterwards_including(config)
+    config.each_pair do |key, value|
+      should "continue afterwards with Samuel.config[#{key.inspect}] set to #{value.inspect}" do
+        assert_equal value, Samuel.config[key]
+      end
+    end
+  end
+
+  def setup_test_logger
+    FileUtils.rm_rf TEST_LOG_PATH
+    FileUtils.touch TEST_LOG_PATH
+    Samuel.logger = Logger.new(TEST_LOG_PATH)
+  end
+
+  def teardown_test_logger
+    FileUtils.rm_rf TEST_LOG_PATH
+  end
+end