webmock 1.0.0 → 1.1.0

data/spec/vendor/samuel-0.2.1/README.rdoc

@@ -1,70 +0,0 @@
-= 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/vendor/samuel-0.2.1/Rakefile

@@ -1,62 +0,0 @@
-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/vendor/samuel-0.2.1/VERSION

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

data/spec/vendor/samuel-0.2.1/lib/samuel.rb

@@ -1,52 +0,0 @@
-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/vendor/samuel-0.2.1/lib/samuel/net_http.rb

@@ -1,10 +0,0 @@
-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/vendor/samuel-0.2.1/lib/samuel/request.rb

@@ -1,96 +0,0 @@
-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/vendor/samuel-0.2.1/samuel.gemspec

@@ -1,69 +0,0 @@
-# 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/vendor/samuel-0.2.1/test/request_test.rb

@@ -1,193 +0,0 @@
-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