webmock-1.22.6/ 0000755 0000041 0000041 00000000000 12646134265 013272 5 ustar www-data www-data webmock-1.22.6/Rakefile 0000755 0000041 0000041 00000003260 12646134265 014743 0 ustar www-data www-data #!/usr/bin/env rake
require 'bundler'
Bundler::GemHelper.install_tasks
namespace :rvm do
desc 'Run specs against 1.8.6, REE, 1.8.7, 1.9.2 and jRuby'
task :specs do
# JCF: I'd love to be able to use RVM's `rvm {rubies} specs` command but
# the require tests in spec/other_net_http_libs_spec.rb break when doing
# so.
spec_files = Dir[File.dirname(__FILE__) + '/spec/**/*_spec.rb'].join(' ')
sh "rvm 1.8.6@webmock,ree@webmock,1.8.7@webmock,1.9.2@webmock,jruby@webmock exec rspec #{spec_files}"
end
end
require "rspec/core/rake_task"
RSpec::Core::RakeTask.new(:spec) do |t|
t.rspec_opts = ["-c", "-f progress", "-r ./spec/spec_helper.rb"]
t.pattern = 'spec/**/*_spec.rb'
end
RSpec::Core::RakeTask.new(:spec_http_without_webmock) do |t|
t.rspec_opts = ["-c", "-f progress", "-r ./spec/acceptance/net_http/real_net_http_spec.rb"]
t.pattern = 'spec/acceptance/net_http/real_net_http_spec.rb'
end
task :em_http_request_0_x_spec do
sh "EM_HTTP_REQUEST_0_X=true bundle install && EM_HTTP_REQUEST_0_X=true bundle exec rspec spec/acceptance/em_http_request/em_http_request_spec.rb" if RUBY_VERSION <= "1.8.7"
end
require 'rake/testtask'
Rake::TestTask.new(:test) do |test|
test.test_files = FileList["test/**/*.rb"].exclude("test/test_helper.rb")
test.verbose = false
test.warning = false
end
Rake::TestTask.new(:minitest) do |test|
test.test_files = FileList["minitest/**/*.rb"].exclude("test/test_helper.rb")
test.verbose = false
test.warning = false
end
task :default => [:spec, :spec_http_without_webmock, :test, :minitest]
task :require_ruby_18 do
raise "This must be run on Ruby 1.8" unless RUBY_VERSION =~ /^1\.8/
end
task :release => [:require_ruby_18]
webmock-1.22.6/.gemtest 0000644 0000041 0000041 00000000000 12646134265 014731 0 ustar www-data www-data webmock-1.22.6/Gemfile 0000644 0000041 0000041 00000000372 12646134265 014567 0 ustar www-data www-data source 'http://rubygems.org/'
gemspec
if ENV["EM_HTTP_REQUEST_0_X"]
gem 'em-http-request', '~> 0.3.0'
end
group :development do
gem 'rake'
end
group :test do
gem 'minitest_tu_shim', '1.3.2'
end
platforms :jruby do
gem 'jruby-openssl'
end
webmock-1.22.6/webmock.gemspec 0000644 0000041 0000041 00000004164 12646134265 016273 0 ustar www-data www-data # -*- encoding: utf-8 -*-
$:.push File.expand_path('../lib', __FILE__)
require 'webmock/version'
Gem::Specification.new do |s|
s.name = 'webmock'
s.version = WebMock::VERSION
s.platform = Gem::Platform::RUBY
s.authors = ['Bartosz Blimke']
s.email = ['bartosz.blimke@gmail.com']
s.homepage = 'http://github.com/bblimke/webmock'
s.summary = %q{Library for stubbing HTTP requests in Ruby.}
s.description = %q{WebMock allows stubbing HTTP requests and setting expectations on HTTP requests.}
s.license = "MIT"
s.rubyforge_project = 'webmock'
patron_version = (RUBY_VERSION <= '1.8.7') ? '0.4.18' : '>= 0.4.18'
manticore_version = (RUBY_VERSION) > '1.8.7' ? '>= 0.5.1' : '<= 0.5.1'
s.add_dependency 'addressable', '>= 2.3.6'
s.add_dependency 'crack', '>=0.3.2'
s.add_dependency 'hashdiff'
s.add_development_dependency 'rspec', '>= 3.1.0'
s.add_development_dependency 'httpclient', '>= 2.2.4'
s.add_development_dependency('patron', patron_version) unless RUBY_PLATFORM =~ /java/
s.add_development_dependency 'em-http-request', '>= 1.0.2'
s.add_development_dependency 'http', ((RUBY_VERSION <= '1.9.3') ? '0.7.3' : '>= 0.8.0')
s.add_development_dependency 'em-synchrony', '>= 1.0.0' if RUBY_VERSION >= "1.9"
s.add_development_dependency 'curb', '<= 0.8.6' unless RUBY_PLATFORM =~ /java/
s.add_development_dependency 'typhoeus', '>= 0.5.0' unless RUBY_PLATFORM =~ /java/
s.add_development_dependency('manticore', manticore_version) if RUBY_PLATFORM =~ /java/
s.add_development_dependency 'excon', '>= 0.27.5'
s.add_development_dependency 'minitest', '~> 5.0.0'
s.add_development_dependency 'rdoc', ((RUBY_VERSION == '1.8.6') ? '<= 3.5.0' : '>3.5.0')
s.add_development_dependency 'rack'
s.add_development_dependency "appraisal", "~> 2.0"
s.files = `git ls-files`.split("\n")
s.test_files = `git ls-files -- {test,spec,features}/*`.split("\n")
s.executables = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
s.require_paths = ['lib']
end
webmock-1.22.6/spec/ 0000755 0000041 0000041 00000000000 12646134265 014224 5 ustar www-data www-data webmock-1.22.6/spec/quality_spec.rb 0000644 0000041 0000041 00000005362 12646134265 017261 0 ustar www-data www-data require "spec_helper"
# Borrowed from Bundler
# https://github.com/carlhuda/bundler/blob/1-0-stable/spec/quality_spec.rb
# Portions copyright (c) 2010 Andre Arko
# Portions copyright (c) 2009 Engine Yard
# MIT License
# 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.
describe "The library itself" do
def check_for_tab_characters(filename)
failing_lines = []
File.readlines(filename).each_with_index do |line,number|
failing_lines << number + 1 if line =~ /\t/
end
unless failing_lines.empty?
"#{filename} has tab characters on lines #{failing_lines.join(', ')}"
end
end
def check_for_extra_spaces(filename)
failing_lines = []
File.readlines(filename).each_with_index do |line,number|
next if line =~ /^\s+#.*\s+\n$/
failing_lines << number + 1 if line =~ /\s+\n$/
end
unless failing_lines.empty?
"#{filename} has spaces on the EOL on lines #{failing_lines.join(', ')}"
end
end
RSpec::Matchers.define :be_well_formed do
failure_message do |actual|
actual.join("\n")
end
match do |actual|
actual.empty?
end
end
it "has no malformed whitespace" do
error_messages = []
Dir.chdir(File.expand_path("../..", __FILE__)) do
`git ls-files`.split("\n").each do |filename|
next if filename =~ /\.gitmodules|fixtures/
error_messages << check_for_tab_characters(filename)
error_messages << check_for_extra_spaces(filename)
end
end
expect(error_messages.compact).to be_well_formed
end
it "can still be built" do
Dir.chdir(File.expand_path('../../', __FILE__)) do
`gem build webmock.gemspec`
expect($?).to eq(0)
# clean up the .gem generated
system("rm webmock-#{WebMock.version}.gem")
end
end
end
webmock-1.22.6/spec/spec_helper.rb 0000644 0000041 0000041 00000002776 12646134265 017056 0 ustar www-data www-data require 'rubygems'
require 'httpclient'
unless RUBY_PLATFORM =~ /java/
require 'curb'
require 'patron'
require 'em-http'
require 'typhoeus'
end
if RUBY_PLATFORM =~ /java/
require 'manticore'
end
$LOAD_PATH.unshift(File.dirname(__FILE__))
$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
require 'rspec'
require 'webmock/rspec'
require 'support/network_connection'
require 'support/webmock_server'
require 'support/my_rack_app'
CURL_EXAMPLE_OUTPUT_PATH = File.expand_path('../support/example_curl_output.txt', __FILE__)
RSpec.configure do |config|
unless NetworkConnection.is_network_available?
warn("No network connectivity. Only examples which do not make real network connections will run.")
no_network_connection = true
end
if ENV["NO_CONNECTION"] || no_network_connection
config.filter_run_excluding :net_connect => true
end
if RUBY_VERSION <= "1.8.7"
config.filter_run_excluding "ruby>1.9" => true
end
config.filter_run_excluding :without_webmock => true
config.before(:suite) do
WebMockServer.instance.start unless WebMockServer.instance.started
end
config.after(:suite) do
WebMockServer.instance.stop
end
config.filter_run :focus => true
config.run_all_when_everything_filtered = true
end
RSpec::Expectations.configuration.warn_about_potential_false_positives = false
def fail()
raise_error(RSpec::Expectations::ExpectationNotMetError)
end
def fail_with(message)
raise_error(RSpec::Expectations::ExpectationNotMetError, message)
end
webmock-1.22.6/spec/unit/ 0000755 0000041 0000041 00000000000 12646134265 015203 5 ustar www-data www-data webmock-1.22.6/spec/unit/request_body_diff_spec.rb 0000644 0000041 0000041 00000004573 12646134265 022250 0 ustar www-data www-data require 'spec_helper'
RSpec.describe WebMock::RequestBodyDiff do
subject { WebMock::RequestBodyDiff.new(request_signature, request_stub) }
let(:uri) { "http://example.com" }
let(:method) { "GET" }
let(:request_stub) { WebMock::RequestStub.new(method, uri) }
let(:request_signature) { WebMock::RequestSignature.new(method, uri) }
let(:request_stub_body) { { "key" => "value"} }
let(:request_signature_body) { {"key" => "different value"}.to_json }
let(:request_pattern) {
WebMock::RequestPattern.new(
method, uri, {:body => request_stub_body}
)
}
before :each do
request_stub.request_pattern = request_pattern
request_signature.headers = {"Content-Type" => "application/json"}
request_signature.body = request_signature_body
end
describe "#body_diff" do
context "request signature is unparseable json" do
let(:request_signature_body) { "youcan'tparsethis!" }
it "returns an empty hash" do
expect(subject.body_diff).to eq({})
end
end
context "request stub body as unparseable json" do
let(:request_stub_body) { "youcan'tparsethis!" }
it "returns an empty hash" do
expect(subject.body_diff).to eq({})
end
end
context "request stub body pattern is hash" do
let(:request_stub_body) { { "key" => "value"} }
it "generates a diff" do
expect(subject.body_diff).to eq(
[["~", "key", "different value", "value"]]
)
end
end
context "request signature doesn't have json headers" do
before :each do
request_signature.headers = {"Content-Type" => "application/xml"}
end
it "returns an empty hash" do
expect(subject.body_diff).to eq({})
end
end
context "request stub body pattern is a string" do
let(:request_stub_body) { { "key" => "value"}.to_json }
it "generates a diff" do
expect(subject.body_diff).to eq(
[["~", "key", "different value", "value"]]
)
end
end
context "stub request has no request pattern" do
let(:request_signature_body) { nil }
it "returns an empty hash" do
expect(subject.body_diff).to eq({})
end
end
context "stub request has no body pattern" do
let(:request_stub_body) { nil }
it "returns an empty hash" do
expect(subject.body_diff).to eq({})
end
end
end
end
webmock-1.22.6/spec/unit/request_stub_spec.rb 0000644 0000041 0000041 00000016060 12646134265 021272 0 ustar www-data www-data require 'spec_helper'
describe WebMock::RequestStub do
before(:each) do
@request_stub = WebMock::RequestStub.new(:get, "www.example.com")
end
it "should have request pattern with method and uri" do
expect(@request_stub.request_pattern.to_s).to eq("GET http://www.example.com/")
end
it "should have response" do
expect(@request_stub.response).to be_a(WebMock::Response)
end
describe "with" do
it "should assign body to request pattern" do
@request_stub.with(:body => "abc")
expect(@request_stub.request_pattern.to_s).to eq(WebMock::RequestPattern.new(:get, "www.example.com", :body => "abc").to_s)
end
it "should assign normalized headers to request pattern" do
@request_stub.with(:headers => {'A' => 'a'})
expect(@request_stub.request_pattern.to_s).to eq(
WebMock::RequestPattern.new(:get, "www.example.com", :headers => {'A' => 'a'}).to_s
)
end
it "should assign given block to request profile" do
@request_stub.with { |req| req.body == "abc" }
expect(@request_stub.request_pattern.matches?(WebMock::RequestSignature.new(:get, "www.example.com", :body => "abc"))).to be_truthy
end
end
describe "to_return" do
it "should assign response with provided options" do
@request_stub.to_return(:body => "abc", :status => 500)
expect(@request_stub.response.body).to eq("abc")
expect(@request_stub.response.status).to eq([500, ""])
end
it "should assign responses with provided options" do
@request_stub.to_return([{:body => "abc"}, {:body => "def"}])
expect([@request_stub.response.body, @request_stub.response.body]).to eq(["abc", "def"])
end
end
describe "then" do
it "should return stub without any modifications, acting as syntactic sugar" do
expect(@request_stub.then).to eq(@request_stub)
end
end
describe "response" do
it "should return responses in a sequence passed as array" do
@request_stub.to_return([{:body => "abc"}, {:body => "def"}])
expect(@request_stub.response.body).to eq("abc")
expect(@request_stub.response.body).to eq("def")
end
it "should repeat returning last response" do
@request_stub.to_return([{:body => "abc"}, {:body => "def"}])
@request_stub.response
@request_stub.response
expect(@request_stub.response.body).to eq("def")
end
it "should return responses in a sequence passed as comma separated params" do
@request_stub.to_return({:body => "abc"}, {:body => "def"})
expect(@request_stub.response.body).to eq("abc")
expect(@request_stub.response.body).to eq("def")
end
it "should return responses declared in multiple to_return declarations" do
@request_stub.to_return({:body => "abc"}).to_return({:body => "def"})
expect(@request_stub.response.body).to eq("abc")
expect(@request_stub.response.body).to eq("def")
end
end
describe "to_raise" do
it "should assign response with exception to be thrown" do
@request_stub.to_raise(ArgumentError)
expect {
@request_stub.response.raise_error_if_any
}.to raise_error(ArgumentError, "Exception from WebMock")
end
it "should assign sequence of responses with response with exception to be thrown" do
@request_stub.to_return(:body => "abc").then.to_raise(ArgumentError)
expect(@request_stub.response.body).to eq("abc")
expect {
@request_stub.response.raise_error_if_any
}.to raise_error(ArgumentError, "Exception from WebMock")
end
it "should assign a list responses to be thrown in a sequence" do
@request_stub.to_raise(ArgumentError, IndexError)
expect {
@request_stub.response.raise_error_if_any
}.to raise_error(ArgumentError, "Exception from WebMock")
expect {
@request_stub.response.raise_error_if_any
}.to raise_error(IndexError, "Exception from WebMock")
end
it "should raise exceptions declared in multiple to_raise declarations" do
@request_stub.to_raise(ArgumentError).then.to_raise(IndexError)
expect {
@request_stub.response.raise_error_if_any
}.to raise_error(ArgumentError, "Exception from WebMock")
expect {
@request_stub.response.raise_error_if_any
}.to raise_error(IndexError, "Exception from WebMock")
end
end
describe "to_timeout" do
it "should assign response with timeout" do
@request_stub.to_timeout
expect(@request_stub.response.should_timeout).to be_truthy
end
it "should assign sequence of responses with response with timeout" do
@request_stub.to_return(:body => "abc").then.to_timeout
expect(@request_stub.response.body).to eq("abc")
expect(@request_stub.response.should_timeout).to be_truthy
end
it "should allow multiple timeouts to be declared" do
@request_stub.to_timeout.then.to_timeout.then.to_return(:body => "abc")
expect(@request_stub.response.should_timeout).to be_truthy
expect(@request_stub.response.should_timeout).to be_truthy
expect(@request_stub.response.body).to eq("abc")
end
end
describe "times" do
it "should give error if declared before any response declaration is declared" do
expect {
@request_stub.times(3)
}.to raise_error("Invalid WebMock stub declaration. times(N) can be declared only after response declaration.")
end
it "should repeat returning last declared response declared number of times" do
@request_stub.to_return({:body => "abc"}).times(2).then.to_return({:body => "def"})
expect(@request_stub.response.body).to eq("abc")
expect(@request_stub.response.body).to eq("abc")
expect(@request_stub.response.body).to eq("def")
end
it "should repeat raising last declared exception declared number of times" do
@request_stub.to_return({:body => "abc"}).times(2).then.to_return({:body => "def"})
expect(@request_stub.response.body).to eq("abc")
expect(@request_stub.response.body).to eq("abc")
expect(@request_stub.response.body).to eq("def")
end
it "should repeat returning last declared sequence of responses declared number of times" do
@request_stub.to_return({:body => "abc"}, {:body => "def"}).times(2).then.to_return({:body => "ghj"})
expect(@request_stub.response.body).to eq("abc")
expect(@request_stub.response.body).to eq("def")
expect(@request_stub.response.body).to eq("abc")
expect(@request_stub.response.body).to eq("def")
expect(@request_stub.response.body).to eq("ghj")
end
it "should return self" do
expect(@request_stub.to_return({:body => "abc"}).times(1)).to eq(@request_stub)
end
it "should raise error if argument is not integer" do
expect {
@request_stub.to_return({:body => "abc"}).times("not number")
}.to raise_error("times(N) accepts integers >= 1 only")
end
it "should raise error if argument is < 1" do
expect {
@request_stub.to_return({:body => "abc"}).times(0)
}.to raise_error("times(N) accepts integers >= 1 only")
end
end
end
webmock-1.22.6/spec/unit/stub_registry_spec.rb 0000644 0000041 0000041 00000010546 12646134265 021455 0 ustar www-data www-data require 'spec_helper'
describe WebMock::StubRegistry do
before(:each) do
WebMock::StubRegistry.instance.reset!
@request_pattern = WebMock::RequestPattern.new(:get, "www.example.com")
@request_signature = WebMock::RequestSignature.new(:get, "www.example.com")
@request_stub = WebMock::RequestStub.new(:get, "www.example.com")
end
describe "remove_request_stub" do
it "should remove stub from registry" do
WebMock::StubRegistry.instance.register_request_stub(@request_stub)
expect(WebMock::StubRegistry.instance.registered_request?(@request_signature)).to eq(@request_stub)
WebMock::StubRegistry.instance.remove_request_stub(@request_stub)
expect(WebMock::StubRegistry.instance.registered_request?(@request_signature)).to eq(nil)
end
end
describe "reset!" do
before(:each) do
WebMock::StubRegistry.instance.register_request_stub(@request_stub)
end
it "should clean request stubs" do
expect(WebMock::StubRegistry.instance.registered_request?(@request_signature)).to eq(@request_stub)
WebMock::StubRegistry.instance.reset!
expect(WebMock::StubRegistry.instance.registered_request?(@request_signature)).to eq(nil)
end
end
describe "registering and reporting registered requests" do
it "should return registered stub" do
expect(WebMock::StubRegistry.instance.register_request_stub(@request_stub)).to eq(@request_stub)
end
it "should report if request stub is not registered" do
expect(WebMock::StubRegistry.instance.registered_request?(@request_signature)).to eq(nil)
end
it "should register and report registered stub" do
WebMock::StubRegistry.instance.register_request_stub(@request_stub)
expect(WebMock::StubRegistry.instance.registered_request?(@request_signature)).to eq(@request_stub)
end
end
describe "response for request" do
it "should report registered evaluated response for request pattern" do
@request_stub.to_return(:body => "abc")
WebMock::StubRegistry.instance.register_request_stub(@request_stub)
expect(WebMock::StubRegistry.instance.response_for_request(@request_signature)).
to eq(WebMock::Response.new(:body => "abc"))
end
it "should report evaluated response" do
@request_stub.to_return {|request| {:body => request.method.to_s} }
WebMock::StubRegistry.instance.register_request_stub(@request_stub)
response1 = WebMock::StubRegistry.instance.response_for_request(@request_signature)
expect(response1).to eq(WebMock::Response.new(:body => "get"))
end
it "should report clone of the response" do
@request_stub.to_return(:body => lambda{|r| r.method.to_s})
WebMock::StubRegistry.instance.register_request_stub(@request_stub)
response1 = WebMock::StubRegistry.instance.response_for_request(@request_signature)
response2 = WebMock::StubRegistry.instance.response_for_request(@request_signature)
expect(response1).not_to be(response2)
end
it "should report clone of the dynamic response" do
@request_stub.to_return {|request| {:body => request.method.to_s} }
WebMock::StubRegistry.instance.register_request_stub(@request_stub)
response1 = WebMock::StubRegistry.instance.response_for_request(@request_signature)
response2 = WebMock::StubRegistry.instance.response_for_request(@request_signature)
expect(response1).not_to be(response2)
end
it "should report nothing if no response for request is registered" do
expect(WebMock::StubRegistry.instance.response_for_request(@request_signature)).to eq(nil)
end
it "should always return last registered matching response" do
@request_stub1 = WebMock::RequestStub.new(:get, "www.example.com")
@request_stub1.to_return(:body => "abc")
@request_stub2 = WebMock::RequestStub.new(:get, "www.example.com")
@request_stub2.to_return(:body => "def")
@request_stub3 = WebMock::RequestStub.new(:get, "www.example.org")
@request_stub3.to_return(:body => "ghj")
WebMock::StubRegistry.instance.register_request_stub(@request_stub1)
WebMock::StubRegistry.instance.register_request_stub(@request_stub2)
WebMock::StubRegistry.instance.register_request_stub(@request_stub3)
expect(WebMock::StubRegistry.instance.response_for_request(@request_signature)).
to eq(WebMock::Response.new(:body => "def"))
end
end
end
webmock-1.22.6/spec/unit/stub_request_snippet_spec.rb 0000644 0000041 0000041 00000011452 12646134265 023034 0 ustar www-data www-data require 'spec_helper'
describe WebMock::StubRequestSnippet do
describe "to_s" do
describe "GET" do
before(:each) do
@request_signature = WebMock::RequestSignature.new(:get, "www.example.com/?a=b&c=d", :headers => {})
end
it "should print stub request snippet with url with params and method and empty successful response" do
expected = %Q(stub_request(:get, "http://www.example.com/?a=b&c=d").\n to_return(:status => 200, :body => "", :headers => {}))
@request_stub = WebMock::RequestStub.from_request_signature(@request_signature)
expect(WebMock::StubRequestSnippet.new(@request_stub).to_s).to eq(expected)
end
it "should print stub request snippet with body if available" do
@request_signature.body = "abcdef"
expected = %Q(stub_request(:get, "http://www.example.com/?a=b&c=d").)+
"\n with(:body => \"abcdef\")." +
"\n to_return(:status => 200, :body => \"\", :headers => {})"
@request_stub = WebMock::RequestStub.from_request_signature(@request_signature)
expect(WebMock::StubRequestSnippet.new(@request_stub).to_s).to eq(expected)
end
it "should print stub request snippet with multiline body" do
@request_signature.body = "abc\ndef"
expected = %Q(stub_request(:get, "http://www.example.com/?a=b&c=d").)+
"\n with(:body => \"abc\\ndef\")." +
"\n to_return(:status => 200, :body => \"\", :headers => {})"
@request_stub = WebMock::RequestStub.from_request_signature(@request_signature)
expect(WebMock::StubRequestSnippet.new(@request_stub).to_s).to eq(expected)
end
it "should print stub request snippet with headers if any" do
@request_signature.headers = {'B' => 'b', 'A' => 'a'}
expected = 'stub_request(:get, "http://www.example.com/?a=b&c=d").'+
"\n with(:headers => {\'A\'=>\'a\', \'B\'=>\'b\'})." +
"\n to_return(:status => 200, :body => \"\", :headers => {})"
@request_stub = WebMock::RequestStub.from_request_signature(@request_signature)
expect(WebMock::StubRequestSnippet.new(@request_stub).to_s).to eq(expected)
end
it "should print stub request snippet with body and headers" do
@request_signature.body = "abcdef"
@request_signature.headers = {'B' => 'b', 'A' => 'a'}
expected = 'stub_request(:get, "http://www.example.com/?a=b&c=d").'+
"\n with(:body => \"abcdef\",\n :headers => {\'A\'=>\'a\', \'B\'=>\'b\'})." +
"\n to_return(:status => 200, :body => \"\", :headers => {})"
@request_stub = WebMock::RequestStub.from_request_signature(@request_signature)
expect(WebMock::StubRequestSnippet.new(@request_stub).to_s).to eq(expected)
end
it "should not print to_return part if not wanted" do
expected = 'stub_request(:get, "http://www.example.com/").'+
"\n with(:body => \"abcdef\")"
stub = WebMock::RequestStub.new(:get, "www.example.com").with(:body => "abcdef").to_return(:body => "hello")
expect(WebMock::StubRequestSnippet.new(stub).to_s(false)).to eq(expected)
end
end
describe "POST" do
let(:form_body) { 'user%5bfirst_name%5d=Bartosz' }
let(:multipart_form_body) { 'complicated stuff--ABC123--goes here' }
it "should print stub request snippet with body as a hash using rails conventions on form posts" do
@request_signature = WebMock::RequestSignature.new(:post, "www.example.com",
:headers => {'Content-Type' => 'application/x-www-form-urlencoded'},
:body => form_body)
@request_stub = WebMock::RequestStub.from_request_signature(@request_signature)
expected = <<-STUB
stub_request(:post, "http://www.example.com/").
with(:body => {"user"=>{"first_name"=>"Bartosz"}},
:headers => {'Content-Type'=>'application/x-www-form-urlencoded'}).
to_return(:status => 200, :body => \"\", :headers => {})
STUB
expect(WebMock::StubRequestSnippet.new(@request_stub).to_s).to eq(expected.strip)
end
it "should print stub request snippet leaving body as string when not a urlencoded form" do
@request_signature = WebMock::RequestSignature.new(:post, "www.example.com",
:headers => {'Content-Type' => 'multipart/form-data; boundary=ABC123'},
:body => multipart_form_body)
@request_stub = WebMock::RequestStub.from_request_signature(@request_signature)
expected = <<-STUB
stub_request(:post, "http://www.example.com/").
with(:body => "#{multipart_form_body}",
:headers => {'Content-Type'=>'multipart/form-data; boundary=ABC123'}).
to_return(:status => 200, :body => \"\", :headers => {})
STUB
expect(WebMock::StubRequestSnippet.new(@request_stub).to_s).to eq(expected.strip)
end
end
end
end
webmock-1.22.6/spec/unit/rack_response_spec.rb 0000644 0000041 0000041 00000006611 12646134265 021404 0 ustar www-data www-data # encoding: utf-8
require 'spec_helper'
describe WebMock::RackResponse do
before :each do
@rack_response = WebMock::RackResponse.new(MyRackApp)
end
it "should hook up to a rack appliance" do
request = WebMock::RequestSignature.new(:get, 'www.example.com')
response = @rack_response.evaluate(request)
expect(response.status.first).to eq(200)
expect(response.body).to include('This is my root!')
end
it "should behave correctly when the rack response is not a simple array of strings" do
request = WebMock::RequestSignature.new(:get, 'www.example.com/non_array_response')
response = @rack_response.evaluate(request)
expect(response.status.first).to eq(200)
expect(response.body).to include('This is not in an array!')
end
it "should shouldn't blow up when hitting a locked resource twice" do
@locked_rack_response = WebMock::RackResponse.new(MyLockedRackApp)
request = WebMock::RequestSignature.new(:get, 'www.example.com/locked')
@locked_rack_response.evaluate(request)
response2 = @locked_rack_response.evaluate(request)
expect(response2.body).to include('Single threaded response.')
expect(response2.status.first).to eq(200)
end
it "should send along params" do
request = WebMock::RequestSignature.new(:get, 'www.example.com/greet?name=Johnny')
response = @rack_response.evaluate(request)
expect(response.status.first).to eq(200)
expect(response.body).to include('Hello, Johnny')
end
it "should send along POST params" do
request = WebMock::RequestSignature.new(:post, 'www.example.com/greet',
:body => 'name=Jimmy'
)
response = @rack_response.evaluate(request)
expect(response.body).to include('Good to meet you, Jimmy!')
end
it "should send params with proper content length if params have non-ascii symbols" do
request = WebMock::RequestSignature.new(:post, 'www.example.com/greet',
:body => 'name=Олег'
)
response = @rack_response.evaluate(request)
expect(response.body).to include('Good to meet you, Олег!')
end
describe 'rack error output' do
before :each do
@original_stderr = $stderr
$stderr = StringIO.new
end
after :each do
$stderr = @original_stderr
end
it 'should behave correctly when an app uses rack.errors' do
request = WebMock::RequestSignature.new(:get, 'www.example.com/error')
expect { @rack_response.evaluate(request) }.to_not raise_error
expect($stderr.length).to_not eq 0
end
end
describe 'basic auth request' do
before :each do
@rack_response_with_basic_auth = WebMock::RackResponse.new(
Rack::Auth::Basic.new(MyRackApp) do |username, password|
username == 'username' && password == 'password'
end
)
end
it 'should be failure when wrong credentials' do
request = WebMock::RequestSignature.new(:get, 'foo:bar@www.example.com')
response = @rack_response_with_basic_auth.evaluate(request)
expect(response.status.first).to eq(401)
expect(response.body).not_to include('This is my root!')
end
it 'should be success when valid credentials' do
request = WebMock::RequestSignature.new(:get, 'username:password@www.example.com')
response = @rack_response_with_basic_auth.evaluate(request)
expect(response.status.first).to eq(200)
expect(response.body).to include('This is my root!')
end
end
end
webmock-1.22.6/spec/unit/errors_spec.rb 0000644 0000041 0000041 00000014533 12646134265 020064 0 ustar www-data www-data require 'spec_helper'
describe "errors" do
describe WebMock::NetConnectNotAllowedError do
describe "message" do
it "should have message with request signature and snippet" do
allow(WebMock::RequestStub).to receive(:from_request_signature).and_return(request_stub)
allow(WebMock::StubRequestSnippet).to receive(:new).
with(request_stub).and_return(stub_result)
expected = \
"Real HTTP connections are disabled. Unregistered request: #{request_signature}" \
"\n\nYou can stub this request with the following snippet:" \
"\n\n#{stub_result}" \
"\n\n============================================================"
expect(WebMock::NetConnectNotAllowedError.new(request_signature).message).to eq(expected)
end
it "should have message with registered stubs if available" do
allow(WebMock::StubRegistry.instance).to receive(:request_stubs).and_return([request_stub])
allow(WebMock::RequestStub).to receive(:from_request_signature).and_return(request_stub)
allow(WebMock::StubRequestSnippet).to receive(:new).
with(request_stub).and_return(stub_result)
allow_any_instance_of(WebMock::RequestBodyDiff).to receive(:body_diff).and_return({})
expected = \
"Real HTTP connections are disabled. Unregistered request: #{request_signature}" \
"\n\nYou can stub this request with the following snippet:" \
"\n\n#{stub_result}" \
"\n\nregistered request stubs:" \
"\n\n#{stub_result}" \
"\n\n============================================================"
expect(WebMock::NetConnectNotAllowedError.new(request_signature).message).to eq(expected)
end
it "should not be caught by a rescue block without arguments" do
allow(WebMock::RequestStub).to receive(:from_request_signature).and_return(request_stub)
allow(WebMock::StubRequestSnippet).to receive(:new).
with(request_stub).and_return(stub_result)
exception = WebMock::NetConnectNotAllowedError.new(request_signature)
expect do
begin
raise exception
rescue
raise "exception should not be caught"
end
end.to raise_exception exception
end
it "should print body diff if available" do
allow(WebMock::StubRegistry.instance).to receive(:request_stubs).and_return([request_stub])
allow(WebMock::RequestStub).to receive(:from_request_signature).and_return(request_stub)
allow(WebMock::StubRequestSnippet).to receive(:new).
with(request_stub).and_return(stub_result)
allow_any_instance_of(WebMock::RequestBodyDiff).to receive(:body_diff).and_return(body_diff)
expected = \
"Real HTTP connections are disabled. Unregistered request: #{request_signature}" \
"\n\nYou can stub this request with the following snippet:" \
"\n\n#{stub_result}" \
"\n\nregistered request stubs:" \
"\n\n#{stub_result}" \
"\n\nBody diff:\n [[\"+\", \"test\", \"test2\"], [\"-\", \"test3\"], [\"~\", \"test5\", \"test6\"]]" \
"\n\n\n============================================================"
expect(WebMock::NetConnectNotAllowedError.new(request_signature).message).to eq(expected)
end
context "WebMock.show_body_diff? is false" do
before do
WebMock.hide_body_diff!
end
it "should not show body diff" do
allow(WebMock::StubRegistry.instance).to receive(:request_stubs).and_return([request_stub])
allow(WebMock::RequestStub).to receive(:from_request_signature).and_return(request_stub)
allow(WebMock::StubRequestSnippet).to receive(:new).
with(request_stub).and_return(stub_result)
expect_any_instance_of(WebMock::RequestBodyDiff).to_not receive(:body_diff)
expected = \
"Real HTTP connections are disabled. Unregistered request: #{request_signature}" \
"\n\nYou can stub this request with the following snippet:" \
"\n\n#{stub_result}" \
"\n\nregistered request stubs:" \
"\n\n#{stub_result}" \
"\n\n============================================================"
expect(WebMock::NetConnectNotAllowedError.new(request_signature).message).to eq(expected)
end
end
context "WebMock.show_stubbing_instructions? is false" do
before do
WebMock.hide_stubbing_instructions!
end
it "should have message with request signature and snippet" do
allow(WebMock::RequestStub).to receive(:from_request_signature).and_return(request_stub)
allow(WebMock::StubRequestSnippet).to receive(:new).
with(request_stub).and_return(stub_result)
expected = \
"Real HTTP connections are disabled. Unregistered request: #{request_signature}" \
"\n\n============================================================"
expect(WebMock::NetConnectNotAllowedError.new(request_signature).message).to eq(expected)
end
it "should have message with registered stubs if available" do
allow(WebMock::StubRegistry.instance).to receive(:request_stubs).and_return([request_stub])
allow(WebMock::RequestStub).to receive(:from_request_signature).and_return(request_stub)
allow(WebMock::StubRequestSnippet).to receive(:new).
with(request_stub).and_return(stub_result)
allow(request_stub).to receive(:request_pattern).and_return(body_pattern)
expected = \
"Real HTTP connections are disabled. Unregistered request: #{request_signature}" \
"\n\nregistered request stubs:" \
"\n\n#{stub_result}" \
"\n\n============================================================"
expect(WebMock::NetConnectNotAllowedError.new(request_signature).message).to eq(expected)
end
end
end
let(:request_signature) { double(:request_signature, :to_s => rand(10**20).to_s) }
let(:stub_result) { double(:stub_result, :to_s => rand(10**20).to_s) }
let(:request_stub) { double(:request_stub) }
let(:body_pattern) { double(:body_pattern, :body_pattern => nil)}
let(:body_diff) { [["+", "test", "test2"], ["-", "test3"], ["~", "test5", "test6"]] }
end
end
webmock-1.22.6/spec/unit/http_lib_adapters/ 0000755 0000041 0000041 00000000000 12646134265 020673 5 ustar www-data www-data webmock-1.22.6/spec/unit/http_lib_adapters/http_lib_adapter_spec.rb 0000644 0000041 0000041 00000000544 12646134265 025542 0 ustar www-data www-data require 'spec_helper'
describe WebMock::HttpLibAdapter do
describe "adapter_for" do
it "should add adapter to adapter registry" do
class MyAdapter < WebMock::HttpLibAdapter; end
expect(WebMock::HttpLibAdapterRegistry.instance).
to receive(:register).with(:my_lib, MyAdapter)
MyAdapter.adapter_for(:my_lib)
end
end
end webmock-1.22.6/spec/unit/http_lib_adapters/http_lib_adapter_registry_spec.rb 0000644 0000041 0000041 00000001057 12646134265 027472 0 ustar www-data www-data require 'spec_helper'
describe WebMock::HttpLibAdapterRegistry do
describe "each_adapter" do
it "should yield block over each adapter" do
class MyAdapter < WebMock::HttpLibAdapter; end
WebMock::HttpLibAdapterRegistry.instance.register(:my_lib, MyAdapter)
adapters = []
WebMock::HttpLibAdapterRegistry.instance.each_adapter {|n,a|
adapters << [n, a]
}
expect(adapters).to include([:my_lib, MyAdapter])
WebMock::HttpLibAdapterRegistry.instance.
http_lib_adapters.delete(:my_lib)
end
end
end webmock-1.22.6/spec/unit/api_spec.rb 0000644 0000041 0000041 00000004332 12646134265 017315 0 ustar www-data www-data require 'spec_helper'
describe WebMock::API do
describe '#hash_including' do
subject { klass.new.hash_including(args) }
let(:args) { {:data => :one} }
context 'when mixed into a class that does not define `hash_including`' do
let(:klass) do
Class.new do
include WebMock::API
end
end
it 'uses WebMock::Matchers::HashIncludingMatcher' do
expect(subject).to be_a(WebMock::Matchers::HashIncludingMatcher)
end
# by testing equality for HashIncludingMatcher (which stringifies the passed hash) we are
# testing HashIncludingMatcher.initialize behavior as well
context "when args correspond to an hash" do
it "creates 'HashIncludingMatcher'" do
expect(subject).to eq("data" => :one)
end
end
context "when args are one or many keys" do
subject {klass.new.hash_including(:foo, :bar)}
let(:anything) { WebMock::Matchers::AnyArgMatcher.new(nil) }
it "creates 'HashIncludingMatcher' with keys anythingized" do
expect(subject).to eq("foo" => anything, "bar" => anything )
end
end
context "when args are both keys and key/value pairs" do
subject {klass.new.hash_including(:foo, :bar, :data => :one)}
let(:anything) { WebMock::Matchers::AnyArgMatcher.new(nil) }
it "creates 'HashIncludingMatcher' with keys anythingized" do
expect(subject).to eq("foo" => anything, "bar" => anything, "data" => :one)
end
end
context "when args are an emtpy hash" do
subject {klass.new.hash_including({})}
it "creates 'HashIncludingMatcher' with an empty hash" do
expect(subject).to eq({})
end
end
end
context 'when mixed into a class with a parent that defines `hash_including`' do
subject {klass.new.hash_including(*args)}
let(:args) { %w(:foo, :bar, {:data => :one}) }
let(:klass) do
Class.new(
Class.new do
def hash_including(*args)
args
end
end
) { include WebMock::API }
end
it 'uses super and passes the args untampered' do
expect(subject).to eq(args)
end
end
end
end webmock-1.22.6/spec/unit/request_execution_verifier_spec.rb 0000644 0000041 0000041 00000021015 12646134265 024207 0 ustar www-data www-data require 'spec_helper'
describe WebMock::RequestExecutionVerifier do
before(:each) do
@verifier = WebMock::RequestExecutionVerifier.new
@request_pattern = double(WebMock::RequestPattern, :to_s => "www.example.com")
@verifier.request_pattern = @request_pattern
allow(WebMock::RequestRegistry.instance).to receive(:to_s).and_return("executed requests")
@executed_requests_info = "\n\nThe following requests were made:\n\nexecuted requests\n" + "="*60
end
describe "description" do
it "reports the description" do
@verifier.expected_times_executed = 2
expect(@verifier.description).to eq "request www.example.com 2 times"
end
it "reports description correctly when expectation is 1 time" do
@verifier.expected_times_executed = 1
expect(@verifier.description).to eq "request www.example.com 1 time"
end
context "at_least_times_executed is set" do
it "reports description correctly when expectation at least 2 times" do
@verifier.at_least_times_executed = 2
expect(@verifier.description).to eq "request www.example.com at least 2 times"
end
it "reports description correctly when expectation is at least 3 times" do
@verifier.at_least_times_executed = 3
expect(@verifier.description).to eq "request www.example.com at least 3 times"
end
end
context "at_most_times_executed is set" do
it "reports description correctly when expectation is at most 2 times" do
@verifier.at_most_times_executed = 2
expect(@verifier.description).to eq "request www.example.com at most 2 times"
end
it "reports description correctly when expectation is at most 1 time" do
@verifier.at_most_times_executed = 1
expect(@verifier.description).to eq "request www.example.com at most 1 time"
end
end
end
describe "failure message" do
it "reports the failure message" do
@verifier.times_executed = 0
@verifier.expected_times_executed = 2
expected_text = "The request www.example.com was expected to execute 2 times but it executed 0 times"
expected_text << @executed_requests_info
expect(@verifier.failure_message).to eq(expected_text)
end
it "reports failure message correctly when executed times is one" do
@verifier.times_executed = 1
@verifier.expected_times_executed = 1
expected_text = "The request www.example.com was expected to execute 1 time but it executed 1 time"
expected_text << @executed_requests_info
expect(@verifier.failure_message).to eq(expected_text)
end
context "at_least_times_executed is set" do
it "reports failure message correctly when executed times is one" do
@verifier.times_executed = 1
@verifier.at_least_times_executed = 2
expected_text = "The request www.example.com was expected to execute at least 2 times but it executed 1 time"
expected_text << @executed_requests_info
expect(@verifier.failure_message).to eq(expected_text)
end
it "reports failure message correctly when executed times is two" do
@verifier.times_executed = 2
@verifier.at_least_times_executed = 3
expected_text = "The request www.example.com was expected to execute at least 3 times but it executed 2 times"
expected_text << @executed_requests_info
expect(@verifier.failure_message).to eq(expected_text)
end
end
context "at_most_times_executed is set" do
it "reports failure message correctly when executed times is three" do
@verifier.times_executed = 3
@verifier.at_most_times_executed = 2
expected_text = "The request www.example.com was expected to execute at most 2 times but it executed 3 times"
expected_text << @executed_requests_info
expect(@verifier.failure_message).to eq(expected_text)
end
it "reports failure message correctly when executed times is two" do
@verifier.times_executed = 2
@verifier.at_most_times_executed = 1
expected_text = "The request www.example.com was expected to execute at most 1 time but it executed 2 times"
expected_text << @executed_requests_info
expect(@verifier.failure_message).to eq(expected_text)
end
end
end
describe "negative failure message" do
it "reports failure message if it executed number of times specified" do
@verifier.times_executed = 2
@verifier.expected_times_executed = 2
expected_text = "The request www.example.com was not expected to execute 2 times but it executed 2 times"
expected_text << @executed_requests_info
expect(@verifier.failure_message_when_negated).to eq(expected_text)
end
it "reports failure message when not expected request but it executed" do
@verifier.times_executed = 1
expected_text = "The request www.example.com was not expected to execute but it executed 1 time"
expected_text << @executed_requests_info
expect(@verifier.failure_message_when_negated).to eq(expected_text)
end
context "at_least_times_executed is set" do
it "reports failure message correctly when executed times is one" do
@verifier.times_executed = 3
@verifier.at_least_times_executed = 2
expected_text = "The request www.example.com was not expected to execute at least 2 times but it executed 3 times"
expected_text << @executed_requests_info
expect(@verifier.failure_message_when_negated).to eq(expected_text)
end
it "reports failure message correctly when executed times is two" do
@verifier.times_executed = 2
@verifier.at_least_times_executed = 2
expected_text = "The request www.example.com was not expected to execute at least 2 times but it executed 2 times"
expected_text << @executed_requests_info
expect(@verifier.failure_message_when_negated).to eq(expected_text)
end
end
context "at_most_times_executed is set" do
it "reports failure message correctly when executed times is three" do
@verifier.times_executed = 2
@verifier.at_most_times_executed = 3
expected_text = "The request www.example.com was not expected to execute at most 3 times but it executed 2 times"
expected_text << @executed_requests_info
expect(@verifier.failure_message_when_negated).to eq(expected_text)
end
it "reports failure message correctly when executed times is one" do
@verifier.times_executed = 1
@verifier.at_most_times_executed = 2
expected_text = "The request www.example.com was not expected to execute at most 2 times but it executed 1 time"
expected_text << @executed_requests_info
expect(@verifier.failure_message_when_negated).to eq(expected_text)
end
end
end
describe "matches?" do
it "succeeds if request was executed expected number of times" do
expect(WebMock::RequestRegistry.instance).
to receive(:times_executed).with(@request_pattern).and_return(10)
@verifier.expected_times_executed = 10
expect(@verifier.matches?).to be_truthy
end
it "fails if request was not executed expected number of times" do
expect(WebMock::RequestRegistry.instance).
to receive(:times_executed).with(@request_pattern).and_return(10)
@verifier.expected_times_executed = 5
expect(@verifier.matches?).to be_falsey
end
end
describe "does_not_match?" do
it "fails if request executed expected number of times" do
expect(WebMock::RequestRegistry.instance).
to receive(:times_executed).with(@request_pattern).and_return(10)
@verifier.expected_times_executed = 10
expect(@verifier.does_not_match?).to be_falsey
end
it "succeeds if request was not executed at all and expected number of times was not set" do
expect(WebMock::RequestRegistry.instance).
to receive(:times_executed).with(@request_pattern).and_return(0)
expect(@verifier.does_not_match?).to be_truthy
end
it "fails if request was executed and expected number of times was not set" do
expect(WebMock::RequestRegistry.instance).
to receive(:times_executed).with(@request_pattern).and_return(1)
expect(@verifier.does_not_match?).to be_falsey
end
it "succeeds if request was not executed expected number of times" do
expect(WebMock::RequestRegistry.instance).
to receive(:times_executed).with(@request_pattern).and_return(10)
@verifier.expected_times_executed = 5
expect(@verifier.does_not_match?).to be_truthy
end
end
end
webmock-1.22.6/spec/unit/request_pattern_spec.rb 0000644 0000041 0000041 00000074365 12646134265 022006 0 ustar www-data www-data require 'spec_helper'
describe WebMock::RequestPattern do
describe "describing itself" do
it "should report string describing itself" do
expect(WebMock::RequestPattern.new(:get, "www.example.com",
:body => "abc", :headers => {'A' => 'a', 'B' => 'b'}).to_s).to eq(
"GET http://www.example.com/ with body \"abc\" with headers {'A'=>'a', 'B'=>'b'}"
)
end
it "should report string describing itself with block" do
expect(WebMock::RequestPattern.new(:get, "www.example.com",
:body => "abc", :headers => {'A' => 'a', 'B' => 'b'}).with {|req| true}.to_s).to eq(
"GET http://www.example.com/ with body \"abc\" with headers {'A'=>'a', 'B'=>'b'} with given block"
)
end
it "should report string describing itself with query params" do
expect(WebMock::RequestPattern.new(:get, /.*example.*/, :query => {'a' => ['b', 'c']}).to_s).to eq(
"GET /.*example.*/ with query params {\"a\"=>[\"b\", \"c\"]}"
)
end
it "should report string describing itself with query params as hash including matcher" do
expect(WebMock::RequestPattern.new(:get, /.*example.*/,
:query => WebMock::Matchers::HashIncludingMatcher.new({'a' => ['b', 'c']})).to_s).to eq(
"GET /.*example.*/ with query params hash_including({\"a\"=>[\"b\", \"c\"]})"
)
end
it "should report string describing itself with body as hash including matcher" do
expect(WebMock::RequestPattern.new(:get, /.*example.*/,
:body => WebMock::Matchers::HashIncludingMatcher.new({'a' => ['b', 'c']})).to_s).to eq(
"GET /.*example.*/ with body hash_including({\"a\"=>[\"b\", \"c\"]})"
)
end
end
describe "with" do
before(:each) do
@request_pattern =WebMock::RequestPattern.new(:get, "www.example.com")
end
it "should have assigned body pattern" do
@request_pattern.with(:body => "abc")
expect(@request_pattern.to_s).to eq(WebMock::RequestPattern.new(:get, "www.example.com", :body => "abc").to_s)
end
it "should have assigned normalized headers pattern" do
@request_pattern.with(:headers => {'A' => 'a'})
expect(@request_pattern.to_s).to eq(WebMock::RequestPattern.new(:get, "www.example.com", :headers => {'A' => 'a'}).to_s)
end
it "should raise an error if options passed to `with` are invalid" do
expect { @request_pattern.with(:foo => "bar") }.to raise_error('Unknown key: "foo". Valid keys are: "body", "headers", "query"')
end
it "should raise an error if neither options or block is provided" do
expect { @request_pattern.with() }.to raise_error('#with method invoked with no arguments. Either options hash or block must be specified.')
end
end
class WebMock::RequestPattern
def match(request_signature)
self.matches?(request_signature)
end
end
describe "when matching" do
it "should match if uri matches and method matches" do
expect(WebMock::RequestPattern.new(:get, "www.example.com")).
to match(WebMock::RequestSignature.new(:get, "www.example.com"))
end
it "should match if uri matches and method pattern is any" do
expect(WebMock::RequestPattern.new(:any, "www.example.com")).
to match(WebMock::RequestSignature.new(:get, "www.example.com"))
end
it "should not match if request has different method" do
expect(WebMock::RequestPattern.new(:post, "www.example.com")).
not_to match(WebMock::RequestSignature.new(:get, "www.example.com"))
end
it "should match if uri matches request uri" do
expect(WebMock::RequestPattern.new(:get, "www.example.com")).
to match(WebMock::RequestSignature.new(:get, "www.example.com"))
end
it "should match if request has unescaped uri" do
expect(WebMock::RequestPattern.new(:get, "www.example.com/my%20path")).
to match(WebMock::RequestSignature.new(:get, "www.example.com/my path"))
end
it "should match if request has escaped uri" do
expect(WebMock::RequestPattern.new(:get, "www.example.com/my path")).
to match(WebMock::RequestSignature.new(:get, "www.example.com/my%20path"))
end
it "should match if uri regexp pattern matches unescaped form of request uri" do
expect(WebMock::RequestPattern.new(:get, /.*my path.*/)).
to match(WebMock::RequestSignature.new(:get, "www.example.com/my%20path"))
end
it "should match if uri regexp pattern matches request uri" do
expect(WebMock::RequestPattern.new(:get, /.*example.*/)).
to match(WebMock::RequestSignature.new(:get, "www.example.com"))
end
it "should match if uri Addressable::Template pattern matches unescaped form of request uri" do
expect(WebMock::RequestPattern.new(:get, Addressable::Template.new("www.example.com/{any_path}"))).
to match(WebMock::RequestSignature.new(:get, "www.example.com/my%20path"))
end
it "should match if uri Addressable::Template pattern matches request uri" do
expect(WebMock::RequestPattern.new(:get, Addressable::Template.new("www.example.com"))).
to match(WebMock::RequestSignature.new(:get, "www.example.com"))
end
it "should match for uris with same parameters as pattern" do
expect(WebMock::RequestPattern.new(:get, "www.example.com?a=1&b=2")).
to match(WebMock::RequestSignature.new(:get, "www.example.com?a=1&b=2"))
end
it "should not match for uris with different parameters" do
expect(WebMock::RequestPattern.new(:get, "www.example.com?a=1&b=2")).
not_to match(WebMock::RequestSignature.new(:get, "www.example.com?a=2&b=1"))
end
it "should match for uri parameters in different order" do
expect(WebMock::RequestPattern.new(:get, "www.example.com?b=2&a=1")).
to match(WebMock::RequestSignature.new(:get, "www.example.com?a=1&b=2"))
end
describe "when parameters are escaped" do
it "should match if uri pattern has escaped parameters and request has unescaped parameters" do
expect(WebMock::RequestPattern.new(:get, "www.example.com/?a=a%20b")).
to match(WebMock::RequestSignature.new(:get, "www.example.com/?a=a b"))
end
it "should match if uri pattern has unescaped parameters and request has escaped parameters" do
expect(WebMock::RequestPattern.new(:get, "www.example.com/?a=a b")).
to match(WebMock::RequestSignature.new(:get, "www.example.com/?a=a%20b"))
end
it "should match if uri regexp pattern matches uri with unescaped parameters and request has escaped parameters" do
expect(WebMock::RequestPattern.new(:get, /.*a=a b.*/)).
to match(WebMock::RequestSignature.new(:get, "www.example.com/?a=a%20b"))
end
it "should match if uri regexp pattern matches uri with escaped parameters and request has unescaped parameters" do
expect(WebMock::RequestPattern.new(:get, /.*a=a%20b.*/)).
to match(WebMock::RequestSignature.new(:get, "www.example.com/?a=a b"))
end
it "should match if uri Addressable::Template pattern matches uri without parameter value and request has escaped parameters" do
expect(WebMock::RequestPattern.new(:get, Addressable::Template.new("www.example.com/{?a}"))).
to match(WebMock::RequestSignature.new(:get, "www.example.com/?a=a%20b"))
end
it "should match if uri Addressable::Template pattern matches uri without parameter value and request has unescaped parameters" do
expect(WebMock::RequestPattern.new(:get, Addressable::Template.new("www.example.com/{?a}"))).
to match(WebMock::RequestSignature.new(:get, "www.example.com/?a=a b"))
end
it "should match if uri Addressable::Template pattern matches uri with unescaped parameter value and request has unescaped parameters" do
expect(WebMock::RequestPattern.new(:get, Addressable::Template.new("www.example.com/?a=a b"))).
to match(WebMock::RequestSignature.new(:get, "www.example.com/?a=a b"))
end
it "should match if uri Addressable::Template pattern matches uri with escaped parameter value and request has escaped parameters" do
expect(WebMock::RequestPattern.new(:get, Addressable::Template.new("www.example.com/?a=a%20b"))).
to match(WebMock::RequestSignature.new(:get, "www.example.com/?a=a%20b"))
end
end
describe "when matching requests on query params" do
describe "when uri is described as regexp" do
it "should match request query params" do
expect(WebMock::RequestPattern.new(:get, /.*example.*/, :query => {"a" => ["b", "c"]})).
to match(WebMock::RequestSignature.new(:get, "www.example.com?a[]=b&a[]=c"))
end
it "should match request query params if params don't match" do
expect(WebMock::RequestPattern.new(:get, /.*example.*/, :query => {"x" => ["b", "c"]})).
not_to match(WebMock::RequestSignature.new(:get, "www.example.com?a[]=b&a[]=c"))
end
it "should match when query params are declared as HashIncluding matcher matching params" do
expect(WebMock::RequestPattern.new(:get, /.*example.*/,
:query => WebMock::Matchers::HashIncludingMatcher.new({"a" => ["b", "c"]}))).
to match(WebMock::RequestSignature.new(:get, "www.example.com?a[]=b&a[]=c&b=1"))
end
it "should not match when query params are declared as HashIncluding matcher not matching params" do
expect(WebMock::RequestPattern.new(:get, /.*example.*/,
:query => WebMock::Matchers::HashIncludingMatcher.new({"x" => ["b", "c"]}))).
not_to match(WebMock::RequestSignature.new(:get, "www.example.com?a[]=b&a[]=c&b=1"))
end
it "should match when query params are declared as RSpec HashIncluding matcher matching params" do
expect(WebMock::RequestPattern.new(:get, /.*example.*/,
:query => RSpec::Mocks::ArgumentMatchers::HashIncludingMatcher.new({"a" => ["b", "c"]}))).
to match(WebMock::RequestSignature.new(:get, "www.example.com?a[]=b&a[]=c&b=1"))
end
it "should not match when query params are declared as RSpec HashIncluding matcher not matching params" do
expect(WebMock::RequestPattern.new(:get, /.*example.*/,
:query => RSpec::Mocks::ArgumentMatchers::HashIncludingMatcher.new({"a" => ["b", "d"]}))).
not_to match(WebMock::RequestSignature.new(:get, "www.example.com?a[]=b&a[]=c&b=1"))
end
end
describe "when uri is described as Addressable::Template" do
it "should raise error if query params are specified" do
expect(WebMock::RequestPattern.new(:get, Addressable::Template.new("www.example.com"), :query => {"a" => ["b", "c"]})).
to match(WebMock::RequestSignature.new(:get, "www.example.com?a[]=b&a[]=c"))
end
it "should match request query params if params don't match" do
expect(WebMock::RequestPattern.new(:get, Addressable::Template.new("www.example.com"), :query => {"x" => ["b", "c"]})).
not_to match(WebMock::RequestSignature.new(:get, "www.example.com?a[]=b&a[]=c"))
end
it "should match when query params are declared as HashIncluding matcher matching params" do
expect(WebMock::RequestPattern.new(:get, Addressable::Template.new("www.example.com"),
:query => WebMock::Matchers::HashIncludingMatcher.new({"a" => ["b", "c"]}))).
to match(WebMock::RequestSignature.new(:get, "www.example.com?a[]=b&a[]=c&b=1"))
end
it "should not match when query params are declared as HashIncluding matcher not matching params" do
expect(WebMock::RequestPattern.new(:get, Addressable::Template.new("www.example.com"),
:query => WebMock::Matchers::HashIncludingMatcher.new({"x" => ["b", "c"]}))).
not_to match(WebMock::RequestSignature.new(:get, "www.example.com?a[]=b&a[]=c&b=1"))
end
it "should match when query params are declared as RSpec HashIncluding matcher matching params" do
expect(WebMock::RequestPattern.new(:get, Addressable::Template.new("www.example.com"),
:query => RSpec::Mocks::ArgumentMatchers::HashIncludingMatcher.new({"a" => ["b", "c"]}))).
to match(WebMock::RequestSignature.new(:get, "www.example.com?a[]=b&a[]=c&b=1"))
end
it "should not match when query params are declared as RSpec HashIncluding matcher not matching params" do
expect(WebMock::RequestPattern.new(:get, Addressable::Template.new("www.example.com"),
:query => RSpec::Mocks::ArgumentMatchers::HashIncludingMatcher.new({"a" => ["b", "d"]}))).
not_to match(WebMock::RequestSignature.new(:get, "www.example.com?a[]=b&a[]=c&b=1"))
end
end
describe "when uri is described as string" do
it "should match when query params are the same as declared in hash" do
expect(WebMock::RequestPattern.new(:get, "www.example.com", :query => {"a" => ["b", "c"]})).
to match(WebMock::RequestSignature.new(:get, "www.example.com?a[]=b&a[]=c"))
end
it "should not match when query params are different than the declared in hash" do
expect(WebMock::RequestPattern.new(:get, "www.example.com", :query => {"a" => ["b", "c"]})).
not_to match(WebMock::RequestSignature.new(:get, "www.example.com?x[]=b&a[]=c"))
end
it "should match when query params are the same as declared as string" do
expect(WebMock::RequestPattern.new(:get, "www.example.com", :query => "a[]=b&a[]=c")).
to match(WebMock::RequestSignature.new(:get, "www.example.com?a[]=b&a[]=c"))
end
it "should match when query params are the same as declared both in query option or url" do
expect(WebMock::RequestPattern.new(:get, "www.example.com/?x=3", :query => "a[]=b&a[]=c")).
to match(WebMock::RequestSignature.new(:get, "www.example.com/?x=3&a[]=b&a[]=c"))
end
it "should match when query params are declared as HashIncluding matcher matching params" do
expect(WebMock::RequestPattern.new(:get, "www.example.com",
:query => WebMock::Matchers::HashIncludingMatcher.new({"a" => ["b", "c"]}))).
to match(WebMock::RequestSignature.new(:get, "www.example.com?a[]=b&a[]=c&b=1"))
end
it "should not match when query params are declared as HashIncluding matcher not matching params" do
expect(WebMock::RequestPattern.new(:get, "www.example.com",
:query => WebMock::Matchers::HashIncludingMatcher.new({"x" => ["b", "c"]}))).
not_to match(WebMock::RequestSignature.new(:get, "www.example.com?a[]=b&a[]=c&b=1"))
end
it "should match when query params are declared as RSpec HashIncluding matcher matching params" do
expect(WebMock::RequestPattern.new(:get, "www.example.com",
:query => RSpec::Mocks::ArgumentMatchers::HashIncludingMatcher.new({"a" => ["b", "c"]}))).
to match(WebMock::RequestSignature.new(:get, "www.example.com?a[]=b&a[]=c&b=1"))
end
it "should not match when query params are declared as RSpec HashIncluding matcher not matching params" do
expect(WebMock::RequestPattern.new(:get, "www.example.com",
:query => RSpec::Mocks::ArgumentMatchers::HashIncludingMatcher.new({"a" => ["b", "d"]}))).
not_to match(WebMock::RequestSignature.new(:get, "www.example.com?a[]=b&a[]=c&b=1"))
end
context "when using query values notation as flat array" do
before :all do
WebMock::Config.instance.query_values_notation = :flat_array
end
it "should not match when repeated query params are not the same as declared as string" do
expect(WebMock::RequestPattern.new(:get, "www.example.com", :query => "a=b&a=c")).
to match(WebMock::RequestSignature.new(:get, "www.example.com?a=b&a=c"))
end
after :all do
WebMock::Config.instance.query_values_notation = nil
end
end
end
end
describe "when matching requests with body" do
it "should match if request body and body pattern are the same" do
expect(WebMock::RequestPattern.new(:get, "www.example.com", :body => "abc")).
to match(WebMock::RequestSignature.new(:get, "www.example.com", :body => "abc"))
end
it "should match if request body matches regexp" do
expect(WebMock::RequestPattern.new(:get, "www.example.com", :body => /^abc$/)).
to match(WebMock::RequestSignature.new(:get, "www.example.com", :body => "abc"))
end
it "should not match if body pattern is different than request body" do
expect(WebMock::RequestPattern.new(:get, "www.example.com", :body => "def")).
not_to match(WebMock::RequestSignature.new(:get, "www.example.com", :body => "abc"))
end
it "should not match if request body doesn't match regexp pattern" do
expect(WebMock::RequestPattern.new(:get, "www.example.com", :body => /^abc$/)).
not_to match(WebMock::RequestSignature.new(:get, "www.example.com", :body => "xabc"))
end
it "should match if pattern doesn't have specified body" do
expect(WebMock::RequestPattern.new(:get, "www.example.com")).
to match(WebMock::RequestSignature.new(:get, "www.example.com", :body => "abc"))
end
it "should not match if pattern has body specified as nil but request body is not empty" do
expect(WebMock::RequestPattern.new(:get, "www.example.com", :body => nil)).
not_to match(WebMock::RequestSignature.new(:get, "www.example.com", :body => "abc"))
end
it "should not match if pattern has empty body but request body is not empty" do
expect(WebMock::RequestPattern.new(:get, "www.example.com", :body => "")).
not_to match(WebMock::RequestSignature.new(:get, "www.example.com", :body => "abc"))
end
it "should not match if pattern has body specified but request has no body" do
expect(WebMock::RequestPattern.new(:get, "www.example.com", :body => "abc")).
not_to match(WebMock::RequestSignature.new(:get, "www.example.com"))
end
describe "when body in pattern is declared as a hash" do
let(:body_hash) { {:a => '1', :b => 'five', 'c' => {'d' => ['e', 'f']}} }
describe "for request with url encoded body" do
it "should match when hash matches body" do
expect(WebMock::RequestPattern.new(:post, 'www.example.com', :body => body_hash)).
to match(WebMock::RequestSignature.new(:post, "www.example.com", :body => 'a=1&c[d][]=e&c[d][]=f&b=five'))
end
it "should match when hash matches body in different order of params" do
expect(WebMock::RequestPattern.new(:post, 'www.example.com', :body => body_hash)).
to match(WebMock::RequestSignature.new(:post, "www.example.com", :body => 'a=1&c[d][]=e&b=five&c[d][]=f'))
end
it "should not match when hash doesn't match url encoded body" do
expect(WebMock::RequestPattern.new(:post, 'www.example.com', :body => body_hash)).
not_to match(WebMock::RequestSignature.new(:post, "www.example.com", :body => 'c[d][]=f&a=1&c[d][]=e'))
end
it "should not match when body is not url encoded" do
expect(WebMock::RequestPattern.new(:post, 'www.example.com', :body => body_hash)).
not_to match(WebMock::RequestSignature.new(:post, "www.example.com", :body => 'foo bar'))
end
it "should match when hash contains regex values" do
expect(WebMock::RequestPattern.new(:post, "www.example.com", :body => {:a => /^\w{5}$/, :b => {:c => /^\d{3}$/}})).
to match(WebMock::RequestSignature.new(:post, "www.example.com", :body => 'a=abcde&b[c]=123'))
end
it "should not match when hash does not contains regex values" do
expect(WebMock::RequestPattern.new(:post, "www.example.com", :body => {:a => /^\d+$/, :b => {:c => /^\d{3}$/}})).
not_to match(WebMock::RequestSignature.new(:post, "www.example.com", :body => 'a=abcde&b[c]=123'))
end
end
describe "for request with json body and content type is set to json" do
it "should match when hash matches body" do
expect(WebMock::RequestPattern.new(:post, 'www.example.com', :body => body_hash)).
to match(WebMock::RequestSignature.new(:post, "www.example.com", :headers => {:content_type => 'application/json'},
:body => "{\"a\":\"1\",\"c\":{\"d\":[\"e\",\"f\"]},\"b\":\"five\"}"))
end
it "should match if hash matches body in different form" do
expect(WebMock::RequestPattern.new(:post, 'www.example.com', :body => body_hash)).
to match(WebMock::RequestSignature.new(:post, "www.example.com", :headers => {:content_type => 'application/json'},
:body => "{\"a\":\"1\",\"b\":\"five\",\"c\":{\"d\":[\"e\",\"f\"]}}"))
end
it "should not match when body is not json" do
expect(WebMock::RequestPattern.new(:post, 'www.example.com', :body => body_hash)).
not_to match(WebMock::RequestSignature.new(:post, "www.example.com",
:headers => {:content_type => 'application/json'}, :body => "foo bar"))
end
it "should not match if request body is different" do
expect(WebMock::RequestPattern.new(:post, 'www.example.com', :body => {:a => 1, :b => 2})).
not_to match(WebMock::RequestSignature.new(:post, "www.example.com",
:headers => {:content_type => 'application/json'}, :body => "{\"a\":1,\"c\":null}"))
end
it "should not match if request body is has less params than pattern" do
expect(WebMock::RequestPattern.new(:post, 'www.example.com', :body => {:a => 1, :b => 2})).
not_to match(WebMock::RequestSignature.new(:post, "www.example.com",
:headers => {:content_type => 'application/json'}, :body => "{\"a\":1}"))
end
it "should not match if request body is has more params than pattern" do
expect(WebMock::RequestPattern.new(:post, 'www.example.com', :body => {:a => 1})).
not_to match(WebMock::RequestSignature.new(:post, "www.example.com",
:headers => {:content_type => 'application/json'}, :body => "{\"a\":1,\"c\":1}"))
end
end
describe "for request with xml body and content type is set to xml" do
let(:body_hash) { {"opt" => {:a => '1', :b => 'five', 'c' => {'d' => ['e', 'f']}}} }
it "should match when hash matches body" do
expect(WebMock::RequestPattern.new(:post, 'www.example.com', :body => body_hash)).
to match(WebMock::RequestSignature.new(:post, "www.example.com", :headers => {:content_type => 'application/xml'},
:body => "\n \n e\n f\n \n\n"))
end
it "should match if hash matches body in different form" do
expect(WebMock::RequestPattern.new(:post, 'www.example.com', :body => body_hash)).
to match(WebMock::RequestSignature.new(:post, "www.example.com", :headers => {:content_type => 'application/xml'},
:body => "\n \n e\n f\n \n\n"))
end
it "should not match when body is not xml" do
expect(WebMock::RequestPattern.new(:post, 'www.example.com', :body => body_hash)).
not_to match(WebMock::RequestSignature.new(:post, "www.example.com",
:headers => {:content_type => 'application/xml'}, :body => "foo bar"))
end
it "matches when the content type include a charset" do
expect(WebMock::RequestPattern.new(:post, 'www.example.com', :body => body_hash)).
to match(WebMock::RequestSignature.new(:post, "www.example.com", :headers => {:content_type => 'application/xml;charset=UTF-8'},
:body => "\n \n e\n f\n \n\n"))
end
end
end
describe "when body in a pattern is declared as a partial hash matcher" do
let(:signature) { WebMock::RequestSignature.new(:post, "www.example.com", :body => 'a=1&c[d][]=e&c[d][]=f&b=five') }
it "should match when query params are declared as HashIncluding matcher matching params" do
expect(WebMock::RequestPattern.new(:post, "www.example.com",
:body => WebMock::Matchers::HashIncludingMatcher.new({:a => '1', 'c' => {'d' => ['e', 'f']}}))).
to match(signature)
end
it "should not match when query params are declared as HashIncluding matcher not matching params" do
expect(WebMock::RequestPattern.new(:post, "www.example.com",
:body => WebMock::Matchers::HashIncludingMatcher.new({:x => '1', 'c' => {'d' => ['e', 'f']}}))).
not_to match(signature)
end
it "should match when query params are declared as RSpec HashIncluding matcher matching params" do
expect(WebMock::RequestPattern.new(:post, "www.example.com",
:body => RSpec::Mocks::ArgumentMatchers::HashIncludingMatcher.new({:a => '1', 'c' => {'d' => ['e', 'f']}}))).
to match(signature)
end
it "should not match when query params are declared as RSpec HashIncluding matcher not matching params" do
expect(WebMock::RequestPattern.new(:post, "www.example.com",
:body => RSpec::Mocks::ArgumentMatchers::HashIncludingMatcher.new({:x => '1', 'c' => {'d' => ['e', 'f']}}))).
not_to match(signature)
end
end
end
it "should match if pattern and request have the same headers" do
expect(WebMock::RequestPattern.new(:get, "www.example.com", :headers => {'Content-Type' => 'image/jpeg'})).
to match(WebMock::RequestSignature.new(:get, "www.example.com", :headers => {'Content-Type' => 'image/jpeg'}))
end
it "should match if pattern headers values are regexps matching request header values" do
expect(WebMock::RequestPattern.new(:get, "www.example.com", :headers => {'Content-Type' => %r{^image/jpeg$}})).
to match(WebMock::RequestSignature.new(:get, "www.example.com", :headers => {'Content-Type' => 'image/jpeg'}))
end
it "should not match if pattern has different value of header than request" do
expect(WebMock::RequestPattern.new(:get, "www.example.com", :headers => {'Content-Type' => 'image/png'})).
not_to match(WebMock::RequestSignature.new(:get, "www.example.com", :headers => {'Content-Type' => 'image/jpeg'}))
end
it "should not match if pattern header value regexp doesn't match request header value" do
expect(WebMock::RequestPattern.new(:get, "www.example.com", :headers => {'Content-Type' => %r{^image\/jpeg$}})).
not_to match(WebMock::RequestSignature.new(:get, "www.example.com", :headers => {'Content-Type' => 'image/jpegx'}))
end
it "should match if request has more headers than request pattern" do
expect(WebMock::RequestPattern.new(:get, "www.example.com", :headers => {'Content-Type' => 'image/jpeg'})).
to match(WebMock::RequestSignature.new(:get, "www.example.com", :headers => {'Content-Type' => 'image/jpeg', 'Content-Length' => '8888'}))
end
it "should not match if request has less headers than the request pattern" do
expect(WebMock::RequestPattern.new(:get, "www.example.com", :headers => {'Content-Type' => 'image/jpeg', 'Content-Length' => '8888'})).
not_to match(WebMock::RequestSignature.new(:get, "www.example.com", :headers => {'Content-Type' => 'image/jpeg'}))
end
it "should match even is header keys are declared in different form" do
expect(WebMock::RequestPattern.new(:get, "www.example.com", :headers => {'ContentLength' => '8888', 'Content-type' => 'image/png'})).
to match(WebMock::RequestSignature.new(:get, "www.example.com", :headers => {:ContentLength => 8888, 'content_type' => 'image/png'}))
end
it "should match is pattern doesn't have specified headers" do
expect(WebMock::RequestPattern.new(:get, "www.example.com")).
to match(WebMock::RequestSignature.new(:get, "www.example.com", :headers => {'A' => 'a'}))
end
it "should not match if pattern has nil headers but request has headers" do
expect(WebMock::RequestPattern.new(:get, "www.example.com", :headers => nil)).
not_to match(WebMock::RequestSignature.new(:get, "www.example.com", :headers => {'A' => 'a'}))
end
it "should not match if pattern has empty headers but request has headers" do
expect(WebMock::RequestPattern.new(:get, "www.example.com", :headers => {})).
not_to match(WebMock::RequestSignature.new(:get, "www.example.com", :headers => {'A' => 'a'}))
end
it "should not match if pattern has specified headers but request has nil headers" do
expect(WebMock::RequestPattern.new(:get, "www.example.com", :headers => {'A'=>'a'})).
not_to match(WebMock::RequestSignature.new(:get, "www.example.com"))
end
it "should not match if pattern has specified headers but request has empty headers" do
expect(WebMock::RequestPattern.new(:get, "www.example.com", :headers => {'A'=>'a'})).
not_to match(WebMock::RequestSignature.new(:get, "www.example.com", :headers => {}))
end
it "should match if block given in pattern evaluates request to true" do
expect(WebMock::RequestPattern.new(:get, "www.example.com").with { |request| true }).
to match(WebMock::RequestSignature.new(:get, "www.example.com"))
end
it "should not match if block given in pattrn evaluates request to false" do
expect(WebMock::RequestPattern.new(:get, "www.example.com").with { |request| false }).
not_to match(WebMock::RequestSignature.new(:get, "www.example.com"))
end
it "should yield block with request signature" do
signature = WebMock::RequestSignature.new(:get, "www.example.com")
expect(WebMock::RequestPattern.new(:get, "www.example.com").with { |request| request == signature }).
to match(signature)
end
end
end
webmock-1.22.6/spec/unit/response_spec.rb 0000644 0000041 0000041 00000021710 12646134265 020401 0 ustar www-data www-data require 'spec_helper'
describe WebMock::ResponseFactory do
describe "response_for" do
it "should create response with options passed as arguments" do
options = {:body => "abc", :headers => {:a => :b}}
expect(WebMock::Response).to receive(:new).with(options).and_return(@response = double(WebMock::Response))
expect(WebMock::ResponseFactory.response_for(options)).to eq(@response)
end
it "should create dynamic response for argument responding to call" do
callable = double(:call => {:body => "abc"})
expect(WebMock::DynamicResponse).to receive(:new).with(callable).and_return(@response = double(WebMock::Response))
expect(WebMock::ResponseFactory.response_for(callable)).to eq(@response)
end
end
end
describe WebMock::Response do
before(:each) do
@response = WebMock::Response.new(:headers => {'A' => 'a'})
end
it "should raise an error when initialized with unknown option" do
expect { WebMock::Response.new(:foo => "bar") }.to raise_error('Unknown key: "foo". Valid keys are: "headers", "status", "body", "exception", "should_timeout"')
end
it "should report normalized headers" do
expect(WebMock::Util::Headers).to receive(:normalize_headers).with('A' => 'a').and_return('B' => 'b')
@response = WebMock::Response.new(:headers => {'A' => 'a'})
expect(@response.headers).to eq({'B' => 'b'})
end
describe "status" do
it "should have 200 code and empty message by default" do
expect(@response.status).to eq([200, ""])
end
it "should return assigned status" do
@response = WebMock::Response.new(:status => 500)
expect(@response.status).to eq([500, ""])
end
it "should return assigned message" do
@response = WebMock::Response.new(:status => [500, "Internal Server Error"])
expect(@response.status).to eq([500, "Internal Server Error"])
end
end
describe "raising error" do
it "should raise error if any assigned" do
@response = WebMock::Response.new(:exception => ArgumentError)
expect {
@response.raise_error_if_any
}.to raise_error(ArgumentError, "Exception from WebMock")
end
it "should raise error if any assigned as instance" do
@response = WebMock::Response.new(:exception => ArgumentError.new("hello world"))
expect {
@response.raise_error_if_any
}.to raise_error(ArgumentError, "hello world")
end
it "should raise error if any assigned as string" do
@response = WebMock::Response.new(:exception => "hello world")
expect {
@response.raise_error_if_any
}.to raise_error("hello world")
end
it "should not raise error if no error assigned" do
@response.raise_error_if_any
end
end
describe "timeout" do
it "should know if it should timeout" do
@response = WebMock::Response.new(:should_timeout => true)
expect(@response.should_timeout).to be_truthy
end
it "should not timeout by default" do
@response = WebMock::Response.new
expect(@response.should_timeout).to be_falsey
end
end
describe "body" do
it "should return empty body by default" do
expect(@response.body).to eq('')
end
it "should report body if assigned" do
@response = WebMock::Response.new(:body => "abc")
expect(@response.body).to eq("abc")
end
it "should report string even if existing file path was provided" do
@response = WebMock::Response.new(:body => __FILE__)
expect(@response.body).to eq(__FILE__)
end
it "should report content of a IO object if provided" do
@response = WebMock::Response.new(:body => File.new(__FILE__))
expect(@response.body).to eq(File.read(__FILE__))
end
it "should report many times content of a IO object if provided" do
@response = WebMock::Response.new(:body => File.new(__FILE__))
expect(@response.body).to eq(File.read(__FILE__))
expect(@response.body).to eq(File.read(__FILE__))
end
it "should work with Pathnames" do
@response = WebMock::Response.new(:body => Pathname.new(__FILE__))
expect(@response.body).to eq(File.read(__FILE__))
end
# Users of webmock commonly make the mistake of stubbing the response
# body to return a hash, to prevent this:
#
it "should error if not given one of the allowed types" do
expect { WebMock::Response.new(:body => Hash.new) }.to \
raise_error(WebMock::Response::InvalidBody)
end
end
describe "from raw response" do
describe "when input is IO" do
before(:each) do
@file = File.new(CURL_EXAMPLE_OUTPUT_PATH)
@response = WebMock::Response.new(@file)
end
it "should read status" do
expect(@response.status).to eq([202, "OK"])
end
it "should read headers" do
expect(@response.headers).to eq({
"Date"=>"Sat, 23 Jan 2010 01:01:05 GMT",
"Content-Type"=>"text/html; charset=UTF-8",
"Content-Length"=>"419",
"Connection"=>"Keep-Alive",
"Accept"=>"image/jpeg, image/png"
})
end
it "should read body" do
expect(@response.body.size).to eq(419)
end
it "should close IO" do
expect(@file).to be_closed
end
end
describe "when input is String" do
before(:each) do
@input = File.read(CURL_EXAMPLE_OUTPUT_PATH)
@response = WebMock::Response.new(@input)
end
it "should read status" do
expect(@response.status).to eq([202, "OK"])
end
it "should read headers" do
expect(@response.headers).to eq({
"Date"=>"Sat, 23 Jan 2010 01:01:05 GMT",
"Content-Type"=>"text/html; charset=UTF-8",
"Content-Length"=>"419",
"Connection"=>"Keep-Alive",
"Accept"=>"image/jpeg, image/png"
})
end
it "should read body" do
expect(@response.body.size).to eq(419)
end
it "should work with transfer-encoding set to chunked" do
@input.gsub!("Content-Length: 419", "Transfer-Encoding: chunked")
@response = WebMock::Response.new(@input)
expect(@response.body.size).to eq(419)
end
end
describe "with dynamically evaluated options" do
before(:each) do
@request_signature = WebMock::RequestSignature.new(:post, "www.example.com", :body => "abc", :headers => {'A' => 'a'})
end
it "should have evaluated body" do
@response = WebMock::Response.new(:body => lambda {|request| request.body})
expect(@response.evaluate(@request_signature).body).to eq("abc")
end
it "should have evaluated headers" do
@response = WebMock::Response.new(:headers => lambda {|request| request.headers})
expect(@response.evaluate(@request_signature).headers).to eq({'A' => 'a'})
end
it "should have evaluated status" do
@response = WebMock::Response.new(:status => lambda {|request| 302})
expect(@response.evaluate(@request_signature).status).to eq([302, ""])
end
end
end
describe WebMock::DynamicResponse do
describe "evaluating response options" do
it "should evaluate new response with evaluated options" do
request_signature = WebMock::RequestSignature.new(:post, "www.example.com", :body => "abc", :headers => {'A' => 'a'})
response = WebMock::DynamicResponse.new(lambda {|request|
{
:body => request.body,
:headers => request.headers,
:status => 302
}
})
evaluated_response = response.evaluate(request_signature)
expect(evaluated_response.body).to eq("abc")
expect(evaluated_response.headers).to eq({'A' => 'a'})
expect(evaluated_response.status).to eq([302, ""])
end
it "should be equal to static response after evaluation" do
request_signature = WebMock::RequestSignature.new(:post, "www.example.com", :body => "abc")
response = WebMock::DynamicResponse.new(lambda {|request| {:body => request.body}})
evaluated_response = response.evaluate(request_signature)
expect(evaluated_response).to eq(WebMock::Response.new(:body => "abc"))
end
describe "when raw response is evaluated" do
before(:each) do
@files = {
"www.example.com" => File.new(CURL_EXAMPLE_OUTPUT_PATH)
}
@request_signature = WebMock::RequestSignature.new(:get, "www.example.com")
end
describe "as a file" do
it "should return response" do
response = WebMock::DynamicResponse.new(lambda {|request| @files[request.uri.host.to_s] })
expect(response.evaluate(@request_signature).body.size).to eq(419)
end
end
describe "as a string" do
it "should return response" do
response = WebMock::DynamicResponse.new(lambda {|request| @files[request.uri.host.to_s].read })
expect(response.evaluate(@request_signature).body.size).to eq(419)
end
end
end
end
end
end
webmock-1.22.6/spec/unit/matchers/ 0000755 0000041 0000041 00000000000 12646134265 017011 5 ustar www-data www-data webmock-1.22.6/spec/unit/matchers/hash_including_matcher_spec.rb 0000644 0000041 0000041 00000005746 12646134265 025046 0 ustar www-data www-data require 'spec_helper'
module WebMock
module Matchers
describe HashIncludingMatcher do
it "stringifies the given hash keys" do
expect(HashIncludingMatcher.new(:a => 1, :b => 2)).to eq("a" => 1, "b" => 2)
end
it "sorts elements in the hash" do
expect(HashIncludingMatcher.new(:b => 2, :a => 1)).to eq("a" => 1, "b" => 2)
end
it "describes itself properly" do
expect(HashIncludingMatcher.new(:a => 1).inspect).to eq "hash_including({\"a\"=>1})"
end
describe "success" do
it "matches the same hash" do
expect(HashIncludingMatcher.new("a" => 1, "b" => 2)).to eq("a" => 1, "b" => 2)
end
it "matches a hash with extra stuff" do
expect(HashIncludingMatcher.new(:a => 1)).to eq("a" => 1, "b" => 2)
end
describe "when matching anythingized keys" do
let(:anything) { WebMock::Matchers::AnyArgMatcher.new(nil) }
it "matches an int against anything()" do
expect(HashIncludingMatcher.new(:a => anything, :b => 2)).to eq({'a' => 1, 'b' => 2})
end
it "matches a string against anything()" do
expect(HashIncludingMatcher.new(:a => anything, :b => 2)).to eq({'a' => "1", 'b' => 2})
end
it "matches if the key is present" do
expect(HashIncludingMatcher.new(:a => anything)).to eq({'a' => 1, 'b' => 2})
end
it "matches if more keys are present" do
expect(HashIncludingMatcher.new(:a => anything, :b => anything)).to eq({'a' => 1, 'b' => 2, 'c' => 3})
end
it "matches if passed many keys and many key/value pairs" do
expect(HashIncludingMatcher.new(:a => anything, :b => anything, :c => 3, :e => 5)).to eq({'a' => 1, 'b' => 2, 'c' => 3, 'd' => 4, 'e' => 5})
end
end
describe "when matching an empty hash" do
it "matches against any hash" do
expect(HashIncludingMatcher.new({})).to eq({:a => 1, :b => 2, :c => 3})
end
end
end
describe "failing" do
it "does not match a non-hash" do
expect(HashIncludingMatcher.new(:a => 1)).not_to eq 1
end
it "does not match a hash with a missing key" do
expect(HashIncludingMatcher.new(:a => 1)).not_to eq('b' => 2)
end
it "does not match an empty hash with a given key" do
expect(HashIncludingMatcher.new(:a => 1)).not_to eq({})
end
it "does not match a hash with a missing key when one pair is matching" do
expect(HashIncludingMatcher.new(:a => 1, :b => 2)).not_to eq('b' => 2)
end
it "does not match a hash with an incorrect value" do
expect(HashIncludingMatcher.new(:a => 1, :b => 2)).not_to eq('a' => 1, 'b' => 3)
end
it "does not match when values are nil but keys are different" do
expect(HashIncludingMatcher.new(:a => nil)).not_to eq('b' => nil)
end
end
end
end
end
webmock-1.22.6/spec/unit/request_registry_spec.rb 0000644 0000041 0000041 00000006302 12646134265 022163 0 ustar www-data www-data require 'spec_helper'
describe WebMock::RequestRegistry do
before(:each) do
WebMock::RequestRegistry.instance.reset!
@request_pattern = WebMock::RequestPattern.new(:get, "www.example.com")
@request_signature = WebMock::RequestSignature.new(:get, "www.example.com")
end
describe "reset!" do
before(:each) do
WebMock::RequestRegistry.instance.requested_signatures.put(@request_signature)
end
it "should clean list of executed requests" do
expect(WebMock::RequestRegistry.instance.times_executed(@request_pattern)).to eq(1)
WebMock::RequestRegistry.instance.reset!
expect(WebMock::RequestRegistry.instance.times_executed(@request_pattern)).to eq(0)
end
end
describe "times executed" do
before(:each) do
@request_stub1 = WebMock::RequestStub.new(:get, "www.example.com")
@request_stub2 = WebMock::RequestStub.new(:get, "www.example.net")
@request_stub3 = WebMock::RequestStub.new(:get, "www.example.org")
WebMock::RequestRegistry.instance.requested_signatures.put(WebMock::RequestSignature.new(:get, "www.example.com"))
WebMock::RequestRegistry.instance.requested_signatures.put(WebMock::RequestSignature.new(:get, "www.example.com"))
WebMock::RequestRegistry.instance.requested_signatures.put(WebMock::RequestSignature.new(:get, "www.example.org"))
end
it "should report 0 if no request matching pattern was requested" do
expect(WebMock::RequestRegistry.instance.times_executed(WebMock::RequestPattern.new(:get, "www.example.net"))).to eq(0)
end
it "should report number of times matching pattern was requested" do
expect(WebMock::RequestRegistry.instance.times_executed(WebMock::RequestPattern.new(:get, "www.example.com"))).to eq(2)
end
it "should report number of times all matching pattern were requested" do
expect(WebMock::RequestRegistry.instance.times_executed(WebMock::RequestPattern.new(:get, /.*example.*/))).to eq(3)
end
end
describe "request_signatures" do
it "should return hash of unique request signatures with accumulated number" do
WebMock::RequestRegistry.instance.requested_signatures.put(WebMock::RequestSignature.new(:get, "www.example.com"))
WebMock::RequestRegistry.instance.requested_signatures.put(WebMock::RequestSignature.new(:get, "www.example.com"))
expect(WebMock::RequestRegistry.instance.requested_signatures.
get(WebMock::RequestSignature.new(:get, "www.example.com"))).to eq(2)
end
end
describe "to_s" do
it "should output string with all executed requests and numbers of executions" do
[
WebMock::RequestSignature.new(:get, "www.example.com"),
WebMock::RequestSignature.new(:get, "www.example.com"),
WebMock::RequestSignature.new(:put, "www.example.org"),
].each do |s|
WebMock::RequestRegistry.instance.requested_signatures.put(s)
end
expect(WebMock::RequestRegistry.instance.to_s).to eq(
"GET http://www.example.com/ was made 2 times\nPUT http://www.example.org/ was made 1 time\n"
)
end
it "should output info if no requests were executed" do
expect(WebMock::RequestRegistry.instance.to_s).to eq("No requests were made.")
end
end
end
webmock-1.22.6/spec/unit/request_signature_spec.rb 0000644 0000041 0000041 00000014020 12646134265 022310 0 ustar www-data www-data require 'spec_helper'
describe WebMock::RequestSignature do
describe "initialization" do
it "assign the uri to be the normalized uri" do
expect(WebMock::Util::URI).to receive(:normalize_uri).and_return("www.example.kom")
signature = WebMock::RequestSignature.new(:get, "www.example.com")
expect(signature.uri).to eq("www.example.kom")
end
it "assigns the uri without normalization if uri is already a URI" do
expect(WebMock::Util::URI).not_to receive(:normalize_uri)
uri = Addressable::URI.parse("www.example.com")
signature = WebMock::RequestSignature.new(:get, uri)
expect(signature.uri).to eq(uri)
end
it "assigns normalized headers" do
expect(WebMock::Util::Headers).to receive(:normalize_headers).with('A' => 'a').and_return('B' => 'b')
expect(
WebMock::RequestSignature.new(:get, "www.example.com", :headers => {'A' => 'a'}).headers
).to eq({'B' => 'b'})
end
it "assign the body" do
expect(WebMock::RequestSignature.new(:get, "www.example.com", :body => "abc").body).to eq("abc")
end
it "symbolizes the method" do
expect(WebMock::RequestSignature.new('get', "www.example.com", :body => "abc").method).to eq(:get)
end
end
describe "#to_s" do
it "describes itself" do
expect(WebMock::RequestSignature.new(:get, "www.example.com",
:body => "abc", :headers => {'A' => 'a', 'B' => 'b'}).to_s).to eq(
"GET http://www.example.com/ with body 'abc' with headers {'A'=>'a', 'B'=>'b'}"
)
end
end
describe "#hash" do
it "reporst same hash for two signatures with the same values" do
signature1 = WebMock::RequestSignature.new(:get, "www.example.com",
:body => "abc", :headers => {'A' => 'a', 'B' => 'b'})
signature2 = WebMock::RequestSignature.new(:get, "www.example.com",
:body => "abc", :headers => {'A' => 'a', 'B' => 'b'})
expect(signature1.hash).to eq(signature2.hash)
end
it "reports different hash for two signatures with different method" do
signature1 = WebMock::RequestSignature.new(:get, "www.example.com")
signature2 = WebMock::RequestSignature.new(:put, "www.example.com")
expect(signature1.hash).not_to eq(signature2.hash)
end
it "reports different hash for two signatures with different uri" do
signature1 = WebMock::RequestSignature.new(:get, "www.example.com")
signature2 = WebMock::RequestSignature.new(:get, "www.example.org")
expect(signature1.hash).not_to eq(signature2.hash)
end
it "reports different hash for two signatures with different body" do
signature1 = WebMock::RequestSignature.new(:get, "www.example.com", :body => "abc")
signature2 = WebMock::RequestSignature.new(:get, "www.example.com", :body => "def")
expect(signature1.hash).not_to eq(signature2.hash)
end
it "reports different hash for two signatures with different headers" do
signature1 = WebMock::RequestSignature.new(:get, "www.example.com",
:headers => {'A' => 'a'})
signature2 = WebMock::RequestSignature.new(:get, "www.example.com",
:headers => {'A' => 'A'})
expect(signature1.hash).not_to eq(signature2.hash)
end
end
[:==, :eql?].each do |method|
describe method do
it "is true for two signatures with the same values" do
signature1 = WebMock::RequestSignature.new(:get, "www.example.com",
:body => "abc", :headers => {'A' => 'a', 'B' => 'b'})
signature2 = WebMock::RequestSignature.new(:get, "www.example.com",
:body => "abc", :headers => {'A' => 'a', 'B' => 'b'})
expect(signature1.send(method, signature2)).to be_truthy
end
it "is false for two signatures with different method" do
signature1 = WebMock::RequestSignature.new(:get, "www.example.com")
signature2 = WebMock::RequestSignature.new(:put, "www.example.com")
expect(signature1.send(method, signature2)).to be_falsey
end
it "is false for two signatures with different uri" do
signature1 = WebMock::RequestSignature.new(:get, "www.example.com")
signature2 = WebMock::RequestSignature.new(:get, "www.example.org")
expect(signature1.send(method, signature2)).to be_falsey
end
it "is false for two signatures with different body" do
signature1 = WebMock::RequestSignature.new(:get, "www.example.com", :body => "abc")
signature2 = WebMock::RequestSignature.new(:get, "www.example.com", :body => "def")
expect(signature1.send(method, signature2)).to be_falsey
end
it "is false for two signatures with different headers" do
signature1 = WebMock::RequestSignature.new(:get, "www.example.com",
:headers => {'A' => 'a'})
signature2 = WebMock::RequestSignature.new(:get, "www.example.com",
:headers => {'A' => 'A'})
expect(signature1.send(method, signature2)).to be_falsey
end
end
end
subject { WebMock::RequestSignature.new(:get, "www.example.com") }
describe "#url_encoded?" do
it "returns true if the headers are urlencoded" do
subject.headers = { "Content-Type" => "application/x-www-form-urlencoded" }
expect(subject.url_encoded?).to be true
end
it "returns false if the headers are NOT urlencoded" do
subject.headers = { "Content-Type" => "application/made-up-format" }
expect(subject.url_encoded?).to be false
end
it "returns false when no headers are set" do
subject.headers = nil
expect(subject.url_encoded?).to be false
end
end
describe "#json_headers?" do
it "returns true if the headers are json" do
subject.headers = { "Content-Type" => "application/json" }
expect(subject.json_headers?).to be true
end
it "returns false if the headers are NOT json" do
subject.headers = { "Content-Type" => "application/made-up-format" }
expect(subject.json_headers?).to be false
end
it "returns false when no headers are set" do
subject.headers = nil
expect(subject.json_headers?).to be false
end
end
end
webmock-1.22.6/spec/unit/webmock_spec.rb 0000644 0000041 0000041 00000000351 12646134265 020170 0 ustar www-data www-data require 'spec_helper'
describe "WebMock version" do
it "should report version" do
expect(WebMock.version).to eq(WebMock::VERSION)
end
it "should not require safe_yaml" do
expect(defined?SafeYAML).to eq(nil)
end
end
webmock-1.22.6/spec/unit/util/ 0000755 0000041 0000041 00000000000 12646134265 016160 5 ustar www-data www-data webmock-1.22.6/spec/unit/util/hash_counter_spec.rb 0000644 0000041 0000041 00000002051 12646134265 022177 0 ustar www-data www-data require 'spec_helper'
describe WebMock::Util::HashCounter do
it "should return 0 for non existing key" do
expect(WebMock::Util::HashCounter.new.get(:abc)).to eq(0)
end
it "should increase the returned value on every put with the same key" do
counter = WebMock::Util::HashCounter.new
counter.put(:abc)
expect(counter.get(:abc)).to eq(1)
counter.put(:abc)
expect(counter.get(:abc)).to eq(2)
end
it "should only increase value for given key provided to put" do
counter = WebMock::Util::HashCounter.new
counter.put(:abc)
expect(counter.get(:abc)).to eq(1)
expect(counter.get(:def)).to eq(0)
end
describe "each" do
it "should provide elements in order of the last modified" do
counter = WebMock::Util::HashCounter.new
counter.put(:a)
counter.put(:b)
counter.put(:c)
counter.put(:b)
counter.put(:a)
counter.put(:d)
elements = []
counter.each {|k,v| elements << [k,v]}
expect(elements).to eq([[:c, 1], [:b, 2], [:a, 2], [:d, 1]])
end
end
end
webmock-1.22.6/spec/unit/util/uri_spec.rb 0000644 0000041 0000041 00000025574 12646134265 020333 0 ustar www-data www-data require 'spec_helper'
URIS_WITHOUT_PATH_OR_PARAMS =
[
"www.example.com",
"www.example.com/",
"www.example.com:80",
"www.example.com:80/",
"http://www.example.com",
"http://www.example.com/",
"http://www.example.com:80",
"http://www.example.com:80/"
].sort
URIS_WITHOUT_PATH_BUT_WITH_PARAMS =
[
"www.example.com?a=b",
"www.example.com/?a=b",
"www.example.com:80?a=b",
"www.example.com:80/?a=b",
"http://www.example.com?a=b",
"http://www.example.com/?a=b",
"http://www.example.com:80?a=b",
"http://www.example.com:80/?a=b"
].sort
URIS_WITH_AUTH =
[
"a b:pass@www.example.com",
"a b:pass@www.example.com/",
"a b:pass@www.example.com:80",
"a b:pass@www.example.com:80/",
"http://a b:pass@www.example.com",
"http://a b:pass@www.example.com/",
"http://a b:pass@www.example.com:80",
"http://a b:pass@www.example.com:80/",
"a%20b:pass@www.example.com",
"a%20b:pass@www.example.com/",
"a%20b:pass@www.example.com:80",
"a%20b:pass@www.example.com:80/",
"http://a%20b:pass@www.example.com",
"http://a%20b:pass@www.example.com/",
"http://a%20b:pass@www.example.com:80",
"http://a%20b:pass@www.example.com:80/"
].sort
URIS_WITH_PATH_AND_PARAMS =
[
"www.example.com/my path/?a=my param&b=c d",
"www.example.com/my%20path/?a=my%20param&b=c%20d",
"www.example.com:80/my path/?a=my param&b=c d",
"www.example.com:80/my%20path/?a=my%20param&b=c%20d",
"http://www.example.com/my path/?a=my param&b=c d",
"http://www.example.com/my%20path/?a=my%20param&b=c%20d",
"http://www.example.com:80/my path/?a=my param&b=c d",
"http://www.example.com:80/my%20path/?a=my%20param&b=c%20d",
].sort
URIS_WITH_DIFFERENT_PORT =
[
"www.example.com:88",
"www.example.com:88/",
"http://www.example.com:88",
"http://www.example.com:88/"
].sort
URIS_FOR_HTTPS =
[
"https://www.example.com",
"https://www.example.com/",
"https://www.example.com:443",
"https://www.example.com:443/"
].sort
describe WebMock::Util::URI do
describe "reporting variations of uri" do
it "should find all variations of the same uri for all variations of uri with params and path" do
URIS_WITH_PATH_AND_PARAMS.each do |uri|
expect(WebMock::Util::URI.variations_of_uri_as_strings(uri).sort).to eq(URIS_WITH_PATH_AND_PARAMS)
end
end
it "should find all variations of the same uri for all variations of uri with params but without path" do
URIS_WITHOUT_PATH_BUT_WITH_PARAMS.each do |uri|
expect(WebMock::Util::URI.variations_of_uri_as_strings(uri).sort).to eq(URIS_WITHOUT_PATH_BUT_WITH_PARAMS)
end
end
it "should find all variations of the same uri for all variations of uri without params or path" do
URIS_WITHOUT_PATH_OR_PARAMS.each do |uri|
expect(WebMock::Util::URI.variations_of_uri_as_strings(uri).sort).to eq(URIS_WITHOUT_PATH_OR_PARAMS)
end
end
it "should find all variations of the same uri for all variations of uri with auth" do
URIS_WITH_AUTH.each do |uri|
expect(WebMock::Util::URI.variations_of_uri_as_strings(uri).sort).to eq(URIS_WITH_AUTH)
end
end
it "should find all variations of the same uri for all variations of uri with different port" do
URIS_WITH_DIFFERENT_PORT.each do |uri|
expect(WebMock::Util::URI.variations_of_uri_as_strings(uri).sort).to eq(URIS_WITH_DIFFERENT_PORT)
end
end
it "should find all variations of the same uri for all variations of https uris" do
URIS_FOR_HTTPS.each do |uri|
expect(WebMock::Util::URI.variations_of_uri_as_strings(uri).sort).to eq(URIS_FOR_HTTPS)
end
end
end
describe "normalized uri equality" do
it "should successfully compare all variations of the same uri with path and params" do
URIS_WITH_PATH_AND_PARAMS.each do |uri_a|
URIS_WITH_PATH_AND_PARAMS.each do |uri_b|
expect(WebMock::Util::URI.normalize_uri(uri_a)).to be === WebMock::Util::URI.normalize_uri(uri_b)
end
end
end
it "should successfully compare all variations of the same uri with path but with params" do
URIS_WITHOUT_PATH_BUT_WITH_PARAMS.each do |uri_a|
URIS_WITHOUT_PATH_BUT_WITH_PARAMS.each do |uri_b|
expect(WebMock::Util::URI.normalize_uri(uri_a)).to be === WebMock::Util::URI.normalize_uri(uri_b)
end
end
end
it "should successfully compare all variations of the same uri without path or params" do
URIS_WITHOUT_PATH_OR_PARAMS.each do |uri_a|
URIS_WITHOUT_PATH_OR_PARAMS.each do |uri_b|
expect(WebMock::Util::URI.normalize_uri(uri_a)).to be === WebMock::Util::URI.normalize_uri(uri_b)
end
end
end
it "should successfully compare all variations of the same uri with authority" do
URIS_WITH_AUTH.each do |uri_a|
URIS_WITH_AUTH.each do |uri_b|
expect(WebMock::Util::URI.normalize_uri(uri_a)).to be === WebMock::Util::URI.normalize_uri(uri_b)
end
end
end
it "should successfully compare all variations of the same uri custom port" do
URIS_WITH_DIFFERENT_PORT.each do |uri_a|
URIS_WITH_DIFFERENT_PORT.each do |uri_b|
expect(WebMock::Util::URI.normalize_uri(uri_a)).to be === WebMock::Util::URI.normalize_uri(uri_b)
end
end
end
it "should successfully compare all variations of the same https uri" do
URIS_FOR_HTTPS.each do |uri_a|
URIS_FOR_HTTPS.each do |uri_b|
expect(WebMock::Util::URI.normalize_uri(uri_a)).to be === WebMock::Util::URI.normalize_uri(uri_b)
end
end
end
it "should successfully handle array parameters" do
uri_string = 'http://www.example.com:80/path?a[]=b&a[]=c'
uri = WebMock::Util::URI.normalize_uri(uri_string)
expect(WebMock::Util::QueryMapper.query_to_values(uri.query)).to eq({"a"=>["b", "c"]})
end
it "should successfully handle hash parameters" do
uri_string = 'http://www.example.com:80/path?a[d]=b&a[e]=c&a[b][c]=1'
uri = WebMock::Util::URI.normalize_uri(uri_string)
expect(WebMock::Util::QueryMapper.query_to_values(uri.query)).to eq({"a"=>{"d"=>"b", "e"=>"c", "b"=>{"c"=>"1"}}})
end
it "should successfully handle nested hash parameters" do
uri_string = 'http://www.example.com:80/path?one[two][three][]=four&one[two][three][]=five'
uri = WebMock::Util::URI.normalize_uri(uri_string)
expect(WebMock::Util::QueryMapper.query_to_values(uri.query)).to eq({"one"=>{"two"=>{"three" => ["four", "five"]}}})
end
it "should successfully handle mixed array and hash parameters" do
# derived from an elasticsearch query:
# load => {
# :include => [
# { :staff => :email },
# :business_name
# ]
# }
uri_string = "http://www.example.com:80/path?load[include][][staff]=email&load[include][]=business_name"
uri = WebMock::Util::URI.normalize_uri(uri_string)
expect(WebMock::Util::QueryMapper.query_to_values(uri.query)).to eq({"load"=>{"include"=>[{"staff"=>"email"},"business_name"]}})
end
context "when query notation is set to :flat_array" do
before :all do
WebMock::Config.instance.query_values_notation = :flat_array
end
it "should successfully handle repeated paramters" do
uri_string = "http://www.example.com:80/path?target=host1&target=host2"
uri = WebMock::Util::URI.normalize_uri(uri_string)
expect(WebMock::Util::QueryMapper.query_to_values(uri.query, :notation => WebMock::Config.instance.query_values_notation)).to eq([['target', 'host1'], ['target', 'host2']])
end
end
end
describe "sorting query values" do
context "when query values is a Hash" do
it "returns an alphabetically sorted hash" do
sorted_query = WebMock::Util::URI.sort_query_values({"b"=>"one", "a"=>"two"})
expect(sorted_query).to eq({"a"=>"two", "b"=>"one"})
end
end
context "when query values is an Array" do
it "returns an alphabetically sorted array" do
sorted_query = WebMock::Util::URI.sort_query_values([["b","two"],["a","one_b"],["a","one_a"]])
expect(sorted_query).to eq([["a","one_a"],["a","one_b"],["b","two"]])
end
end
end
describe "stripping default port" do
it "should strip_default_port_from_uri strips 80 from http with path" do
uri = "http://example.com:80/foo/bar"
stripped_uri = WebMock::Util::URI.strip_default_port_from_uri_string(uri)
expect(stripped_uri).to eq("http://example.com/foo/bar")
end
it "should strip_default_port_from_uri strips 80 from http without path" do
uri = "http://example.com:80"
stripped_uri = WebMock::Util::URI.strip_default_port_from_uri_string(uri)
expect(stripped_uri).to eq("http://example.com")
end
it "should strip_default_port_from_uri strips 443 from https without path" do
uri = "https://example.com:443"
stripped_uri = WebMock::Util::URI.strip_default_port_from_uri_string(uri)
expect(stripped_uri).to eq("https://example.com")
end
it "should strip_default_port_from_uri strips 443 from https" do
uri = "https://example.com:443/foo/bar"
stripped_uri = WebMock::Util::URI.strip_default_port_from_uri_string(uri)
expect(stripped_uri).to eq("https://example.com/foo/bar")
end
it "should strip_default_port_from_uri does not strip 8080 from http" do
uri = "http://example.com:8080/foo/bar"
expect(WebMock::Util::URI.strip_default_port_from_uri_string(uri)).to eq(uri)
end
it "should strip_default_port_from_uri does not strip 443 from http" do
uri = "http://example.com:443/foo/bar"
expect(WebMock::Util::URI.strip_default_port_from_uri_string(uri)).to eq(uri)
end
it "should strip_default_port_from_uri does not strip 80 from query string" do
uri = "http://example.com/?a=:80&b=c"
expect(WebMock::Util::URI.strip_default_port_from_uri_string(uri)).to eq(uri)
end
it "should strip_default_port_from_uri does not modify strings that do not start with http or https" do
uri = "httpz://example.com:80/"
expect(WebMock::Util::URI.strip_default_port_from_uri_string(uri)).to eq(uri)
end
end
describe "encoding userinfo" do
it "should encode unsafe chars in userinfo does not encode userinfo safe punctuation" do
userinfo = "user;&=+$,:secret"
expect(WebMock::Util::URI.encode_unsafe_chars_in_userinfo(userinfo)).to eq(userinfo)
end
it "should encode unsafe chars in userinfo does not encode rfc 3986 unreserved characters" do
userinfo = "-.!~*'()abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789:secret"
expect(WebMock::Util::URI.encode_unsafe_chars_in_userinfo(userinfo)).to eq(userinfo)
end
it "should encode unsafe chars in userinfo does encode other characters" do
userinfo, safe_userinfo = 'us#rn@me:sec//ret?"', 'us%23rn%40me:sec%2F%2Fret%3F%22'
expect(WebMock::Util::URI.encode_unsafe_chars_in_userinfo(userinfo)).to eq(safe_userinfo)
end
end
end
webmock-1.22.6/spec/unit/util/hash_keys_stringifier_spec.rb 0000644 0000041 0000041 00000000761 12646134265 024106 0 ustar www-data www-data require 'spec_helper'
describe WebMock::Util::HashKeysStringifier do
it "should recursively stringify all symbol keys" do
hash = {
:a => {
:b => [
{
:c => [{:d => "1"}]
}
]
}
}
stringified = {
'a' => {
'b' => [
{
'c' => [{'d' => "1"}]
}
]
}
}
expect(WebMock::Util::HashKeysStringifier.stringify_keys!(hash, :deep => true)).to eq(stringified)
end
end
webmock-1.22.6/spec/unit/util/query_mapper_spec.rb 0000644 0000041 0000041 00000007707 12646134265 022243 0 ustar www-data www-data require 'spec_helper'
describe WebMock::Util::QueryMapper do
subject { described_class }
context '#query_to_values' do
it 'should raise on invalid notation' do
query = 'a=&b=c'
expect { subject.query_to_values(query, {:notation => 'foo'}) }.to raise_error(
ArgumentError,
'Invalid notation. Must be one of: [:flat, :dot, :subscript, :flat_array].'
)
end
it 'should parse hash queries' do
# {"one" => {"two" => {"three" => ["four", "five"]}}}
query = 'one%5Btwo%5D%5Bthree%5D%5B%5D=four&one%5Btwo%5D%5Bthree%5D%5B%5D=five'
hsh = subject.query_to_values(query)
expect(hsh['one']['two']['three']).to eq(%w(four five))
end
it 'should parse one nil value queries' do
# {'a' => nil, 'b' => 'c'}
query = 'a=&b=c'
hsh = subject.query_to_values(query)
expect(hsh['a']).to be_empty
expect(hsh['b']).to eq('c')
end
it 'should parse array queries' do
# {"one" => ["foo", "bar"]}
query = 'one%5B%5D=foo&one%5B%5D=bar'
hsh = subject.query_to_values(query)
expect(hsh['one']).to eq(%w(foo bar))
end
it 'should parse string queries' do
# {"one" => "two", "three" => "four"}
query = 'one=two&three=four'
hsh = subject.query_to_values(query)
expect(hsh).to eq({'one' => 'two', 'three' => 'four'})
end
it 'should parse nested queries' do
# [{"b"=>[{"c"=>[{"d"=>["1", {"e"=>"2"}]}]}]}]
query = 'a%5B%5D%5Bb%5D%5B%5D%5Bc%5D%5B%5D%5Bd%5D%5B%5D=1&a%5B%5D%5Bb%5D%5B%5D%5Bc%5D%5B%5D%5Bd%5D%5B%5D%5Be%5D=2'
hsh = subject.query_to_values(query)
expect(hsh['a'][0]['b'][0]['c'][0]['d'][0]).to eq('1')
expect(hsh['a'][0]['b'][0]['c'][0]['d'][1]['e']).to eq('2')
end
end
context '#to_query' do
it 'should transform nil value' do
expect(subject.to_query('a', nil)).to eq('a')
end
it 'should transform string value' do
expect(subject.to_query('a', 'b')).to eq('a=b')
end
it 'should transform hash value' do
expect(subject.to_query('a', {'key' => 'value'})).to eq('a[key]=value')
end
it 'should transform hash value with keys that are symbols' do
expect(subject.to_query('a', {:key => 'value'})).to eq('a[key]=value')
end
it 'should transform array value' do
expect(subject.to_query('a', ['b', 'c'])).to eq('a[0]=b&a[1]=c')
end
it 'should transform boolean values' do
expect(subject.to_query('a', true)).to eq('a=true')
expect(subject.to_query('a', false)).to eq('a=false')
end
end
context '#values_to_query' do
it 'converts values to a query string' do
query = "key=value&other_key=other_value"
values = [['key','value'],['other_key','other_value']]
expect(subject.values_to_query values).to eq query
end
it 'converts values with missing keys to a query string' do
query = "=value"
values = { '' => 'value' }
expect(subject.values_to_query values).to eq query
end
it 'converts values with nil keys to a query string' do
query = "=value"
values = { nil => 'value' }
expect(subject.values_to_query values).to eq query
end
end
it 'converts array values, vice versa' do
query = "one%5B%5D=1&one%5B%5D=2" # one[]=1&one[]=2
values = {"one" => ["1","2"]}
expect(subject.values_to_query values).to eq query
expect(subject.query_to_values query).to eq values
end
it 'converts hash values, vice versa' do
query = "one%5Ba%5D=1&one%5Bb%5D=2" # one[a]=1&one[b]=2
values = {"one" => {"a" => "1", "b" => "2"}}
expect(subject.values_to_query values).to eq query
expect(subject.query_to_values query).to eq values
end
it 'converts complex nested values, vice versa' do
query = "one%5B%5D[foo]=bar&one%5B%5D[zoo]=car" # one[][foo]=bar&one[][zoo]=car
values = {"one" => [{"foo" => "bar"}, {"zoo" => "car"}]}
expect(subject.values_to_query values).to eq query
expect(subject.query_to_values query).to eq values
end
end
webmock-1.22.6/spec/unit/util/json_spec.rb 0000644 0000041 0000041 00000001773 12646134265 020500 0 ustar www-data www-data # encoding: utf-8
require 'spec_helper'
describe WebMock::Util::JSON do
describe ".parse" do
it "should parse json without parsing dates" do
expect(WebMock::Util::JSON.parse("\"a\":\"2011-01-01\"")).to eq(
{"a" => "2011-01-01"}
)
end
it "can parse json with multibyte characters" do
expect(WebMock::Util::JSON.parse(
"{\"name\":\"山田太郎\"\,\"job\":\"会社員\"}"
)).to eq({"name" => "山田太郎", "job" => "会社員"})
end
it "rescues ArgumentError's from YAML.load" do
allow(YAML).to receive(:load).and_raise(ArgumentError)
expect {
WebMock::Util::JSON.parse("Bad JSON")
}.to raise_error WebMock::Util::JSON::ParseError
end
end
describe ".convert_json_to_yaml" do
it "parses multibyte characters" do
expect(WebMock::Util::JSON.convert_json_to_yaml(
"{\"name\":\"山田太郎\"\,\"job\":\"会社員\"}"
)).to eq "{\"name\": \"山田太郎\", \"job\": \"会社員\"}"
end
end
end
webmock-1.22.6/spec/unit/util/headers_spec.rb 0000644 0000041 0000041 00000001655 12646134265 021141 0 ustar www-data www-data require 'spec_helper'
describe WebMock::Util::Headers do
it "should decode_userinfo_from_header handles basic auth" do
authorization_header = "Basic dXNlcm5hbWU6c2VjcmV0"
userinfo = WebMock::Util::Headers.decode_userinfo_from_header(authorization_header)
expect(userinfo).to eq("username:secret")
end
describe "sorted_headers_string" do
it "should return nice string for hash with string values" do
expect(WebMock::Util::Headers.sorted_headers_string({"a" => "b"})).to eq("{'A'=>'b'}")
end
it "should return nice string for hash with array values" do
expect(WebMock::Util::Headers.sorted_headers_string({"a" => ["b", "c"]})).to eq("{'A'=>['b', 'c']}")
end
it "should return nice string for hash with array values and string values" do
expect(WebMock::Util::Headers.sorted_headers_string({"a" => ["b", "c"], "d" => "e"})).to eq("{'A'=>['b', 'c'], 'D'=>'e'}")
end
end
end
webmock-1.22.6/spec/unit/util/version_checker_spec.rb 0000644 0000041 0000041 00000005007 12646134265 022672 0 ustar www-data www-data require 'spec_helper'
module WebMock
describe VersionChecker do
it 'prints a warning if the major version is too low' do
checker = VersionChecker.new('foo', '0.7.3', '1.0.0', '1.1')
expect(Kernel).to receive(:warn).with("\e[31mYou are using foo 0.7.3. WebMock supports version >= 1.0.0, < 1.2.\e[0m")
checker.check_version!
end
it 'prints a warning if the minor version is too low' do
checker = VersionChecker.new('foo', '1.0.99', '1.1.3', '1.2')
expect(Kernel).to receive(:warn).with("\e[31mYou are using foo 1.0.99. WebMock supports version >= 1.1.3, < 1.3.\e[0m")
checker.check_version!
end
it 'prints a warning if the patch version is too low' do
checker = VersionChecker.new('foo', '1.0.8', '1.0.10', '1.2')
expect(Kernel).to receive(:warn).with("\e[31mYou are using foo 1.0.8. WebMock supports version >= 1.0.10, < 1.3.\e[0m")
checker.check_version!
end
it 'prints a warning if the patch version is too low and max version is not specified' do
checker = VersionChecker.new('foo', '1.0.8', '1.0.10')
expect(Kernel).to receive(:warn).with("\e[31mYou are using foo 1.0.8. WebMock supports version >= 1.0.10.\e[0m")
checker.check_version!
end
it 'prints a warning if the major version is too high' do
checker = VersionChecker.new('foo', '2.0.0', '1.0.0', '1.1')
expect(Kernel).to receive(:warn).with(/may not work with this version/)
checker.check_version!
end
it 'prints a warning if the minor version is too high' do
checker = VersionChecker.new('foo', '1.2.0', '1.0.0', '1.1')
expect(Kernel).to receive(:warn).with(/may not work with this version/)
checker.check_version!
end
it 'does not raise an error or print a warning when the major version is between the min and max' do
checker = VersionChecker.new('foo', '2.0.0', '1.0.0', '3.0')
expect(Kernel).not_to receive(:warn)
checker.check_version!
end
it 'does not raise an error or print a warning when the min_patch is 0.6.5, the max_minor is 0.7 and the version is 0.7.3' do
checker = VersionChecker.new('foo', '0.7.3', '0.6.5', '0.7')
expect(Kernel).not_to receive(:warn)
checker.check_version!
end
it 'does not raise an error or print a warning when the min_patch is 0.6.5, the max_minor is not specified and the version is 0.8.3' do
checker = VersionChecker.new('foo', '0.8.3', '0.6.5')
expect(Kernel).not_to receive(:warn)
checker.check_version!
end
end
end
webmock-1.22.6/spec/unit/request_signature_snippet_spec.rb 0000644 0000041 0000041 00000004702 12646134265 024060 0 ustar www-data www-data require "spec_helper"
RSpec.describe WebMock::RequestSignatureSnippet do
it("is real"){expect{subject}.not_to(raise_error)}
subject { WebMock::RequestSignatureSnippet.new(request_signature) }
let(:uri) { "http://example.com" }
let(:method) { "GET" }
let(:request_signature) { WebMock::RequestSignature.new(method, uri) }
let(:request_signature_body) { {"key" => "different value"}.to_json }
let(:request_pattern) {
WebMock::RequestPattern.new(
method, uri, {:body => request_signature_body}
)
}
before :each do
request_signature.headers = {"Content-Type" => "application/json"}
request_signature.body = request_signature_body
end
describe "#stubbing_instructions" do
context "with stubbing instructions turned off" do
before :each do
WebMock.hide_stubbing_instructions!
end
it "returns nil" do
expect(subject.stubbing_instructions).to be nil
end
after :each do
WebMock.show_stubbing_instructions!
end
end
context "with stubbing instructions turned on" do
it "returns a stub snippet" do
expect(subject.stubbing_instructions).to include(
"You can stub this request with the following snippet:"
)
end
end
end
describe "#request_stubs" do
before :each do
WebMock.stub_request(:get, "https://www.example.com").with(:body => {"a" => "b"})
end
context "when showing the body diff is turned off" do
before :each do
WebMock.hide_body_diff!
end
it "returns does not show the body diff" do
result = subject.request_stubs
result.sub!("registered request stubs:\n\n", "")
expect(result).to eq(
"stub_request(:get, \"https://www.example.com/\").\n with(:body => {\"a\"=>\"b\"})"
)
end
after :each do
WebMock.show_body_diff!
end
end
context "when showing the body diff is turned on" do
it "shows the body diff" do
result = subject.request_stubs
result.sub!("registered request stubs:\n\n", "")
expect(result).to eq(
"stub_request(:get, \"https://www.example.com/\").\n with(:body => {\"a\"=>\"b\"})\n\nBody diff:\n [[\"-\", \"key\", \"different value\"], [\"+\", \"a\", \"b\"]]\n"
)
end
end
context "with no request stubs" do
it "returns nil" do
WebMock.reset!
expect(subject.request_stubs).to be nil
end
end
end
end
webmock-1.22.6/spec/support/ 0000755 0000041 0000041 00000000000 12646134265 015740 5 ustar www-data www-data webmock-1.22.6/spec/support/my_rack_app.rb 0000644 0000041 0000041 00000003012 12646134265 020546 0 ustar www-data www-data require 'rack'
class MyRackApp
class NonArrayResponse
# The rack response body need not implement #join,
# but it must implement #each. It need not be an Array.
# ActionDispatch::Response, for example, exercises that fact.
# See: http://rack.rubyforge.org/doc/SPEC.html
def each(*args, &blk)
["This is not in an array!"].each(*args, &blk)
end
end
def self.call(env)
case env.values_at('REQUEST_METHOD', 'PATH_INFO')
when ['GET', '/']
[200, {}, ["This is my root!"]]
when ['GET', '/greet']
name = env['QUERY_STRING'][/name=([^&]*)/, 1] || "World"
[200, {}, ["Hello, #{name}"]]
when ['GET', '/non_array_response']
[200, {}, NonArrayResponse.new]
when ['GET', '/locked']
[200, {}, ["Single threaded response."]]
when ['POST', '/greet']
name = env["rack.input"].read(env["CONTENT_LENGTH"])
name = name.force_encoding("UTF-8") if name.respond_to? :force_encoding
name = name[/name=([^&]*)/, 1] || "World"
[200, {}, ["Good to meet you, #{name}!"]]
when ['GET', '/compute']
if env['SERVER_PORT'] == 80 && env["SCRIPT_NAME"] == ""
[200, {}, [""]]
else
[401, {}, [""]]
end
when ['GET', '/error']
env['rack.errors'].puts('Error!')
[500, {}, ['']]
else
[404, {}, ['']]
end
end
end
class MyLockedRackApp
MUTEX = Mutex.new
def self.call(env)
lock = Rack::Lock.new(MyRackApp, MUTEX)
lock.call(env)
end
end
webmock-1.22.6/spec/support/example_curl_output.txt 0000644 0000041 0000041 00000001117 12646134265 022601 0 ustar www-data www-data HTTP/1.1 202 OK
Content-Type: text/html; charset=UTF-8
Connection: Keep-Alive
Date: Sat, 23 Jan 2010 01:01:05 GMT
Content-Length: 419
Accept: image/jpeg
Accept: image/png
Example Web Page
You have reached this web page by typing "example.com",
"example.net",
or "example.org" into your web browser.
These domain names are reserved for use in documentation and are not available
for registration. See RFC
2606, Section 3.
webmock-1.22.6/spec/support/network_connection.rb 0000644 0000041 0000041 00000001267 12646134265 022203 0 ustar www-data www-data module NetworkConnection
def self.connect_to(host, port, timeout=nil)
addr = Socket.getaddrinfo(host, nil)
sock = Socket.new(Socket.const_get(addr[0][0]), Socket::SOCK_STREAM, 0)
if timeout
secs = Integer(timeout)
usecs = Integer((timeout - secs) * 1_000_000)
optval = [secs, usecs].pack("l_2")
sock.setsockopt Socket::SOL_SOCKET, Socket::SO_RCVTIMEO, optval
sock.setsockopt Socket::SOL_SOCKET, Socket::SO_SNDTIMEO, optval
end
sock.connect(Socket.pack_sockaddr_in(port, addr[0][3]))
sock
end
def self.is_network_available?
begin
self.connect_to("173.194.113.176", 80, 5)
true
rescue
false
end
end
end
webmock-1.22.6/spec/support/webmock_server.rb 0000644 0000041 0000041 00000002404 12646134265 021302 0 ustar www-data www-data require 'webrick'
require 'logger'
require 'singleton'
class WebMockServer
include Singleton
attr_reader :port, :started
def host_with_port
"localhost:#{port}"
end
def concurrent
unless RUBY_PLATFORM =~ /java/
@pid = Process.fork do
yield
end
else
Thread.new { yield }
end
end
def start
@started = true
server = WEBrick::GenericServer.new(:Port => 0, :Logger => Logger.new("/dev/null"))
server.logger.level = 0
@port = server.config[:Port]
concurrent do
['TERM', 'INT'].each do |signal|
trap(signal) do
Thread.new do
server.shutdown
end
end
end
server.start do |socket|
socket.puts <<-EOT.gsub(/^\s+\|/, '')
|HTTP/1.1 200 OK\r
|Date: Fri, 31 Dec 1999 23:59:59 GMT\r
|Content-Type: text/html\r
|Content-Length: 11\r
|Set-Cookie: bar\r
|Set-Cookie: foo\r
|\r
|hello world
EOT
end
end
loop do
begin
TCPSocket.new("localhost", port)
sleep 0.1
break
rescue Errno::ECONNREFUSED
sleep 0.1
end
end
end
def stop
if @pid
Process.kill('INT', @pid)
end
end
end
webmock-1.22.6/spec/acceptance/ 0000755 0000041 0000041 00000000000 12646134265 016312 5 ustar www-data www-data webmock-1.22.6/spec/acceptance/curb/ 0000755 0000041 0000041 00000000000 12646134265 017245 5 ustar www-data www-data webmock-1.22.6/spec/acceptance/curb/curb_spec.rb 0000644 0000041 0000041 00000032263 12646134265 021545 0 ustar www-data www-data require 'spec_helper'
require 'acceptance/webmock_shared'
unless RUBY_PLATFORM =~ /java/
require 'acceptance/curb/curb_spec_helper'
shared_examples_for "Curb" do
include CurbSpecHelper
include_examples "with WebMock"
describe "when doing PUTs" do
it "should stub them" do
stub_request(:put, "www.example.com").with(:body => "01234")
expect(http_request(:put, "http://www.example.com", :body => "01234").
status).to eq("200")
end
end
end
describe "Curb features" do
before(:each) do
WebMock.disable_net_connect!
WebMock.reset!
end
describe "callbacks" do
before(:each) do
@curl = Curl::Easy.new
@curl.url = "http://example.com"
end
it "should call on_success with 2xx response" do
body = "on_success fired"
stub_request(:any, "example.com").to_return(:body => body)
test = nil
@curl.on_success do |c|
test = c.body_str
end
@curl.http_get
expect(test).to eq(body)
end
it "should call on_missing with 4xx response" do
response_code = 403
stub_request(:any, "example.com").
to_return(:status => [response_code, "None shall pass"])
test = nil
@curl.on_missing do |c, code|
test = code
end
@curl.http_get
expect(test).to eq(response_code)
end
it "should call on_failure with 5xx response" do
response_code = 599
stub_request(:any, "example.com").
to_return(:status => [response_code, "Server On Fire"])
test = nil
@curl.on_failure do |c, code|
test = code
end
@curl.http_get
expect(test).to eq(response_code)
end
it "should call on_body when response body is read" do
body = "on_body fired"
stub_request(:any, "example.com").
to_return(:body => body)
test = nil
@curl.on_body do |data|
test = data
end
@curl.http_get
expect(test).to eq(body)
end
it "should call on_body for each chunk with chunked response" do
stub_request(:any, "example.com").
to_return(:body => ["first_chunk", "second_chunk"],
:headers => {"Transfer-Encoding" => "chunked"})
test = []
@curl.on_body do |data|
test << data
end
@curl.http_get
expect(test).to eq(["first_chunk", "second_chunk"])
end
it "should call on_header when response headers are read" do
stub_request(:any, "example.com").
to_return(:headers => {:one => 1})
test = []
@curl.on_header do |data|
test << data
end
@curl.http_get
expect(test).to eq([
"HTTP/1.1 200 \r\n",
'One: 1'
])
end
it "should call on_complete when request is complete" do
body = "on_complete fired"
stub_request(:any, "example.com").to_return(:body => body)
test = nil
@curl.on_complete do |curl|
test = curl.body_str
end
@curl.http_get
expect(test).to eq(body)
end
it "should call on_progress when portion of response body is read" do
stub_request(:any, "example.com").to_return(:body => "01234")
test = nil
@curl.on_progress do |*args|
expect(args.length).to eq(4)
args.each {|arg| expect(arg.is_a?(Float)).to eq(true) }
test = true
end
@curl.http_get
expect(test).to eq(true)
end
it "should call callbacks in correct order on successful request" do
stub_request(:any, "example.com")
order = []
@curl.on_success {|*args| order << :on_success }
@curl.on_missing {|*args| order << :on_missing }
@curl.on_failure {|*args| order << :on_failure }
@curl.on_header {|*args| order << :on_header }
@curl.on_body {|*args| order << :on_body }
@curl.on_complete {|*args| order << :on_complete }
@curl.on_progress {|*args| order << :on_progress }
@curl.http_get
expect(order).to eq([:on_progress,:on_header,:on_body,:on_complete,:on_success])
end
it "should call callbacks in correct order on failed request" do
stub_request(:any, "example.com").to_return(:status => [500, ""])
order = []
@curl.on_success {|*args| order << :on_success }
@curl.on_missing {|*args| order << :on_missing }
@curl.on_failure {|*args| order << :on_failure }
@curl.on_header {|*args| order << :on_header }
@curl.on_body {|*args| order << :on_body }
@curl.on_complete {|*args| order << :on_complete }
@curl.on_progress {|*args| order << :on_progress }
@curl.http_get
expect(order).to eq([:on_progress,:on_header,:on_body,:on_complete,:on_failure])
end
it "should call callbacks in correct order on missing request" do
stub_request(:any, "example.com").to_return(:status => [403, ""])
order = []
@curl.on_success {|*args| order << :on_success }
@curl.on_missing {|*args| order << :on_missing }
@curl.on_failure {|*args| order << :on_failure }
@curl.on_header {|*args| order << :on_header }
@curl.on_body {|*args| order << :on_body }
@curl.on_complete {|*args| order << :on_complete }
@curl.on_progress {|*args| order << :on_progress }
@curl.http_get
expect(order).to eq([:on_progress,:on_header,:on_body,:on_complete,:on_missing])
end
end
describe '#last_effective_url' do
before(:each) do
@curl = Curl::Easy.new
@curl.url = "http://example.com"
end
context 'when not following redirects' do
before { @curl.follow_location = false }
it 'should be the same as #url even with a location header' do
stub_request(:any, 'example.com').
to_return(:body => "abc",
:status => 302,
:headers => { 'Location' => 'http://www.example.com' })
@curl.http_get
expect(@curl.last_effective_url).to eq('http://example.com')
end
end
context 'when following redirects' do
before { @curl.follow_location = true }
it 'should be the same as #url when no location header is present' do
stub_request(:any, "example.com")
@curl.http_get
expect(@curl.last_effective_url).to eq('http://example.com')
end
it 'should be the value of the location header when present' do
stub_request(:any, 'example.com').
to_return(:headers => { 'Location' => 'http://www.example.com' })
stub_request(:any, 'www.example.com')
@curl.http_get
expect(@curl.last_effective_url).to eq('http://www.example.com')
end
it 'should work with more than one redirect' do
stub_request(:any, 'example.com').
to_return(:headers => { 'Location' => 'http://www.example.com' })
stub_request(:any, 'www.example.com').
to_return(:headers => { 'Location' => 'http://blog.example.com' })
stub_request(:any, 'blog.example.com')
@curl.http_get
expect(@curl.last_effective_url).to eq('http://blog.example.com')
end
it 'should maintain the original url' do
stub_request(:any, 'example.com').
to_return(:headers => { 'Location' => 'http://www.example.com' })
stub_request(:any, 'www.example.com')
@curl.http_get
expect(@curl.url).to eq('http://example.com')
end
it 'should have the redirected-to attrs (body, response code)' do
stub_request(:any, 'example.com').
to_return(:body => 'request A',
:status => 302,
:headers => { 'Location' => 'http://www.example.com' })
stub_request(:any, 'www.example.com').to_return(:body => 'request B')
@curl.http_get
expect(@curl.body_str).to eq('request B')
expect(@curl.response_code).to eq(200)
end
it 'should follow more than one redirect' do
stub_request(:any, 'example.com').
to_return(:headers => { 'Location' => 'http://www.example.com' })
stub_request(:any, 'www.example.com').
to_return(:headers => { 'Location' => 'http://blog.example.com' })
stub_request(:any, 'blog.example.com').to_return(:body => 'blog post')
@curl.http_get
expect(@curl.url).to eq('http://example.com')
expect(@curl.body_str).to eq('blog post')
end
end
end
describe "#content_type" do
before(:each) do
@curl = Curl::Easy.new
@curl.url = "http://example.com"
end
context "when response includes Content-Type header" do
it "returns correct content_type" do
content_type = "application/json"
stub_request(:any, 'example.com').
to_return(:body => "abc",
:status => 200,
:headers => { 'Content-Type' => content_type })
@curl.http_get
expect(@curl.content_type).to eq(content_type)
end
end
context "when response does not include Content-Type header" do
it "returns nil for content_type" do
stub_request(:any, 'example.com').
to_return(:body => "abc",
:status => 200 )
@curl.http_get
expect(@curl.content_type).to be_nil
end
end
end
describe "#chunked_response?" do
before(:each) do
@curl = Curl::Easy.new
@curl.url = "http://example.com"
end
it "is true when Transfer-Encoding is 'chunked' and body responds to each" do
stub_request(:any, 'example.com').
to_return(:body => ["abc", "def"],
:status => 200,
:headers => { 'Transfer-Encoding' => 'chunked' })
@curl.http_get
expect(@curl).to be_chunked_response
end
it "is false when Transfer-Encoding is not 'chunked'" do
stub_request(:any, 'example.com').
to_return(:body => ["abc", "def"],
:status => 200)
@curl.http_get
expect(@curl).not_to be_chunked_response
end
it "is false when Transfer-Encoding is 'chunked' but body does not respond to each" do
stub_request(:any, 'example.com').
to_return(:body => "abc",
:status => 200)
@curl.http_get
expect(@curl).not_to be_chunked_response
end
end
end
describe "Webmock with Curb" do
describe "using #http for requests" do
it_should_behave_like "Curb"
include CurbSpecHelper::DynamicHttp
it "should work with uppercase arguments" do
stub_request(:get, "www.example.com").to_return(:body => "abc")
c = Curl::Easy.new
c.url = "http://www.example.com"
c.http(:GET)
expect(c.body_str).to eq("abc")
end
it "should alias body to body_str" do
stub_request(:get, "www.example.com").to_return(:body => "abc")
c = Curl::Easy.new
c.url = "http://www.example.com"
c.http(:GET)
expect(c.body).to eq("abc")
end
end
describe "using #http_* methods for requests" do
it_should_behave_like "Curb"
include CurbSpecHelper::NamedHttp
it "should work with blank arguments for post" do
stub_request(:post, "www.example.com").with(:body => "01234")
c = Curl::Easy.new
c.url = "http://www.example.com"
c.post_body = "01234"
c.http_post
expect(c.response_code).to eq(200)
end
it "should work with several body arguments for post using the class method" do
stub_request(:post, "www.example.com").with(:body => {:user => {:first_name=>'Bartosz', :last_name=>'Blimke'}})
c = Curl::Easy.http_post "http://www.example.com", 'user[first_name]=Bartosz', 'user[last_name]=Blimke'
expect(c.response_code).to eq(200)
end
it "should work with blank arguments for put" do
stub_request(:put, "www.example.com").with(:body => "01234")
c = Curl::Easy.new
c.url = "http://www.example.com"
c.put_data = "01234"
c.http_put
expect(c.response_code).to eq(200)
end
it "should work with multiple arguments for post" do
data = { :name => "john", :address => "111 example ave" }
stub_request(:post, "www.example.com").with(:body => data)
c = Curl::Easy.new
c.url = "http://www.example.com"
c.http_post Curl::PostField.content('name', data[:name]), Curl::PostField.content('address', data[:address])
expect(c.response_code).to eq(200)
end
end
describe "using #perform for requests" do
it_should_behave_like "Curb"
include CurbSpecHelper::Perform
end
describe "using .http_* methods for requests" do
it_should_behave_like "Curb"
include CurbSpecHelper::ClassNamedHttp
end
describe "using .perform for requests" do
it_should_behave_like "Curb"
include CurbSpecHelper::ClassPerform
end
end
end
webmock-1.22.6/spec/acceptance/curb/curb_spec_helper.rb 0000644 0000041 0000041 00000006205 12646134265 023101 0 ustar www-data www-data require 'ostruct'
module CurbSpecHelper
def http_request(method, uri, options = {}, &block)
uri = Addressable::URI.heuristic_parse(uri)
body = options[:body]
curl = curb_http_request(uri, method, body, options)
status, response_headers =
WebMock::HttpLibAdapters::CurbAdapter.parse_header_string(curl.header_str)
# Deal with the fact that the HTTP spec allows multi-values headers
# to either be a single entry with a comma-separated listed of
# values, or multiple separate entries
response_headers.keys.each do |k|
v = response_headers[k]
if v.is_a?(Array)
response_headers[k] = v.join(', ')
end
end
OpenStruct.new(
:body => curl.body_str,
:headers => WebMock::Util::Headers.normalize_headers(response_headers),
:status => curl.response_code.to_s,
:message => status
)
end
def setup_request(uri, curl, options={})
curl ||= Curl::Easy.new
curl.url = uri.omit(:userinfo).to_s
curl.username = uri.user
curl.password = uri.password
curl.timeout = 30
curl.connect_timeout = 30
if headers = options[:headers]
headers.each {|k,v| curl.headers[k] = v }
end
curl
end
def client_timeout_exception_class
Curl::Err::TimeoutError
end
def connection_refused_exception_class
Curl::Err::ConnectionFailedError
end
def http_library
:curb
end
module DynamicHttp
def curb_http_request(uri, method, body, options)
curl = setup_request(uri, nil, options)
case method
when :post
curl.post_body = body
when :put
curl.put_data = body
end
curl.http(method.to_s.upcase)
curl
end
end
module NamedHttp
def curb_http_request(uri, method, body, options)
curl = setup_request(uri, nil, options)
case method
when :put, :post
curl.send( "http_#{method}", body )
else
curl.send( "http_#{method}" )
end
curl
end
end
module Perform
def curb_http_request(uri, method, body, options)
curl = setup_request(uri, nil, options)
case method
when :post
curl.post_body = body
when :put
curl.put_data = body
when :head
curl.head = true
when :delete
curl.delete = true
end
curl.perform
curl
end
end
module ClassNamedHttp
def curb_http_request(uri, method, body, options)
args = ["http_#{method}", uri]
args << body if method == :post || method == :put
c = Curl::Easy.send(*args) do |curl|
setup_request(uri, curl, options)
end
c
end
end
module ClassPerform
def curb_http_request(uri, method, body, options)
args = ["http_#{method}", uri]
args << body if method == :post || method == :put
c = Curl::Easy.send(*args) do |curl|
setup_request(uri, curl, options)
case method
when :post
curl.post_body = body
when :put
curl.put_data = body
when :head
curl.head = true
when :delete
curl.delete = true
end
end
c
end
end
end
webmock-1.22.6/spec/acceptance/em_http_request/ 0000755 0000041 0000041 00000000000 12646134265 021522 5 ustar www-data www-data webmock-1.22.6/spec/acceptance/em_http_request/em_http_request_spec.rb 0000644 0000041 0000041 00000033066 12646134265 026301 0 ustar www-data www-data # encoding: utf-8
require 'spec_helper'
require 'acceptance/webmock_shared'
require 'ostruct'
unless RUBY_PLATFORM =~ /java/
require 'acceptance/em_http_request/em_http_request_spec_helper'
describe "EM::HttpRequest" do
include EMHttpRequestSpecHelper
include_context "with WebMock", :no_status_message
#functionality only supported for em-http-request 1.x
if defined?(EventMachine::HttpConnection)
context 'when a real request is made and redirects are followed', :net_connect => true do
before { WebMock.allow_net_connect! }
# This url redirects to the https URL.
let(:http_url) { "http://raw.github.com:80/gist/fb555cb593f3349d53af/6921dd638337d3f6a51b0e02e7f30e3c414f70d6/vcr_gist" }
let(:https_url) { http_url.gsub('http', 'https').gsub('80', '443') }
def make_request
EM.run do
request = EM::HttpRequest.new(http_url).get(:redirects => 1)
request.callback { EM.stop }
end
end
it "invokes the globally_stub_request hook with both requests" do
urls = []
WebMock.globally_stub_request { |r| urls << r.uri.to_s; nil }
make_request
expect(urls).to eq([http_url, https_url])
end
it 'invokes the after_request hook with both requests' do
urls = []
WebMock.after_request { |req, res| urls << req.uri.to_s }
make_request
expect(urls).to eq([http_url, https_url])
end
end
describe "with middleware" do
it "should work with request middleware" do
stub_request(:get, "www.example.com").with(:body => 'bar')
middleware = Class.new do
def request(client, head, body)
[{}, 'bar']
end
end
EM.run do
conn = EventMachine::HttpRequest.new('http://www.example.com/')
conn.use middleware
http = conn.get(:body => 'foo')
http.callback do
expect(WebMock).to have_requested(:get, "www.example.com").with(:body => 'bar')
EM.stop
end
end
end
let(:response_middleware) do
Class.new do
def response(resp)
resp.response = 'bar'
end
end
end
it "should work with response middleware" do
stub_request(:get, "www.example.com").to_return(:body => 'foo')
EM.run do
conn = EventMachine::HttpRequest.new('http://www.example.com/')
conn.use response_middleware
http = conn.get
http.callback do
expect(http.response).to eq('bar')
EM.stop
end
end
end
let(:webmock_server_url) { "http://#{WebMockServer.instance.host_with_port}/" }
shared_examples_for "em-http-request middleware/after_request hook integration" do
it 'yields the original raw body to the after_request hook even if a response middleware modifies the body' do
yielded_response_body = nil
::WebMock.after_request do |request, response|
yielded_response_body = response.body
end
EM::HttpRequest.use response_middleware
EM.run do
http = EventMachine::HttpRequest.new(webmock_server_url).get
http.callback { EM.stop }
end
expect(yielded_response_body).to eq("hello world")
end
end
context 'making a real request', :net_connect => true do
before { WebMock.allow_net_connect! }
include_examples "em-http-request middleware/after_request hook integration"
end
context 'when the request is stubbed' do
before { stub_request(:get, webmock_server_url).to_return(:body => 'hello world') }
include_examples "em-http-request middleware/after_request hook integration"
end
end
it 'should trigger error callbacks asynchronously' do
stub_request(:get, 'www.example.com').to_timeout
called = false
EM.run do
conn = EventMachine::HttpRequest.new('http://www.example.com/')
http = conn.get
http.errback do
called = true
EM.stop
end
expect(called).to eq(false)
end
expect(called).to eq(true)
end
# not pretty, but it works
if defined?(EventMachine::Synchrony)
describe "with synchrony" do
let(:webmock_em_http) { File.expand_path(File.join(File.dirname(__FILE__), "../lib/webmock/http_lib_adapters/em_http_request/em_http_request_1_x.rb")) }
before(:each) do
# need to reload the webmock em-http adapter after we require synchrony
WebMock::HttpLibAdapters::EmHttpRequestAdapter.disable!
$".delete webmock_em_http
$".delete File.expand_path(File.join(File.dirname(__FILE__), "../../../lib/webmock/http_lib_adapters/em_http_request_adapter.rb"))
require 'em-synchrony'
require 'em-synchrony/em-http'
require File.expand_path(File.join(File.dirname(__FILE__), "../../../lib/webmock/http_lib_adapters/em_http_request_adapter.rb"))
end
it "should work" do
stub_request(:post, /.*.testserver.com*/).to_return(:status => 200, :body => 'ok')
expect {
EM.run do
fiber = Fiber.new do
EM::HttpRequest.new("http://www.testserver.com").post :body => "foo=bar&baz=bang", :timeout => 60
EM.stop
end
fiber.resume
end
}.not_to raise_error
end
after(:each) do
EM.send(:remove_const, :Synchrony)
EM.send(:remove_const, :HTTPMethods)
WebMock::HttpLibAdapters::EmHttpRequestAdapter.disable!
$".reject! {|path| path.include? "em-http-request"}
$".delete webmock_em_http
$".delete File.expand_path(File.join(File.dirname(__FILE__), "../../../lib/webmock/http_lib_adapters/em_http_request_adapter.rb"))
require 'em-http-request'
require File.expand_path(File.join(File.dirname(__FILE__), "../../../lib/webmock/http_lib_adapters/em_http_request_adapter.rb"))
end
end
end
end
it "should work with streaming" do
stub_request(:get, "www.example.com").to_return(:body => "abc")
response = ""
EM.run {
http = EventMachine::HttpRequest.new('http://www.example.com/').get
http.stream { |chunk| response = chunk; EM.stop }
}
expect(response).to eq("abc")
end
it "should work with responses that use chunked transfer encoding" do
stub_request(:get, "www.example.com").to_return(:body => "abc", :headers => { 'Transfer-Encoding' => 'chunked' })
expect(http_request(:get, "http://www.example.com").body).to eq("abc")
end
it "should work with optional query params" do
stub_request(:get, "www.example.com/?x=3&a[]=b&a[]=c").to_return(:body => "abc")
expect(http_request(:get, "http://www.example.com/?x=3", :query => {"a" => ["b", "c"]}).body).to eq("abc")
end
it "should work with optional query params declared as string" do
stub_request(:get, "www.example.com/?x=3&a[]=b&a[]=c").to_return(:body => "abc")
expect(http_request(:get, "http://www.example.com/?x=3", :query => "a[]=b&a[]=c").body).to eq("abc")
end
it "should work when the body is passed as a Hash" do
stub_request(:post, "www.example.com").with(:body => {:a => "1", :b => "2"}).to_return(:body => "ok")
expect(http_request(:post, "http://www.example.com", :body => {:a => "1", :b => "2"}).body).to eq("ok")
end
if defined?(EventMachine::HttpConnection)
it "should work when a file is passed as body" do
stub_request(:post, "www.example.com").with(:body => File.read(__FILE__)).to_return(:body => "ok")
expect(http_request(:post, "http://www.example.com", :file => __FILE__).body).to eq("ok")
end
end
it "should work with UTF-8 strings" do
body = "Привет, Мир!"
stub_request(:post, "www.example.com").to_return(:body => body)
expect(http_request(:post, "http://www.example.com").body.bytesize).to eq(body.bytesize)
end
it "should work with multiple requests to the same connection" do
stub_request(:get, "www.example.com/foo").to_return(:body => "bar")
stub_request(:get, "www.example.com/baz").to_return(:body => "wombat")
err1 = nil
err2 = nil
body1 = nil
body2 = nil
i = 0
EM.run do
conn = EM::HttpRequest.new("http://www.example.com")
conn.get(:path => "/foo").callback do |resp|
body1 = resp.response
i += 1; EM.stop if i == 2
end.errback do |resp|
err1 = resp.error
i += 1; EM.stop if i == 2
end
conn.get(:path => "/baz").callback do |resp|
body2 = resp.response
i += 1; EM.stop if i == 2
end.errback do |resp|
err2 = resp.error
i += 1; EM.stop if i == 2
end
end
expect(err1).to be(nil)
expect(err2).to be(nil)
expect(body1).to eq("bar")
expect(body2).to eq("wombat")
end
it "should work with multiple requests to the same connection when the first request times out" do
stub_request(:get, "www.example.com/foo").to_timeout.then.to_return(:status => 200, :body => "wombat")
err = nil
body = nil
EM.run do
conn = EM::HttpRequest.new("http://www.example.com")
conn.get(:path => "/foo").callback do |resp|
err = :success_from_timeout
EM.stop
end.errback do |resp|
conn.get(:path => "/foo").callback do |resp|
expect(resp.response_header.status).to eq(200)
body = resp.response
EM.stop
end.errback do |resp|
err = resp.error
EM.stop
end
end
end
expect(err).to be(nil)
expect(body).to eq("wombat")
end
describe "mocking EM::HttpClient API" do
let(:uri) { "http://www.example.com/" }
before do
stub_request(:get, uri)
WebMock::HttpLibAdapters::EmHttpRequestAdapter.enable!
end
def client(uri, options = {})
client = nil
EM.run do
client = EventMachine::HttpRequest.new(uri).get(options)
client.callback { EM.stop }
client.errback { failed }
end
client
end
subject { client(uri) }
it 'should support #uri' do
expect(subject.uri).to eq(Addressable::URI.parse(uri))
end
it 'should support #last_effective_url' do
expect(subject.last_effective_url).to eq(Addressable::URI.parse(uri))
end
context "with a query" do
let(:uri) { "http://www.example.com/?a=1&b=2" }
subject { client("http://www.example.com/?a=1", :query => { 'b' => 2 }) }
it "#request_signature doesn't mutate the original uri" do
expect(subject.uri).to eq(Addressable::URI.parse("http://www.example.com/?a=1"))
signature = WebMock::RequestRegistry.instance.requested_signatures.hash.keys.first
expect(signature.uri).to eq(Addressable::URI.parse(uri))
end
end
describe 'get_response_cookie' do
before(:each) do
stub_request(:get, "http://example.org/").
to_return(
:status => 200,
:body => "",
:headers => { 'Set-Cookie' => cookie_string }
)
end
describe 'success' do
context 'with only one cookie' do
let(:cookie_name) { 'name_of_the_cookie' }
let(:cookie_value) { 'value_of_the_cookie' }
let(:cookie_string) { "#{cookie_name}=#{cookie_value}" }
it 'successfully gets the cookie' do
EM.run {
http = EventMachine::HttpRequest.new('http://example.org').get
http.errback { fail(http.error) }
http.callback {
expect(http.get_response_cookie(cookie_name)).to eq(cookie_value)
EM.stop
}
}
end
end
context 'with several cookies' do
let(:cookie_name) { 'name_of_the_cookie' }
let(:cookie_value) { 'value_of_the_cookie' }
let(:cookie_2_name) { 'name_of_the_2nd_cookie' }
let(:cookie_2_value) { 'value_of_the_2nd_cookie' }
let(:cookie_string) { %W(#{cookie_name}=#{cookie_value} #{cookie_2_name}=#{cookie_2_value}) }
it 'successfully gets both cookies' do
EM.run {
http = EventMachine::HttpRequest.new('http://example.org').get
http.errback { fail(http.error) }
http.callback {
expect(http.get_response_cookie(cookie_name)).to eq(cookie_value)
expect(http.get_response_cookie(cookie_2_name)).to eq(cookie_2_value)
EM.stop
}
}
end
end
end
describe 'failure' do
let(:cookie_string) { 'a=b' }
it 'returns nil when no cookie is found' do
EM.run {
http = EventMachine::HttpRequest.new('http://example.org').get
http.errback { fail(http.error) }
http.callback {
expect(http.get_response_cookie('not_found_cookie')).to eq(nil)
EM.stop
}
}
end
end
end
end
end
end
webmock-1.22.6/spec/acceptance/em_http_request/em_http_request_spec_helper.rb 0000644 0000041 0000041 00000003203 12646134265 027626 0 ustar www-data www-data module EMHttpRequestSpecHelper
def failed
EventMachine.stop
fail
end
def http_request(method, uri, options = {}, &block)
@http = nil
head = options[:headers] || {}
response = nil
error = nil
error_set = false
uri = Addressable::URI.heuristic_parse(uri)
EventMachine.run {
request = EventMachine::HttpRequest.new("#{uri.normalize.to_s}")
http = request.send(method, {
:timeout => 30,
:body => options[:body],
:file => options[:file],
:query => options[:query],
:head => head.merge('authorization' => [uri.user, uri.password])
}, &block)
http.errback {
error_set = true
error = if http.respond_to?(:errors)
http.errors
else
http.error
end
failed
}
http.callback {
response = OpenStruct.new({
:body => http.response,
:headers => WebMock::Util::Headers.normalize_headers(extract_response_headers(http)),
:message => http.response_header.http_reason,
:status => http.response_header.status.to_s
})
EventMachine.stop
}
@http = http
}
raise error.to_s if error_set
response
end
def client_timeout_exception_class
"WebMock timeout error"
end
def connection_refused_exception_class
RuntimeError
end
def http_library
:em_http_request
end
private
def extract_response_headers(http)
headers = {}
if http.response_header
http.response_header.each do |k,v|
v = v.join(", ") if v.is_a?(Array)
headers[k] = v
end
end
headers
end
end
webmock-1.22.6/spec/acceptance/net_http/ 0000755 0000041 0000041 00000000000 12646134265 020137 5 ustar www-data www-data webmock-1.22.6/spec/acceptance/net_http/net_http_shared.rb 0000644 0000041 0000041 00000010550 12646134265 023640 0 ustar www-data www-data shared_examples_for "Net::HTTP" do
describe "when making real requests", :net_connect => true do
let(:port){ WebMockServer.instance.port }
before(:each) do
@http = Net::HTTP.new("localhost", port)
end
it "should return a Net::ReadAdapter from response.body when a real request is made with a block and #read_body", :net_connect => true do
response = Net::HTTP.new("localhost", port).request_get('/') { |r| r.read_body { } }
expect(response.body).to be_a(Net::ReadAdapter)
end
it "should handle requests with block passed to read_body", :net_connect => true do
body = ""
req = Net::HTTP::Get.new("/")
Net::HTTP.start("localhost", port) do |http|
http.request(req) do |res|
res.read_body do |str|
body << str
end
end
end
expect(body).to match(/hello world/)
end
it "should connect only once when connected on start", :net_connect => true do
@http = Net::HTTP.new('localhost', port)
socket_id_before_request = socket_id_after_request = nil
@http.start {|conn|
socket_id_before_request = conn.instance_variable_get(:@socket).object_id
conn.request(Net::HTTP::Get.new("/"))
socket_id_after_request = conn.instance_variable_get(:@socket).object_id
}
if !defined?(WebMock::Config) || WebMock::Config.instance.net_http_connect_on_start
expect(socket_id_before_request).not_to eq(nil.object_id)
expect(socket_id_after_request).not_to eq(nil.object_id)
expect(socket_id_after_request).to eq(socket_id_before_request)
else
expect(socket_id_before_request).to eq(nil.object_id)
expect(socket_id_after_request).not_to eq(nil.object_id)
end
end
describe "without start" do
it "should close connection after a real request" do
@http.get('/') { }
expect(@http).not_to be_started
end
it "should execute block exactly once" do
times = 0
@http.get('/') { times += 1 }
expect(times).to eq(1)
end
it "should have socket open during a real request" do
socket_id = nil
@http.get('/') {
socket_id = @http.instance_variable_get(:@socket).object_id
}
expect(socket_id).not_to be_nil
end
it "should be started during a real request" do
started = nil
@http.get('/') {
started = @http.started?
}
expect(started).to eq(true)
expect(@http.started?).to eq(false)
end
end
describe "with start" do
it "should close connection after a real request" do
@http.start {|conn| conn.get('/') { } }
expect(@http).not_to be_started
end
it "should execute block exactly once" do
times = 0
@http.start {|conn| conn.get('/') { times += 1 }}
expect(times).to eq(1)
end
it "should have socket open during a real request" do
socket_id = nil
@http.start {|conn| conn.get('/') {
socket_id = conn.instance_variable_get(:@socket).object_id
}
}
expect(socket_id).not_to be_nil
end
it "should be started during a real request" do
started = nil
@http.start {|conn| conn.get('/') {
started = conn.started?
}
}
expect(started).to eq(true)
expect(@http.started?).to eq(false)
end
end
describe "with start without request block" do
it "should close connection after a real request" do
@http.start {|conn| conn.get('/') }
expect(@http).not_to be_started
end
it "should have socket open during a real request" do
socket_id = nil
@http.start {|conn|
socket_id = conn.instance_variable_get(:@socket).object_id
}
expect(socket_id).not_to be_nil
end
it "should be started during a real request" do
started = nil
@http.start {|conn|
started = conn.started?
}
expect(started).to eq(true)
expect(@http.started?).to eq(false)
end
end
describe "with start without a block and finish" do
it "should gracefully start and close connection" do
@http.start
@http.get("/")
expect(@http).to be_started
@http.finish
expect(@http).not_to be_started
end
end
end
end
webmock-1.22.6/spec/acceptance/net_http/real_net_http_spec.rb 0000644 0000041 0000041 00000000733 12646134265 024331 0 ustar www-data www-data require 'rubygems'
require 'rspec'
require 'net/http'
require 'net/https'
require 'stringio'
require 'acceptance/net_http/net_http_shared'
require 'support/webmock_server'
describe "Real Net:HTTP without webmock", :without_webmock => true do
before(:all) do
raise "WebMock has no access here!!!" if defined?(WebMock::NetHTTPUtility)
WebMockServer.instance.start
end
after(:all) do
WebMockServer.instance.stop
end
it_should_behave_like "Net::HTTP"
end webmock-1.22.6/spec/acceptance/net_http/net_http_spec_helper.rb 0000644 0000041 0000041 00000002716 12646134265 024670 0 ustar www-data www-data module NetHTTPSpecHelper
def http_request(method, uri, options = {}, &block)
begin
uri = URI.parse(uri)
rescue
uri = Addressable::URI.heuristic_parse(uri)
end
response = nil
clazz = Net::HTTP.const_get("#{method.to_s.capitalize}")
req = clazz.new("#{uri.path}#{uri.query ? '?' : ''}#{uri.query}", nil)
options[:headers].each do |k,v|
if v.is_a?(Array)
v.each_with_index do |v,i|
i == 0 ? (req[k] = v) : req.add_field(k, v)
end
else
req[k] = v
end
end if options[:headers]
req.basic_auth uri.user, uri.password if uri.user
http = Net::HTTP.new(uri.host, uri.port)
if uri.scheme == "https"
http.use_ssl = true
#1.9.1 has a bug with ssl_timeout
http.ssl_timeout = 20 unless RUBY_PLATFORM =~ /java/
http.open_timeout = 60
http.read_timeout = 60
end
http.verify_mode = OpenSSL::SSL::VERIFY_NONE
response = http.start {|http|
http.request(req, options[:body], &block)
}
headers = {}
response.each_header {|name, value| headers[name] = value}
OpenStruct.new({
:body => response.body,
:headers => WebMock::Util::Headers.normalize_headers(headers),
:status => response.code,
:message => response.message
})
end
def client_timeout_exception_class
Timeout::Error
end
def connection_refused_exception_class
Errno::ECONNREFUSED
end
def http_library
:net_http
end
end
webmock-1.22.6/spec/acceptance/net_http/net_http_spec.rb 0000644 0000041 0000041 00000025224 12646134265 023330 0 ustar www-data www-data require 'spec_helper'
require 'ostruct'
require 'acceptance/webmock_shared'
require 'acceptance/net_http/net_http_spec_helper'
require 'acceptance/net_http/net_http_shared'
include NetHTTPSpecHelper
describe "Net:HTTP" do
include_examples "with WebMock"
let(:port) { WebMockServer.instance.port }
describe "marshalling" do
class TestMarshalingInWebMockNetHTTP
attr_accessor :r
end
before(:each) do
@b = TestMarshalingInWebMockNetHTTP.new
end
after(:each) do
WebMock.enable!
end
it "should be possible to load object marshalled when webmock was disabled" do
WebMock.disable!
original_constants = [
Net::HTTP::Get,
Net::HTTP::Post,
Net::HTTP::Put,
Net::HTTP::Delete,
Net::HTTP::Head,
Net::HTTP::Options
]
@b.r = original_constants
original_serialized = Marshal.dump(@b)
Marshal.load(original_serialized)
WebMock.enable!
Marshal.load(original_serialized)
end
it "should be possible to load object marshalled when webmock was enabled" do
WebMock.enable!
new_constants = [
Net::HTTP::Get,
Net::HTTP::Post,
Net::HTTP::Put,
Net::HTTP::Delete,
Net::HTTP::Head,
Net::HTTP::Options
]
@b.r = new_constants
new_serialized = Marshal.dump(@b)
Marshal.load(new_serialized)
WebMock.disable!
Marshal.load(new_serialized)
end
end
describe "constants" do
it "should still have const Get defined on replaced Net::HTTP" do
expect(Object.const_get("Net").const_get("HTTP").const_defined?("Get")).to be_truthy
end
it "should still have const Get within constants on replaced Net::HTTP" do
expect(Object.const_get("Net").const_get("HTTP").constants.map(&:to_s)).to include("Get")
end
it "should still have const Get within constants on replaced Net::HTTP" do
expect(Object.const_get("Net").const_get("HTTP").const_get("Get")).not_to be_nil
end
if Module.method(:const_defined?).arity != 1
it "should still have const Get defined (and not inherited) on replaced Net::HTTP" do
expect(Object.const_get("Net").const_get("HTTP").const_defined?("Get", false)).to be_truthy
end
end
if Module.method(:const_get).arity != 1
it "should still be able to get non inherited constant Get on replaced Net::HTTP" do
expect(Object.const_get("Net").const_get("HTTP").const_get("Get", false)).not_to be_nil
end
end
if Module.method(:constants).arity != 0
it "should still Get within non inherited constants on replaced Net::HTTP" do
expect(Object.const_get("Net").const_get("HTTP").constants(false).map(&:to_s)).to include("Get")
end
end
describe "after WebMock is disabled" do
after(:each) do
WebMock.enable!
end
it "Net::HTTP should have the same constants" do
orig_consts_number = WebMock::HttpLibAdapters::NetHttpAdapter::OriginalNetHTTP.constants.size
Net::HTTP.send(:const_set, "TEST_CONST", 10)
expect(Net::HTTP.constants.size).to eq(orig_consts_number + 1)
WebMock.disable!
expect(Net::HTTP.constants.size).to eq(orig_consts_number + 1)
end
end
end
it "should work with block provided" do
stub_http_request(:get, "www.example.com").to_return(:body => "abc"*100000)
expect(Net::HTTP.start("www.example.com") { |query| query.get("/") }.body).to eq("abc"*100000)
end
it "raises an ArgumentError if passed headers as symbols" do
uri = URI.parse("http://google.com/")
http = Net::HTTP.new(uri.host, uri.port)
request = Net::HTTP::Get.new(uri.request_uri)
# Net::HTTP calls downcase on header keys assigned with []=
# In Ruby 1.8.7 symbols do not respond to downcase
#
# Meaning you can not assign header keys as symbols in ruby 1.8.7 using []=
if :symbol.respond_to?(:downcase)
request[:InvalidHeaderSinceItsASymbol] = "this will not be valid"
else
request.instance_eval do
@header = request.to_hash.merge({:InvalidHeaderSinceItsASymbol => "this will not be valid"})
end
end
expect do
http.request(request)
end.to raise_error ArgumentError, "Net:HTTP does not accept headers as symbols"
end
it "should handle multiple values for the same response header" do
stub_http_request(:get, "www.example.com").to_return(:headers => { 'Set-Cookie' => ['foo=bar', 'bar=bazz'] })
response = Net::HTTP.get_response(URI.parse("http://www.example.com/"))
expect(response.get_fields('Set-Cookie')).to eq(['bar=bazz', 'foo=bar'])
end
it "should yield block on response" do
stub_http_request(:get, "www.example.com").to_return(:body => "abc")
response_body = ""
http_request(:get, "http://www.example.com/") do |response|
response_body = response.body
end
expect(response_body).to eq("abc")
end
it "should handle Net::HTTP::Post#body" do
stub_http_request(:post, "www.example.com").with(:body => "my_params").to_return(:body => "abc")
req = Net::HTTP::Post.new("/")
req.body = "my_params"
expect(Net::HTTP.start("www.example.com") { |http| http.request(req)}.body).to eq("abc")
end
it "should handle Net::HTTP::Post#body_stream" do
stub_http_request(:post, "www.example.com").with(:body => "my_params").to_return(:body => "abc")
req = Net::HTTP::Post.new("/")
req.body_stream = StringIO.new("my_params")
expect(Net::HTTP.start("www.example.com") { |http| http.request(req)}.body).to eq("abc")
end
it "should behave like Net::HTTP and raise error if both request body and body argument are set" do
stub_http_request(:post, "www.example.com").with(:body => "my_params").to_return(:body => "abc")
req = Net::HTTP::Post.new("/")
req.body = "my_params"
expect {
Net::HTTP.start("www.example.com") { |http| http.request(req, "my_params")}
}.to raise_error("both of body argument and HTTPRequest#body set")
end
it "should return a Net::ReadAdapter from response.body when a stubbed request is made with a block and #read_body" do
WebMock.stub_request(:get, 'http://example.com/').to_return(:body => "the body")
response = Net::HTTP.new('example.com', 80).request_get('/') { |r| r.read_body { } }
expect(response.body).to be_a(Net::ReadAdapter)
end
it "should have request 1 time executed in registry after 1 real request", :net_connect => true do
WebMock.allow_net_connect!
http = Net::HTTP.new('localhost', port)
http.get('/') {}
expect(WebMock::RequestRegistry.instance.requested_signatures.hash.size).to eq(1)
expect(WebMock::RequestRegistry.instance.requested_signatures.hash.values.first).to eq(1)
end
it "should work with Addressable::URI passed to Net::HTTP.get_response" do
stub_request(:get, 'http://www.example.com/hello?a=1').to_return(:body => "abc")
expect(Net::HTTP.get_response(Addressable::URI.parse('http://www.example.com/hello?a=1')).body).to eq("abc")
end
describe "connecting on Net::HTTP.start" do
before(:each) do
@http = Net::HTTP.new('www.google.com', 443)
@http.use_ssl = true
@http.verify_mode = OpenSSL::SSL::VERIFY_NONE
end
describe "when net http is allowed" do
it "should not connect to the server until the request", :net_connect => true do
WebMock.allow_net_connect!
@http.start {|conn|
expect(conn.peer_cert).to be_nil
}
end
it "should connect to the server on start", :net_connect => true do
WebMock.allow_net_connect!(:net_http_connect_on_start => true)
@http.start {|conn|
cert = OpenSSL::X509::Certificate.new conn.peer_cert
expect(cert).to be_a(OpenSSL::X509::Certificate)
}
end
end
describe "when net http is disabled and allowed only for some hosts" do
it "should not connect to the server until the request", :net_connect => true do
WebMock.disable_net_connect!(:allow => "www.google.com")
@http.start {|conn|
expect(conn.peer_cert).to be_nil
}
end
it "should connect to the server on start", :net_connect => true do
WebMock.disable_net_connect!(:allow => "www.google.com", :net_http_connect_on_start => true)
@http.start {|conn|
cert = OpenSSL::X509::Certificate.new conn.peer_cert
expect(cert).to be_a(OpenSSL::X509::Certificate)
}
end
it "should connect to the server if the URI matches an regex", :net_connect => true do
WebMock.disable_net_connect!(:allow => /google.com/)
Net::HTTP.get('www.google.com','/')
end
it "should connect to the server if the URI matches any regex the array", :net_connect => true do
WebMock.disable_net_connect!(:allow => [/google.com/, /yahoo.com/])
Net::HTTP.get('www.google.com','/')
end
end
end
describe "when net_http_connect_on_start is true" do
before(:each) do
WebMock.allow_net_connect!(:net_http_connect_on_start => true)
end
it_should_behave_like "Net::HTTP"
end
describe "when net_http_connect_on_start is false" do
before(:each) do
WebMock.allow_net_connect!(:net_http_connect_on_start => false)
end
it_should_behave_like "Net::HTTP"
end
describe 'after_request callback support', :net_connect => true do
let(:expected_body_regex) { /hello world/ }
before(:each) do
WebMock.allow_net_connect!
@callback_invocation_count = 0
WebMock.after_request do |_, response|
@callback_invocation_count += 1
@callback_response = response
end
end
after(:each) do
WebMock.reset_callbacks
end
def perform_get_with_returning_block
http_request(:get, "http://localhost:#{port}/") do |response|
return response.body
end
end
it "should support the after_request callback on an request with block and read_body" do
response_body = ''
http_request(:get, "http://localhost:#{port}/") do |response|
response.read_body { |fragment| response_body << fragment }
end
expect(response_body).to match(expected_body_regex)
expect(@callback_response.body).to eq(response_body)
end
it "should support the after_request callback on a request with a returning block" do
response_body = perform_get_with_returning_block
expect(response_body).to match(expected_body_regex)
expect(@callback_response).to be_instance_of(WebMock::Response)
expect(@callback_response.body).to eq(response_body)
end
it "should only invoke the after_request callback once, even for a recursive post request" do
Net::HTTP.new('localhost', port).post('/', nil)
expect(@callback_invocation_count).to eq(1)
end
end
end
webmock-1.22.6/spec/acceptance/http_rb/ 0000755 0000041 0000041 00000000000 12646134265 017754 5 ustar www-data www-data webmock-1.22.6/spec/acceptance/http_rb/http_rb_spec_helper.rb 0000644 0000041 0000041 00000002201 12646134265 024307 0 ustar www-data www-data require "ostruct"
module HttpRbSpecHelper
def http_request(method, uri, options = {})
response = HTTP.request(method, normalize_uri(uri), options)
OpenStruct.new({
:body => response.body.to_s,
:headers => normalize_headers(response.headers.to_h),
:status => response.code.to_s,
:message => response.reason
})
end
def client_timeout_exception_class
return Errno::ETIMEDOUT if HTTP::VERSION < "1.0.0"
HTTP::ConnectionError
end
def connection_refused_exception_class
return Errno::ECONNREFUSED if HTTP::VERSION < "1.0.0"
HTTP::ConnectionError
end
def http_library
:http_rb
end
def normalize_uri(uri)
Addressable::URI.heuristic_parse(uri).normalize.to_s
end
def normalize_headers(headers)
headers = Hash[headers.map { |k, v| [k, Array(v).join(", ")] }]
WebMock::Util::Headers.normalize_headers headers
end
def stub_simple_request(host, status = 200, headers = {}, body = nil)
stub_request(:any, host).to_return({
:status => status,
:headers => headers.merge({ "Host" => host }),
:body => body
})
end
end
webmock-1.22.6/spec/acceptance/http_rb/http_rb_spec.rb 0000644 0000041 0000041 00000004241 12646134265 022756 0 ustar www-data www-data # encoding: utf-8
require "spec_helper"
require "acceptance/webmock_shared"
require "acceptance/http_rb/http_rb_spec_helper"
describe "HTTP.rb" do
include HttpRbSpecHelper
include_examples "with WebMock", :no_status_message
context "streaming body" do
let(:response) { HTTP.get "http://example.com" }
before { stub_simple_request "example.com", 302, {}, "abc" }
it "works as if it was streamed from socket" do
expect(response.body.readpartial 1).to eq "a"
end
it "fails if body was already streamed" do
response.body.to_s
expect { response.body.readpartial 1 }.to raise_error
end
end
context "without following redirects" do
let(:response) { http_request(:get, "http://example.com") }
let(:headers) { response.headers }
it "stops on first request" do
stub_simple_request("example.com", 302, "Location" => "http://www.example.com")
stub_simple_request("www.example.com")
expect(headers).to include "Host" => "example.com"
end
end
context "following redirects" do
let(:options) { { :follow => true } }
let(:response) { http_request(:get, "http://example.com", options) }
let(:headers) { response.headers }
it "returns response of destination" do
stub_simple_request("example.com", 302, "Location" => "http://www.example.com")
stub_simple_request("www.example.com")
expect(headers).to include "Host" => "www.example.com"
end
end
context "restored request uri on replayed response object" do
it "keeps non-default port" do
stub_request :get, "example.com:1234/foo"
response = HTTP.get "http://example.com:1234/foo"
expect(response.uri.to_s).to eq "http://example.com:1234/foo"
end
it "does not injects default port" do
stub_request :get, "example.com/foo"
response = HTTP.get "http://example.com/foo"
expect(response.uri.to_s).to eq "http://example.com/foo"
end
it "strips out default port even if it was explicitly given" do
stub_request :get, "example.com/foo"
response = HTTP.get "http://example.com:80/foo"
expect(response.uri.to_s).to eq "http://example.com/foo"
end
end
end
webmock-1.22.6/spec/acceptance/webmock_shared.rb 0000644 0000041 0000041 00000002617 12646134265 021622 0 ustar www-data www-data require 'spec_helper'
require 'acceptance/shared/enabling_and_disabling_webmock'
require 'acceptance/shared/returning_declared_responses'
require 'acceptance/shared/callbacks'
require 'acceptance/shared/request_expectations'
require 'acceptance/shared/stubbing_requests'
require 'acceptance/shared/allowing_and_disabling_net_connect'
require 'acceptance/shared/precedence_of_stubs'
require 'acceptance/shared/complex_cross_concern_behaviors'
unless defined? SAMPLE_HEADERS
SAMPLE_HEADERS = { "Content-Length" => "8888", "Accept" => "application/json" }
ESCAPED_PARAMS = "x=ab%20c&z=%27Stop%21%27%20said%20Fred%20m"
NOT_ESCAPED_PARAMS = "z='Stop!' said Fred m&x=ab c"
end
shared_examples "with WebMock" do |*adapter_info|
describe "with WebMock" do
let(:webmock_server_url) {"http://#{WebMockServer.instance.host_with_port}/"}
before(:each) do
WebMock.disable_net_connect!
WebMock.reset!
end
include_context "allowing and disabling net connect", *adapter_info
include_context "stubbing requests", *adapter_info
include_context "declared responses", *adapter_info
include_context "precedence of stubs", *adapter_info
include_context "request expectations", *adapter_info
include_context "callbacks", *adapter_info
include_context "enabled and disabled webmock", *adapter_info
include_context "complex cross-concern behaviors", *adapter_info
end
end
webmock-1.22.6/spec/acceptance/shared/ 0000755 0000041 0000041 00000000000 12646134265 017560 5 ustar www-data www-data webmock-1.22.6/spec/acceptance/shared/enabling_and_disabling_webmock.rb 0000644 0000041 0000041 00000004721 12646134265 026235 0 ustar www-data www-data shared_context "enabled and disabled webmock" do |*adapter_info|
describe "when webmock is disabled" do
before(:each) do
WebMock.disable!
end
after(:each) do
WebMock.enable!
end
include_context "disabled WebMock"
end
describe "when webmock is enabled again" do
before(:each) do
WebMock.disable!
WebMock.enable!
end
include_context "enabled WebMock"
end
describe "when webmock is disabled except this lib" do
before(:each) do
WebMock.disable!(:except => [http_library])
end
after(:each) do
WebMock.enable!
end
include_context "enabled WebMock"
end
describe "when webmock is enabled except this lib" do
before(:each) do
WebMock.disable!
WebMock.enable!(:except => [http_library])
end
after(:each) do
WebMock.enable!
end
include_context "disabled WebMock"
end
end
shared_context "disabled WebMock" do
it "should not register executed requests" do
http_request(:get, webmock_server_url)
expect(a_request(:get, webmock_server_url)).not_to have_been_made
end
it "should not block unstubbed requests" do
expect {
http_request(:get, webmock_server_url)
}.not_to raise_error
end
it "should return real response even if there are stubs" do
stub_request(:get, /.*/).to_return(:body => "x")
expect(http_request(:get, webmock_server_url).body).to eq("hello world")
end
it "should not invoke any callbacks" do
WebMock.reset_callbacks
stub_request(:get, webmock_server_url)
@called = nil
WebMock.after_request { @called = 1 }
http_request(:get, webmock_server_url)
expect(@called).to eq(nil)
end
end
shared_context "enabled WebMock" do
it "should register executed requests" do
WebMock.allow_net_connect!
http_request(:get, webmock_server_url)
expect(a_request(:get, webmock_server_url)).to have_been_made
end
it "should block unstubbed requests" do
expect {
http_request(:get, "http://www.example.com/")
}.to raise_error(WebMock::NetConnectNotAllowedError)
end
it "should return stubbed response" do
stub_request(:get, /.*/).to_return(:body => "x")
expect(http_request(:get, "http://www.example.com/").body).to eq("x")
end
it "should invoke callbacks" do
WebMock.allow_net_connect!
WebMock.reset_callbacks
@called = nil
WebMock.after_request { @called = 1 }
http_request(:get, webmock_server_url)
expect(@called).to eq(1)
end
end
webmock-1.22.6/spec/acceptance/shared/allowing_and_disabling_net_connect.rb 0000644 0000041 0000041 00000013576 12646134265 027152 0 ustar www-data www-data shared_context "allowing and disabling net connect" do |*adapter_info|
describe "when net connect" do
describe "is allowed", :net_connect => true do
before(:each) do
WebMock.allow_net_connect!
end
it "should make a real web request if request is not stubbed" do
expect(http_request(:get, webmock_server_url).status).to eq("200")
end
it "should make a real https request if request is not stubbed" do
unless http_library == :httpclient
result = http_request(:get, "https://www.google.com/").body
if result.respond_to? :encode
result = result.encode(
'UTF-8',
'binary',
:invalid => :replace,
:undef => :replace,
:replace => ''
)
end
expect(result).to match(/.*google.*/)
end
end
it "should return stubbed response if request was stubbed" do
stub_request(:get, "www.example.com").to_return(:body => "abc")
expect(http_request(:get, "http://www.example.com/").body).to eq("abc")
end
end
describe "is not allowed" do
before(:each) do
WebMock.disable_net_connect!
end
it "should return stubbed response if request was stubbed" do
stub_request(:get, "www.example.com").to_return(:body => "abc")
expect(http_request(:get, "http://www.example.com/").body).to eq("abc")
end
it "should return stubbed response if request with path was stubbed" do
stub_request(:get, "www.example.com/hello_world").to_return(:body => "abc")
expect(http_request(:get, "http://www.example.com/hello_world").body).to eq("abc")
end
it "should raise exception if request was not stubbed" do
expect {
http_request(:get, "http://www.example.com/")
}.to raise_error(WebMock::NetConnectNotAllowedError, %r(Real HTTP connections are disabled. Unregistered request: GET http://www.example.com/))
end
end
describe "is not allowed with exception for localhost" do
before(:each) do
WebMock.disable_net_connect!(:allow_localhost => true)
end
it "should return stubbed response if request was stubbed" do
stub_request(:get, "www.example.com").to_return(:body => "abc")
expect(http_request(:get, "http://www.example.com/").body).to eq("abc")
end
it "should raise exception if request was not stubbed" do
expect {
http_request(:get, "http://www.example.com/")
}.to raise_error(WebMock::NetConnectNotAllowedError, %r(Real HTTP connections are disabled. Unregistered request: GET http://www.example.com/))
end
it "should make a real request to localhost" do
expect {
http_request(:get, "http://localhost:12345/")
}.to raise_error(connection_refused_exception_class)
end
it "should make a real request to 127.0.0.1" do
expect {
http_request(:get, "http://127.0.0.1:12345/")
}.to raise_error(connection_refused_exception_class)
end
it "should make a real request to 0.0.0.0" do
expect {
http_request(:get, "http://0.0.0.0:12345/")
}.to raise_error(connection_refused_exception_class)
end
end
describe "is not allowed with exception for allowed domains" do
let(:host_with_port){ WebMockServer.instance.host_with_port }
before(:each) do
WebMock.disable_net_connect!(:allow => ["www.example.org", "httpstat.us", host_with_port])
end
context "when the host is not allowed" do
it "should return stubbed response if request was stubbed" do
stub_request(:get, "www.example.com").to_return(:body => "abc")
expect(http_request(:get, "http://www.example.com/").body).to eq("abc")
end
it "should raise exception if request was not stubbed" do
expect {
http_request(:get, "http://www.example.com/")
}.to raise_error(WebMock::NetConnectNotAllowedError, %r(Real HTTP connections are disabled. Unregistered request: GET http://www.example.com/))
end
end
context "when the host with port is not allowed" do
it "should return stubbed response if request was stubbed" do
stub_request(:get, "http://localhost:2345").to_return(:body => "abc")
expect(http_request(:get, "http://localhost:2345/").body).to eq("abc")
end
it "should raise exception if request was not stubbed" do
expect {
http_request(:get, "http://localhost:2345/")
}.to raise_error(WebMock::NetConnectNotAllowedError, %r(Real HTTP connections are disabled. Unregistered request: GET http://localhost:2345/))
end
end
context "when the host is allowed" do
it "should raise exception if request was not stubbed" do
expect {
http_request(:get, "http://www.example.com/")
}.to raise_error(WebMock::NetConnectNotAllowedError, %r(Real HTTP connections are disabled. Unregistered request: GET http://www.example.com/))
end
it "should make a real request to allowed host", :net_connect => true do
expect(http_request(:get, "http://httpstat.us/200").status).to eq("200")
end
end
context "when the host with port is allowed" do
it "should make a real request to allowed host", :net_connect => true do
expect(http_request(:get, "http://#{host_with_port}/").status).to eq("200")
end
end
context "when the host is allowed but not port" do
it "should make a real request to allowed host", :net_connect => true do
expect {
http_request(:get, "http://localhost:123/")
}.to raise_error(WebMock::NetConnectNotAllowedError, %r(Real HTTP connections are disabled. Unregistered request: GET http://localhost:123/))
end
end
end
end
end
webmock-1.22.6/spec/acceptance/shared/request_expectations.rb 0000644 0000041 0000041 00000121126 12646134265 024366 0 ustar www-data www-data shared_context "request expectations" do |*adapter_info|
describe "when request expectations are set" do
describe "when net connect is not allowed" do
before(:each) do
WebMock.disable_net_connect!
stub_request(:any, "http://www.example.com")
stub_request(:any, "https://www.example.com")
end
it "should satisfy expectation if request was executed with the same uri and method" do
expect {
http_request(:get, "http://www.example.com/")
expect(a_request(:get, "http://www.example.com")).to have_been_made.once
}.not_to raise_error
end
it "should satisfy expectation declared on WebMock.resuest" do
expect {
http_request(:get, "http://www.example.com/")
expect(WebMock.request(:get, "http://www.example.com")).to have_been_made.once
}.not_to raise_error
end
it "should satisfy expectation if request was not expected and not executed" do
expect {
expect(a_request(:get, "http://www.example.com")).not_to have_been_made
}.not_to raise_error
end
it "should fail if request was not expected but executed" do
expect {
http_request(:get, "http://www.example.com/")
expect(a_request(:get, "http://www.example.com")).not_to have_been_made
}.to fail_with(%r(The request GET http://www.example.com/ was not expected to execute but it executed 1 time))
end
it "should fail resulting with failure with a message and executed requests listed" do
expect {
http_request(:get, "http://www.example.com/")
expect(a_request(:get, "http://www.example.com")).not_to have_been_made
}.to fail_with(%r{The following requests were made:\n\nGET http://www.example.com/.+was made 1 time})
end
it "should fail if request was not executed" do
expect {
expect(a_request(:get, "http://www.example.com")).to have_been_made
}.to fail_with(%r(The request GET http://www.example.com/ was expected to execute 1 time but it executed 0 times))
end
it "should fail if request was executed to different uri" do
expect {
http_request(:get, "http://www.example.com/")
expect(a_request(:get, "http://www.example.org")).to have_been_made
}.to fail_with(%r(The request GET http://www.example.org/ was expected to execute 1 time but it executed 0 times))
end
it "should fail if request was executed with different method" do
expect {
http_request(:post, "http://www.example.com/", :body => "abc")
expect(a_request(:get, "http://www.example.com")).to have_been_made
}.to fail_with(%r(The request GET http://www.example.com/ was expected to execute 1 time but it executed 0 times))
end
it "should satisfy expectation if request was executed with different form of uri" do
expect {
http_request(:get, "http://www.example.com/")
expect(a_request(:get, "www.example.com")).to have_been_made
}.not_to raise_error
end
it "should satisfy expectation if request was executed with different form of uri without port " do
expect {
http_request(:get, "http://www.example.com/")
expect(a_request(:get, "www.example.com:80")).to have_been_made
}.not_to raise_error
end
it "should satisfy expectation if request was executed with different form of uri with port" do
expect {
http_request(:get, "http://www.example.com/")
expect(a_request(:get, "www.example.com:80")).to have_been_made
}.not_to raise_error
end
it "should fail if request was executed to a different port" do
expect {
http_request(:get, "http://www.example.com:80/")
expect(a_request(:get, "www.example.com:90")).to have_been_made
}.to fail_with(%r(The request GET http://www.example.com:90/ was expected to execute 1 time but it executed 0 times))
end
it "should satisfy expectation if request was executed with different form of uri with https port" do
expect {
http_request(:get, "https://www.example.com/")
expect(a_request(:get, "https://www.example.com:443/")).to have_been_made
}.not_to raise_error
end
describe "when matching requests with escaped or unescaped uris" do
before(:each) do
WebMock.disable_net_connect!
stub_request(:any, "http://www.example.com/?#{NOT_ESCAPED_PARAMS}")
end
it "should satisfy expectation if request was executed with escaped params" do
expect {
http_request(:get, "http://www.example.com/?#{ESCAPED_PARAMS}")
expect(a_request(:get, "http://www.example.com/?#{NOT_ESCAPED_PARAMS}")).to have_been_made
}.not_to raise_error
end
it "should satisfy expectation if request was executed with non escaped params" do
expect {
http_request(:get, "http://www.example.com/?#{NOT_ESCAPED_PARAMS}")
expect(a_request(:get, "http://www.example.com/?#{ESCAPED_PARAMS}")).to have_been_made
}.not_to raise_error
end
it "should satisfy expectation if request was executed with escaped params and uri matching regexp was expected" do
expect {
http_request(:get, "http://www.example.com/?#{ESCAPED_PARAMS}")
expect(a_request(:get, /.*example.*/)).to have_been_made
}.not_to raise_error
end
end
describe "when matching requests with query params" do
before(:each) do
stub_request(:any, /.*example.*/)
end
it "should satisfy expectation if the request was executed with query params declared as a hash in a query option" do
expect {
http_request(:get, "http://www.example.com/?a[]=b&a[]=c")
expect(a_request(:get, "www.example.com").with(:query => {"a" => ["b", "c"]})).to have_been_made
}.not_to raise_error
end
it "should satisfy expectation if the request was executed with query params declared as string in query option" do
expect {
http_request(:get, "http://www.example.com/?a[]=b&a[]=c")
expect(a_request(:get, "www.example.com").with(:query => "a[]=b&a[]=c")).to have_been_made
}.not_to raise_error
end
it "should satisfy expectation if the request was executed with query params both in uri and in query option" do
expect {
http_request(:get, "http://www.example.com/?x=3&a[]=b&a[]=c")
expect(a_request(:get, "www.example.com/?x=3").with(:query => {"a" => ["b", "c"]})).to have_been_made
}.not_to raise_error
end
it "should satisfy expectation if the request was executed with only part query params declared as a hash in a query option" do
expect {
http_request(:get, "http://www.example.com/?a[]=b&a[]=c&b=1")
expect(a_request(:get, "www.example.com").with(:query => hash_including({"a" => ["b", "c"]}))).to have_been_made
}.not_to raise_error
end
end
context "when using flat array notation" do
before :all do
WebMock::Config.instance.query_values_notation = :flat_array
end
it "should satisfy expectation if request includes different repeated query params in flat array notation" do
expect {
stub_request(:get, "http://www.example.com/?a=1&a=2")
http_request(:get, "http://www.example.com/?a=1&a=2")
expect(a_request(:get, "http://www.example.com/?a=1&a=2")).to have_been_made
}.not_to raise_error
end
after :all do
WebMock::Config.instance.query_values_notation = nil
end
end
describe "at_most_times" do
it "fails if request was made more times than maximum" do
expect {
http_request(:get, "http://www.example.com/")
http_request(:get, "http://www.example.com/")
http_request(:get, "http://www.example.com/")
expect(a_request(:get, "http://www.example.com")).to have_been_made.at_most_times(2)
}.to fail_with(%r(The request GET http://www.example.com/ was expected to execute at most 2 times but it executed 3 times))
end
it "passes if request was made the maximum number of times" do
expect {
http_request(:get, "http://www.example.com/")
http_request(:get, "http://www.example.com/")
expect(a_request(:get, "http://www.example.com")).to have_been_made.at_most_times(2)
}.not_to raise_error
end
it "passes if request was made fewer than the maximum number of times" do
expect {
http_request(:get, "http://www.example.com/")
expect(a_request(:get, "http://www.example.com")).to have_been_made.at_most_times(2)
}.not_to raise_error
end
it "passes if request was not made at all" do
expect {
expect(a_request(:get, "http://www.example.com")).to have_been_made.at_most_times(2)
}.not_to raise_error
end
end
describe "at_least_times" do
it "fails if request was made fewer times than minimum" do
expect {
http_request(:get, "http://www.example.com/")
expect(a_request(:get, "http://www.example.com")).to have_been_made.at_least_times(2)
}.to fail_with(%r(The request GET http://www.example.com/ was expected to execute at least 2 times but it executed 1 time))
end
it "passes if request was made the minimum number of times" do
expect {
http_request(:get, "http://www.example.com/")
http_request(:get, "http://www.example.com/")
expect(a_request(:get, "http://www.example.com")).to have_been_made.at_least_times(2)
}.not_to raise_error
end
it "passes if request was made more than the minimum number of times" do
expect {
http_request(:get, "http://www.example.com/")
http_request(:get, "http://www.example.com/")
http_request(:get, "http://www.example.com/")
expect(a_request(:get, "http://www.example.com")).to have_been_made.at_least_times(2)
}.not_to raise_error
end
context "descriptive at_most_ matcher" do
context "at_most_once" do
it "succeeds if no request was executed" do
expect {
expect(a_request(:get, "http://www.example.com")).to have_been_made.at_most_once
}.not_to raise_error
end
it "satisfies expectation if request was executed with the same uri and method once" do
expect {
http_request(:get, "http://www.example.com/")
expect(a_request(:get, "http://www.example.com")).to have_been_made.at_most_once
}.not_to raise_error
end
it "fails if request was executed with the same uri and method twice" do
expect {
http_request(:get, "http://www.example.com/")
http_request(:get, "http://www.example.com/")
expect(a_request(:get, "http://www.example.com")).to have_been_made.at_most_once
}.to raise_error
end
end
context "at_most_twice" do
it "succeeds if no request was executed" do
expect {
expect(a_request(:get, "http://www.example.com")).to have_been_made.at_most_twice
}.not_to raise_error
end
it "succeeds if too few requests were executed" do
expect {
http_request(:get, "http://www.example.com/")
expect(a_request(:get, "http://www.example.com")).to have_been_made.at_most_twice
}.not_to raise_error
end
it "satisfies expectation if request was executed with the same uri and method twice" do
expect {
http_request(:get, "http://www.example.com/")
http_request(:get, "http://www.example.com/")
expect(a_request(:get, "http://www.example.com")).to have_been_made.at_most_twice
}.not_to raise_error
end
it "fails if request was executed with the same uri and method three times" do
expect {
http_request(:get, "http://www.example.com/")
http_request(:get, "http://www.example.com/")
http_request(:get, "http://www.example.com/")
expect(a_request(:get, "http://www.example.com")).to have_been_made.at_most_twice
}.to raise_error
end
end
end
context "descriptive at_least_ matcher" do
context "at_least_once" do
it "fails if no request was executed" do
expect {
expect(a_request(:get, "http://www.example.com")).to have_been_made.at_least_once
}.to raise_error
end
it "satisfies expectation if request was executed with the same uri and method once" do
expect {
http_request(:get, "http://www.example.com/")
expect(a_request(:get, "http://www.example.com")).to have_been_made.at_least_once
}.not_to raise_error
end
it "satisfies expectation if request was executed with the same uri and method twice" do
expect {
http_request(:get, "http://www.example.com/")
http_request(:get, "http://www.example.com/")
expect(a_request(:get, "http://www.example.com")).to have_been_made.at_least_once
}.not_to raise_error
end
end
context "at_least_twice" do
it "fails if no request was executed" do
expect {
expect(a_request(:get, "http://www.example.com")).to have_been_made.at_least_twice
}.to raise_error
end
it "fails if too few requests were executed" do
expect {
http_request(:get, "http://www.example.com/")
expect(a_request(:get, "http://www.example.com")).to have_been_made.at_least_twice
}.to raise_error
end
it "satisfies expectation if request was executed with the same uri and method twice" do
expect {
http_request(:get, "http://www.example.com/")
http_request(:get, "http://www.example.com/")
expect(a_request(:get, "http://www.example.com")).to have_been_made.at_least_twice
}.not_to raise_error
end
it "satisfies expectation if request was executed with the same uri and method three times" do
expect {
http_request(:get, "http://www.example.com/")
http_request(:get, "http://www.example.com/")
http_request(:get, "http://www.example.com/")
expect(a_request(:get, "http://www.example.com")).to have_been_made.at_least_twice
}.not_to raise_error
end
end
end
end
it "should fail if request was made more times than expected" do
expect {
http_request(:get, "http://www.example.com/")
http_request(:get, "http://www.example.com/")
expect(a_request(:get, "http://www.example.com")).to have_been_made
}.to fail_with(%r(The request GET http://www.example.com/ was expected to execute 1 time but it executed 2 times))
end
it "should fail if request was made less times than expected" do
expect {
http_request(:get, "http://www.example.com/")
expect(a_request(:get, "http://www.example.com")).to have_been_made.twice
}.to fail_with(%r(The request GET http://www.example.com/ was expected to execute 2 times but it executed 1 time))
end
it "should fail if request was made less times than expected when 3 times expected" do
expect {
http_request(:get, "http://www.example.com/")
expect(a_request(:get, "http://www.example.com")).to have_been_made.times(3)
}.to fail_with(%r(The request GET http://www.example.com/ was expected to execute 3 times but it executed 1 time))
end
it "should satisfy expectation if request was executed with the same body" do
expect {
http_request(:post, "http://www.example.com/", :body => "abc")
expect(a_request(:post, "www.example.com").with(:body => "abc")).to have_been_made
}.not_to raise_error
end
it "should fail if request was executed with different body" do
expect {
http_request(:post, "http://www.example.com/", :body => "abc")
expect(a_request(:post, "www.example.com").
with(:body => "def")).to have_been_made
}.to fail_with(%r(The request POST http://www.example.com/ with body "def" was expected to execute 1 time but it executed 0 times))
end
describe "when expected request body is declared as a regexp" do
it "should satisfy expectation if request was executed with body matching regexp" do
expect {
http_request(:post, "http://www.example.com/", :body => "abc")
expect(a_request(:post, "www.example.com").with(:body => /^abc$/)).to have_been_made
}.not_to raise_error
end
it "should fail if request was executed with body not matching regexp" do
expect {
http_request(:post, "http://www.example.com/", :body => "abc")
expect(a_request(:post, "www.example.com").
with(:body => /^xabc/)).to have_been_made
}.to fail_with(%r(The request POST http://www.example.com/ with body /\^xabc/ was expected to execute 1 time but it executed 0 times))
end
end
describe "when expected reqest body is declared as a hash" do
let(:body_hash) { {:a => '1', :b => 'five', 'c' => {'d' => ['e', 'f']}} }
let(:fail_message) {%r(The request POST http://www.example.com/ with body .+ was expected to execute 1 time but it executed 0 times)}
describe "when request is made with url encoded body matching hash" do
it "should satisfy expectation" do
expect {
http_request(:post, "http://www.example.com/", :body => 'a=1&c[d][]=e&c[d][]=f&b=five')
expect(a_request(:post, "www.example.com").with(:body => body_hash)).to have_been_made
}.not_to raise_error
end
it "should satisfy expectation even if url encoded params have different order" do
expect {
http_request(:post, "http://www.example.com/", :body => 'a=1&c[d][]=e&b=five&c[d][]=f')
expect(a_request(:post, "www.example.com").with(:body => body_hash)).to have_been_made
}.not_to raise_error
end
it "should fail if request is executed with url encoded body not matching hash" do
expect {
http_request(:post, "http://www.example.com/", :body => 'c[d][]=f&a=1&c[d][]=e')
expect(a_request(:post, "www.example.com").with(:body => body_hash)).to have_been_made
}.to fail_with(fail_message)
end
end
describe "when request is executed with json body matching hash and Content-Type is set to json" do
it "should satisfy expectation" do
expect {
http_request(:post, "http://www.example.com/", :headers => {'Content-Type' => 'application/json'},
:body => "{\"a\":\"1\",\"c\":{\"d\":[\"e\",\"f\"]},\"b\":\"five\"}")
expect(a_request(:post, "www.example.com").with(:body => body_hash)).to have_been_made
}.not_to raise_error
end
it "should satisfy expectation even if json body is in different form" do
expect {
http_request(:post, "http://www.example.com/", :headers => {'Content-Type' => 'application/json'},
:body => "{\"a\":\"1\",\"b\":\"five\",\"c\":{\"d\":[\"e\",\"f\"]}}")
expect(a_request(:post, "www.example.com").with(:body => body_hash)).to have_been_made
}.not_to raise_error
end
it "should satisfy expectation even if json body contains date string" do
expect {
http_request(:post, "http://www.example.com/", :headers => {'Content-Type' => 'application/json'},
:body => "{\"foo\":\"2010-01-01\"}")
expect(a_request(:post, "www.example.com").with(:body => {"foo" => "2010-01-01"})).to have_been_made
}.not_to raise_error
end
end
describe "when request is executed with xml body matching hash and content type is set to xml" do
let(:body_hash) { { "opt" => {:a => "1", :b => 'five', 'c' => {'d' => ['e', 'f']}} }}
it "should satisfy expectation" do
expect {
http_request(:post, "http://www.example.com/", :headers => {'Content-Type' => 'application/xml'},
:body => "\n \n e\n f\n \n\n")
expect(a_request(:post, "www.example.com").with(:body => body_hash)).to have_been_made
}.not_to raise_error
end
it "should satisfy expectation even if xml body is in different form" do
expect {
http_request(:post, "http://www.example.com/", :headers => {'Content-Type' => 'application/xml'},
:body => "\n \n e\n f\n \n\n")
expect(a_request(:post, "www.example.com").with(:body => body_hash)).to have_been_made
}.not_to raise_error
end
it "should satisfy expectation even if xml body contains date string" do
expect {
http_request(:post, "http://www.example.com/", :headers => {'Content-Type' => 'application/xml'},
:body => "\n\n")
expect(a_request(:post, "www.example.com").with(:body => {"opt" => {"foo" => "2010-01-01"}})).to have_been_made
}.not_to raise_error
end
end
end
describe "when expected reqest body is declared as a partial hash matcher" do
let(:body_hash) { hash_including({:a => '1', 'c' => {'d' => ['e', 'f']}}) }
let(:fail_message) {%r(The request POST http://www.example.com/ with body hash_including(.+) was expected to execute 1 time but it executed 0 times)}
describe "when request is made with url encoded body matching hash" do
it "should satisfy expectation" do
expect {
http_request(:post, "http://www.example.com/", :body => 'a=1&c[d][]=e&c[d][]=f&b=five')
expect(a_request(:post, "www.example.com").with(:body => body_hash)).to have_been_made
}.not_to raise_error
end
it "should fail if request is executed with url encoded body not matching hash" do
expect {
http_request(:post, "http://www.example.com/", :body => 'c[d][]=f&a=1&c[d][]=e')
expect(a_request(:post, "www.example.com").with(:body => body_hash)).to have_been_made
}.to fail_with(fail_message)
end
end
end
describe "when request with headers is expected" do
it "should satisfy expectation if request was executed with the same headers" do
expect {
http_request(:get, "http://www.example.com/", :headers => SAMPLE_HEADERS)
expect(a_request(:get, "www.example.com").
with(:headers => SAMPLE_HEADERS)).to have_been_made
}.not_to raise_error
end
it "should satisfy expectation if request was executed with the same headers but with header value declared as array" do
expect {
http_request(:get, "http://www.example.com/", :headers => {"a" => "b"})
expect(a_request(:get, "www.example.com").
with(:headers => {"a" => ["b"]})).to have_been_made
}.not_to raise_error
end
describe "when multiple headers with the same key are passed" do
it "should satisfy expectation" do
expect {
http_request(:get, "http://www.example.com/", :headers => {"a" => ["b", "c"]})
expect(a_request(:get, "www.example.com").
with(:headers => {"a" => ["b", "c"]})).to have_been_made
}.not_to raise_error
end
it "should satisfy expectation even if request was executed with the same headers but different order" do
expect {
http_request(:get, "http://www.example.com/", :headers => {"a" => ["b", "c"]})
expect(a_request(:get, "www.example.com").
with(:headers => {"a" => ["c", "b"]})).to have_been_made
}.not_to raise_error
end
it "should fail if request was executed with different headers" do
expect {
http_request(:get, "http://www.example.com/", :headers => {"a" => ["b", "c"]})
expect(a_request(:get, "www.example.com").
with(:headers => {"a" => ["b", "d"]})).to have_been_made
}.to fail_with(%r(The request GET http://www.example.com/ with headers \{'A'=>\['b', 'd'\]\} was expected to execute 1 time but it executed 0 times))
end
end
it "should fail if request was executed with different headers" do
expect {
http_request(:get, "http://www.example.com/", :headers => SAMPLE_HEADERS)
expect(a_request(:get, "www.example.com").
with(:headers => { 'Content-Length' => '9999'})).to have_been_made
}.to fail_with(%r(The request GET http://www.example.com/ with headers \{'Content-Length'=>'9999'\} was expected to execute 1 time but it executed 0 times))
end
it "should fail if request was executed with less headers" do
expect {
http_request(:get, "http://www.example.com/", :headers => {'A' => 'a'})
expect(a_request(:get, "www.example.com").
with(:headers => {'A' => 'a', 'B' => 'b'})).to have_been_made
}.to fail_with(%r(The request GET http://www.example.com/ with headers \{'A'=>'a', 'B'=>'b'\} was expected to execute 1 time but it executed 0 times))
end
it "should satisfy expectation if request was executed with more headers" do
expect {
http_request(:get, "http://www.example.com/",
:headers => {'A' => 'a', 'B' => 'b'}
)
expect(a_request(:get, "www.example.com").
with(:headers => {'A' => 'a'})).to have_been_made
}.not_to raise_error
end
it "should satisfy expectation if request was executed with body and headers but they were not specified in expectantion" do
expect {
http_request(:post, "http://www.example.com/",
:body => "abc",
:headers => SAMPLE_HEADERS
)
expect(a_request(:post, "www.example.com")).to have_been_made
}.not_to raise_error
end
it "should satisfy expectation if request was executed with headers matching regular expressions" do
expect {
http_request(:get, "http://www.example.com/", :headers => { 'some-header' => 'MyAppName' })
expect(a_request(:get, "www.example.com").
with(:headers => { :some_header => /^MyAppName$/ })).to have_been_made
}.not_to raise_error
end
it "should fail if request was executed with headers not matching regular expression" do
expect {
http_request(:get, "http://www.example.com/", :headers => { 'some-header' => 'xMyAppName' })
expect(a_request(:get, "www.example.com").
with(:headers => { :some_header => /^MyAppName$/ })).to have_been_made
}.to fail_with(%r(The request GET http://www.example.com/ with headers \{'Some-Header'=>/\^MyAppName\$/\} was expected to execute 1 time but it executed 0 times))
end
end
describe "when expectation contains a request matching block" do
it "should satisfy expectation if request was executed and block evaluated to true" do
expect {
http_request(:post, "http://www.example.com/", :body => "wadus")
expect(a_request(:post, "www.example.com").with { |req| req.body == "wadus" }).to have_been_made
}.not_to raise_error
end
it "should fail if request was executed and block evaluated to false" do
expect {
http_request(:post, "http://www.example.com/", :body => "abc")
expect(a_request(:post, "www.example.com").with { |req| req.body == "wadus" }).to have_been_made
}.to fail_with(%r(The request POST http://www.example.com/ with given block was expected to execute 1 time but it executed 0 times))
end
it "should fail if request was not expected but it executed and block matched request" do
expect {
http_request(:post, "http://www.example.com/", :body => "wadus")
expect(a_request(:post, "www.example.com").with { |req| req.body == "wadus" }).not_to have_been_made
}.to fail_with(%r(The request POST http://www.example.com/ with given block was not expected to execute but it executed 1 time))
end
end
describe "with authentication", :unless => (adapter_info.include?(:no_url_auth)) do
before(:each) do
stub_request(:any, "http://user:pass@www.example.com")
stub_request(:any, "http://user:pazz@www.example.com")
end
it "should satisfy expectation if request was executed with expected credentials" do
expect {
http_request(:get, "http://user:pass@www.example.com/")
expect(a_request(:get, "http://user:pass@www.example.com")).to have_been_made.once
}.not_to raise_error
end
it "should fail if request was executed with different credentials than expected" do
expect {
http_request(:get, "http://user:pass@www.example.com/")
expect(a_request(:get, "http://user:pazz@www.example.com")).to have_been_made.once
}.to fail_with(%r(The request GET http://user:pazz@www.example.com/ was expected to execute 1 time but it executed 0 times))
end
it "should fail if request was executed without credentials and credentials were expected" do
expect {
http_request(:get, "http://www.example.com/")
expect(a_request(:get, "http://user:pass@www.example.com")).to have_been_made.once
}.to fail_with(%r(The request GET http://user:pass@www.example.com/ was expected to execute 1 time but it executed 0 times))
end
it "should fail if request was executed with credentials but expected without credentials" do
expect {
http_request(:get, "http://user:pass@www.example.com/")
expect(a_request(:get, "http://www.example.com")).to have_been_made.once
}.to fail_with(%r(The request GET http://www.example.com/ was expected to execute 1 time but it executed 0 times))
end
it "should satisfy expectations even if requests were executed in different order than expectations were declared" do
stub_request(:post, "http://www.example.com")
http_request(:post, "http://www.example.com/", :body => "def")
http_request(:post, "http://www.example.com/", :body => "abc")
expect(WebMock).to have_requested(:post, "www.example.com").with(:body => "abc")
expect(WebMock).to have_requested(:post, "www.example.com").with(:body => "def")
end
end
describe "when expectations were set on WebMock object" do
it "should satisfy expectation if expected request was made" do
expect {
http_request(:get, "http://www.example.com/")
expect(WebMock).to have_requested(:get, "http://www.example.com").once
}.not_to raise_error
end
it "should satisfy expectation if request with body and headers was expected and request was made" do
expect {
http_request(:post, "http://www.example.com/", :body => "abc", :headers => {'A' => 'a'})
expect(WebMock).to have_requested(:post, "http://www.example.com").with(:body => "abc", :headers => {'A' => 'a'}).once
}.not_to raise_error
end
it "should fail if request expected not to be made was made" do
expect {
http_request(:get, "http://www.example.com/")
expect(WebMock).not_to have_requested(:get, "http://www.example.com")
}.to fail_with(%r(The request GET http://www.example.com/ was not expected to execute but it executed 1 time))
end
it "should satisfy expectation if request was executed and expectation had block which evaluated to true" do
expect {
http_request(:post, "http://www.example.com/", :body => "wadus")
expect(WebMock).to have_requested(:post, "www.example.com").with { |req| req.body == "wadus" }
}.not_to raise_error
end
it "should fail if request was executed and expectation had block which evaluated to false" do
expect {
http_request(:post, "http://www.example.com/", :body => "abc")
expect(WebMock).to have_requested(:post, "www.example.com").with { |req| req.body == "wadus" }
}.to fail_with(%r(The request POST http://www.example.com/ with given block was expected to execute 1 time but it executed 0 times))
end
it "should fail if request was expected not to be made but was made and block matched request" do
expect {
http_request(:post, "http://www.example.com/", :body => "wadus")
expect(WebMock).not_to have_requested(:post, "www.example.com").with { |req| req.body == "wadus" }
}.to fail_with(%r(The request POST http://www.example.com/ with given block was not expected to execute but it executed 1 time))
end
end
describe "when expectation is declared using assert_requested" do
it "should satisfy expectation if requests was made" do
expect {
http_request(:get, "http://www.example.com/")
assert_requested(:get, "http://www.example.com", :times => 1)
assert_requested(:get, "http://www.example.com")
}.not_to raise_error
end
it "should satisfy expectation if request was made with body and headers" do
expect {
http_request(:post, "http://www.example.com/", :body => "abc", :headers => {'A' => 'a'})
assert_requested(:post, "http://www.example.com", :body => "abc", :headers => {'A' => 'a'})
}.not_to raise_error
end
it "should fail if request expected not to be made was not wade" do
expect {
http_request(:get, "http://www.example.com/")
assert_not_requested(:get, "http://www.example.com")
}.to fail_with(%r(The request GET http://www.example.com/ was not expected to execute but it executed 1 time))
end
it "should fail if request expected not to be made was made and expectation block evaluated to true" do
expect {
http_request(:post, "http://www.example.com/", :body => "wadus")
assert_not_requested(:post, "www.example.com") { |req| req.body == "wadus" }
}.to fail_with(%r(The request POST http://www.example.com/ with given block was not expected to execute but it executed 1 time))
end
it "should satisfy expectation if request was made and expectation block evaluated to true" do
expect {
http_request(:post, "http://www.example.com/", :body => "wadus")
assert_requested(:post, "www.example.com") { |req| req.body == "wadus" }
}.not_to raise_error
end
it "should fail if request was made and expectation block evaluated to false" do
expect {
http_request(:post, "http://www.example.com/", :body => "abc")
assert_requested(:post, "www.example.com") { |req| req.body == "wadus" }
}.to fail_with(%r(The request POST http://www.example.com/ with given block was expected to execute 1 time but it executed 0 times))
end
end
describe "when expectation is declared using assert_requested" do
it "should satisfy expectation if requests was made" do
stub_http = stub_http_request(:get, "http://www.example.com")
expect {
http_request(:get, "http://www.example.com/")
assert_requested(stub_http, :times => 1)
assert_requested(stub_http)
}.not_to raise_error
end
it "should fail if request expected not to be made was not wade" do
stub_http = stub_http_request(:get, "http://www.example.com")
expect {
http_request(:get, "http://www.example.com/")
assert_not_requested(stub_http)
}.to fail_with(%r(The request GET http://www.example.com/ was not expected to execute but it executed 1 time))
end
end
end
describe "expectation is set on the request stub" do
it "should satisfy expectation if expected request was made" do
stub = stub_request(:get, "http://www.example.com/")
http_request(:get, "http://www.example.com/")
expect(stub).to have_been_requested.once
end
it "should satisfy expectations if subsequent requests were made" do
stub = stub_request(:get, "http://www.example.com/")
http_request(:get, "http://www.example.com/")
expect(stub).to have_been_requested.once
http_request(:get, "http://www.example.com/")
expect(stub).to have_been_requested.twice
end
it "should satisfy expectation if expected request with body and headers was made" do
stub = stub_request(:post, "http://www.example.com").with(:body => "abc", :headers => {'A' => 'a'})
http_request(:post, "http://www.example.com/", :body => "abc", :headers => {'A' => 'a'})
expect(stub).to have_been_requested.once
end
it "should fail if request not expected to be made was made" do
expect {
stub = stub_request(:get, "http://www.example.com")
http_request(:get, "http://www.example.com/")
expect(stub).not_to have_been_requested
}.to fail_with(%r(The request GET http://www.example.com/ was not expected to execute but it executed 1 time))
end
it "should fail request not expected to be made was made and expectation block evaluated to true" do
expect {
stub = stub_request(:post, "www.example.com").with { |req| req.body == "wadus" }
http_request(:post, "http://www.example.com/", :body => "wadus")
expect(stub).not_to have_been_requested
}.to fail_with(%r(The request POST http://www.example.com/ with given block was not expected to execute but it executed 1 time))
end
it "should satisfy expectation if request was made and expectation block evaluated to true" do
stub = stub_request(:post, "www.example.com").with { |req| req.body == "wadus" }
http_request(:post, "http://www.example.com/", :body => "wadus")
expect(stub).to have_been_requested
end
it "should satisfy expectation if request was made and expectation block evaluated to false" do
expect {
stub_request(:any, /.+/) #stub any request
stub = stub_request(:post, "www.example.com").with { |req| req.body == "wadus" }
http_request(:post, "http://www.example.com/", :body => "abc")
expect(stub).to have_been_requested
}.to fail_with(%r(The request POST http://www.example.com/ with given block was expected to execute 1 time but it executed 0 times))
end
end
describe "when net connect is allowed", :net_connect => true do
before(:each) do
WebMock.allow_net_connect!
end
it "should satisfy expectation if expected requests was made" do
expect {
http_request(:get, "http://www.example.com/")
expect(a_request(:get, "http://www.example.com")).to have_been_made
}.not_to raise_error
end
it "should fail request expected not to be made, was made" do
expect {
http_request(:get, "http://www.example.com/")
expect(a_request(:get, "http://www.example.com")).not_to have_been_made
}.to fail_with(%r(The request GET http://www.example.com/ was not expected to execute but it executed 1 time))
end
end
end
end
webmock-1.22.6/spec/acceptance/shared/callbacks.rb 0000644 0000041 0000041 00000011506 12646134265 022027 0 ustar www-data www-data shared_context "callbacks" do |*adapter_info|
describe "when after_request callback is declared" do
before(:each) do
@called = nil
WebMock.reset_callbacks
stub_request(:get, "http://www.example.com")
end
it "should not invoke callback unless request is made" do
WebMock.after_request {
@called = true
}
expect(@called).to eq(nil)
end
it "should invoke a callback after request is made" do
WebMock.after_request {
@called = true
}
http_request(:get, "http://www.example.com/")
expect(@called).to eq(true)
end
it "should not invoke a callback if this http library should be ignored" do
WebMock.after_request(:except => [http_library()]) {
@called = true
}
http_request(:get, "http://www.example.com/")
expect(@called).to eq(nil)
end
it "should invoke a callback even if other http libraries should be ignored" do
WebMock.after_request(:except => [:other_lib]) {
@called = true
}
http_request(:get, "http://www.example.com/")
expect(@called).to eq(true)
end
it "should pass request signature to the callback" do
WebMock.after_request(:except => [:other_lib]) do |request_signature, _|
@request_signature = request_signature
end
http_request(:get, "http://www.example.com/")
expect(@request_signature.uri.to_s).to eq("http://www.example.com:80/")
end
after(:each) do
WebMock::StubRegistry.instance.global_stubs.clear
end
it 'passes the same request signature instance to the callback that was passed to the global stub callback' do
global_stub_request_sig = after_request_request_sig = nil
WebMock.globally_stub_request do |request_sig|
global_stub_request_sig = request_sig
nil
end
WebMock.after_request do |request_sig, _|
after_request_request_sig = request_sig
end
http_request(:get, "http://www.example.com/")
expect(global_stub_request_sig).to be(after_request_request_sig)
end
context "passing response to callback" do
context "when request is stubbed" do
before(:each) do
stub_request(:get, "http://www.example.com").
to_return(
:status => [200, "hello"],
:headers => {'Content-Length' => '666', 'Hello' => 'World'},
:body => "foo bar"
)
WebMock.after_request(:except => [:other_lib]) do |_, response|
@response = response
end
http_request(:get, "http://www.example.com/")
end
it "should pass response to callback with the status and message" do
expect(@response.status).to eq([200, "hello"])
end
it "should pass response to callback with headers" do
expect(@response.headers).to eq({
'Content-Length' => '666',
'Hello' => 'World'
})
end
it "should pass response to callback with body" do
expect(@response.body).to eq("foo bar")
end
end
describe "when request is not stubbed", :net_connect => true do
before(:each) do
WebMock.reset!
WebMock.allow_net_connect!
WebMock.after_request(:except => [:other_lib]) do |_, response|
@response = response
end
http_request(:get, "http://httpstat.us/201")
end
it "should pass real response to callback with status and message" do
expect(@response.status[0]).to eq(201)
expect(@response.status[1]).to eq("Created") unless adapter_info.include?(:no_status_message)
end
it "should pass real response to callback with headers" do
expect(@response.headers["Content-Length"]).to eq("11")
end
it "should pass response to callback with body" do
expect(@response.body.size).to eq(11)
end
end
end
it "should invoke multiple callbacks in order of their declarations" do
WebMock.after_request { @called = 1 }
WebMock.after_request { @called += 1 }
http_request(:get, "http://www.example.com/")
expect(@called).to eq(2)
end
it "should invoke callbacks only for real requests if requested", :net_connect => true do
WebMock.after_request(:real_requests_only => true) { @called = true }
http_request(:get, "http://www.example.com/")
expect(@called).to eq(nil)
WebMock.allow_net_connect!
http_request(:get, "http://www.example.net/")
expect(@called).to eq(true)
end
it "should not invoke any callbacks after callbacks were reset" do
WebMock.after_request { @called = 1 }
WebMock.reset_callbacks
stub_request(:get, "http://www.example.com/")
http_request(:get, "http://www.example.com/")
expect(@called).to eq(nil)
end
end
end
webmock-1.22.6/spec/acceptance/shared/returning_declared_responses.rb 0000644 0000041 0000041 00000041173 12646134265 026054 0 ustar www-data www-data class MyException < StandardError; end;
shared_context "declared responses" do |*adapter_info|
describe "when request stub declares that request should raise exception" do
it "should raise exception" do
stub_request(:get, "www.example.com").to_raise(MyException)
expect {
http_request(:get, "http://www.example.com/")
}.to raise_error(MyException, "Exception from WebMock")
end
it "should raise exception if declared as and exception instance" do
stub_request(:get, "www.example.com").to_raise(MyException.new("hello world"))
expect {
http_request(:get, "http://www.example.com/")
}.to raise_error(MyException, "hello world")
end
it "should raise exception if declared as an exception instance" do
stub_request(:get, "www.example.com").to_raise("hello world")
expect {
http_request(:get, "http://www.example.com/")
}.to raise_error("hello world")
end
it "should raise exception after returning declared successful response first" do
stub_request(:get, "www.example.com").to_return(:body => "abc").then.to_raise(MyException)
expect(http_request(:get, "http://www.example.com/").body).to eq("abc")
expect {
http_request(:get, "http://www.example.com/")
}.to raise_error(MyException, "Exception from WebMock")
end
end
describe "when request stub declares that request should timeout" do
it "should timeout" do
stub_request(:get, "www.example.com").to_timeout
expect {
http_request(:get, "http://www.example.com/")
}.to raise_error(client_timeout_exception_class)
end
it "should timeout after returning declared successful response" do
stub_request(:get, "www.example.com").to_return(:body => "abc").then.to_timeout
expect(http_request(:get, "http://www.example.com/").body).to eq("abc")
expect {
http_request(:get, "http://www.example.com/")
}.to raise_error(client_timeout_exception_class)
end
end
describe "when request stub declares that request should return a response" do
it "should return response with declared body" do
stub_request(:get, "www.example.com").to_return(:body => "abc")
expect(http_request(:get, "http://www.example.com/").body).to eq("abc")
end
it "should return response with declared headers" do
stub_request(:get, "www.example.com").to_return(:headers => SAMPLE_HEADERS)
response = http_request(:get, "http://www.example.com/")
expect(response.headers["Content-Length"]).to eq("8888")
end
it "should return response with declared headers even if there are multiple headers with the same key" do
stub_request(:get, "www.example.com").to_return(:headers => {"a" => ["b", "c"]})
response = http_request(:get, "http://www.example.com/")
expect(response.headers["A"]).to eq("b, c")
end
it "should return response with declared status code" do
stub_request(:get, "www.example.com").to_return(:status => 500)
expect(http_request(:get, "http://www.example.com/").status).to eq("500")
end
it "should return response with declared status message", :unless => (adapter_info.include?(:no_status_message)) do
stub_request(:get, "www.example.com").to_return(:status => [500, "Internal Server Error"])
response = http_request(:get, "http://www.example.com/")
expect(response.message).to eq("Internal Server Error")
end
it "should return response with a default status code" do
stub_request(:get, "www.example.com")
expect(http_request(:get, "http://www.example.com/").status).to eq("200")
end
it "should return default response with empty message if response was not declared", :unless => (adapter_info.include?(:no_status_message)) do
stub_request(:get, "www.example.com")
response = http_request(:get, "http://www.example.com/")
expect(response.message).to eq("")
end
describe "when response body was declared as IO" do
it "should return response body" do
stub_request(:get, "www.example.com").to_return(:body => File.new(__FILE__))
expect(http_request(:get, "http://www.example.com/").body).to eq(File.read(__FILE__))
end
it "should return response body if requested many times" do
stub_request(:get, "www.example.com").to_return(:body => File.new(__FILE__))
2.times do
expect(http_request(:get, "http://www.example.com/").body).to eq(File.read(__FILE__))
end
end
it "should close IO after request" do
stub_request(:get, "www.example.com").to_return(:body => @file = File.new(__FILE__))
expect(@file).to be_closed
end
end
describe "when response parts were declared as lambdas" do
it "should return evaluated response body" do
stub_request(:post, "www.example.com").to_return(:body => lambda { |request| request.body })
expect(http_request(:post, "http://www.example.com/", :body => "echo").body).to eq("echo")
end
it "should return evaluated response headers" do
stub_request(:post, "www.example.com").to_return(:headers => lambda { |request| request.headers })
expect(http_request(:post, "http://www.example.com/", :body => "abc", :headers => {'A' => 'B'}).headers['A']).to eq('B')
expect(http_request(:post, "http://www.example.com/", :body => "abc", :headers => {'A' => 'C'}).headers['A']).to eq('C')
end
it "should evaluate response body for each request" do
stub_request(:post, "www.example.com").to_return(:body => lambda { |request| request.body })
expect(http_request(:post, "http://www.example.com/", :body => "echo").body).to eq("echo")
expect(http_request(:post, "http://www.example.com/", :body => "foxtrot").body).to eq("foxtrot")
end
end
describe "when response was declared as lambda" do
class Responder
def call(request)
{:body => request.body}
end
end
it "should return evaluated response body" do
stub_request(:post, "www.example.com").to_return(lambda {|request|
{:body => request.body}
})
expect(http_request(:post, "http://www.example.com/", :body => "echo").body).to eq("echo")
expect(http_request(:post, "http://www.example.com/", :body => "foxtrot").body).to eq("foxtrot")
end
it "should return evaluated response headers" do
stub_request(:get, "www.example.com").to_return(lambda { |request|
{:headers => request.headers}
})
expect(http_request(:get, "http://www.example.com/", :headers => {'A' => 'B'}).headers['A']).to eq('B')
end
it "should return dynamic response declared as a block" do
stub_request(:post, "www.example.com").to_return do |request|
{:body => request.body}
end
expect(http_request(:post, "http://www.example.com/", :body => "echo").body).to eq("echo")
end
it "should return dynamic response declared as an object responding to call" do
stub_request(:post, "www.example.com").to_return(Responder.new)
expect(http_request(:post, "http://www.example.com/", :body => "echo").body).to eq("echo")
end
end
describe "when response was declared as a file with a raw response" do
before(:each) do
@file = File.new(CURL_EXAMPLE_OUTPUT_PATH)
stub_request(:get, "www.example.com").to_return(@file)
@response = http_request(:get, "http://www.example.com/")
end
it "should return recorded headers" do
expect(@response.headers).to eq({
"Date"=>"Sat, 23 Jan 2010 01:01:05 GMT",
"Content-Type"=>"text/html; charset=UTF-8",
"Content-Length"=>"419",
"Connection"=>"Keep-Alive",
"Accept"=>"image/jpeg, image/png"
})
end
it "should return recorded body" do
expect(@response.body.size).to eq(419)
end
it "should return recorded status" do
expect(@response.status).to eq("202")
end
it "should return recorded status message", :unless => (adapter_info.include?(:no_status_message)) do
expect(@response.message).to eq("OK")
end
it "should ensure file is closed" do
expect(@file).to be_closed
end
end
describe "when response was declared as a string with a raw response" do
before(:each) do
@input = File.read(CURL_EXAMPLE_OUTPUT_PATH)
stub_request(:get, "www.example.com").to_return(@input)
@response = http_request(:get, "http://www.example.com/")
end
it "should return recorded headers" do
expect(@response.headers).to eq({
"Date"=>"Sat, 23 Jan 2010 01:01:05 GMT",
"Content-Type"=>"text/html; charset=UTF-8",
"Content-Length"=>"419",
"Connection"=>"Keep-Alive",
"Accept"=>"image/jpeg, image/png"
})
end
it "should return recorded body" do
expect(@response.body.size).to eq(419)
end
it "should return recorded status" do
expect(@response.status).to eq("202")
end
it "should return recorded status message", :unless => (adapter_info.include?(:no_status_message)) do
expect(@response.message).to eq("OK")
end
end
describe "when response was declared as lambda evaluating to a string with a raw response" do
before(:each) do
@files = {
"www.example.com" => File.new(CURL_EXAMPLE_OUTPUT_PATH)
}
end
it "should return response from evaluated file" do
stub_request(:get, "www.example.com").to_return(lambda {|request| @files[request.uri.host.to_s] })
expect(http_request(:get, "http://www.example.com/").body.size).to eq(419)
end
it "should return response from evaluated string" do
stub_request(:get, "www.example.com").to_return(lambda {|request| @files[request.uri.host.to_s].read })
expect(http_request(:get, "http://www.example.com/").body.size).to eq(419)
end
end
describe "when response is declared as an Rack app" do
it "should return response returned by the rack app" do
stub_request(:any, "http://www.example.com/greet").to_rack(MyRackApp)
expect(http_request(:post, 'http://www.example.com/greet', :body => 'name=Jimmy').body).to eq('Good to meet you, Jimmy!')
end
it "should pass along the port number to the rack app" do
stub_request(:get, "http://www.example.com/compute").to_rack(MyRackApp)
expect(http_request(:get, "http://www.example.com/compute").status).to eq("200")
end
it "preserves content-type header when proxying to a rack app" do
stub_request(:any, //).to_rack(lambda {|req| [200, {}, ["OK"]] })
url = "https://google.com/hi/there"
headers = {
"Accept" => "application/json",
"Content-Type" => "application/json"
}
http_request(:get, url, :headers => headers)
expect(WebMock).to have_requested(:get, url).with(:headers => headers)
end
end
describe "when sequences of responses are declared" do
it "should return responses one by one if declared in array" do
stub_request(:get, "www.example.com").to_return([ {:body => "1"}, {:body => "2"}, {:body => "3"} ])
expect(http_request(:get, "http://www.example.com/").body).to eq("1")
expect(http_request(:get, "http://www.example.com/").body).to eq("2")
expect(http_request(:get, "http://www.example.com/").body).to eq("3")
end
it "should repeat returning last declared response from a sequence after all responses were returned" do
stub_request(:get, "www.example.com").to_return([ {:body => "1"}, {:body => "2"} ])
expect(http_request(:get, "http://www.example.com/").body).to eq("1")
expect(http_request(:get, "http://www.example.com/").body).to eq("2")
expect(http_request(:get, "http://www.example.com/").body).to eq("2")
end
it "should return responses one by one if declared as comma separated params" do
stub_request(:get, "www.example.com").to_return({:body => "1"}, {:body => "2"}, {:body => "3"})
expect(http_request(:get, "http://www.example.com/").body).to eq("1")
expect(http_request(:get, "http://www.example.com/").body).to eq("2")
expect(http_request(:get, "http://www.example.com/").body).to eq("3")
end
it "should return responses one by one if declared with several to_return invokations" do
stub_request(:get, "www.example.com").
to_return({:body => "1"}).
to_return({:body => "2"}).
to_return({:body => "3"})
expect(http_request(:get, "http://www.example.com/").body).to eq("1")
expect(http_request(:get, "http://www.example.com/").body).to eq("2")
expect(http_request(:get, "http://www.example.com/").body).to eq("3")
end
it "should return responses one by one if declared with to_return invocations separated with then syntactic sugar" do
stub_request(:get, "www.example.com").to_return({:body => "1"}).then.
to_return({:body => "2"}).then.to_return({:body => "3"})
expect(http_request(:get, "http://www.example.com/").body).to eq("1")
expect(http_request(:get, "http://www.example.com/").body).to eq("2")
expect(http_request(:get, "http://www.example.com/").body).to eq("3")
end
end
describe "when responses are declared to return more than once" do
it "should repeat one response declared number of times" do
stub_request(:get, "www.example.com").
to_return({:body => "1"}).times(2).
to_return({:body => "2"})
expect(http_request(:get, "http://www.example.com/").body).to eq("1")
expect(http_request(:get, "http://www.example.com/").body).to eq("1")
expect(http_request(:get, "http://www.example.com/").body).to eq("2")
end
it "should repeat sequence of response declared number of times" do
stub_request(:get, "www.example.com").
to_return({:body => "1"}, {:body => "2"}).times(2).
to_return({:body => "3"})
expect(http_request(:get, "http://www.example.com/").body).to eq("1")
expect(http_request(:get, "http://www.example.com/").body).to eq("2")
expect(http_request(:get, "http://www.example.com/").body).to eq("1")
expect(http_request(:get, "http://www.example.com/").body).to eq("2")
expect(http_request(:get, "http://www.example.com/").body).to eq("3")
end
it "should repeat infinitely last response even if number of declared times is lower" do
stub_request(:get, "www.example.com").
to_return({:body => "1"}).times(2)
expect(http_request(:get, "http://www.example.com/").body).to eq("1")
expect(http_request(:get, "http://www.example.com/").body).to eq("1")
expect(http_request(:get, "http://www.example.com/").body).to eq("1")
end
it "should give error if times is declared without specifying response" do
expect {
stub_request(:get, "www.example.com").times(3)
}.to raise_error("Invalid WebMock stub declaration. times(N) can be declared only after response declaration.")
end
end
describe "when exception is declared to be raised more than once" do
it "should repeat raising exception declared number of times" do
stub_request(:get, "www.example.com").
to_raise(MyException).times(2).
to_return({:body => "2"})
expect {
http_request(:get, "http://www.example.com/")
}.to raise_error(MyException, "Exception from WebMock")
expect {
http_request(:get, "http://www.example.com/")
}.to raise_error(MyException, "Exception from WebMock")
expect(http_request(:get, "http://www.example.com/").body).to eq("2")
end
it "should repeat raising sequence of exceptions declared number of times" do
stub_request(:get, "www.example.com").
to_raise(MyException, ArgumentError).times(2).
to_return({:body => "2"})
expect {
http_request(:get, "http://www.example.com/")
}.to raise_error(MyException, "Exception from WebMock")
expect {
http_request(:get, "http://www.example.com/")
}.to raise_error(ArgumentError)
expect {
http_request(:get, "http://www.example.com/")
}.to raise_error(MyException, "Exception from WebMock")
expect {
http_request(:get, "http://www.example.com/")
}.to raise_error(ArgumentError)
expect(http_request(:get, "http://www.example.com/").body).to eq("2")
end
end
end
end
webmock-1.22.6/spec/acceptance/shared/precedence_of_stubs.rb 0000644 0000041 0000041 00000001300 12646134265 024100 0 ustar www-data www-data shared_context "precedence of stubs" do |*adapter_info|
describe "when choosing a matching request stub" do
it "should use the last declared matching request stub" do
stub_request(:get, "www.example.com").to_return(:body => "abc")
stub_request(:get, "www.example.com").to_return(:body => "def")
expect(http_request(:get, "http://www.example.com/").body).to eq("def")
end
it "should not be affected by the type of uri or request method" do
stub_request(:get, "www.example.com").to_return(:body => "abc")
stub_request(:any, /.*example.*/).to_return(:body => "def")
expect(http_request(:get, "http://www.example.com/").body).to eq("def")
end
end
end
webmock-1.22.6/spec/acceptance/shared/stubbing_requests.rb 0000644 0000041 0000041 00000056614 12646134265 023671 0 ustar www-data www-data # encoding: utf-8
shared_examples_for "stubbing requests" do |*adapter_info|
describe "when requests are stubbed" do
describe "based on uri" do
it "should return stubbed response even if request have escaped parameters" do
stub_request(:get, "www.example.com/hello+/?#{NOT_ESCAPED_PARAMS}").to_return(:body => "abc")
expect(http_request(:get, "http://www.example.com/hello%2B/?#{ESCAPED_PARAMS}").body).to eq("abc")
end
it "should return stubbed response even if query params have integer values" do
stub_request(:get, "www.example.com").with(:query => {"a" => 1}).to_return(:body => "abc")
expect(http_request(:get, "http://www.example.com/?a=1").body).to eq("abc")
end
it "should return stubbed response even if request has non escaped params" do
stub_request(:get, "www.example.com/hello%2B/?#{ESCAPED_PARAMS}").to_return(:body => "abc")
expect(http_request(:get, "http://www.example.com/hello+/?#{NOT_ESCAPED_PARAMS}").body).to eq("abc")
end
it "should return stubbed response for url with non utf query params", "ruby>1.9" => true do
param = 'aäoöuü'.encode('iso-8859-1')
param = CGI.escape(param)
stub_request(:get, "www.example.com/?#{param}").to_return(:body => "abc")
expect(http_request(:get, "http://www.example.com/?#{param}").body).to eq("abc")
end
it "should return stubbed response even if stub uri is declared as regexp and request params are escaped" do
stub_request(:get, /.*x=ab c.*/).to_return(:body => "abc")
expect(http_request(:get, "http://www.example.com/hello/?#{ESCAPED_PARAMS}").body).to eq("abc")
end
it "should raise error specifying stubbing instructions with escaped characters in params if there is no matching stub" do
begin
http_request(:get, "http://www.example.com/hello+/?#{NOT_ESCAPED_PARAMS}")
rescue WebMock::NetConnectNotAllowedError => e
expect(e.message).to match /Unregistered request: GET http:\/\/www\.example\.com\/hello\+\/\?x=ab%20c&z='Stop!'%20said%20Fred%20m/m
expect(e.message).to match /stub_request\(:get, "http:\/\/www\.example\.com\/hello\+\/\?x=ab%20c&z='Stop!'%20said%20Fred%20m"\)/m
end
stub_request(:get, "http://www.example.com/hello+/?x=ab%20c&z='Stop!'%20said%20Fred%20m")
http_request(:get, "http://www.example.com/hello+/?#{NOT_ESCAPED_PARAMS}")
end
end
describe "based on query params" do
it "should return stubbed response when stub declares query params as a hash" do
stub_request(:get, "www.example.com").with(:query => {"a" => ["b x", "c d"]}).to_return(:body => "abc")
expect(http_request(:get, "http://www.example.com/?a[]=b+x&a[]=c%20d").body).to eq("abc")
end
it "should return stubbed response when stub declares query params as a hash" do
stub_request(:get, "www.example.com").with(:query => "a[]=b&a[]=c").to_return(:body => "abc")
expect(http_request(:get, "http://www.example.com/?a[]=b&a[]=c").body).to eq("abc")
end
it "should return stubbed response when stub declares query params both in uri and as a hash" do
stub_request(:get, "www.example.com/?x=3").with(:query => {"a" => ["b", "c"]}).to_return(:body => "abc")
expect(http_request(:get, "http://www.example.com/?x=3&a[]=b&a[]=c").body).to eq("abc")
end
it "should return stubbed response when stub expects only part of query params" do
stub_request(:get, "www.example.com").with(:query => hash_including({"a" => ["b", "c"]})).to_return(:body => "abc")
expect(http_request(:get, "http://www.example.com/?a[]=b&a[]=c&b=1").body).to eq("abc")
end
end
describe "based on method" do
it "should return stubbed response" do
stub_request(:get, "www.example.com")
expect(http_request(:get, "http://www.example.com/").status).to eq("200")
end
it "should match stubbed request when http request was made with method given as string" do
stub_request(:get, "www.example.com")
expect(http_request('get', "http://www.example.com/").status).to eq("200")
end
it "should raise error if stubbed request has different method" do
stub_request(:get, "www.example.com")
expect(http_request(:get, "http://www.example.com/").status).to eq("200")
expect {
http_request(:delete, "http://www.example.com/")
}.to raise_error(WebMock::NetConnectNotAllowedError, %r(Real HTTP connections are disabled. Unregistered request: DELETE http://www.example.com/)
)
end
end
describe "based on body" do
it "should match requests if body is the same" do
stub_request(:post, "www.example.com").with(:body => "abc")
expect(http_request(
:post, "http://www.example.com/",
:body => "abc").status).to eq("200")
end
it "should match requests if body is not set in the stub" do
stub_request(:post, "www.example.com")
expect(http_request(
:post, "http://www.example.com/",
:body => "abc").status).to eq("200")
end
it "should not match requests if body is different" do
stub_request(:post, "www.example.com").with(:body => "abc")
expect {
http_request(:post, "http://www.example.com/", :body => "def")
}.to raise_error(WebMock::NetConnectNotAllowedError, %r(Real HTTP connections are disabled. Unregistered request: POST http://www.example.com/ with body 'def'))
end
describe "with regular expressions" do
it "should match requests if body matches regexp" do
stub_request(:post, "www.example.com").with(:body => /\d+abc$/)
expect(http_request(
:post, "http://www.example.com/",
:body => "123abc").status).to eq("200")
end
it "should not match requests if body doesn't match regexp" do
stub_request(:post, "www.example.com").with(:body => /^abc/)
expect {
http_request(:post, "http://www.example.com/", :body => "xabc")
}.to raise_error(WebMock::NetConnectNotAllowedError, %r(Real HTTP connections are disabled. Unregistered request: POST http://www.example.com/ with body 'xabc'))
end
end
describe "when body is declared as a hash" do
before(:each) do
stub_request(:post, "www.example.com").
with(:body => {:a => '1', :b => 'five x', 'c' => {'d' => ['e', 'f']} })
end
describe "for request with url encoded body" do
it "should match request if hash matches body" do
expect(http_request(
:post, "http://www.example.com/",
:body => 'a=1&c[d][]=e&c[d][]=f&b=five+x').status).to eq("200")
end
it "should match request if hash matches body in different order of params" do
expect(http_request(
:post, "http://www.example.com/",
:body => 'a=1&c[d][]=e&b=five+x&c[d][]=f').status).to eq("200")
end
it "should not match if hash doesn't match url encoded body" do
expect {
http_request(
:post, "http://www.example.com/",
:body => 'c[d][]=f&a=1&c[d][]=e')
}.to raise_error(WebMock::NetConnectNotAllowedError, %r(Real HTTP connections are disabled. Unregistered request: POST http://www.example.com/ with body 'c\[d\]\[\]=f&a=1&c\[d\]\[\]=e'))
end
end
describe "for request with json body and content type is set to json" do
it "should match if hash matches body" do
expect(http_request(
:post, "http://www.example.com/", :headers => {'Content-Type' => 'application/json'},
:body => "{\"a\":\"1\",\"c\":{\"d\":[\"e\",\"f\"]},\"b\":\"five x\"}").status).to eq("200")
end
it "should match if hash matches body in different form" do
expect(http_request(
:post, "http://www.example.com/", :headers => {'Content-Type' => 'application/json'},
:body => "{\"a\":\"1\",\"b\":\"five x\",\"c\":{\"d\":[\"e\",\"f\"]}}").status).to eq("200")
end
it "should match if hash contains date string" do #Crack creates date object
WebMock.reset!
stub_request(:post, "www.example.com").
with(:body => {"foo" => "2010-01-01"})
expect(http_request(
:post, "http://www.example.com/", :headers => {'Content-Type' => 'application/json'},
:body => "{\"foo\":\"2010-01-01\"}").status).to eq("200")
end
it "should match if any of the strings have spaces" do
WebMock.reset!
stub_request(:post, "www.example.com").with(:body => {"foo" => "a b c"})
expect(http_request(
:post, "http://www.example.com/", :headers => {'Content-Type' => 'application/json'},
:body => "{\"foo\":\"a b c\"}").status).to eq("200")
end
end
describe "for request with xml body and content type is set to xml" do
before(:each) do
WebMock.reset!
stub_request(:post, "www.example.com").
with(:body => { "opt" => {:a => '1', :b => 'five', 'c' => {'d' => ['e', 'f']} }})
end
it "should match if hash matches body" do
expect(http_request(
:post, "http://www.example.com/", :headers => {'Content-Type' => 'application/xml'},
:body => "\n \n e\n f\n \n\n").status).to eq("200")
end
it "should match if hash matches body in different form" do
expect(http_request(
:post, "http://www.example.com/", :headers => {'Content-Type' => 'application/xml'},
:body => "\n \n e\n f\n \n\n").status).to eq("200")
end
it "should match if hash contains date string" do #Crack creates date object
WebMock.reset!
stub_request(:post, "www.example.com").
with(:body => {"opt" => {"foo" => "2010-01-01"}})
expect(http_request(
:post, "http://www.example.com/", :headers => {'Content-Type' => 'application/xml'},
:body => "\n\n").status).to eq("200")
end
end
end
describe "when body is declared as partial hash matcher" do
subject(:request) { http_request( :post, "http://www.example.com/",
:body => 'a=1&c[d][]=e&c[d][]=f&b=five') }
subject(:wrong_request) { http_request(:post, "http://www.example.com/",
:body => 'c[d][]=f&a=1&c[d][]=e').status }
describe "when using 'RSpec:Mocks::ArgumentMatchers#hash_including'" do
before(:each) do
stub_request(:post, "www.example.com").
with(:body => hash_including(:a, :c => {'d' => ['e', 'f']} ))
end
describe "for request with url encoded body" do
it "should match request if hash matches body" do
expect(request.status).to eq("200")
end
it "should not match if hash doesn't match url encoded body" do
expect { wrong_request }.to raise_error
end
end
describe "for request with json body and content type is set to json" do
it "should match if hash matches body" do
expect(http_request(
:post, "http://www.example.com/", :headers => {'Content-Type' => 'application/json'},
:body => "{\"a\":\"1\",\"c\":{\"d\":[\"e\",\"f\"]},\"b\":\"five\"}").status).to eq("200")
end
end
end
describe "when using 'WebMock::API#hash_including'" do
before(:each) do
stub_request(:post, "www.example.com").
with(:body => WebMock::API.hash_including(:a, :c => {'d' => ['e', 'f']} ))
end
describe "for request with url encoded body" do
it "should match request if hash matches body" do
expect(request.status).to eq("200")
end
it "should not match if hash doesn't match url encoded body" do
expect { wrong_request }.to raise_error
end
end
describe "for request with json body and content type is set to json" do
it "should match if hash matches body" do
expect(http_request(
:post, "http://www.example.com/", :headers => {'Content-Type' => 'application/json'},
:body => "{\"a\":\"1\",\"c\":{\"d\":[\"e\",\"f\"]},\"b\":\"five\"}").status).to eq("200")
end
end
end
end
end
describe "based on headers" do
it "should match requests if headers are the same" do
stub_request(:get, "www.example.com").with(:headers => SAMPLE_HEADERS )
expect(http_request(
:get, "http://www.example.com/",
:headers => SAMPLE_HEADERS).status).to eq("200")
end
it "should match requests if headers are the same and declared as array" do
stub_request(:get, "www.example.com").with(:headers => {"a" => ["b"]} )
expect(http_request(
:get, "http://www.example.com/",
:headers => {"a" => "b"}).status).to eq("200")
end
describe "when multiple headers with the same key are used" do
it "should match requests if headers are the same" do
stub_request(:get, "www.example.com").with(:headers => {"a" => ["b", "c"]} )
expect(http_request(
:get, "http://www.example.com/",
:headers => {"a" => ["b", "c"]}).status).to eq("200")
end
it "should match requests if headers are the same but in different order" do
stub_request(:get, "www.example.com").with(:headers => {"a" => ["b", "c"]} )
expect(http_request(
:get, "http://www.example.com/",
:headers => {"a" => ["c", "b"]}).status).to eq("200")
end
it "should not match requests if headers are different" do
stub_request(:get, "www.example.com").with(:headers => {"a" => ["b", "c"]})
expect {
http_request(
:get, "http://www.example.com/",
:headers => {"a" => ["b", "d"]})
}.to raise_error(WebMock::NetConnectNotAllowedError, %r(Real HTTP connections are disabled. Unregistered request: GET http://www.example.com/ with headers))
end
end
it "should match requests if request headers are not stubbed" do
stub_request(:get, "www.example.com")
expect(http_request(
:get, "http://www.example.com/",
:headers => SAMPLE_HEADERS).status).to eq("200")
end
it "should not match requests if headers are different" do
stub_request(:get, "www.example.com").with(:headers => SAMPLE_HEADERS)
expect {
http_request(
:get, "http://www.example.com/",
:headers => { 'Content-Length' => '9999'})
}.to raise_error(WebMock::NetConnectNotAllowedError, %r(Real HTTP connections are disabled. Unregistered request: GET http://www.example.com/ with headers))
end
it "should not match if accept header is different" do
stub_request(:get, "www.example.com").
with(:headers => { 'Accept' => 'application/json'})
expect {
http_request(
:get, "http://www.example.com/",
:headers => { 'Accept' => 'application/xml'})
}.to raise_error(WebMock::NetConnectNotAllowedError, %r(Real HTTP connections are disabled. Unregistered request: GET http://www.example.com/ with headers))
end
describe "declared as regular expressions" do
it "should match requests if header values match regular expression" do
stub_request(:get, "www.example.com").with(:headers => { :some_header => /^MyAppName$/ })
expect(http_request(
:get, "http://www.example.com/",
:headers => { 'some-header' => 'MyAppName' }).status).to eq("200")
end
it "should not match requests if headers values do not match regular expression" do
stub_request(:get, "www.example.com").with(:headers => { :some_header => /^MyAppName$/ })
expect {
http_request(
:get, "http://www.example.com/",
:headers => { 'some-header' => 'xMyAppName' })
}.to raise_error(WebMock::NetConnectNotAllowedError, %r(Real HTTP connections are disabled. Unregistered request: GET http://www.example.com/ with headers))
end
end
end
describe "when stubbing request with basic authentication", :unless => (adapter_info.include?(:no_url_auth)) do
it "should match if credentials are the same" do
stub_request(:get, "user:pass@www.example.com")
expect(http_request(:get, "http://user:pass@www.example.com/").status).to eq("200")
end
it "should not match if credentials are different" do
stub_request(:get, "user:pass@www.example.com")
expect {
expect(http_request(:get, "http://user:pazz@www.example.com/").status).to eq("200")
}.to raise_error(WebMock::NetConnectNotAllowedError, %r(Real HTTP connections are disabled. Unregistered request: GET http://user:pazz@www.example.com/))
end
it "should not match if credentials are stubbed but not provided in the request" do
stub_request(:get, "user:pass@www.example.com")
expect {
expect(http_request(:get, "http://www.example.com/").status).to eq("200")
}.to raise_error(WebMock::NetConnectNotAllowedError, %r(Real HTTP connections are disabled. Unregistered request: GET http://www.example.com/))
end
it "should not match if credentials are not stubbed but exist in the request" do
stub_request(:get, "www.example.com")
expect {
expect(http_request(:get, "http://user:pazz@www.example.com/").status).to eq("200")
}.to raise_error(WebMock::NetConnectNotAllowedError, %r(Real HTTP connections are disabled. Unregistered request: GET http://user:pazz@www.example.com/))
end
end
describe "when stubbing request with a global hook" do
after(:each) do
WebMock::StubRegistry.instance.global_stubs.clear
end
it 'returns the response returned by the hook' do
WebMock.globally_stub_request do |request|
{ :body => "global stub body" }
end
expect(http_request(:get, "http://www.example.com/").body).to eq("global stub body")
end
it 'does not get cleared when a user calls WebMock.reset!' do
WebMock.globally_stub_request do |request|
{ :body => "global stub body" }
end
WebMock.reset!
expect(http_request(:get, "http://www.example.com/").body).to eq("global stub body")
end
it "does not stub the request if the hook does not return anything" do
WebMock.globally_stub_request { |r| }
expect {
http_request(:get, "http://www.example.com/")
}.to raise_error(WebMock::NetConnectNotAllowedError, %r(Real HTTP connections are disabled. Unregistered request: GET http://www.example.com/))
end
it "passes the request to the block" do
passed_request = nil
WebMock.globally_stub_request do |request|
passed_request = request
{ :body => "global stub body" }
end
http_request(:get, "http://www.example.com:456/bar")
expect(passed_request.uri.to_s).to eq("http://www.example.com:456/bar")
end
it "should call the block only once per request" do
call_count = 0
WebMock.globally_stub_request do |request|
call_count += 1
{ :body => "global stub body" }
end
http_request(:get, "http://www.example.com/")
expect(call_count).to eq(1)
end
it 'supports multiple global stubs; the first registered one that returns a non-nil value determines the stub' do
stub_invocation_order = []
WebMock.globally_stub_request do |request|
stub_invocation_order << :nil_stub
nil
end
WebMock.globally_stub_request do |request|
stub_invocation_order << :hash_stub
{ :body => "global stub body" }
end
expect(http_request(:get, "http://www.example.com/").body).to eq("global stub body")
expect(stub_invocation_order).to eq([:nil_stub, :hash_stub])
end
[:before, :after].each do |before_or_after|
context "when there is also a non-global registered stub #{before_or_after} the global stub" do
def stub_non_globally
stub_request(:get, "www.example.com").to_return(:body => 'non-global stub body')
end
define_method :register_stubs do |block|
stub_non_globally if before_or_after == :before
WebMock.globally_stub_request(&block)
stub_non_globally if before_or_after == :after
end
it 'uses the response from the global stub if the block returns a non-nil value' do
register_stubs(lambda { |req| { :body => 'global stub body' } })
expect(http_request(:get, "http://www.example.com/").body).to eq("global stub body")
end
it 'uses the response from the non-global stub if the block returns a nil value' do
register_stubs(lambda { |req| nil })
expect(http_request(:get, "http://www.example.com/").body).to eq("non-global stub body")
end
end
end
end
describe "when stubbing request with a block evaluated on request" do
it "should match if block returns true" do
stub_request(:get, "www.example.com").with { |request| true }
expect(http_request(:get, "http://www.example.com/").status).to eq("200")
end
it "should not match if block returns false" do
stub_request(:get, "www.example.com").with { |request| false }
expect {
http_request(:get, "http://www.example.com/")
}.to raise_error(WebMock::NetConnectNotAllowedError, %r(Real HTTP connections are disabled. Unregistered request: GET http://www.example.com/))
end
it "should pass the request to the block" do
stub_request(:post, "www.example.com").with { |request| request.body == "wadus" }
expect(http_request(
:post, "http://www.example.com/",
:body => "wadus").status).to eq("200")
expect {
http_request(:post, "http://www.example.com/", :body => "jander")
}.to raise_error(WebMock::NetConnectNotAllowedError, %r(Real HTTP connections are disabled. Unregistered request: POST http://www.example.com/ with body 'jander'))
end
it "should call the block only once per request" do
call_count = 0
stub_request(:get, "www.example.com").with { |request| call_count += 1; true }
expect(http_request(:get, "http://www.example.com/").status).to eq("200")
expect(call_count).to eq(1)
end
end
end
describe "when request stub was removed" do
it "should raise an error on request" do
stub = stub_request(:get, "www.example.com")
http_request(:get, "http://www.example.com/")
remove_request_stub(stub)
expect {
http_request(:get, "http://www.example.com/")
}.to raise_error(WebMock::NetConnectNotAllowedError, %r(Real HTTP connections are disabled. Unregistered request: GET http://www.example.com/))
end
end
end
webmock-1.22.6/spec/acceptance/shared/complex_cross_concern_behaviors.rb 0000644 0000041 0000041 00000002504 12646134265 026537 0 ustar www-data www-data shared_context "complex cross-concern behaviors" do |*adapter_info|
it 'allows a response with multiple values for the same header to be recorded and played back exactly as-is' do
WebMock.allow_net_connect!
recorded_response = nil
WebMock.after_request { |_,r| recorded_response = r }
real_response = http_request(:get, webmock_server_url)
stub_request(:get, webmock_server_url).to_return(
:status => recorded_response.status,
:body => recorded_response.body,
:headers => recorded_response.headers
)
played_back_response = http_request(:get, webmock_server_url)
expect(played_back_response.headers.keys).to include('Set-Cookie')
expect(played_back_response).to eq(real_response)
end
let(:no_content_url) { 'http://httpstat.us/204' }
[nil, ''].each do |stub_val|
it "returns the same value (nil or "") for a request stubbed as #{stub_val.inspect} that a real empty response has", :net_connect => true do
unless http_library == :curb
WebMock.allow_net_connect!
real_response = http_request(:get, no_content_url)
stub_request(:get, no_content_url).to_return(:status => 204, :body => stub_val)
stubbed_response = http_request(:get, no_content_url)
expect(stubbed_response.body).to eq(real_response.body)
end
end
end
end
webmock-1.22.6/spec/acceptance/httpclient/ 0000755 0000041 0000041 00000000000 12646134265 020470 5 ustar www-data www-data webmock-1.22.6/spec/acceptance/httpclient/httpclient_spec.rb 0000644 0000041 0000041 00000012642 12646134265 024212 0 ustar www-data www-data require 'spec_helper'
require 'acceptance/webmock_shared'
require 'ostruct'
require 'acceptance/httpclient/httpclient_spec_helper'
describe "HTTPClient" do
include HTTPClientSpecHelper
before(:each) do
WebMock.reset_callbacks
HTTPClientSpecHelper.async_mode = false
end
include_examples "with WebMock"
it "should yield block on response if block provided" do
stub_request(:get, "www.example.com").to_return(:body => "abc")
response_body = ""
http_request(:get, "http://www.example.com/") do |body|
response_body = body
end
expect(response_body).to eq("abc")
end
it "should match requests if headers are the same but in different order" do
stub_request(:get, "www.example.com").with(:headers => {"a" => ["b", "c"]} )
expect(http_request(
:get, "http://www.example.com/",
:headers => {"a" => ["c", "b"]}).status).to eq("200")
end
describe "when using async requests" do
before(:each) do
HTTPClientSpecHelper.async_mode = true
end
include_examples "with WebMock"
end
it "should work with get_content" do
stub_request(:get, 'www.example.com').to_return(:status => 200, :body => 'test', :headers => {})
str = ''
HTTPClient.get_content('www.example.com') do |content|
str << content
end
expect(str).to eq('test')
end
it "should work via JSONClient subclass" do
stub_request(:get, 'www.example.com').to_return(
:status => 200,
:body => '{"test": "foo"}',
:headers => {'Content-Type' => 'application/json'}
)
content = JSONClient.get('www.example.com').content
expect(content).to eq("test" => "foo")
end
context "multipart bodies" do
let(:header) {{
'Accept' => 'application/json',
'Content-Type' => 'multipart/form-data'
}}
let(:body) {[
{
'Content-Type' => 'application/json',
'Content-Disposition' => 'form-data',
:content => '{"foo": "bar", "baz": 2}'
}
]}
let(:make_request) {HTTPClient.new.post("http://www.example.com", :body => body, :header => header)}
before do
stub_request(:post, "www.example.com")
end
it "should work with multipart bodies" do
make_request
end
end
context "Filters" do
class Filter
def filter_request(request)
request.header["Authorization"] = "Bearer 0123456789"
end
def filter_response(request, response)
response.header.set('X-Powered-By', 'webmock')
end
end
before do
@client = HTTPClient.new
@client.request_filter << Filter.new
stub_request(:get, 'www.example.com').with(:headers => {'Authorization' => 'Bearer 0123456789'})
end
it "supports request filters" do
expect(@client.request(:get, 'http://www.example.com/').status).to eq(200)
end
it "supports response filters" do
res = @client.request(:get, 'http://www.example.com/')
expect(res.header['X-Powered-By'].first).to eq('webmock')
end
end
context 'when a client instance is re-used for another identical request' do
let(:client) { HTTPClient.new }
let(:webmock_server_url) {"http://#{WebMockServer.instance.host_with_port}/"}
before { WebMock.allow_net_connect! }
it 'invokes the global_stub_request hook for each request' do
request_signatures = []
WebMock.globally_stub_request do |request_sig|
request_signatures << request_sig
nil # to let the request be made for real
end
http_request(:get, webmock_server_url, :client => client, :headers => { "Cookie" => "bar=; foo=" })
if defined? HTTP::CookieJar
http_request(:get, webmock_server_url, :client => client, :headers => { "Cookie" => "bar=; foo=" })
else
# If http-cookie is not present, then the cookie headers will saved between requests
http_request(:get, webmock_server_url, :client => client)
end
expect(request_signatures.size).to eq(2)
# Verify the request signatures were identical as needed by this example
expect(request_signatures.first).to eq(request_signatures.last)
end
end
context 'session headers' do
it "client sends a User-Agent header when given an agent_name explicitly to the client" do
user_agent = "Client/0.1"
stub_request(:get, "www.example.com").with(:headers => { 'User-agent' => "#{user_agent} #{HTTPClient::LIB_NAME}" })
HTTPClient.new(:agent_name => user_agent).get("www.example.com")
end
it "client sends the Accept, User-Agent, and Date by default" do
WebMock.disable_net_connect!
stub_request(:get, "www.example.com").with do |req|
req.headers["Accept"] == "*/*" &&
req.headers["User-Agent"] == "#{HTTPClient::DEFAULT_AGENT_NAME} #{HTTPClient::LIB_NAME}" &&
req.headers["Date"]
end
http_request(:get, "www.example.com")
end
it "explicitly defined headers take precedence over session defaults" do
headers = { 'Accept' => 'foo/bar', 'User-Agent' => 'custom', 'Date' => 'today' }
stub_request(:get, "www.example.com").with(:headers => headers)
HTTPClient.new.get("www.example.com", nil, headers)
end
end
context 'httpclient response header' do
it 'receives request_method, request_uri, and request_query from the request header' do
stub_request :get, 'www.example.com'
message = HTTPClient.new.get 'www.example.com'
expect(message.header.request_uri.to_s).to eq('www.example.com')
end
end
end
webmock-1.22.6/spec/acceptance/httpclient/httpclient_spec_helper.rb 0000644 0000041 0000041 00000002661 12646134265 025551 0 ustar www-data www-data module HTTPClientSpecHelper
class << self
attr_accessor :async_mode
end
def http_request(method, uri, options = {}, &block)
uri = Addressable::URI.heuristic_parse(uri)
c = options.fetch(:client) { HTTPClient.new }
c.ssl_config.verify_mode = OpenSSL::SSL::VERIFY_NONE
c.set_basic_auth(nil, uri.user, uri.password) if uri.user
params = [method, "#{uri.omit(:userinfo, :query).normalize.to_s}",
WebMock::Util::QueryMapper.query_to_values(uri.query, :notation => WebMock::Config.instance.query_values_notation), options[:body], options[:headers] || {}]
if HTTPClientSpecHelper.async_mode
connection = c.request_async(*params)
connection.join
response = connection.pop
else
response = c.request(*params, &block)
end
headers = response.header.all.inject({}) do |headers, header|
if !headers.has_key?(header[0])
headers[header[0]] = header[1]
else
headers[header[0]] = [headers[header[0]], header[1]].join(', ')
end
headers
end
OpenStruct.new({
:body => HTTPClientSpecHelper.async_mode ? response.content.read : response.content,
:headers => headers,
:status => response.code.to_s,
:message => response.reason
})
end
def client_timeout_exception_class
HTTPClient::TimeoutError
end
def connection_refused_exception_class
Errno::ECONNREFUSED
end
def http_library
:httpclient
end
end
webmock-1.22.6/spec/acceptance/manticore/ 0000755 0000041 0000041 00000000000 12646134265 020273 5 ustar www-data www-data webmock-1.22.6/spec/acceptance/manticore/manticore_spec_helper.rb 0000644 0000041 0000041 00000001275 12646134265 025157 0 ustar www-data www-data module ManticoreSpecHelper
def http_request(method, uri, options = {})
client = Manticore::Client.new
response = client.http(method, uri, options)
OpenStruct.new({
:body => response.body || '',
:headers => WebMock::Util::Headers.normalize_headers(join_array_values(response.headers)),
:status => response.code.to_s
})
end
def join_array_values(hash)
hash.reduce({}) do |h, (k,v)|
v = v.join(', ') if v.is_a?(Array)
h.merge(k => v)
end
end
def client_timeout_exception_class
Manticore::ConnectTimeout
end
def connection_refused_exception_class
Manticore::SocketException
end
def http_library
:manticore
end
end
webmock-1.22.6/spec/acceptance/manticore/manticore_spec.rb 0000644 0000041 0000041 00000003673 12646134265 023624 0 ustar www-data www-data require 'spec_helper'
require 'acceptance/webmock_shared'
if RUBY_PLATFORM =~ /java/
require 'acceptance/manticore/manticore_spec_helper'
describe "Manticore" do
include ManticoreSpecHelper
include_context "with WebMock", :no_status_message
context "calling http methods on Manticore directly using Manticore's facade" do
it "handles GET" do
stub_request(:get, "http://example-foo.com").to_return(:status => 301)
response = Manticore.get("http://example-foo.com")
expect(response.code).to eq(301)
end
it "handles POST" do
stub_request(:post, "http://example-foo.com").to_return(:status => 201)
response = Manticore.post("http://example-foo.com", {:hello => "world"})
expect(response.code).to eq(201)
end
it "handles PUT" do
stub_request(:put, "http://example-foo.com").to_return(:status => 409)
response = Manticore.put("http://example-foo.com", {:hello => "world"})
expect(response.code).to eq(409)
end
it "handles PATCH" do
stub_request(:patch, "http://example-foo.com").to_return(:status => 409)
response = Manticore.patch("http://example-foo.com", {:hello => "world"})
expect(response.code).to eq(409)
end
it "handles DELETE" do
stub_request(:delete, "http://example-foo.com").to_return(:status => 204)
response = Manticore.delete("http://example-foo.com", {:id => 1})
expect(response.code).to eq(204)
end
it "handles OPTIONS" do
stub_request(:options, "http://example-foo.com").to_return(:status => 200)
response = Manticore.options("http://example-foo.com")
expect(response.code).to eq(200)
end
it "handles HEAD" do
stub_request(:head, "http://example-foo.com").to_return(:status => 204)
response = Manticore.head("http://example-foo.com")
expect(response.code).to eq(204)
end
end
end
end
webmock-1.22.6/spec/acceptance/excon/ 0000755 0000041 0000041 00000000000 12646134265 017426 5 ustar www-data www-data webmock-1.22.6/spec/acceptance/excon/excon_spec.rb 0000644 0000041 0000041 00000005203 12646134265 022101 0 ustar www-data www-data require 'spec_helper'
require 'acceptance/webmock_shared'
require 'acceptance/excon/excon_spec_helper'
describe "Excon" do
include ExconSpecHelper
include_context "with WebMock", :no_status_message, :no_url_auth
it 'should allow Excon requests to use query hash paramters' do
stub_request(:get, "http://example.com/resource/?a=1&b=2").to_return(:body => "abc")
expect(Excon.new('http://example.com').get(:path => "resource/", :query => {:a => 1, :b => 2}).body).to eq("abc")
end
it 'should support Excon :expects options' do
stub_request(:get, "http://example.com/").to_return(:body => 'a')
expect { Excon.new('http://example.com').get(:expects => 204) }.to raise_error(Excon::Errors::OK)
end
context "with response_block" do
it "should support excon response_block for real requests", :net_connect => true do
a = []
WebMock.allow_net_connect!
r = Excon.new('http://httpstat.us/200').get(:response_block => lambda {|e, remaining, total| a << e}, :chunk_size => 1)
expect(a).to eq(["2", "0", "0", " ", "O", "K"])
expect(r.body).to eq("")
end
it "should support excon response_block" do
a = []
stub_request(:get, "http://example.com/").to_return(:body => "abc")
r = Excon.new('http://example.com').get(:response_block => lambda {|e, remaining, total| a << e}, :chunk_size => 1)
expect(a).to eq(['a', 'b', 'c'])
expect(r.body).to eq("")
end
it "should invoke callbacks with response body even if a real request is made", :net_connect => true do
a = []
WebMock.allow_net_connect!
response = nil
WebMock.after_request { |_, res|
response = res
}
r = Excon.new('http://httpstat.us/200').get(:response_block => lambda {|e, remaining, total| a << e}, :chunk_size => 1)
expect(response.body).to eq("200 OK")
expect(a).to eq(["2", "0", "0", " ", "O", "K"])
expect(r.body).to eq("")
end
end
let(:file) { File.new(__FILE__) }
let(:file_contents) { File.read(__FILE__) }
it 'handles file uploads correctly' do
stub_request(:put, "http://example.com/upload").with(:body => file_contents)
yielded_request_body = nil
WebMock.after_request do |req, res|
yielded_request_body = req.body
end
Excon.new("http://example.com").put(:path => "upload", :body => file)
expect(yielded_request_body).to eq(file_contents)
end
describe '.request_params_from' do
it 'rejects invalid request keys' do
request_params = WebMock::HttpLibAdapters::ExconAdapter.request_params_from(:body => :keep, :fake => :reject)
expect(request_params).to eq(:body => :keep)
end
end
end
webmock-1.22.6/spec/acceptance/excon/excon_spec_helper.rb 0000644 0000041 0000041 00000002242 12646134265 023440 0 ustar www-data www-data require 'ostruct'
module ExconSpecHelper
def http_request(method, uri, options = {}, &block)
Excon.defaults[:ssl_verify_peer] = false
uri = Addressable::URI.heuristic_parse(uri)
uri = uri.omit(:userinfo).to_s.gsub(' ', '%20')
if Gem::Version.new(Excon::VERSION) < Gem::Version.new("0.29.0")
options = options.merge(:method => method, :nonblock => false) # Dup and merge
response = Excon.new(uri).request(options, &block)
else
options = options.merge(:method => method) # Dup and merge
response = Excon.new(uri, :nonblock => false).request(options, &block)
end
headers = WebMock::Util::Headers.normalize_headers(response.headers)
headers = headers.inject({}) do |res, (name, value)|
res[name] = value.is_a?(Array) ? value.flatten.join(', ') : value
res
end
OpenStruct.new \
:body => response.body,
:headers => headers,
:status => response.status.to_s,
:message => ""
end
def client_timeout_exception_class
Excon::Errors::Timeout
end
def connection_refused_exception_class
Excon::Errors::SocketError
end
def http_library
:excon
end
end
webmock-1.22.6/spec/acceptance/typhoeus/ 0000755 0000041 0000041 00000000000 12646134265 020172 5 ustar www-data www-data webmock-1.22.6/spec/acceptance/typhoeus/typhoeus_hydra_spec_helper.rb 0000644 0000041 0000041 00000002530 12646134265 026137 0 ustar www-data www-data require 'ostruct'
module TyphoeusHydraSpecHelper
class FakeTyphoeusHydraTimeoutError < StandardError; end
class FakeTyphoeusHydraConnectError < StandardError; end
def http_request(method, uri, options = {}, &block)
uri.gsub!(" ", "%20") #typhoeus doesn't like spaces in the uri
request = Typhoeus::Request.new(uri,
{
:method => method,
:body => options[:body],
:headers => options[:headers],
:timeout => 25000
}
)
hydra = Typhoeus::Hydra.new
hydra.queue(request)
hydra.run
response = request.response
raise FakeTyphoeusHydraConnectError.new if response.return_code == :couldnt_connect
raise FakeTyphoeusHydraTimeoutError.new if response.timed_out?
OpenStruct.new({
:body => response.body,
:headers => WebMock::Util::Headers.normalize_headers(join_array_values(response.headers)),
:status => response.code.to_s,
:message => response.status_message
})
end
def join_array_values(hash)
joined = {}
if hash
hash.each do |k,v|
v = v.join(", ") if v.is_a?(Array)
joined[k] = v
end
end
joined
end
def client_timeout_exception_class
FakeTyphoeusHydraTimeoutError
end
def connection_refused_exception_class
FakeTyphoeusHydraConnectError
end
def http_library
:typhoeus
end
end
webmock-1.22.6/spec/acceptance/typhoeus/typhoeus_hydra_spec.rb 0000644 0000041 0000041 00000010576 12646134265 024611 0 ustar www-data www-data require 'spec_helper'
require 'acceptance/webmock_shared'
unless RUBY_PLATFORM =~ /java/
require 'acceptance/typhoeus/typhoeus_hydra_spec_helper'
describe "Typhoeus::Hydra" do
include TyphoeusHydraSpecHelper
let(:hydra) { Typhoeus::Hydra.new }
before do
Typhoeus::Expectation.clear
end
include_context "with WebMock"
describe "Typhoeus::Hydra features" do
before(:each) do
WebMock.disable_net_connect!
WebMock.reset!
end
describe "supposed response fields" do
it "present" do
stub_request(:get, "http://www.example.com").to_return(:headers => {'X-Test' => '1'})
response = Typhoeus.get("http://www.example.com")
expect(response.code).not_to be_nil
expect(response.status_message).not_to be_nil
expect(response.body).not_to be_nil
expect(response.headers).not_to be_nil
expect(response.effective_url).not_to be_nil
end
end
describe "when params are used" do
it "should take into account params for POST request" do
stub_request(:post, "www.example.com/?hello=world").with(:query => {:hello => 'world'})
request = Typhoeus::Request.new("http://www.example.com", :method => :post, :params => {:hello => 'world'})
hydra.queue(request)
hydra.run
end
it "should take into account body for POST request" do
stub_request(:post, "www.example.com").with(:body => {:hello => 'world'})
response = Typhoeus.post("http://www.example.com", :method => :post, :body => {:hello => 'world'})
expect(response.code).to eq(200)
end
it "should take into account params for GET request" do
stub_request(:get, "http://www.example.com/?hello=world").to_return({})
request = Typhoeus::Request.new("http://www.example.com/?hello=world", :method => :get)
hydra.queue(request)
hydra.run
end
end
describe "timeouts" do
it "should support native typhoeus timeouts" do
stub_request(:any, "example.com").to_timeout
request = Typhoeus::Request.new("http://example.com", :method => :get)
hydra.queue(request)
hydra.run
expect(request.response).to be_timed_out
end
end
describe "callbacks" do
before(:each) do
@request = Typhoeus::Request.new("http://example.com")
end
it "should call on_complete with 2xx response" do
body = "on_success fired"
stub_request(:any, "example.com").to_return(:body => body)
test = nil
Typhoeus.on_complete do |c|
test = c.body
end
hydra.queue @request
hydra.run
expect(test).to eq(body)
end
it "should call on_complete with 5xx response" do
response_code = 599
stub_request(:any, "example.com").to_return(:status => [response_code, "Server On Fire"])
test = nil
Typhoeus.on_complete do |c|
test = c.code
end
hydra.queue @request
hydra.run
expect(test).to eq(response_code)
end
it "should call on_body with 2xx response" do
body = "on_body fired"
stub_request(:any, "example.com").to_return(:body => body)
test_body = nil
test_complete = nil
skip("This test requires a newer version of Typhoeus") unless @request.respond_to?(:on_body)
@request.on_body do |body, response|
test_body = body
end
@request.on_complete do |response|
test_complete = response.body
end
hydra.queue @request
hydra.run
expect(test_body).to eq(body)
expect(test_complete).to eq("")
end
it "should call on_headers with 2xx response" do
body = "on_headers fired"
stub_request(:any, "example.com").to_return(:body => body, :headers => {'X-Test' => '1'})
test_headers = nil
skip("This test requires a newer version of Typhoeus") unless @request.respond_to?(:on_headers)
@request.on_headers do |response|
test_headers = response.headers
end
hydra.queue @request
hydra.run
expect(test_headers).to include('X-Test' => '1')
end
end
end
end
end
webmock-1.22.6/spec/acceptance/patron/ 0000755 0000041 0000041 00000000000 12646134265 017615 5 ustar www-data www-data webmock-1.22.6/spec/acceptance/patron/patron_spec.rb 0000644 0000041 0000041 00000010642 12646134265 022462 0 ustar www-data www-data # encoding: utf-8
require 'spec_helper'
require 'acceptance/webmock_shared'
unless RUBY_PLATFORM =~ /java/
require 'acceptance/patron/patron_spec_helper'
require 'tmpdir'
require 'fileutils'
describe "Patron" do
include PatronSpecHelper
include_examples "with WebMock"
describe "when custom functionality is used" do
before(:each) do
@sess = Patron::Session.new
@sess.base_url = "http://www.example.com"
end
describe "file requests" do
before(:each) do
@dir_path = Dir.mktmpdir('webmock-')
@file_path = File.join(@dir_path, "webmock_temp_test_file")
FileUtils.rm_rf(@file_path) if File.exist?(@file_path)
end
after(:each) do
FileUtils.rm_rf(@dir_path) if File.exist?(@dir_path)
end
it "should work with get_file" do
stub_request(:get, "www.example.com").to_return(:body => "abc")
@sess.get_file("/", @file_path)
expect(File.read(@file_path)).to eq("abc")
end
it "should raise same error as Patron if file is not readable for get request" do
stub_request(:get, "www.example.com")
File.open("/tmp/read_only_file", "w") do |tmpfile|
tmpfile.chmod(0400)
end
begin
expect {
@sess.get_file("/", "/tmp/read_only_file")
}.to raise_error(ArgumentError, "Unable to open specified file.")
ensure
File.unlink("/tmp/read_only_file")
end
end
it "should work with put_file" do
File.open(@file_path, "w") {|f| f.write "abc"}
stub_request(:put, "www.example.com").with(:body => "abc")
@sess.put_file("/", @file_path)
end
it "should work with post_file" do
File.open(@file_path, "w") {|f| f.write "abc"}
stub_request(:post, "www.example.com").with(:body => "abc")
@sess.post_file("/", @file_path)
end
it "should raise same error as Patron if file is not readable for post request" do
stub_request(:post, "www.example.com").with(:body => "abc")
expect {
@sess.post_file("/", "/path/to/non/existing/file")
}.to raise_error(ArgumentError, "Unable to open specified file.")
end
end
describe "handling errors same way as patron" do
it "should raise error if put request has neither upload_data nor file_name" do
stub_request(:post, "www.example.com")
expect {
@sess.post("/", nil)
}.to raise_error(ArgumentError, "Must provide either data or a filename when doing a PUT or POST")
end
end
it "should work with WebDAV copy request" do
stub_request(:copy, "www.example.com/abc").with(:headers => {'Destination' => "/def"})
@sess.copy("/abc", "/def")
end
if /^1\.9/ === RUBY_VERSION
describe "handling encoding same way as patron" do
around(:each) do |example|
@encoding = Encoding.default_internal
Encoding.default_internal = "UTF-8"
example.run
Encoding.default_internal = @encoding
end
it "should encode body with default encoding" do
stub_request(:get, "www.example.com").
to_return(:body => "Øl")
expect(@sess.get("").body.encoding).to eq(Encoding::UTF_8)
end
it "should encode body to default internal" do
stub_request(:get, "www.example.com").
to_return(:headers => {'Content-Type' => 'text/html; charset=iso-8859-1'},
:body => "Øl".encode("iso-8859-1"))
expect(@sess.get("").body.encoding).to eq(Encoding.default_internal)
end
it "should encode body based on encoding-attribute in body" do
stub_request(:get, "www.example.com").
to_return(:body => "Øl".encode("iso-8859-1"))
expect(@sess.get("").body.encoding).to eq(Encoding::ISO_8859_1)
end
it "should encode body based on Session#default_response_charset" do
stub_request(:get, "www.example.com").
to_return(:body => "Øl".encode("iso-8859-1"))
@sess.default_response_charset = "iso-8859-1"
expect(@sess.get("").body.encoding).to eq(Encoding::ISO_8859_1)
end
end
end
end
end
end
webmock-1.22.6/spec/acceptance/patron/patron_spec_helper.rb 0000644 0000041 0000041 00000002447 12646134265 024025 0 ustar www-data www-data require 'ostruct'
module PatronSpecHelper
def http_request(method, uri, options = {}, &block)
method = method.to_sym
uri = Addressable::URI.heuristic_parse(uri)
sess = Patron::Session.new
sess.base_url = "#{uri.omit(:userinfo, :path, :query).normalize.to_s}".gsub(/\/$/,"")
sess.username = uri.user
sess.password = uri.password
sess.connect_timeout = 30
sess.timeout = 30
sess.max_redirects = 0
uri = "#{uri.path}#{uri.query ? '?' : ''}#{uri.query}"
uri.gsub!(' ','%20')
response = sess.request(method, uri, options[:headers] || {}, {
:data => options[:body]
})
headers = {}
if response.headers
response.headers.each do |k,v|
v = v.join(", ") if v.is_a?(Array)
headers[k] = v
end
end
status_line_pattern = %r(\AHTTP/(\d+\.\d+)\s+(\d\d\d)\s*([^\r\n]+)?)
message = response.status_line.match(status_line_pattern)[3] || ""
OpenStruct.new({
:body => response.body,
:headers => WebMock::Util::Headers.normalize_headers(headers),
:status => response.status.to_s,
:message => message
})
end
def client_timeout_exception_class
Patron::TimeoutError
end
def connection_refused_exception_class
Patron::ConnectionFailed
end
def http_library
:patron
end
end
webmock-1.22.6/.travis.yml 0000644 0000041 0000041 00000001173 12646134265 015405 0 ustar www-data www-data rvm:
- 1.9.2
- 1.9.3
- 2.0.0
- 2.1.0
- 2.2.1
- 2.2.3
- 2.3.0
- rbx-2
- ruby-head
- jruby-9.0.0.0
- jruby-9.0.1.0
- jruby-19mode
- jruby
- jruby-head
matrix:
include:
- rvm: 1.8.7
gemfile: gemfiles/ruby_1_8.gemfile
- rvm: ree
gemfile: gemfiles/ruby_1_8.gemfile
- rvm: jruby-18mode
gemfile: gemfiles/ruby_1_8.gemfile
allow_failures:
- rvm: jruby-9.0.0.0
- rvm: jruby-18mode
- rvm: jruby-head
- rvm: ruby-head
- rvm: rbx-2
# Send builds to container-based infrastructure
# http://docs.travis-ci.com/user/workers/container-based-infrastructure/
sudo: false
webmock-1.22.6/lib/ 0000755 0000041 0000041 00000000000 12646134265 014040 5 ustar www-data www-data webmock-1.22.6/lib/webmock/ 0000755 0000041 0000041 00000000000 12646134265 015467 5 ustar www-data www-data webmock-1.22.6/lib/webmock/stub_registry.rb 0000644 0000041 0000041 00000003220 12646134265 020716 0 ustar www-data www-data module WebMock
class StubRegistry
include Singleton
attr_accessor :request_stubs
def initialize
reset!
end
def global_stubs
@global_stubs ||= []
end
def reset!
self.request_stubs = []
end
def register_global_stub(&block)
# This hash contains the responses returned by the block,
# keyed by the exact request (using the object_id).
# That way, there's no race condition in case #to_return
# doesn't run immediately after stub.with.
responses = {}
stub = ::WebMock::RequestStub.new(:any, /.*/).with { |request|
responses[request.object_id] = block.call(request)
}.to_return(lambda { |request| responses.delete(request.object_id) })
global_stubs.push stub
end
def register_request_stub(stub)
request_stubs.insert(0, stub)
stub
end
def remove_request_stub(stub)
if not request_stubs.delete(stub)
raise "Request stub \n\n #{stub.to_s} \n\n is not registered."
end
end
def registered_request?(request_signature)
request_stub_for(request_signature)
end
def response_for_request(request_signature)
stub = request_stub_for(request_signature)
stub ? evaluate_response_for_request(stub.response, request_signature) : nil
end
private
def request_stub_for(request_signature)
(global_stubs + request_stubs).detect { |registered_request_stub|
registered_request_stub.request_pattern.matches?(request_signature)
}
end
def evaluate_response_for_request(response, request_signature)
response.dup.evaluate(request_signature)
end
end
end
webmock-1.22.6/lib/webmock/callback_registry.rb 0000644 0000041 0000041 00000001465 12646134265 021506 0 ustar www-data www-data module WebMock
class CallbackRegistry
@@callbacks = []
def self.add_callback(options, block)
@@callbacks << {:options => options, :block => block}
end
def self.callbacks
@@callbacks
end
def self.invoke_callbacks(options, request_signature, response)
return if @@callbacks.empty?
CallbackRegistry.callbacks.each do |callback|
except = callback[:options][:except]
real_only = callback[:options][:real_requests_only]
unless except && except.include?(options[:lib])
if !real_only || options[:real_request]
callback[:block].call(request_signature, response)
end
end
end
end
def self.reset
@@callbacks = []
end
def self.any_callbacks?
!@@callbacks.empty?
end
end
end
webmock-1.22.6/lib/webmock/request_pattern.rb 0000644 0000041 0000041 00000022743 12646134265 021251 0 ustar www-data www-data module WebMock
module RSpecMatcherDetector
def rSpecHashIncludingMatcher?(matcher)
matcher.class.name =~ /R?Spec::Mocks::ArgumentMatchers::HashIncludingMatcher/
end
end
class RequestPattern
attr_reader :method_pattern, :uri_pattern, :body_pattern, :headers_pattern
def initialize(method, uri, options = {})
@method_pattern = MethodPattern.new(method)
@uri_pattern = create_uri_pattern(uri)
@body_pattern = nil
@headers_pattern = nil
@with_block = nil
assign_options(options)
end
def with(options = {}, &block)
raise ArgumentError.new('#with method invoked with no arguments. Either options hash or block must be specified.') if options.empty? && !block_given?
assign_options(options)
@with_block = block
self
end
def matches?(request_signature)
content_type = request_signature.headers['Content-Type'] if request_signature.headers
content_type = content_type.split(';').first if content_type
@method_pattern.matches?(request_signature.method) &&
@uri_pattern.matches?(request_signature.uri) &&
(@body_pattern.nil? || @body_pattern.matches?(request_signature.body, content_type || "")) &&
(@headers_pattern.nil? || @headers_pattern.matches?(request_signature.headers)) &&
(@with_block.nil? || @with_block.call(request_signature))
end
def to_s
string = "#{@method_pattern.to_s.upcase}"
string << " #{@uri_pattern.to_s}"
string << " with body #{@body_pattern.to_s}" if @body_pattern
string << " with headers #{@headers_pattern.to_s}" if @headers_pattern
string << " with given block" if @with_block
string
end
private
def assign_options(options)
options = WebMock::Util::HashKeysStringifier.stringify_keys!(options, :deep => true)
HashValidator.new(options).validate_keys('body', 'headers', 'query')
@body_pattern = BodyPattern.new(options['body']) if options.has_key?('body')
@headers_pattern = HeadersPattern.new(options['headers']) if options.has_key?('headers')
@uri_pattern.add_query_params(options['query']) if options.has_key?('query')
end
def create_uri_pattern(uri)
if uri.is_a?(Regexp)
URIRegexpPattern.new(uri)
elsif uri.is_a?(Addressable::Template)
URIAddressablePattern.new(uri)
else
URIStringPattern.new(uri)
end
end
end
class MethodPattern
def initialize(pattern)
@pattern = pattern
end
def matches?(method)
@pattern == method || @pattern == :any
end
def to_s
@pattern.to_s
end
end
class URIPattern
include RSpecMatcherDetector
def initialize(pattern)
@pattern = case pattern
when Addressable::URI, Addressable::Template
pattern
else
WebMock::Util::URI.normalize_uri(pattern)
end
@query_params = nil
end
def add_query_params(query_params)
@query_params = if query_params.is_a?(Hash)
query_params
elsif query_params.is_a?(WebMock::Matchers::HashIncludingMatcher)
query_params
elsif rSpecHashIncludingMatcher?(query_params)
WebMock::Matchers::HashIncludingMatcher.from_rspec_matcher(query_params)
else
WebMock::Util::QueryMapper.query_to_values(query_params, :notation => Config.instance.query_values_notation)
end
end
def to_s
str = @pattern.inspect
str += " with query params #{@query_params.inspect}" if @query_params
str
end
end
class URIRegexpPattern < URIPattern
def matches?(uri)
WebMock::Util::URI.variations_of_uri_as_strings(uri).any? { |u| u.match(@pattern) } &&
(@query_params.nil? || @query_params == WebMock::Util::QueryMapper.query_to_values(uri.query, :notation => Config.instance.query_values_notation))
end
def to_s
str = @pattern.inspect
str += " with query params #{@query_params.inspect}" if @query_params
str
end
end
class URIAddressablePattern < URIPattern
def matches?(uri)
if @query_params.nil?
# Let Addressable check the whole URI
WebMock::Util::URI.variations_of_uri_as_strings(uri).any? { |u| @pattern.match(u) }
else
# WebMock checks the query, Addressable checks everything else
WebMock::Util::URI.variations_of_uri_as_strings(uri.omit(:query)).any? { |u| @pattern.match(u) } &&
@query_params == WebMock::Util::QueryMapper.query_to_values(uri.query)
end
end
def add_query_params(query_params)
warn "WebMock warning: ignoring query params in RFC 6570 template and checking them with WebMock"
super(query_params)
end
def to_s
str = @pattern.pattern.inspect
str += " with variables #{@pattern.variables.inspect}" if @pattern.variables
str
end
end
class URIStringPattern < URIPattern
def matches?(uri)
if @pattern.is_a?(Addressable::URI)
if @query_params
uri.omit(:query) === @pattern &&
(@query_params.nil? || @query_params == WebMock::Util::QueryMapper.query_to_values(uri.query, :notation => Config.instance.query_values_notation))
else
uri === @pattern
end
else
false
end
end
def add_query_params(query_params)
super
if @query_params.is_a?(Hash) || @query_params.is_a?(String)
query_hash = (WebMock::Util::QueryMapper.query_to_values(@pattern.query, :notation => Config.instance.query_values_notation) || {}).merge(@query_params)
@pattern.query = WebMock::Util::QueryMapper.values_to_query(query_hash, :notation => WebMock::Config.instance.query_values_notation)
@query_params = nil
end
end
def to_s
str = WebMock::Util::URI.strip_default_port_from_uri_string(@pattern.to_s)
str += " with query params #{@query_params.inspect}" if @query_params
str
end
end
class BodyPattern
include RSpecMatcherDetector
BODY_FORMATS = {
'text/xml' => :xml,
'application/xml' => :xml,
'application/json' => :json,
'text/json' => :json,
'application/javascript' => :json,
'text/javascript' => :json,
'text/html' => :html,
'application/x-yaml' => :yaml,
'text/yaml' => :yaml,
'text/plain' => :plain
}
attr_reader :pattern
def initialize(pattern)
@pattern = if pattern.is_a?(Hash)
normalize_hash(pattern)
elsif rSpecHashIncludingMatcher?(pattern)
WebMock::Matchers::HashIncludingMatcher.from_rspec_matcher(pattern)
else
pattern
end
end
def matches?(body, content_type = "")
if (@pattern).is_a?(Hash)
return true if @pattern.empty?
matching_hashes?(body_as_hash(body, content_type), @pattern)
elsif (@pattern).is_a?(WebMock::Matchers::HashIncludingMatcher)
@pattern == body_as_hash(body, content_type)
else
empty_string?(@pattern) && empty_string?(body) ||
@pattern == body ||
@pattern === body
end
end
def to_s
@pattern.inspect
end
private
def body_as_hash(body, content_type)
case BODY_FORMATS[content_type]
when :json then
WebMock::Util::JSON.parse(body)
when :xml then
Crack::XML.parse(body)
else
WebMock::Util::QueryMapper.query_to_values(body, :notation => Config.instance.query_values_notation)
end
end
# Compare two hashes for equality
#
# For two hashes to match they must have the same length and all
# values must match when compared using `#===`.
#
# The following hashes are examples of matches:
#
# {a: /\d+/} and {a: '123'}
#
# {a: '123'} and {a: '123'}
#
# {a: {b: /\d+/}} and {a: {b: '123'}}
#
# {a: {b: 'wow'}} and {a: {b: 'wow'}}
#
# @param [Hash] query_parameters typically the result of parsing
# JSON, XML or URL encoded parameters.
#
# @param [Hash] pattern which contains keys with a string, hash or
# regular expression value to use for comparison.
#
# @return [Boolean] true if the paramaters match the comparison
# hash, false if not.
def matching_hashes?(query_parameters, pattern)
return false unless query_parameters.is_a?(Hash)
return false unless query_parameters.keys.sort == pattern.keys.sort
query_parameters.each do |key, actual|
expected = pattern[key]
if actual.is_a?(Hash) && expected.is_a?(Hash)
return false unless matching_hashes?(actual, expected)
else
return false unless expected === actual
end
end
true
end
def empty_string?(string)
string.nil? || string == ""
end
def normalize_hash(hash)
Hash[WebMock::Util::HashKeysStringifier.stringify_keys!(hash, :deep => true).sort]
end
end
class HeadersPattern
def initialize(pattern)
@pattern = WebMock::Util::Headers.normalize_headers(pattern) || {}
end
def matches?(headers)
if empty_headers?(@pattern)
empty_headers?(headers)
else
return false if empty_headers?(headers)
@pattern.each do |key, value|
return false unless headers.has_key?(key) && value === headers[key]
end
true
end
end
def to_s
WebMock::Util::Headers.sorted_headers_string(@pattern)
end
private
def empty_headers?(headers)
headers.nil? || headers == {}
end
end
end
webmock-1.22.6/lib/webmock/deprecation.rb 0000644 0000041 0000041 00000000243 12646134265 020310 0 ustar www-data www-data module WebMock
class Deprecation
class << self
def warning(message)
warn "WebMock deprecation warning: #{message}"
end
end
end
end
webmock-1.22.6/lib/webmock/errors.rb 0000644 0000041 0000041 00000000732 12646134265 017332 0 ustar www-data www-data module WebMock
class NetConnectNotAllowedError < Exception
def initialize(request_signature)
request_signature_snippet = RequestSignatureSnippet.new(request_signature)
text = [
"Real HTTP connections are disabled. Unregistered request: #{request_signature}",
request_signature_snippet.stubbing_instructions,
request_signature_snippet.request_stubs,
"="*60
].compact.join("\n\n")
super(text)
end
end
end
webmock-1.22.6/lib/webmock/response.rb 0000644 0000041 0000041 00000010115 12646134265 017650 0 ustar www-data www-data require "pathname"
#compatibility with Ruby 1.9.2 preview1 to allow reading raw responses
if RUBY_VERSION <= "1.9.2"
class StringIO
alias_method :read_nonblock, :sysread
end
end
module WebMock
class ResponseFactory
def self.response_for(options)
if options.respond_to?(:call)
WebMock::DynamicResponse.new(options)
else
WebMock::Response.new(options)
end
end
end
class Response
def initialize(options = {})
if options.is_a?(IO) || options.is_a?(String)
self.options = read_raw_response(options)
else
self.options = options
end
end
def headers
@headers
end
def headers=(headers)
@headers = headers
if @headers && !@headers.is_a?(Proc)
@headers = Util::Headers.normalize_headers(@headers)
end
end
def body
@body || ''
end
def body=(body)
@body = body
assert_valid_body!
stringify_body!
end
def status
@status || [200, ""]
end
def status=(status)
@status = status.is_a?(Integer) ? [status, ""] : status
end
def exception
@exception
end
def exception=(exception)
@exception = case exception
when String then StandardError.new(exception)
when Class then exception.new('Exception from WebMock')
when Exception then exception
end
end
def raise_error_if_any
raise @exception if @exception
end
def should_timeout
@should_timeout == true
end
def options=(options)
options = WebMock::Util::HashKeysStringifier.stringify_keys!(options)
HashValidator.new(options).validate_keys('headers', 'status', 'body', 'exception', 'should_timeout')
self.headers = options['headers']
self.status = options['status']
self.body = options['body']
self.exception = options['exception']
@should_timeout = options['should_timeout']
end
def evaluate(request_signature)
self.body = @body.call(request_signature) if @body.is_a?(Proc)
self.headers = @headers.call(request_signature) if @headers.is_a?(Proc)
self.status = @status.call(request_signature) if @status.is_a?(Proc)
@should_timeout = @should_timeout.call(request_signature) if @should_timeout.is_a?(Proc)
@exception = @exception.call(request_signature) if @exception.is_a?(Proc)
self
end
def ==(other)
self.body == other.body &&
self.headers === other.headers &&
self.status == other.status &&
self.exception == other.exception &&
self.should_timeout == other.should_timeout
end
private
def stringify_body!
if @body.is_a?(IO) || @body.is_a?(Pathname)
io = @body
@body = io.read
io.close if io.respond_to?(:close)
end
end
def assert_valid_body!
valid_types = [Proc, IO, Pathname, String, Array]
return if @body.nil?
return if valid_types.any? { |c| @body.is_a?(c) }
raise InvalidBody, "must be one of: #{valid_types}. '#{@body.class}' given"
end
def read_raw_response(raw_response)
if raw_response.is_a?(IO)
string = raw_response.read
raw_response.close
raw_response = string
end
socket = ::Net::BufferedIO.new(raw_response)
response = ::Net::HTTPResponse.read_new(socket)
transfer_encoding = response.delete('transfer-encoding') #chunks were already read by curl
response.reading_body(socket, true) {}
options = {}
options[:headers] = {}
response.each_header {|name, value| options[:headers][name] = value}
options[:headers]['transfer-encoding'] = transfer_encoding if transfer_encoding
options[:body] = response.read_body
options[:status] = [response.code.to_i, response.message]
options
end
InvalidBody = Class.new(StandardError)
end
class DynamicResponse < Response
attr_accessor :responder
def initialize(responder)
@responder = responder
end
def evaluate(request_signature)
options = @responder.call(request_signature)
Response.new(options)
end
end
end
webmock-1.22.6/lib/webmock/responses_sequence.rb 0000644 0000041 0000041 00000001243 12646134265 021725 0 ustar www-data www-data module WebMock
class ResponsesSequence
attr_accessor :times_to_repeat
def initialize(responses)
@times_to_repeat = 1
@responses = responses
@current_position = 0
end
def end?
@times_to_repeat == 0
end
def next_response
if @times_to_repeat > 0
response = @responses[@current_position]
increase_position
response
else
@responses.last
end
end
private
def increase_position
if @current_position == (@responses.length - 1)
@current_position = 0
@times_to_repeat -= 1
else
@current_position += 1
end
end
end
end
webmock-1.22.6/lib/webmock/rack_response.rb 0000644 0000041 0000041 00000003323 12646134265 020653 0 ustar www-data www-data module WebMock
class RackResponse < Response
def initialize(app)
@app = app
end
def evaluate(request)
env = build_rack_env(request)
status, headers, response = @app.call(env)
Response.new(
:body => body_from_rack_response(response),
:headers => headers,
:status => status
)
end
def body_from_rack_response(response)
body = ""
response.each { |line| body << line }
response.close if response.respond_to?(:close)
return body
end
def build_rack_env(request)
uri = request.uri
headers = (request.headers || {}).dup
body = request.body || ''
env = {
# CGI variables specified by Rack
'REQUEST_METHOD' => request.method.to_s.upcase,
'CONTENT_TYPE' => headers.delete('Content-Type'),
'CONTENT_LENGTH' => body.bytesize,
'PATH_INFO' => uri.path,
'QUERY_STRING' => uri.query || '',
'SERVER_NAME' => uri.host,
'SERVER_PORT' => uri.port,
'SCRIPT_NAME' => ""
}
env['HTTP_AUTHORIZATION'] = 'Basic ' + [uri.userinfo].pack('m').delete("\r\n") if uri.userinfo
# Rack-specific variables
env['rack.input'] = StringIO.new(body)
env['rack.errors'] = $stderr
env['rack.version'] = Rack::VERSION
env['rack.url_scheme'] = uri.scheme
env['rack.run_once'] = true
env['rack.session'] = session
env['rack.session.options'] = session_options
headers.each do |k, v|
env["HTTP_#{k.tr('-','_').upcase}"] = v
end
env
end
def session
@session ||= {}
end
def session_options
@session_options ||= {}
end
end
end
webmock-1.22.6/lib/webmock/assertion_failure.rb 0000644 0000041 0000041 00000000332 12646134265 021530 0 ustar www-data www-data module WebMock
class AssertionFailure
@error_class = RuntimeError
class << self
attr_accessor :error_class
def failure(message)
raise @error_class.new(message)
end
end
end
end
webmock-1.22.6/lib/webmock/minitest.rb 0000644 0000041 0000041 00000001753 12646134265 017656 0 ustar www-data www-data begin
require 'minitest/test'
test_class = Minitest::Test
assertions = "assertions"
rescue LoadError
require "minitest/unit"
test_class = MiniTest::Unit::TestCase
assertions = "_assertions"
end
require 'webmock'
test_class.class_eval do
include WebMock::API
alias_method :teardown_without_webmock, :teardown
def teardown_with_webmock
teardown_without_webmock
WebMock.reset!
end
alias_method :teardown, :teardown_with_webmock
[:assert_request_requested, :assert_request_not_requested].each do |name|
alias_method :"#{name}_without_assertions_count", name
define_method :"#{name}_with_assertions_count" do |*args|
self.send("#{assertions}=", self.send("#{assertions}") + 1)
send :"#{name}_without_assertions_count", *args
end
alias_method name, :"#{name}_with_assertions_count"
end
end
begin
error_class = MiniTest::Assertion
rescue NameError
error_class = Minitest::Assertion
end
WebMock::AssertionFailure.error_class = error_class
webmock-1.22.6/lib/webmock/cucumber.rb 0000644 0000041 0000041 00000000172 12646134265 017621 0 ustar www-data www-data require 'webmock'
require 'webmock/rspec/matchers'
World(WebMock::API, WebMock::Matchers)
After do
WebMock.reset!
end
webmock-1.22.6/lib/webmock/test_unit.rb 0000644 0000041 0000041 00000000710 12646134265 020030 0 ustar www-data www-data require 'test/unit'
require 'webmock'
module Test
module Unit
class TestCase
include WebMock::API
alias_method :teardown_without_webmock, :teardown
def teardown_with_webmock
teardown_without_webmock
WebMock.reset!
end
alias_method :teardown, :teardown_with_webmock
end
end
end
WebMock::AssertionFailure.error_class = Test::Unit::AssertionFailedError rescue MiniTest::Assertion # ruby1.9 compat
webmock-1.22.6/lib/webmock/http_lib_adapters/ 0000755 0000041 0000041 00000000000 12646134265 021157 5 ustar www-data www-data webmock-1.22.6/lib/webmock/http_lib_adapters/em_http_request_adapter.rb 0000644 0000041 0000041 00000000501 12646134265 026410 0 ustar www-data www-data begin
require 'em-http-request'
rescue LoadError
# em-http-request not found
end
if defined?(EventMachine::HttpConnection)
require File.expand_path(File.dirname(__FILE__) + '/em_http_request/em_http_request_1_x')
else
require File.expand_path(File.dirname(__FILE__) + '/em_http_request/em_http_request_0_x')
end
webmock-1.22.6/lib/webmock/http_lib_adapters/http_lib_adapter_registry.rb 0000644 0000041 0000041 00000000511 12646134265 026736 0 ustar www-data www-data module WebMock
class HttpLibAdapterRegistry
include Singleton
attr_accessor :http_lib_adapters
def initialize
@http_lib_adapters = {}
end
def register(lib, adapter)
@http_lib_adapters[lib] = adapter
end
def each_adapter(&block)
@http_lib_adapters.each(&block)
end
end
end webmock-1.22.6/lib/webmock/http_lib_adapters/em_http_request/ 0000755 0000041 0000041 00000000000 12646134265 024367 5 ustar www-data www-data webmock-1.22.6/lib/webmock/http_lib_adapters/em_http_request/em_http_request_1_x.rb 0000644 0000041 0000041 00000016177 12646134265 030707 0 ustar www-data www-data if defined?(EventMachine::HttpClient)
module WebMock
module HttpLibAdapters
class EmHttpRequestAdapter < HttpLibAdapter
adapter_for :em_http_request
OriginalHttpClient = EventMachine::HttpClient unless const_defined?(:OriginalHttpClient)
OriginalHttpConnection = EventMachine::HttpConnection unless const_defined?(:OriginalHttpConnection)
def self.enable!
EventMachine.send(:remove_const, :HttpConnection)
EventMachine.send(:const_set, :HttpConnection, EventMachine::WebMockHttpConnection)
EventMachine.send(:remove_const, :HttpClient)
EventMachine.send(:const_set, :HttpClient, EventMachine::WebMockHttpClient)
end
def self.disable!
EventMachine.send(:remove_const, :HttpConnection)
EventMachine.send(:const_set, :HttpConnection, OriginalHttpConnection)
EventMachine.send(:remove_const, :HttpClient)
EventMachine.send(:const_set, :HttpClient, OriginalHttpClient)
end
end
end
end
module EventMachine
if defined?(Synchrony) && HTTPMethods.instance_methods.include?(:aget)
# have to make the callbacks fire on the next tick in order
# to avoid the dreaded "double resume" exception
module HTTPMethods
%w[get head post delete put].each do |type|
class_eval %[
def #{type}(options = {}, &blk)
f = Fiber.current
conn = setup_request(:#{type}, options, &blk)
conn.callback { EM.next_tick { f.resume(conn) } }
conn.errback { EM.next_tick { f.resume(conn) } }
Fiber.yield
end
]
end
end
end
class WebMockHttpConnection < HttpConnection
def activate_connection(client)
request_signature = client.request_signature
if client.stubbed_webmock_response
conn = HttpStubConnection.new rand(10000)
post_init
@deferred = false
@conn = conn
conn.parent = self
conn.pending_connect_timeout = @connopts.connect_timeout
conn.comm_inactivity_timeout = @connopts.inactivity_timeout
finalize_request(client)
@conn.set_deferred_status :succeeded
elsif WebMock.net_connect_allowed?(request_signature.uri)
super
else
raise WebMock::NetConnectNotAllowedError.new(request_signature)
end
end
def drop_client
@clients.shift
end
end
class WebMockHttpClient < EventMachine::HttpClient
include HttpEncoding
def uri
@req.uri
end
def setup(response, uri, error = nil)
@last_effective_url = @uri = uri
if error
on_error(error)
@conn.drop_client
fail(self)
else
@conn.receive_data(response)
succeed(self)
end
end
def send_request(head, body)
WebMock::RequestRegistry.instance.requested_signatures.put(request_signature)
if stubbed_webmock_response
WebMock::CallbackRegistry.invoke_callbacks({:lib => :em_http_request}, request_signature, stubbed_webmock_response)
@uri ||= nil
EM.next_tick {
setup(make_raw_response(stubbed_webmock_response), @uri,
stubbed_webmock_response.should_timeout ? "WebMock timeout error" : nil)
}
self
elsif WebMock.net_connect_allowed?(request_signature.uri)
super
else
raise WebMock::NetConnectNotAllowedError.new(request_signature)
end
end
def unbind(reason = nil)
if !stubbed_webmock_response && WebMock::CallbackRegistry.any_callbacks?
webmock_response = build_webmock_response
WebMock::CallbackRegistry.invoke_callbacks(
{:lib => :em_http_request, :real_request => true},
request_signature,
webmock_response)
end
@request_signature = nil
remove_instance_variable(:@stubbed_webmock_response)
super
end
def request_signature
@request_signature ||= build_request_signature
end
def stubbed_webmock_response
unless defined?(@stubbed_webmock_response)
@stubbed_webmock_response = WebMock::StubRegistry.instance.response_for_request(request_signature)
end
@stubbed_webmock_response
end
def get_response_cookie(name)
name = name.to_s
raw_cookie = response_header.cookie
raw_cookie = [raw_cookie] if raw_cookie.is_a? String
cookie = raw_cookie.select { |c| c.start_with? name }.first
cookie and cookie.split('=', 2)[1]
end
private
def build_webmock_response
webmock_response = WebMock::Response.new
webmock_response.status = [response_header.status, response_header.http_reason]
webmock_response.headers = response_header
webmock_response.body = response
webmock_response
end
def build_request_signature
headers, body = @req.headers, @req.body
@conn.middleware.select {|m| m.respond_to?(:request) }.each do |m|
headers, body = m.request(self, headers, body)
end
method = @req.method
uri = @req.uri.clone
auth = @req.headers[:'proxy-authorization']
query = @req.query
if auth
userinfo = auth.join(':')
userinfo = WebMock::Util::URI.encode_unsafe_chars_in_userinfo(userinfo)
if @req
@req.proxy.reject! {|k,v| t.to_s == 'authorization' }
else
options.reject! {|k,v| k.to_s == 'authorization' } #we added it to url userinfo
end
uri.userinfo = userinfo
end
uri.query = encode_query(@req.uri, query).slice(/\?(.*)/, 1)
body = form_encode_body(body) if body.is_a?(Hash)
WebMock::RequestSignature.new(
method.downcase.to_sym,
uri.to_s,
:body => body || (@req.file && File.read(@req.file)),
:headers => headers
)
end
def make_raw_response(response)
response.raise_error_if_any
status, headers, body = response.status, response.headers, response.body
headers ||= {}
response_string = []
response_string << "HTTP/1.1 #{status[0]} #{status[1]}"
headers["Content-Length"] = body.bytesize unless headers["Content-Length"]
headers.each do |header, value|
if header =~ /set-cookie/i
[value].flatten.each do |cookie|
response_string << "#{header}: #{cookie}"
end
else
value = value.join(", ") if value.is_a?(Array)
# WebMock's internal processing will not handle the body
# correctly if the header indicates that it is chunked, unless
# we also create all the chunks.
# It's far easier just to remove the header.
next if header =~ /transfer-encoding/i && value =~/chunked/i
response_string << "#{header}: #{value}"
end
end if headers
response_string << "" << body
response_string.join("\n")
end
end
end
end
webmock-1.22.6/lib/webmock/http_lib_adapters/em_http_request/em_http_request_0_x.rb 0000644 0000041 0000041 00000011073 12646134265 030674 0 ustar www-data www-data if defined?(EventMachine::HttpRequest)
module WebMock
module HttpLibAdapters
class EmHttpRequestAdapter < HttpLibAdapter
adapter_for :em_http_request
OriginalHttpRequest = EventMachine::HttpRequest unless const_defined?(:OriginalHttpRequest)
def self.enable!
EventMachine.send(:remove_const, :HttpRequest)
EventMachine.send(:const_set, :HttpRequest, EventMachine::WebMockHttpRequest)
end
def self.disable!
EventMachine.send(:remove_const, :HttpRequest)
EventMachine.send(:const_set, :HttpRequest, OriginalHttpRequest)
end
end
end
end
module EventMachine
class WebMockHttpRequest < EventMachine::HttpRequest
include HttpEncoding
class WebMockHttpClient < EventMachine::HttpClient
def setup(response, uri, error = nil)
@last_effective_url = @uri = uri
if error
on_error(error)
fail(self)
else
EM.next_tick do
receive_data(response)
succeed(self)
end
end
end
def unbind
end
def close_connection
end
end
def send_request(&block)
request_signature = build_request_signature
WebMock::RequestRegistry.instance.requested_signatures.put(request_signature)
if webmock_response = WebMock::StubRegistry.instance.response_for_request(request_signature)
WebMock::CallbackRegistry.invoke_callbacks(
{:lib => :em_http_request}, request_signature, webmock_response)
client = WebMockHttpClient.new(nil)
client.on_error("WebMock timeout error") if webmock_response.should_timeout
client.setup(make_raw_response(webmock_response), @uri,
webmock_response.should_timeout ? "WebMock timeout error" : nil)
client
elsif WebMock.net_connect_allowed?(request_signature.uri)
http = super
http.callback {
if WebMock::CallbackRegistry.any_callbacks?
webmock_response = build_webmock_response(http)
WebMock::CallbackRegistry.invoke_callbacks(
{:lib => :em_http_request, :real_request => true}, request_signature,
webmock_response)
end
}
http
else
raise WebMock::NetConnectNotAllowedError.new(request_signature)
end
end
private
def build_webmock_response(http)
webmock_response = WebMock::Response.new
webmock_response.status = [http.response_header.status, http.response_header.http_reason]
webmock_response.headers = http.response_header
webmock_response.body = http.response
webmock_response
end
def build_request_signature
if @req
options = @req.options
method = @req.method
uri = @req.uri.dup
else
options = @options
method = @method
uri = @uri.dup
end
if options[:authorization] || options['authorization']
auth = (options[:authorization] || options['authorization'])
userinfo = auth.join(':')
userinfo = WebMock::Util::URI.encode_unsafe_chars_in_userinfo(userinfo)
options.reject! {|k,v| k.to_s == 'authorization' } #we added it to url userinfo
uri.userinfo = userinfo
end
uri.query = encode_query(@req.uri, options[:query]).slice(/\?(.*)/, 1)
body = options[:body] || options['body']
body = form_encode_body(body) if body.is_a?(Hash)
WebMock::RequestSignature.new(
method.downcase.to_sym,
uri.to_s,
:body => body,
:headers => (options[:head] || options['head'])
)
end
def make_raw_response(response)
response.raise_error_if_any
status, headers, body = response.status, response.headers, response.body
response_string = []
response_string << "HTTP/1.1 #{status[0]} #{status[1]}"
headers.each do |header, value|
value = value.join(", ") if value.is_a?(Array)
# WebMock's internal processing will not handle the body
# correctly if the header indicates that it is chunked, unless
# we also create all the chunks.
# It's far easier just to remove the header.
next if header =~ /transfer-encoding/i && value =~/chunked/i
response_string << "#{header}: #{value}"
end if headers
response_string << "" << body
response_string.join("\n")
end
end
end
end
webmock-1.22.6/lib/webmock/http_lib_adapters/net_http.rb 0000644 0000041 0000041 00000024534 12646134265 023341 0 ustar www-data www-data require 'net/http'
require 'net/https'
require 'stringio'
require File.join(File.dirname(__FILE__), 'net_http_response')
module WebMock
module HttpLibAdapters
class NetHttpAdapter < HttpLibAdapter
adapter_for :net_http
OriginalNetHTTP = Net::HTTP unless const_defined?(:OriginalNetHTTP)
OriginalNetBufferedIO = Net::BufferedIO unless const_defined?(:OriginalNetBufferedIO)
def self.enable!
Net.send(:remove_const, :BufferedIO)
Net.send(:remove_const, :HTTP)
Net.send(:remove_const, :HTTPSession)
Net.send(:const_set, :HTTP, @webMockNetHTTP)
Net.send(:const_set, :HTTPSession, @webMockNetHTTP)
Net.send(:const_set, :BufferedIO, Net::WebMockNetBufferedIO)
end
def self.disable!
Net.send(:remove_const, :BufferedIO)
Net.send(:remove_const, :HTTP)
Net.send(:remove_const, :HTTPSession)
Net.send(:const_set, :HTTP, OriginalNetHTTP)
Net.send(:const_set, :HTTPSession, OriginalNetHTTP)
Net.send(:const_set, :BufferedIO, OriginalNetBufferedIO)
#copy all constants from @webMockNetHTTP to original Net::HTTP
#in case any constants were added to @webMockNetHTTP instead of Net::HTTP
#after WebMock was enabled.
#i.e Net::HTTP::DigestAuth
@webMockNetHTTP.constants.each do |constant|
if !OriginalNetHTTP.constants.map(&:to_s).include?(constant.to_s)
OriginalNetHTTP.send(:const_set, constant, @webMockNetHTTP.const_get(constant))
end
end
end
@webMockNetHTTP = Class.new(Net::HTTP) do
class << self
def socket_type
StubSocket
end
if Module.method(:const_defined?).arity == 1
def const_defined?(name)
super || self.superclass.const_defined?(name)
end
else
def const_defined?(name, inherit=true)
super || self.superclass.const_defined?(name, inherit)
end
end
if Module.method(:const_get).arity != 1
def const_get(name, inherit=true)
super
rescue NameError
self.superclass.const_get(name, inherit)
end
end
if Module.method(:constants).arity != 0
def constants(inherit=true)
(super + self.superclass.constants(inherit)).uniq
end
end
end
def request(request, body = nil, &block)
request_signature = WebMock::NetHTTPUtility.request_signature_from_request(self, request, body)
WebMock::RequestRegistry.instance.requested_signatures.put(request_signature)
if webmock_response = WebMock::StubRegistry.instance.response_for_request(request_signature)
@socket = Net::HTTP.socket_type.new
WebMock::CallbackRegistry.invoke_callbacks(
{:lib => :net_http}, request_signature, webmock_response)
build_net_http_response(webmock_response, &block)
elsif WebMock.net_connect_allowed?(request_signature.uri)
check_right_http_connection
after_request = lambda do |response|
if WebMock::CallbackRegistry.any_callbacks?
webmock_response = build_webmock_response(response)
WebMock::CallbackRegistry.invoke_callbacks(
{:lib => :net_http, :real_request => true}, request_signature, webmock_response)
end
response.extend Net::WebMockHTTPResponse
block.call response if block
response
end
super_with_after_request = lambda {
response = super(request, nil, &nil)
after_request.call(response)
}
if started?
if WebMock::Config.instance.net_http_connect_on_start
super_with_after_request.call
else
start_with_connect_without_finish {
super_with_after_request.call
}
end
else
start_with_connect {
super_with_after_request.call
}
end
else
raise WebMock::NetConnectNotAllowedError.new(request_signature)
end
end
def start_without_connect
raise IOError, 'HTTP session already opened' if @started
if block_given?
begin
@started = true
return yield(self)
ensure
do_finish
end
end
@started = true
self
end
def start_with_connect_without_finish # :yield: http
if block_given?
begin
do_start
return yield(self)
end
end
do_start
self
end
alias_method :start_with_connect, :start
def start(&block)
if WebMock::Config.instance.net_http_connect_on_start
super(&block)
else
start_without_connect(&block)
end
end
def build_net_http_response(webmock_response, &block)
response = Net::HTTPResponse.send(:response_class, webmock_response.status[0].to_s).new("1.0", webmock_response.status[0].to_s, webmock_response.status[1])
body = webmock_response.body
body = nil if body.to_s == ''
response.instance_variable_set(:@body, body)
webmock_response.headers.to_a.each do |name, values|
values = [values] unless values.is_a?(Array)
values.each do |value|
response.add_field(name, value)
end
end
response.instance_variable_set(:@read, true)
response.extend Net::WebMockHTTPResponse
raise Timeout::Error, "execution expired" if webmock_response.should_timeout
webmock_response.raise_error_if_any
yield response if block_given?
response
end
def build_webmock_response(net_http_response)
webmock_response = WebMock::Response.new
webmock_response.status = [
net_http_response.code.to_i,
net_http_response.message]
webmock_response.headers = net_http_response.to_hash
webmock_response.body = net_http_response.body
webmock_response
end
def check_right_http_connection
unless @@alredy_checked_for_right_http_connection ||= false
WebMock::NetHTTPUtility.puts_warning_for_right_http_if_needed
@@alredy_checked_for_right_http_connection = true
end
end
end
@webMockNetHTTP.version_1_2
[
[:Get, Net::HTTP::Get],
[:Post, Net::HTTP::Post],
[:Put, Net::HTTP::Put],
[:Delete, Net::HTTP::Delete],
[:Head, Net::HTTP::Head],
[:Options, Net::HTTP::Options]
].each do |c|
@webMockNetHTTP.const_set(c[0], c[1])
end
end
end
end
# patch for StringIO behavior in Ruby 2.2.3
# https://github.com/bblimke/webmock/issues/558
class PatchedStringIO < StringIO #:nodoc:
alias_method :orig_read_nonblock, :read_nonblock
def read_nonblock(size, *args)
orig_read_nonblock(size)
end
end
class StubSocket #:nodoc:
attr_accessor :read_timeout, :continue_timeout
def initialize(*args)
end
def closed?
@closed ||= true
end
def readuntil(*args)
end
end
module Net #:nodoc: all
class WebMockNetBufferedIO < BufferedIO
def initialize(io, debug_output = nil)
@read_timeout = 60
@rbuf = ''
@debug_output = debug_output
@io = case io
when Socket, OpenSSL::SSL::SSLSocket, IO
io
when StringIO
PatchedStringIO.new(io.string)
when String
PatchedStringIO.new(io)
end
raise "Unable to create local socket" unless @io
end
end
end
module WebMock
module NetHTTPUtility
def self.request_signature_from_request(net_http, request, body = nil)
protocol = net_http.use_ssl? ? "https" : "http"
path = request.path
if path.respond_to?(:request_uri) #https://github.com/bblimke/webmock/issues/288
path = path.request_uri
end
path = WebMock::Util::URI.heuristic_parse(path).request_uri if path =~ /^http/
if request["authorization"] =~ /^Basic /
userinfo = WebMock::Util::Headers.decode_userinfo_from_header(request["authorization"])
userinfo = WebMock::Util::URI.encode_unsafe_chars_in_userinfo(userinfo) + "@"
else
userinfo = ""
end
uri = "#{protocol}://#{userinfo}#{net_http.address}:#{net_http.port}#{path}"
method = request.method.downcase.to_sym
headers = Hash[*request.to_hash.map {|k,v| [k, v]}.inject([]) {|r,x| r + x}]
validate_headers(headers)
headers.reject! {|k,v| k =~ /[Aa]uthorization/ && v.first =~ /^Basic / } #we added it to url userinfo
if request.body_stream
body = request.body_stream.read
request.body_stream = nil
end
if body != nil && body.respond_to?(:read)
request.set_body_internal body.read
else
request.set_body_internal body
end
WebMock::RequestSignature.new(method, uri, :body => request.body, :headers => headers)
end
def self.validate_headers(headers)
# If you make a request with headers that are symbols Net::HTTP raises a NoMethodError
#
# WebMock normalizes headers when creating a RequestSignature,
# and will update all headers from symbols to strings.
#
# This could create a false positive in a test suite with WebMock.
#
# So before this point, WebMock raises an ArgumentError if any of the headers are symbols
# instead of the cryptic NoMethodError "undefined method `split' ...` from Net::HTTP
header_as_symbol = headers.keys.find {|header| header.is_a? Symbol}
if header_as_symbol
raise ArgumentError.new("Net:HTTP does not accept headers as symbols")
end
end
def self.check_right_http_connection
@was_right_http_connection_loaded = defined?(RightHttpConnection)
end
def self.puts_warning_for_right_http_if_needed
if !@was_right_http_connection_loaded && defined?(RightHttpConnection)
$stderr.puts "\nWarning: RightHttpConnection has to be required before WebMock is required !!!\n"
end
end
end
end
WebMock::NetHTTPUtility.check_right_http_connection
webmock-1.22.6/lib/webmock/http_lib_adapters/http_rb_adapter.rb 0000644 0000041 0000041 00000001504 12646134265 024646 0 ustar www-data www-data begin
require "http"
rescue LoadError
# HTTP gem not found
end
if defined?(HTTP) && defined?(HTTP::VERSION)
WebMock::VersionChecker.new("HTTP Gem", HTTP::VERSION, "0.6.0").check_version!
module WebMock
module HttpLibAdapters
class HttpRbAdapter < HttpLibAdapter
adapter_for :http_rb
class << self
def enable!
@enabled = true
end
def disable!
@enabled = false
end
def enabled?
@enabled
end
end
end
end
end
require "webmock/http_lib_adapters/http_rb/client"
require "webmock/http_lib_adapters/http_rb/request"
require "webmock/http_lib_adapters/http_rb/response"
require "webmock/http_lib_adapters/http_rb/streamer"
require "webmock/http_lib_adapters/http_rb/webmock"
end
webmock-1.22.6/lib/webmock/http_lib_adapters/net_http_response.rb 0000644 0000041 0000041 00000002362 12646134265 025252 0 ustar www-data www-data # This code is entierly copied from VCR (http://github.com/myronmarston/vcr) by courtesy of Myron Marston
# A Net::HTTP response that has already been read raises an IOError when #read_body
# is called with a destination string or block.
#
# This causes a problem when VCR records a response--it reads the body before yielding
# the response, and if the code that is consuming the HTTP requests uses #read_body, it
# can cause an error.
#
# This is a bit of a hack, but it allows a Net::HTTP response to be "re-read"
# after it has aleady been read. This attemps to preserve the behavior of
# #read_body, acting just as if it had never been read.
module Net
module WebMockHTTPResponse
def read_body(dest = nil, &block)
if !(defined?(@__read_body_previously_called).nil?) && @__read_body_previously_called
return super
end
return @body if dest.nil? && block.nil?
raise ArgumentError.new("both arg and block given for HTTP method") if dest && block
return nil if @body.nil?
dest ||= ::Net::ReadAdapter.new(block)
dest << @body
@body = dest
ensure
# allow subsequent calls to #read_body to proceed as normal, without our hack...
@__read_body_previously_called = true
end
end
end
webmock-1.22.6/lib/webmock/http_lib_adapters/http_rb/ 0000755 0000041 0000041 00000000000 12646134265 022621 5 ustar www-data www-data webmock-1.22.6/lib/webmock/http_lib_adapters/http_rb/streamer.rb 0000644 0000041 0000041 00000000752 12646134265 024774 0 ustar www-data www-data module HTTP
class Response
class Streamer
def initialize(str)
@io = StringIO.new str
end
def readpartial(size = nil)
unless size
if defined?(HTTP::Client::BUFFER_SIZE)
size = HTTP::Client::BUFFER_SIZE
elsif defined?(HTTP::Connection::BUFFER_SIZE)
size = HTTP::Connection::BUFFER_SIZE
end
end
@io.read size
end
def sequence_id
-1
end
end
end
end
webmock-1.22.6/lib/webmock/http_lib_adapters/http_rb/response.rb 0000644 0000041 0000041 00000002101 12646134265 024776 0 ustar www-data www-data module HTTP
class Response
def to_webmock
webmock_response = ::WebMock::Response.new
webmock_response.status = [status.to_i, reason]
webmock_response.body = body.to_s
webmock_response.headers = headers.to_h
webmock_response
end
class << self
def from_webmock(webmock_response, request_signature = nil)
status = Status.new(webmock_response.status.first)
headers = webmock_response.headers || {}
body = Body.new Streamer.new webmock_response.body
uri = normalize_uri(request_signature && request_signature.uri)
return new(status, "1.1", headers, body, uri) if HTTP::VERSION < "1.0.0"
new({
:status => status,
:version => "1.1",
:headers => headers,
:body => body,
:uri => uri
})
end
private
def normalize_uri(uri)
return unless uri
uri = URI.parse uri
uri.port = nil if uri.default_port && uri.port == uri.default_port
uri
end
end
end
end
webmock-1.22.6/lib/webmock/http_lib_adapters/http_rb/client.rb 0000644 0000041 0000041 00000000537 12646134265 024431 0 ustar www-data www-data module HTTP
class Client
alias_method :__perform__, :perform
def perform(request, options)
return __perform__(request, options) unless webmock_enabled?
WebMockPerform.new(request) { __perform__(request, options) }.exec
end
def webmock_enabled?
::WebMock::HttpLibAdapters::HttpRbAdapter.enabled?
end
end
end
webmock-1.22.6/lib/webmock/http_lib_adapters/http_rb/request.rb 0000644 0000041 0000041 00000000306 12646134265 024635 0 ustar www-data www-data module HTTP
class Request
def webmock_signature
::WebMock::RequestSignature.new(verb, uri.to_s, {
:headers => headers.to_h,
:body => body
})
end
end
end
webmock-1.22.6/lib/webmock/http_lib_adapters/http_rb/webmock.rb 0000644 0000041 0000041 00000003334 12646134265 024600 0 ustar www-data www-data module HTTP
class WebMockPerform
def initialize(request, &perform)
@request = request
@perform = perform
@request_signature = nil
end
def exec
replay || perform || halt
end
def request_signature
unless @request_signature
@request_signature = @request.webmock_signature
register_request(@request_signature)
end
@request_signature
end
protected
def response_for_request(signature)
::WebMock::StubRegistry.instance.response_for_request(signature)
end
def register_request(signature)
::WebMock::RequestRegistry.instance.requested_signatures.put(signature)
end
def replay
webmock_response = response_for_request request_signature
return unless webmock_response
raise_timeout_error if webmock_response.should_timeout
webmock_response.raise_error_if_any
invoke_callbacks(webmock_response, :real_request => false)
::HTTP::Response.from_webmock webmock_response, request_signature
end
def raise_timeout_error
raise Errno::ETIMEDOUT if HTTP::VERSION < "1.0.0"
raise HTTP::ConnectionError, "connection error: #{Errno::ETIMEDOUT.new}"
end
def perform
return unless ::WebMock.net_connect_allowed?(request_signature.uri)
response = @perform.call
invoke_callbacks(response.to_webmock, :real_request => true)
response
end
def halt
raise ::WebMock::NetConnectNotAllowedError.new request_signature
end
def invoke_callbacks(webmock_response, options = {})
::WebMock::CallbackRegistry.invoke_callbacks(
options.merge({ :lib => :http_rb }),
request_signature,
webmock_response
)
end
end
end
webmock-1.22.6/lib/webmock/http_lib_adapters/typhoeus_hydra_adapter.rb 0000644 0000041 0000041 00000013241 12646134265 026254 0 ustar www-data www-data begin
require 'typhoeus'
rescue LoadError
# typhoeus not found
end
if defined?(Typhoeus)
WebMock::VersionChecker.new('Typhoeus', Typhoeus::VERSION, '0.3.2').check_version!
module WebMock
module HttpLibAdapters
class TyphoeusAdapter < HttpLibAdapter
adapter_for :typhoeus
def self.enable!
@disabled = false
add_before_callback
add_after_request_callback
::Typhoeus::Config.block_connection = true
end
def self.disable!
@disabled = true
remove_after_request_callback
remove_before_callback
::Typhoeus::Config.block_connection = false
end
def self.disabled?
!!@disabled
end
def self.add_before_callback
unless Typhoeus.before.include?(BEFORE_CALLBACK)
Typhoeus.before << BEFORE_CALLBACK
end
end
def self.remove_before_callback
Typhoeus.before.delete_if {|v| v == BEFORE_CALLBACK }
end
def self.add_after_request_callback
unless Typhoeus.on_complete.include?(AFTER_REQUEST_CALLBACK)
Typhoeus.on_complete << AFTER_REQUEST_CALLBACK
end
end
def self.remove_after_request_callback
Typhoeus.on_complete.delete_if {|v| v == AFTER_REQUEST_CALLBACK }
end
def self.build_request_signature(req)
uri = WebMock::Util::URI.heuristic_parse(req.url)
uri.path = uri.normalized_path.gsub("[^:]//","/")
if req.options[:userpwd]
uri.user, uri.password = req.options[:userpwd].split(':')
end
body = req.options[:body]
if body.is_a?(Hash)
body = WebMock::Util::QueryMapper.values_to_query(body)
end
request_signature = WebMock::RequestSignature.new(
req.options[:method] || :get,
uri.to_s,
:body => body,
:headers => req.options[:headers]
)
req.instance_variable_set(:@__webmock_request_signature, request_signature)
request_signature
end
def self.build_webmock_response(typhoeus_response)
webmock_response = WebMock::Response.new
webmock_response.status = [typhoeus_response.code, typhoeus_response.status_message]
webmock_response.body = typhoeus_response.body
webmock_response.headers = typhoeus_response.headers
webmock_response
end
def self.generate_typhoeus_response(request_signature, webmock_response)
response = if webmock_response.should_timeout
::Typhoeus::Response.new(
:code => 0,
:status_message => "",
:body => "",
:headers => {},
:return_code => :operation_timedout
)
else
::Typhoeus::Response.new(
:code => webmock_response.status[0],
:status_message => webmock_response.status[1],
:body => webmock_response.body,
:headers => webmock_response.headers,
:effective_url => request_signature.uri
)
end
response.mock = :webmock
response
end
def self.request_hash(request_signature)
hash = {}
hash[:body] = request_signature.body
hash[:headers] = request_signature.headers
hash
end
AFTER_REQUEST_CALLBACK = Proc.new do |response|
request = response.request
request_signature = request.instance_variable_get(:@__webmock_request_signature)
webmock_response =
::WebMock::HttpLibAdapters::TyphoeusAdapter.
build_webmock_response(response)
if response.mock
WebMock::CallbackRegistry.invoke_callbacks(
{:lib => :typhoeus},
request_signature,
webmock_response
)
else
WebMock::CallbackRegistry.invoke_callbacks(
{:lib => :typhoeus, :real_request => true},
request_signature,
webmock_response
)
end
end
BEFORE_CALLBACK = Proc.new do |request|
Typhoeus::Expectation.all.delete_if {|e| e.from == :webmock }
res = true
unless WebMock::HttpLibAdapters::TyphoeusAdapter.disabled?
request_signature = ::WebMock::HttpLibAdapters::TyphoeusAdapter.build_request_signature(request)
request.block_connection = false;
::WebMock::RequestRegistry.instance.requested_signatures.put(request_signature)
if webmock_response = ::WebMock::StubRegistry.instance.response_for_request(request_signature)
# ::WebMock::HttpLibAdapters::TyphoeusAdapter.stub_typhoeus(request_signature, webmock_response, self)
response = ::WebMock::HttpLibAdapters::TyphoeusAdapter.generate_typhoeus_response(request_signature, webmock_response)
if request.respond_to?(:on_headers)
request.execute_headers_callbacks(response)
end
if request.respond_to?(:streaming?) && request.streaming?
response.options[:response_body] = ""
request.on_body.each { |callback| callback.call(webmock_response.body, response) }
end
request.finish(response)
webmock_response.raise_error_if_any
res = false
elsif !WebMock.net_connect_allowed?(request_signature.uri)
raise WebMock::NetConnectNotAllowedError.new(request_signature)
end
end
res
end
end
end
end
end
webmock-1.22.6/lib/webmock/http_lib_adapters/http_lib_adapter.rb 0000644 0000041 0000041 00000000230 12646134265 025004 0 ustar www-data www-data module WebMock
class HttpLibAdapter
def self.adapter_for(lib)
WebMock::HttpLibAdapterRegistry.instance.register(lib, self)
end
end
end webmock-1.22.6/lib/webmock/http_lib_adapters/patron_adapter.rb 0000644 0000041 0000041 00000011036 12646134265 024510 0 ustar www-data www-data begin
require 'patron'
rescue LoadError
# patron not found
end
if defined?(::Patron)
module WebMock
module HttpLibAdapters
class PatronAdapter < ::WebMock::HttpLibAdapter
adapter_for :patron
OriginalPatronSession = ::Patron::Session unless const_defined?(:OriginalPatronSession)
class WebMockPatronSession < ::Patron::Session
def handle_request(req)
request_signature =
WebMock::HttpLibAdapters::PatronAdapter.build_request_signature(req)
WebMock::RequestRegistry.instance.requested_signatures.put(request_signature)
if webmock_response = WebMock::StubRegistry.instance.response_for_request(request_signature)
WebMock::HttpLibAdapters::PatronAdapter.
handle_file_name(req, webmock_response)
res = WebMock::HttpLibAdapters::PatronAdapter.
build_patron_response(webmock_response, default_response_charset)
WebMock::CallbackRegistry.invoke_callbacks(
{:lib => :patron}, request_signature, webmock_response)
res
elsif WebMock.net_connect_allowed?(request_signature.uri)
res = super
if WebMock::CallbackRegistry.any_callbacks?
webmock_response = WebMock::HttpLibAdapters::PatronAdapter.
build_webmock_response(res)
WebMock::CallbackRegistry.invoke_callbacks(
{:lib => :patron, :real_request => true}, request_signature,
webmock_response)
end
res
else
raise WebMock::NetConnectNotAllowedError.new(request_signature)
end
end
end
def self.enable!
Patron.send(:remove_const, :Session)
Patron.send(:const_set, :Session, WebMockPatronSession)
end
def self.disable!
Patron.send(:remove_const, :Session)
Patron.send(:const_set, :Session, OriginalPatronSession)
end
def self.handle_file_name(req, webmock_response)
if req.action == :get && req.file_name
begin
File.open(req.file_name, "w") do |f|
f.write webmock_response.body
end
rescue Errno::EACCES
raise ArgumentError.new("Unable to open specified file.")
end
end
end
def self.build_request_signature(req)
uri = WebMock::Util::URI.heuristic_parse(req.url)
uri.path = uri.normalized_path.gsub("[^:]//","/")
uri.user = req.username
uri.password = req.password
if [:put, :post].include?(req.action)
if req.file_name
if !File.exist?(req.file_name) || !File.readable?(req.file_name)
raise ArgumentError.new("Unable to open specified file.")
end
request_body = File.read(req.file_name)
elsif req.upload_data
request_body = req.upload_data
else
raise ArgumentError.new("Must provide either data or a filename when doing a PUT or POST")
end
end
request_signature = WebMock::RequestSignature.new(
req.action,
uri.to_s,
:body => request_body,
:headers => req.headers
)
request_signature
end
def self.build_patron_response(webmock_response, default_response_charset)
raise ::Patron::TimeoutError if webmock_response.should_timeout
webmock_response.raise_error_if_any
header_fields = (webmock_response.headers || []).map { |(k, vs)| Array(vs).map { |v| "#{k}: #{v}" } }.flatten
status_line = "HTTP/1.1 #{webmock_response.status[0]} #{webmock_response.status[1]}"
header_data = ([status_line] + header_fields).join("\r\n")
::Patron::Response.new(
"",
webmock_response.status[0],
0,
header_data,
webmock_response.body,
default_response_charset
)
end
def self.build_webmock_response(patron_response)
webmock_response = WebMock::Response.new
reason = patron_response.status_line.
scan(%r(\AHTTP/(\d+\.\d+)\s+(\d\d\d)\s*([^\r\n]+)?))[0][2]
webmock_response.status = [patron_response.status, reason]
webmock_response.body = patron_response.body
webmock_response.headers = patron_response.headers
webmock_response
end
end
end
end
end
webmock-1.22.6/lib/webmock/http_lib_adapters/manticore_adapter.rb 0000644 0000041 0000041 00000010345 12646134265 025170 0 ustar www-data www-data begin
require 'manticore'
rescue LoadError
# manticore not found
end
if defined?(Manticore)
module WebMock
module HttpLibAdapters
class ManticoreAdapter < HttpLibAdapter
adapter_for :manticore
OriginalManticoreClient = Manticore::Client
def self.enable!
Manticore.send(:remove_const, :Client)
Manticore.send(:const_set, :Client, WebMockManticoreClient)
Manticore.instance_variable_set(:@manticore_facade, WebMockManticoreClient.new)
end
def self.disable!
Manticore.send(:remove_const, :Client)
Manticore.send(:const_set, :Client, OriginalManticoreClient)
Manticore.instance_variable_set(:@manticore_facade, OriginalManticoreClient.new)
end
class WebMockManticoreClient < Manticore::Client
def request(klass, url, options={}, &block)
super(klass, WebMock::Util::URI.normalize_uri(url).to_s, format_options(options))
end
private
def format_options(options)
return options unless headers = options[:headers]
options.merge(:headers => join_array_values(headers))
end
def join_array_values(headers)
headers.reduce({}) do |h, (k,v)|
v = v.join(', ') if v.is_a?(Array)
h.merge(k => v)
end
end
def response_object_for(request, context, &block)
request_signature = generate_webmock_request_signature(request)
WebMock::RequestRegistry.instance.requested_signatures.put(request_signature)
if webmock_response = registered_response_for(request_signature)
webmock_response.raise_error_if_any
manticore_response = generate_manticore_response(webmock_response).call
real_request = false
elsif real_request_allowed?(request_signature.uri)
manticore_response = Manticore::Response.new(self, request, context, &block).call
webmock_response = generate_webmock_response(manticore_response)
real_request = true
else
raise WebMock::NetConnectNotAllowedError.new(request_signature)
end
WebMock::CallbackRegistry.invoke_callbacks({:lib => :manticore, :real_request => real_request}, request_signature, webmock_response)
manticore_response
end
def registered_response_for(request_signature)
WebMock::StubRegistry.instance.response_for_request(request_signature)
end
def real_request_allowed?(uri)
WebMock.net_connect_allowed?(uri)
end
def generate_webmock_request_signature(request)
method = request.method.downcase
uri = request.uri.to_s
body = read_body(request)
headers = split_array_values(request.headers)
WebMock::RequestSignature.new(method, uri, {:body => body, :headers => headers})
end
def read_body(request)
if request.respond_to?(:entity) && !request.entity.nil?
Manticore::EntityConverter.new.read_entity(request.entity)
end
end
def split_array_values(headers = [])
headers.each_with_object({}) do |(k, v), h|
h[k] = case v
when /,/ then v.split(',').map(&:strip)
else v
end
end
end
def generate_manticore_response(webmock_response)
raise Manticore::ConnectTimeout if webmock_response.should_timeout
Manticore::StubbedResponse.stub(
:code => webmock_response.status[0],
:body => webmock_response.body,
:headers => webmock_response.headers,
:cookies => {}
)
end
def generate_webmock_response(manticore_response)
webmock_response = WebMock::Response.new
webmock_response.status = [manticore_response.code, manticore_response.message]
webmock_response.body = manticore_response.body
webmock_response.headers = manticore_response.headers
webmock_response
end
end
end
end
end
end
webmock-1.22.6/lib/webmock/http_lib_adapters/curb_adapter.rb 0000644 0000041 0000041 00000016576 12646134265 024156 0 ustar www-data www-data begin
require 'curb'
rescue LoadError
# curb not found
end
if defined?(Curl)
WebMock::VersionChecker.new('Curb', Curl::CURB_VERSION, '0.7.16', '0.8.7').check_version!
module WebMock
module HttpLibAdapters
class CurbAdapter < HttpLibAdapter
adapter_for :curb
OriginalCurlEasy = Curl::Easy unless const_defined?(:OriginalCurlEasy)
def self.enable!
Curl.send(:remove_const, :Easy)
Curl.send(:const_set, :Easy, Curl::WebMockCurlEasy)
end
def self.disable!
Curl.send(:remove_const, :Easy)
Curl.send(:const_set, :Easy, OriginalCurlEasy)
end
# Borrowed from Patron:
# http://github.com/toland/patron/blob/master/lib/patron/response.rb
def self.parse_header_string(header_string)
status, headers = nil, {}
header_string.split(/\r\n/).each do |header|
if header =~ %r|^HTTP/1.[01] \d\d\d (.*)|
status = $1
else
parts = header.split(':', 2)
unless parts.empty?
parts[1].strip! unless parts[1].nil?
if headers.has_key?(parts[0])
headers[parts[0]] = [headers[parts[0]]] unless headers[parts[0]].kind_of? Array
headers[parts[0]] << parts[1]
else
headers[parts[0]] = parts[1]
end
end
end
end
return status, headers
end
end
end
end
module Curl
class WebMockCurlEasy < Curl::Easy
def curb_or_webmock
request_signature = build_request_signature
WebMock::RequestRegistry.instance.requested_signatures.put(request_signature)
if webmock_response = WebMock::StubRegistry.instance.response_for_request(request_signature)
build_curb_response(webmock_response)
WebMock::CallbackRegistry.invoke_callbacks(
{:lib => :curb}, request_signature, webmock_response)
invoke_curb_callbacks
true
elsif WebMock.net_connect_allowed?(request_signature.uri)
res = yield
if WebMock::CallbackRegistry.any_callbacks?
webmock_response = build_webmock_response
WebMock::CallbackRegistry.invoke_callbacks(
{:lib => :curb, :real_request => true}, request_signature,
webmock_response)
end
res
else
raise WebMock::NetConnectNotAllowedError.new(request_signature)
end
end
def build_request_signature
method = @webmock_method.to_s.downcase.to_sym
uri = WebMock::Util::URI.heuristic_parse(self.url)
uri.path = uri.normalized_path.gsub("[^:]//","/")
uri.user = self.username
uri.password = self.password
request_body = case method
when :post
self.post_body || @post_body
when :put
@put_data
else
nil
end
request_signature = WebMock::RequestSignature.new(
method,
uri.to_s,
:body => request_body,
:headers => self.headers
)
request_signature
end
def build_curb_response(webmock_response)
raise Curl::Err::TimeoutError if webmock_response.should_timeout
webmock_response.raise_error_if_any
@body_str = webmock_response.body
@response_code = webmock_response.status[0]
@header_str = "HTTP/1.1 #{webmock_response.status[0]} #{webmock_response.status[1]}\r\n"
if webmock_response.headers
@header_str << webmock_response.headers.map do |k,v|
"#{k}: #{v.is_a?(Array) ? v.join(", ") : v}"
end.join("\r\n")
location = webmock_response.headers['Location']
if self.follow_location? && location
@last_effective_url = location
webmock_follow_location(location)
end
@content_type = webmock_response.headers["Content-Type"]
@transfer_encoding = webmock_response.headers["Transfer-Encoding"]
end
@last_effective_url ||= self.url
end
def webmock_follow_location(location)
first_url = self.url
self.url = location
curb_or_webmock do
send( "http_#{@webmock_method}_without_webmock" )
end
self.url = first_url
end
def invoke_curb_callbacks
@on_progress.call(0.0,1.0,0.0,1.0) if defined?( @on_progress )
self.header_str.lines.each { |header_line| @on_header.call header_line } if defined?( @on_header )
if defined?( @on_body )
if chunked_response?
self.body_str.each do |chunk|
@on_body.call(chunk)
end
else
@on_body.call(self.body_str)
end
end
@on_complete.call(self) if defined?( @on_complete )
case response_code
when 200..299
@on_success.call(self) if defined?( @on_success )
when 400..499
@on_missing.call(self, self.response_code) if defined?( @on_missing )
when 500..599
@on_failure.call(self, self.response_code) if defined?( @on_failure )
end
end
def chunked_response?
defined?( @transfer_encoding ) && @transfer_encoding == 'chunked' && self.body_str.respond_to?(:each)
end
def build_webmock_response
status, headers =
WebMock::HttpLibAdapters::CurbAdapter.parse_header_string(self.header_str)
webmock_response = WebMock::Response.new
webmock_response.status = [self.response_code, status]
webmock_response.body = self.body_str
webmock_response.headers = headers
webmock_response
end
###
### Mocks of Curl::Easy methods below here.
###
def http(method)
@webmock_method = method
super
end
%w[ get head delete ].each do |verb|
define_method "http_#{verb}" do
@webmock_method = verb
super()
end
end
def http_put data = nil
@webmock_method = :put
@put_data = data if data
super
end
alias put http_put
def http_post *data
@webmock_method = :post
@post_body = data.join('&') if data && !data.empty?
super
end
alias post http_post
def perform
@webmock_method ||= :get
curb_or_webmock { super }
end
def put_data= data
@webmock_method = :put
@put_data = data
super
end
def post_body= data
@webmock_method = :post
super
end
def delete= value
@webmock_method = :delete if value
super
end
def head= value
@webmock_method = :head if value
super
end
def body_str
@body_str ||= super
end
alias body body_str
def response_code
@response_code ||= super
end
def header_str
@header_str ||= super
end
alias head header_str
def last_effective_url
@last_effective_url ||= super
end
def content_type
@content_type ||= super
end
%w[ success failure missing header body complete progress ].each do |callback|
class_eval <<-METHOD, __FILE__, __LINE__
def on_#{callback} &block
@on_#{callback} = block
super
end
METHOD
end
end
end
end
webmock-1.22.6/lib/webmock/http_lib_adapters/httpclient_adapter.rb 0000644 0000041 0000041 00000017240 12646134265 025366 0 ustar www-data www-data begin
require 'httpclient'
require 'jsonclient' # defined in 'httpclient' gem as well
rescue LoadError
# httpclient not found
# or jsonclient not defined (in old versions of httclient gem)
end
if defined?(::HTTPClient)
module WebMock
module HttpLibAdapters
class HTTPClientAdapter < HttpLibAdapter
adapter_for :httpclient
unless const_defined?(:OriginalHttpClient)
OriginalHttpClient = ::HTTPClient
end
unless const_defined?(:OriginalJsonClient)
OriginalJsonClient = ::JSONClient if defined?(::JSONClient)
end
def self.enable!
Object.send(:remove_const, :HTTPClient)
Object.send(:const_set, :HTTPClient, WebMockHTTPClient)
if defined? ::JSONClient
Object.send(:remove_const, :JSONClient)
Object.send(:const_set, :JSONClient, WebMockJSONClient)
end
end
def self.disable!
Object.send(:remove_const, :HTTPClient)
Object.send(:const_set, :HTTPClient, OriginalHttpClient)
if defined? ::JSONClient
Object.send(:remove_const, :JSONClient)
Object.send(:const_set, :JSONClient, OriginalJsonClient)
end
end
end
end
end
module WebMockHTTPClients
def do_get_block(req, proxy, conn, &block)
do_get(req, proxy, conn, false, &block)
end
def do_get_stream(req, proxy, conn, &block)
do_get(req, proxy, conn, true, &block)
end
def do_get(req, proxy, conn, stream = false, &block)
request_signature = build_request_signature(req, :reuse_existing)
WebMock::RequestRegistry.instance.requested_signatures.put(request_signature)
if webmock_responses[request_signature]
webmock_response = webmock_responses.delete(request_signature)
response = build_httpclient_response(webmock_response, stream, req.header, &block)
@request_filter.each do |filter|
filter.filter_response(req, response)
end
res = conn.push(response)
WebMock::CallbackRegistry.invoke_callbacks(
{:lib => :httpclient}, request_signature, webmock_response)
res
elsif WebMock.net_connect_allowed?(request_signature.uri)
# in case there is a nil entry in the hash...
webmock_responses.delete(request_signature)
res = if stream
do_get_stream_without_webmock(req, proxy, conn, &block)
else
do_get_block_without_webmock(req, proxy, conn, &block)
end
res = conn.pop
conn.push(res)
if WebMock::CallbackRegistry.any_callbacks?
webmock_response = build_webmock_response(res)
WebMock::CallbackRegistry.invoke_callbacks(
{:lib => :httpclient, :real_request => true}, request_signature,
webmock_response)
end
res
else
raise WebMock::NetConnectNotAllowedError.new(request_signature)
end
end
def do_request_async(method, uri, query, body, extheader)
req = create_request(method, uri, query, body, extheader)
request_signature = build_request_signature(req)
webmock_request_signatures << request_signature
if webmock_responses[request_signature] || WebMock.net_connect_allowed?(request_signature.uri)
super
else
raise WebMock::NetConnectNotAllowedError.new(request_signature)
end
end
def build_httpclient_response(webmock_response, stream = false, req_header = nil, &block)
body = stream ? StringIO.new(webmock_response.body) : webmock_response.body
response = HTTP::Message.new_response(body, req_header)
response.header.init_response(webmock_response.status[0])
response.reason=webmock_response.status[1]
webmock_response.headers.to_a.each { |name, value| response.header.set(name, value) }
raise HTTPClient::TimeoutError if webmock_response.should_timeout
webmock_response.raise_error_if_any
block.call(response, body) if block
response
end
end
class WebMockHTTPClient < HTTPClient
alias_method :do_get_block_without_webmock, :do_get_block
alias_method :do_get_stream_without_webmock, :do_get_stream
include WebMockHTTPClients
end
if defined? ::JSONClient
class WebMockJSONClient < JSONClient
alias_method :do_get_block_without_webmock, :do_get_block
alias_method :do_get_stream_without_webmock, :do_get_stream
include WebMockHTTPClients
end
end
def build_webmock_response(httpclient_response)
webmock_response = WebMock::Response.new
webmock_response.status = [httpclient_response.status, httpclient_response.reason]
webmock_response.headers = {}.tap do |hash|
httpclient_response.header.all.each do |(key, value)|
if hash.has_key?(key)
hash[key] = Array(hash[key]) + [value]
else
hash[key] = value
end
end
end
if httpclient_response.content.respond_to?(:read)
webmock_response.body = httpclient_response.content.read
body = HTTP::Message::Body.new
body.init_response(StringIO.new(webmock_response.body))
httpclient_response.body = body
else
webmock_response.body = httpclient_response.content
end
webmock_response
end
def build_request_signature(req, reuse_existing = false)
uri = WebMock::Util::URI.heuristic_parse(req.header.request_uri.to_s)
uri.query = WebMock::Util::QueryMapper.values_to_query(req.header.request_query, :notation => WebMock::Config.instance.query_values_notation) if req.header.request_query
uri.port = req.header.request_uri.port
uri = uri.omit(:userinfo)
auth = www_auth.basic_auth
auth.challenge(req.header.request_uri, nil)
@request_filter.each do |filter|
filter.filter_request(req)
end
headers = req.header.all.inject({}) do |hdrs, header|
hdrs[header[0]] ||= []
hdrs[header[0]] << header[1]
hdrs
end
headers = headers_from_session(uri).merge(headers)
if (auth_cred = auth.get(req)) && auth.scheme == 'Basic'
userinfo = WebMock::Util::Headers.decode_userinfo_from_header(auth_cred)
userinfo = WebMock::Util::URI.encode_unsafe_chars_in_userinfo(userinfo)
headers.reject! {|k,v| k =~ /[Aa]uthorization/ && v =~ /^Basic / } #we added it to url userinfo
uri.userinfo = userinfo
end
signature = WebMock::RequestSignature.new(
req.header.request_method.downcase.to_sym,
uri.to_s,
:body => req.http_body.dump,
:headers => headers
)
# reuse a previous identical signature object if we stored one for later use
if reuse_existing && previous_signature = previous_signature_for(signature)
return previous_signature
end
signature
end
def webmock_responses
@webmock_responses ||= Hash.new do |hash, request_signature|
hash[request_signature] = WebMock::StubRegistry.instance.response_for_request(request_signature)
end
end
def webmock_request_signatures
@webmock_request_signatures ||= []
end
def previous_signature_for(signature)
return nil unless index = webmock_request_signatures.index(signature)
webmock_request_signatures.delete_at(index)
end
private
# some of the headers sent by HTTPClient are derived from
# the client session
def headers_from_session(uri)
session_headers = HTTP::Message::Headers.new
@session_manager.send(:open, uri).send(:set_header, MessageMock.new(session_headers))
session_headers.all.inject({}) do |hdrs, header|
hdrs[header[0]] = header[1]
hdrs
end
end
# Mocks a HTTPClient HTTP::Message
class MessageMock
attr_reader :header
def initialize(headers)
@header = headers
end
def http_version=(value);end
end
end
webmock-1.22.6/lib/webmock/http_lib_adapters/excon_adapter.rb 0000644 0000041 0000041 00000011474 12646134265 024327 0 ustar www-data www-data begin
require 'excon'
rescue LoadError
# excon not found
end
if defined?(Excon)
WebMock::VersionChecker.new('Excon', Excon::VERSION, '0.27.5').check_version!
module WebMock
module HttpLibAdapters
class ExconAdapter < HttpLibAdapter
PARAMS_TO_DELETE = [:expects, :idempotent,
:instrumentor_name, :instrumentor,
:response_block,
:__construction_args, :stack,
:connection, :response]
adapter_for :excon
def self.enable!
self.add_excon_stub
end
def self.disable!
self.remove_excon_stub
end
def self.add_excon_stub
if not @stub
@original_excon_mock_default = ::Excon.defaults[:mock]
::Excon.defaults[:mock] = true
@stub = ::Excon.stub({}) do |params|
self.handle_request(params)
end
end
end
def self.remove_excon_stub
::Excon.defaults[:mock] = @original_excon_mock_default
@original_excon_mock_default = nil
Excon.stubs.delete(@stub)
@stub = nil
end
def self.handle_request(params)
mock_request = self.build_request params.dup
WebMock::RequestRegistry.instance.requested_signatures.put(mock_request)
if mock_response = WebMock::StubRegistry.instance.response_for_request(mock_request)
self.perform_callbacks(mock_request, mock_response, :real_request => false)
response = self.real_response(mock_response)
response
elsif WebMock.net_connect_allowed?(mock_request.uri)
conn = new_excon_connection(params)
real_response = conn.request(request_params_from(params.merge(:mock => false)))
ExconAdapter.perform_callbacks(mock_request, ExconAdapter.mock_response(real_response), :real_request => true)
real_response.data
else
raise WebMock::NetConnectNotAllowedError.new(mock_request)
end
end
def self.new_excon_connection(params)
# Ensure the connection is constructed with the exact same args
# that the orginal connection was constructed with.
args = params.fetch(:__construction_args)
::Excon::Connection.new(connection_params_from args.merge(:mock => false))
end
def self.connection_params_from(hash)
hash = hash.dup
PARAMS_TO_DELETE.each { |key| hash.delete(key) }
hash
end
def self.request_params_from(hash)
hash = hash.dup
if defined?(Excon::VALID_REQUEST_KEYS)
hash.reject! {|key,_| !Excon::VALID_REQUEST_KEYS.include?(key) }
end
PARAMS_TO_DELETE.each { |key| hash.delete(key) }
hash
end
def self.to_query(hash)
string = ""
for key, values in hash
if values.nil?
string << key.to_s << '&'
else
for value in [*values]
string << key.to_s << '=' << CGI.escape(value.to_s) << '&'
end
end
end
string.chop! # remove trailing '&'
end
def self.build_request(params)
params = params.dup
method = (params.delete(:method) || :get).to_s.downcase.to_sym
params[:query] = to_query(params[:query]) if params[:query].is_a?(Hash)
uri = Addressable::URI.new(params).to_s
WebMock::RequestSignature.new method, uri, :body => body_from(params), :headers => params[:headers]
end
def self.body_from(params)
body = params[:body]
return body unless body.respond_to?(:read)
contents = body.read
body.rewind if body.respond_to?(:rewind)
contents
end
def self.real_response(mock)
raise Excon::Errors::Timeout if mock.should_timeout
mock.raise_error_if_any
{
:body => mock.body,
:status => mock.status[0].to_i,
:headers => mock.headers || {}
}
end
def self.mock_response(real)
mock = WebMock::Response.new
mock.status = real.status
mock.headers = real.headers
mock.body = real.body.dup
mock
end
def self.perform_callbacks(request, response, options = {})
return unless WebMock::CallbackRegistry.any_callbacks?
WebMock::CallbackRegistry.invoke_callbacks(options.merge(:lib => :excon), request, response)
end
end
end
end
Excon::Connection.class_eval do
def self.new(args)
args.delete(:__construction_args)
super(args).tap do |instance|
instance.data[:__construction_args] = args
end
end
end
end
webmock-1.22.6/lib/webmock/webmock.rb 0000644 0000041 0000041 00000010110 12646134265 017434 0 ustar www-data www-data module WebMock
def self.included(clazz)
WebMock::Deprecation.warning("include WebMock is deprecated. Please include WebMock::API instead")
if clazz.instance_methods.map(&:to_s).include?('request')
warn "WebMock#request was not included in #{clazz} to avoid name collision"
else
clazz.class_eval do
def request(method, uri)
WebMock::Deprecation.warning("WebMock#request is deprecated. Please use WebMock::API#a_request method instead")
WebMock.a_request(method, uri)
end
end
end
end
include WebMock::API
extend WebMock::API
class << self
alias :request :a_request
end
def self.version
VERSION
end
def self.disable!(options = {})
except = [options[:except]].flatten.compact
HttpLibAdapterRegistry.instance.each_adapter do |name, adapter|
adapter.enable!
adapter.disable! unless except.include?(name)
end
end
def self.enable!(options = {})
except = [options[:except]].flatten.compact
HttpLibAdapterRegistry.instance.each_adapter do |name, adapter|
adapter.disable!
adapter.enable! unless except.include?(name)
end
end
def self.allow_net_connect!(options = {})
Config.instance.allow_net_connect = true
Config.instance.net_http_connect_on_start = options[:net_http_connect_on_start]
end
def self.disable_net_connect!(options = {})
Config.instance.allow_net_connect = false
Config.instance.allow_localhost = options[:allow_localhost]
Config.instance.allow = options[:allow]
Config.instance.net_http_connect_on_start = options[:net_http_connect_on_start]
end
def self.net_connect_allowed?(uri = nil)
if uri.is_a?(String)
uri = WebMock::Util::URI.normalize_uri(uri)
end
Config.instance.allow_net_connect ||
( Config.instance.allow_localhost && WebMock::Util::URI.is_uri_localhost?(uri) ||
Config.instance.allow && net_connect_explicit_allowed?(Config.instance.allow, uri) )
end
def self.net_connect_explicit_allowed?(allowed, uri=nil)
case allowed
when Array
allowed.any? { |allowed_item| net_connect_explicit_allowed?(allowed_item, uri) }
when Regexp
uri.to_s =~ allowed
when String
allowed == uri.host ||
allowed == "#{uri.host}:#{uri.port}"
end
end
def self.show_body_diff!
Config.instance.show_body_diff = true
end
def self.hide_body_diff!
Config.instance.show_body_diff = false
end
def self.show_body_diff?
Config.instance.show_body_diff
end
def self.hide_stubbing_instructions!
Config.instance.show_stubbing_instructions = false
end
def self.show_stubbing_instructions!
Config.instance.show_stubbing_instructions = true
end
def self.show_stubbing_instructions?
Config.instance.show_stubbing_instructions
end
def self.reset!
WebMock::RequestRegistry.instance.reset!
WebMock::StubRegistry.instance.reset!
end
def self.reset_webmock
WebMock::Deprecation.warning("WebMock.reset_webmock is deprecated. Please use WebMock.reset! method instead")
reset!
end
def self.reset_callbacks
WebMock::CallbackRegistry.reset
end
def self.after_request(options={}, &block)
WebMock::CallbackRegistry.add_callback(options, block)
end
def self.registered_request?(request_signature)
WebMock::StubRegistry.instance.registered_request?(request_signature)
end
def self.print_executed_requests
puts WebMock::RequestExecutionVerifier.executed_requests_message
end
def self.globally_stub_request(&block)
WebMock::StubRegistry.instance.register_global_stub(&block)
end
%w(
allow_net_connect!
disable_net_connect!
net_connect_allowed?
reset_webmock
reset_callbacks
after_request
registered_request?
).each do |method|
self.class_eval(%Q(
def #{method}(*args, &block)
WebMock::Deprecation.warning("WebMock##{method} instance method is deprecated. Please use WebMock.#{method} class method instead")
WebMock.#{method}(*args, &block)
end
))
end
self.enable!
end
webmock-1.22.6/lib/webmock/api.rb 0000644 0000041 0000041 00000006606 12646134265 016575 0 ustar www-data www-data module WebMock
module API
extend self
def stub_request(method, uri)
WebMock::StubRegistry.instance.
register_request_stub(WebMock::RequestStub.new(method, uri))
end
alias_method :stub_http_request, :stub_request
def a_request(method, uri)
WebMock::RequestPattern.new(method, uri)
end
class << self
alias :request :a_request
end
def assert_requested(*args, &block)
if not args[0].is_a?(WebMock::RequestStub)
args = convert_uri_method_and_options_to_request_and_options(args[0], args[1], args[2], &block)
elsif block
raise ArgumentError, "assert_requested with a stub object, doesn't accept blocks"
end
assert_request_requested(*args)
end
def assert_not_requested(*args, &block)
if not args[0].is_a?(WebMock::RequestStub)
args = convert_uri_method_and_options_to_request_and_options(args[0], args[1], args[2], &block)
elsif block
raise ArgumentError, "assert_not_requested with a stub object, doesn't accept blocks"
end
assert_request_not_requested(*args)
end
# Similar to RSpec::Mocks::ArgumentMatchers#hash_including()
#
# Matches a hash that includes the specified key(s) or key/value pairs.
# Ignores any additional keys.
#
# @example
#
# object.should_receive(:message).with(hash_including(:key => val))
# object.should_receive(:message).with(hash_including(:key))
# object.should_receive(:message).with(hash_including(:key, :key2 => val2))
def hash_including(*args)
if defined?(super)
super
else
WebMock::Matchers::HashIncludingMatcher.new(anythingize_lonely_keys(*args))
end
end
def remove_request_stub(stub)
WebMock::StubRegistry.instance.remove_request_stub(stub)
end
private
def convert_uri_method_and_options_to_request_and_options(method, uri, options, &block)
options ||= {}
options_for_pattern = options.dup
[:times, :at_least_times, :at_most_times].each { |key| options_for_pattern.delete(key) }
request = WebMock::RequestPattern.new(method, uri, options_for_pattern)
request = request.with(&block) if block
[request, options]
end
def assert_request_requested(request, options = {})
times = options.delete(:times)
at_least_times = options.delete(:at_least_times)
at_most_times = options.delete(:at_most_times)
times = 1 if times.nil? && at_least_times.nil? && at_most_times.nil?
verifier = WebMock::RequestExecutionVerifier.new(request, times, at_least_times, at_most_times)
WebMock::AssertionFailure.failure(verifier.failure_message) unless verifier.matches?
end
def assert_request_not_requested(request, options = {})
times = options.delete(:times)
at_least_times = options.delete(:at_least_times)
at_most_times = options.delete(:at_most_times)
verifier = WebMock::RequestExecutionVerifier.new(request, times, at_least_times, at_most_times)
WebMock::AssertionFailure.failure(verifier.failure_message_when_negated) unless verifier.does_not_match?
end
#this is a based on RSpec::Mocks::ArgumentMatchers#anythingize_lonely_keys
def anythingize_lonely_keys(*args)
hash = args.last.class == Hash ? args.delete_at(-1) : {}
args.each { | arg | hash[arg] = WebMock::Matchers::AnyArgMatcher.new(nil) }
hash
end
end
end
webmock-1.22.6/lib/webmock/request_execution_verifier.rb 0000644 0000041 0000041 00000004427 12646134265 023471 0 ustar www-data www-data module WebMock
class RequestExecutionVerifier
attr_accessor :request_pattern, :expected_times_executed, :times_executed, :at_least_times_executed, :at_most_times_executed
def initialize(request_pattern = nil, expected_times_executed = nil, at_least_times_executed = nil, at_most_times_executed = nil)
@request_pattern = request_pattern
@expected_times_executed = expected_times_executed
@at_least_times_executed = at_least_times_executed
@at_most_times_executed = at_most_times_executed
end
def matches?
@times_executed =
RequestRegistry.instance.times_executed(@request_pattern)
if @at_least_times_executed
@times_executed >= @at_least_times_executed
elsif @at_most_times_executed
@times_executed <= @at_most_times_executed
else
@times_executed == (@expected_times_executed || 1)
end
end
def does_not_match?
@times_executed =
RequestRegistry.instance.times_executed(@request_pattern)
if @expected_times_executed
@times_executed != @expected_times_executed
else
@times_executed == 0
end
end
def description
"request #{request_pattern} #{quantity_phrase.strip}"
end
def failure_message
failure_message_phrase(false)
end
def failure_message_when_negated
failure_message_phrase(true)
end
def self.executed_requests_message
"\n\nThe following requests were made:\n\n#{RequestRegistry.instance}\n" + "="*60
end
private
def failure_message_phrase(is_negated=false)
negation = is_negated ? "was not" : "was"
text = "The request #{request_pattern} #{negation} expected to execute #{quantity_phrase(is_negated)}but it executed #{times(times_executed)}"
text << self.class.executed_requests_message
text
end
def quantity_phrase(is_negated=false)
if @at_least_times_executed
"at least #{times(@at_least_times_executed)} "
elsif @at_most_times_executed
"at most #{times(@at_most_times_executed)} "
elsif @expected_times_executed
"#{times(@expected_times_executed)} "
else
is_negated ? "" : "#{times(1)} "
end
end
def times(times)
"#{times} time#{ (times == 1) ? '' : 's'}"
end
end
end
webmock-1.22.6/lib/webmock/version.rb 0000644 0000041 0000041 00000000114 12646134265 017475 0 ustar www-data www-data module WebMock
VERSION = '1.22.6' unless defined?(::WebMock::VERSION)
end
webmock-1.22.6/lib/webmock/stub_request_snippet.rb 0000644 0000041 0000041 00000001617 12646134265 022310 0 ustar www-data www-data module WebMock
class StubRequestSnippet
def initialize(request_stub)
@request_stub = request_stub
end
def body_pattern
request_pattern.body_pattern
end
def to_s(with_response = true)
request_pattern = @request_stub.request_pattern
string = "stub_request(:#{request_pattern.method_pattern.to_s},"
string << " \"#{request_pattern.uri_pattern.to_s}\")"
with = ""
if (request_pattern.body_pattern)
with << ":body => #{request_pattern.body_pattern.to_s}"
end
if (request_pattern.headers_pattern)
with << ",\n " unless with.empty?
with << ":headers => #{request_pattern.headers_pattern.to_s}"
end
string << ".\n with(#{with})" unless with.empty?
if with_response
string << ".\n to_return(:status => 200, :body => \"\", :headers => {})"
end
string
end
end
end
webmock-1.22.6/lib/webmock/config.rb 0000644 0000041 0000041 00000000650 12646134265 017262 0 ustar www-data www-data module WebMock
class Config
include Singleton
def initialize
@show_stubbing_instructions = true
@show_body_diff = true
end
attr_accessor :allow_net_connect
attr_accessor :allow_localhost
attr_accessor :allow
attr_accessor :net_http_connect_on_start
attr_accessor :show_stubbing_instructions
attr_accessor :query_values_notation
attr_accessor :show_body_diff
end
end
webmock-1.22.6/lib/webmock/matchers/ 0000755 0000041 0000041 00000000000 12646134265 017275 5 ustar www-data www-data webmock-1.22.6/lib/webmock/matchers/hash_including_matcher.rb 0000644 0000041 0000041 00000001620 12646134265 024303 0 ustar www-data www-data module WebMock
module Matchers
#this is a based on RSpec::Mocks::ArgumentMatchers::HashIncludingMatcher
#https://github.com/rspec/rspec-mocks/blob/master/lib/rspec/mocks/argument_matchers.rb
class HashIncludingMatcher
def initialize(expected)
@expected = Hash[WebMock::Util::HashKeysStringifier.stringify_keys!(expected, :deep => true).sort]
end
def ==(actual)
@expected.all? {|k,v| actual.has_key?(k) && v === actual[k]}
rescue NoMethodError
false
end
def inspect
"hash_including(#{@expected.inspect})"
end
def self.from_rspec_matcher(matcher)
new(matcher.instance_variable_get(:@expected))
end
end
#this is a based on RSpec::Mocks::ArgumentMatchers::AnyArgMatcher
class AnyArgMatcher
def initialize(ignore)
end
def ==(other)
true
end
end
end
end
webmock-1.22.6/lib/webmock/request_body_diff.rb 0000644 0000041 0000041 00000002707 12646134265 021517 0 ustar www-data www-data require "hashdiff"
require "json"
module WebMock
class RequestBodyDiff
def initialize(request_signature, request_stub)
@request_signature = request_signature
@request_stub = request_stub
end
def body_diff
return {} unless request_signature_diffable? && request_stub_diffable?
HashDiff.diff(request_signature_body_hash, request_stub_body_hash)
end
private
attr_reader :request_signature, :request_stub
def request_signature_diffable?
request_signature.json_headers? && request_signature_parseable_json?
end
def request_stub_diffable?
request_stub_body.is_a?(Hash) || request_stub_parseable_json?
end
def request_signature_body_hash
JSON.parse(request_signature.body)
end
def request_stub_body_hash
return request_stub_body if request_stub_body.is_a?(Hash)
JSON.parse(request_stub_body)
end
def request_stub_body
request_stub.request_pattern &&
request_stub.request_pattern.body_pattern &&
request_stub.request_pattern.body_pattern.pattern
end
def request_signature_parseable_json?
parseable_json?(request_signature.body)
end
def request_stub_parseable_json?
parseable_json?(request_stub_body)
end
def parseable_json?(body_pattern)
return false unless body_pattern.is_a?(String)
JSON.parse(body_pattern)
true
rescue JSON::ParserError
false
end
end
end
webmock-1.22.6/lib/webmock/request_signature_snippet.rb 0000644 0000041 0000041 00000003123 12646134265 023326 0 ustar www-data www-data require "pp"
module WebMock
class RequestSignatureSnippet
attr_reader :request_signature, :request_stub
def initialize(request_signature)
@request_signature = request_signature
@request_stub = RequestStub.from_request_signature(request_signature)
end
def stubbing_instructions
return unless WebMock.show_stubbing_instructions?
text = "You can stub this request with the following snippet:\n\n"
text << WebMock::StubRequestSnippet.new(request_stub).to_s
end
def request_stubs
return if WebMock::StubRegistry.instance.request_stubs.empty?
text = "registered request stubs:\n"
WebMock::StubRegistry.instance.request_stubs.each do |stub|
text << "\n#{WebMock::StubRequestSnippet.new(stub).to_s(false)}"
add_body_diff(stub, text) if WebMock.show_body_diff?
end
text
end
private
def add_body_diff(stub, text)
body_diff_str = signature_stub_body_diff(stub)
text << "\n\n#{body_diff_str}" unless body_diff_str.empty?
end
def signature_stub_body_diff(stub)
diff = RequestBodyDiff.new(request_signature, stub).body_diff
diff.empty? ? "" : "Body diff:\n #{pretty_print_to_string(diff)}"
end
def request_params
@request_params ||=
if request_signature.json_headers?
JSON.parse(request_signature.body)
else
""
end
end
def pretty_print_to_string(string_to_print)
StringIO.open("") do |stream|
PP.pp(string_to_print, stream)
stream.rewind
stream.read
end
end
end
end
webmock-1.22.6/lib/webmock/request_registry.rb 0000644 0000041 0000041 00000001503 12646134265 021433 0 ustar www-data www-data module WebMock
class RequestRegistry
include Singleton
attr_accessor :requested_signatures
def initialize
reset!
end
def reset!
self.requested_signatures = Util::HashCounter.new
end
def times_executed(request_pattern)
self.requested_signatures.hash.select { |request_signature, times_executed|
request_pattern.matches?(request_signature)
}.inject(0) {|sum, (_, times_executed)| sum + times_executed }
end
def to_s
if requested_signatures.hash.empty?
"No requests were made."
else
text = ""
self.requested_signatures.each do |request_signature, times_executed|
text << "#{request_signature} was made #{times_executed} time#{times_executed == 1 ? '' : 's' }\n"
end
text
end
end
end
end
webmock-1.22.6/lib/webmock/util/ 0000755 0000041 0000041 00000000000 12646134265 016444 5 ustar www-data www-data webmock-1.22.6/lib/webmock/util/headers.rb 0000644 0000041 0000041 00000002073 12646134265 020406 0 ustar www-data www-data module WebMock
module Util
class Headers
def self.normalize_headers(headers)
return nil unless headers
array = headers.map { |name, value|
[name.to_s.split(/_|-/).map { |segment| segment.capitalize }.join("-"),
case value
when Regexp then value
when Array then (value.size == 1) ? value.first : value.map {|v| v.to_s}.sort
else value.to_s
end
]
}
Hash[*array.inject([]) {|r,x| r + x}]
end
def self.sorted_headers_string(headers)
headers = WebMock::Util::Headers.normalize_headers(headers)
str = '{'
str << headers.map do |k,v|
v = case v
when Regexp then v.inspect
when Array then "["+v.map{|w| "'#{w.to_s}'"}.join(", ")+"]"
else "'#{v.to_s}'"
end
"'#{k}'=>#{v}"
end.sort.join(", ")
str << '}'
end
def self.decode_userinfo_from_header(header)
header.sub(/^Basic /, "").unpack("m").first
end
end
end
end
webmock-1.22.6/lib/webmock/util/query_mapper.rb 0000644 0000041 0000041 00000023365 12646134265 021513 0 ustar www-data www-data module WebMock::Util
class QueryMapper
class << self
#This class is based on Addressable::URI pre 2.3.0
##
# Converts the query component to a Hash value.
#
# @option [Symbol] notation
# May be one of :flat, :dot, or
# :subscript. The :dot notation is not
# supported for assignment. Default value is :subscript.
#
# @return [Hash, Array] The query string parsed as a Hash or Array object.
#
# @example
# WebMock::Util::QueryMapper.query_to_values("?one=1&two=2&three=3")
# #=> {"one" => "1", "two" => "2", "three" => "3"}
# WebMock::Util::QueryMapper("?one[two][three]=four").query_values
# #=> {"one" => {"two" => {"three" => "four"}}}
# WebMock::Util::QueryMapper.query_to_values("?one.two.three=four",
# :notation => :dot
# )
# #=> {"one" => {"two" => {"three" => "four"}}}
# WebMock::Util::QueryMapper.query_to_values("?one[two][three]=four",
# :notation => :flat
# )
# #=> {"one[two][three]" => "four"}
# WebMock::Util::QueryMapper.query_to_values("?one.two.three=four",
# :notation => :flat
# )
# #=> {"one.two.three" => "four"}
# WebMock::Util::QueryMapper(
# "?one[two][three][]=four&one[two][three][]=five"
# )
# #=> {"one" => {"two" => {"three" => ["four", "five"]}}}
# WebMock::Util::QueryMapper.query_to_values(
# "?one=two&one=three").query_values(:notation => :flat_array)
# #=> [['one', 'two'], ['one', 'three']]
def query_to_values(query, options={})
return nil if query.nil?
query.force_encoding('utf-8') if query.respond_to?(:force_encoding)
options[:notation] ||= :subscript
if ![:flat, :dot, :subscript, :flat_array].include?(options[:notation])
raise ArgumentError,
'Invalid notation. Must be one of: ' +
'[:flat, :dot, :subscript, :flat_array].'
end
empty_accumulator = :flat_array == options[:notation] ? [] : {}
query_array = collect_query_parts(query)
query_hash = collect_query_hash(query_array, empty_accumulator, options)
normalize_query_hash(query_hash, empty_accumulator, options)
end
def normalize_query_hash(query_hash, empty_accumulator, options)
query_hash.inject(empty_accumulator.dup) do |accumulator, (key, value)|
if options[:notation] == :flat_array
accumulator << [key, value]
else
accumulator[key] = value.kind_of?(Hash) ? dehash(value) : value
end
accumulator
end
end
def collect_query_parts(query)
query_parts = query.split('&').map do |pair|
pair.split('=', 2) if pair && !pair.empty?
end
query_parts.compact
end
def collect_query_hash(query_array, empty_accumulator, options)
query_array.compact.inject(empty_accumulator.dup) do |accumulator, (key, value)|
value = if value.nil?
nil
else
::Addressable::URI.unencode_component(value.gsub(/\+/, ' '))
end
key = Addressable::URI.unencode_component(key)
key = key.dup.force_encoding(Encoding::ASCII_8BIT) if key.respond_to?(:force_encoding)
self.__send__("fill_accumulator_for_#{options[:notation]}", accumulator, key, value)
accumulator
end
end
def fill_accumulator_for_flat(accumulator, key, value)
if accumulator[key]
raise ArgumentError, "Key was repeated: #{key.inspect}"
end
accumulator[key] = value
end
def fill_accumulator_for_flat_array(accumulator, key, value)
accumulator << [key, value]
end
def fill_accumulator_for_dot(accumulator, key, value)
array_value = false
subkeys = key.split(".")
current_hash = accumulator
subkeys[0..-2].each do |subkey|
current_hash[subkey] = {} unless current_hash[subkey]
current_hash = current_hash[subkey]
end
if array_value
if current_hash[subkeys.last] && !current_hash[subkeys.last].is_a?(Array)
current_hash[subkeys.last] = [current_hash[subkeys.last]]
end
current_hash[subkeys.last] = [] unless current_hash[subkeys.last]
current_hash[subkeys.last] << value
else
current_hash[subkeys.last] = value
end
end
def fill_accumulator_for_subscript(accumulator, key, value)
current_node = accumulator
subkeys = key.split(/(?=\[\w)/)
subkeys[0..-2].each do |subkey|
node = subkey =~ /\[\]\z/ ? [] : {}
subkey = subkey.gsub(/[\[\]]/, '')
if current_node.is_a? Array
container = current_node.find { |n| n.is_a?(Hash) && n.has_key?(subkey) }
if container
current_node = container[subkey]
else
current_node << {subkey => node}
current_node = node
end
else
current_node[subkey] = node unless current_node[subkey]
current_node = current_node[subkey]
end
end
last_key = subkeys.last
array_value = !!(last_key =~ /\[\]$/)
last_key = last_key.gsub(/[\[\]]/, '')
if current_node.is_a? Array
container = current_node.find { |n| n.is_a?(Hash) && n.has_key?(last_key) }
if container
if array_value
container[last_key] << value
else
container[last_key] = value
end
else
if array_value
current_node << {last_key => [value]}
else
current_node << {last_key => value}
end
end
else
if array_value
current_node[last_key] = [] unless current_node[last_key]
current_node[last_key] << value
else
current_node[last_key] = value
end
end
end
##
# Sets the query component for this URI from a Hash object.
# This method produces a query string using the :subscript notation.
# An empty Hash will result in a nil query.
#
# @param [Hash, #to_hash, Array] new_query_values The new query values.
def values_to_query(new_query_values, options = {})
options[:notation] ||= :subscript
return if new_query_values.nil?
unless new_query_values.is_a?(Array)
unless new_query_values.respond_to?(:to_hash)
raise TypeError,
"Can't convert #{new_query_values.class} into Hash."
end
new_query_values = new_query_values.to_hash
new_query_values = new_query_values.inject([]) do |object, (key, value)|
key = key.to_s if key.is_a?(::Symbol) || key.nil?
if value.is_a?(Array)
value.each { |v| object << [key.to_s + '[]', v] }
elsif value.is_a?(Hash)
value.each { |k, v| object << ["#{key.to_s}[#{k}]", v]}
else
object << [key.to_s, value]
end
object
end
# Useful default for OAuth and caching.
# Only to be used for non-Array inputs. Arrays should preserve order.
begin
new_query_values.sort! # may raise for non-comparable values
rescue NoMethodError, ArgumentError
# ignore
end
end
buffer = ''
new_query_values.each do |parent, value|
encoded_parent = ::Addressable::URI.encode_component(
parent.dup, ::Addressable::URI::CharacterClasses::UNRESERVED
)
buffer << "#{to_query(encoded_parent, value, options)}&"
end
buffer.chop
end
def dehash(hash)
hash.each do |(key, value)|
if value.is_a?(::Hash)
hash[key] = self.dehash(value)
end
end
if hash != {} && hash.keys.all? { |key| key =~ /^\d+$/ }
hash.sort.inject([]) do |accu, (_, value)|
accu << value; accu
end
else
hash
end
end
##
# Joins and converts parent and value into a properly encoded and
# ordered URL query.
#
# @private
# @param [String] parent an URI encoded component.
# @param [Array, Hash, Symbol, #to_str] value
#
# @return [String] a properly escaped and ordered URL query.
# new_query_values have form [['key1', 'value1'], ['key2', 'value2']]
def to_query(parent, value, options = {})
options[:notation] ||= :subscript
case value
when ::Hash
value = value.map do |key, val|
[
::Addressable::URI.encode_component(key.to_s.dup, ::Addressable::URI::CharacterClasses::UNRESERVED),
val
]
end
value.sort!
buffer = ''
value.each do |key, val|
new_parent = options[:notation] != :flat_array ? "#{parent}[#{key}]" : parent
buffer << "#{to_query(new_parent, val, options)}&"
end
buffer.chop
when ::Array
buffer = ''
value.each_with_index do |val, i|
new_parent = options[:notation] != :flat_array ? "#{parent}[#{i}]" : parent
buffer << "#{to_query(new_parent, val, options)}&"
end
buffer.chop
when NilClass
parent
else
encoded_value = Addressable::URI.encode_component(
value.to_s.dup, Addressable::URI::CharacterClasses::UNRESERVED
)
"#{parent}=#{encoded_value}"
end
end
end
end
end
webmock-1.22.6/lib/webmock/util/json.rb 0000644 0000041 0000041 00000006261 12646134265 017747 0 ustar www-data www-data # This is a copy of https://github.com/jnunemaker/crack/blob/master/lib/crack/json.rb
# with date parsing removed
# Copyright (c) 2004-2008 David Heinemeier Hansson
# 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.
module WebMock
module Util
class JSON
class ParseError < StandardError; end
def self.parse(json)
yaml = unescape(convert_json_to_yaml(json))
YAML.load(yaml)
rescue ArgumentError => e
raise ParseError, "Invalid JSON string: #{yaml}, Error: #{e.inspect}"
end
protected
def self.unescape(str)
str.gsub(/\\u([0-9a-f]{4})/) { [$1.hex].pack("U") }
end
# Ensure that ":" and "," are always followed by a space
def self.convert_json_to_yaml(json) #:nodoc:
scanner, quoting, marks, pos, times = StringScanner.new(json), false, [], nil, []
while scanner.scan_until(/(\\['"]|['":,\\]|\\.)/)
case char = scanner[1]
when '"', "'"
if !quoting
quoting = char
pos = scanner.pos
elsif quoting == char
quoting = false
end
when ":",","
marks << scanner.pos - 1 unless quoting
when "\\"
scanner.skip(/\\/)
end
end
if marks.empty?
json.gsub(/\\\//, '/')
else
left_pos = [-1].push(*marks)
right_pos = marks << json.bytesize
output = []
if RUBY_VERSION != "1.9.2"
left_pos.each_with_index do |left, i|
if json.respond_to?(:byteslice)
output << json.byteslice(left.succ..right_pos[i])
else
output << json[left.succ..right_pos[i]]
end
end
else
json_as_binary = json.force_encoding("binary")
left_pos.each_with_index do |left, i|
output << json_as_binary[left.succ..right_pos[i]]
end
output.map! do |binary_str|
binary_str.force_encoding("UTF-8")
end
end
output = output * " "
times.each { |i| output[i-1] = ' ' }
output.gsub!(/\\\//, '/')
output
end
end
end
end
end
webmock-1.22.6/lib/webmock/util/uri.rb 0000644 0000041 0000041 00000007414 12646134265 017576 0 ustar www-data www-data module WebMock
module Util
class URI
module CharacterClasses
USERINFO = Addressable::URI::CharacterClasses::UNRESERVED + Addressable::URI::CharacterClasses::SUB_DELIMS + "\\:"
end
ADDRESSABLE_URIS = Hash.new do |hash, key|
hash[key] = Addressable::URI.heuristic_parse(key)
end
NORMALIZED_URIS = Hash.new do |hash, uri|
normalized_uri = WebMock::Util::URI.heuristic_parse(uri)
if normalized_uri.query_values
sorted_query_values = sort_query_values(WebMock::Util::QueryMapper.query_to_values(normalized_uri.query, :notation => Config.instance.query_values_notation) || {})
normalized_uri.query = WebMock::Util::QueryMapper.values_to_query(sorted_query_values, :notation => WebMock::Config.instance.query_values_notation)
end
normalized_uri = normalized_uri.normalize #normalize! is slower
normalized_uri.query = normalized_uri.query.gsub("+", "%2B") if normalized_uri.query
normalized_uri.port = normalized_uri.inferred_port unless normalized_uri.port
hash[uri] = normalized_uri
end
def self.heuristic_parse(uri)
ADDRESSABLE_URIS[uri].dup
end
def self.normalize_uri(uri)
return uri if uri.is_a?(Regexp)
uri = 'http://' + uri unless uri.match('^https?://') if uri.is_a?(String)
NORMALIZED_URIS[uri].dup
end
def self.variations_of_uri_as_strings(uri_object)
normalized_uri = normalize_uri(uri_object.dup).freeze
uris = [ normalized_uri ]
if normalized_uri.path == '/'
uris = uris_with_trailing_slash_and_without(uris)
end
uris = uris_encoded_and_unencoded(uris)
if normalized_uri.port == Addressable::URI.port_mapping[normalized_uri.scheme]
uris = uris_with_inferred_port_and_without(uris)
end
if normalized_uri.scheme == "http"
uris = uris_with_scheme_and_without(uris)
end
uris.map {|uri| uri.to_s.gsub(/^\/\//,'') }.uniq
end
def self.strip_default_port_from_uri_string(uri_string)
case uri_string
when %r{^http://} then uri_string.sub(%r{:80(/|$)}, '\1')
when %r{^https://} then uri_string.sub(%r{:443(/|$)}, '\1')
else uri_string
end
end
def self.encode_unsafe_chars_in_userinfo(userinfo)
Addressable::URI.encode_component(userinfo, WebMock::Util::URI::CharacterClasses::USERINFO)
end
def self.is_uri_localhost?(uri)
uri.is_a?(Addressable::URI) &&
%w(localhost 127.0.0.1 0.0.0.0).include?(uri.host)
end
private
def self.sort_query_values(query_values)
sorted_query_values = query_values.sort
query_values.is_a?(Hash) ? Hash[*sorted_query_values.inject([]) { |values, pair| values + pair}] : sorted_query_values
end
def self.uris_with_inferred_port_and_without(uris)
uris.map { |uri|
uri = uri.dup.force_encoding(Encoding::ASCII_8BIT) if uri.respond_to?(:force_encoding)
[ uri, uri.gsub(%r{(:80)|(:443)}, "").freeze ]
}.flatten
end
def self.uris_encoded_and_unencoded(uris)
uris.map do |uri|
[ uri.to_s, Addressable::URI.unencode(uri, String).freeze ]
end.flatten
end
def self.uris_with_scheme_and_without(uris)
uris.map { |uri|
uri = uri.dup.force_encoding(Encoding::ASCII_8BIT) if uri.respond_to?(:force_encoding)
[ uri, uri.gsub(%r{^https?://},"").freeze ]
}.flatten
end
def self.uris_with_trailing_slash_and_without(uris)
uris = uris.map { |uri|
uri = uri.dup.force_encoding(Encoding::ASCII_8BIT) if uri.respond_to?(:force_encoding)
[ uri, uri.omit(:path).freeze ]
}.flatten
end
end
end
end
webmock-1.22.6/lib/webmock/util/hash_keys_stringifier.rb 0000644 0000041 0000041 00000001104 12646134265 023350 0 ustar www-data www-data module WebMock
module Util
class HashKeysStringifier
def self.stringify_keys!(arg, options = {})
case arg
when Array
arg.map { |elem|
options[:deep] ? stringify_keys!(elem, options) : elem
}
when Hash
Hash[
*arg.map { |key, value|
k = key.is_a?(Symbol) ? key.to_s : key
v = (options[:deep] ? stringify_keys!(value, options) : value)
[k,v]
}.inject([]) {|r,x| r + x}]
else
arg
end
end
end
end
end
webmock-1.22.6/lib/webmock/util/hash_validator.rb 0000644 0000041 0000041 00000000766 12646134265 021772 0 ustar www-data www-data module WebMock
class HashValidator
def initialize(hash)
@hash = hash
end
#This code is based on https://github.com/rails/rails/blob/master/activesupport/lib/active_support/core_ext/hash/keys.rb
def validate_keys(*valid_keys)
valid_keys.flatten!
@hash.each_key do |k|
unless valid_keys.include?(k)
raise ArgumentError.new("Unknown key: #{k.inspect}. Valid keys are: #{valid_keys.map(&:inspect).join(', ')}")
end
end
end
end
end
webmock-1.22.6/lib/webmock/util/version_checker.rb 0000644 0000041 0000041 00000006351 12646134265 022147 0 ustar www-data www-data # This code was created based on https://github.com/myronmarston/vcr/blob/master/lib/vcr/util/version_checker.rb
# Thanks to @myronmarston
# Copyright (c) 2010-2012 Myron Marston
# 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.
module WebMock
class VersionChecker
def initialize(library_name, library_version, min_patch_level, max_minor_version = nil)
@library_name, @library_version = library_name, library_version
@min_patch_level, @max_minor_version = min_patch_level, max_minor_version
@major, @minor, @patch = parse_version(library_version)
@min_major, @min_minor, @min_patch = parse_version(min_patch_level)
@max_major, @max_minor = parse_version(max_minor_version) if max_minor_version
@comparison_result = compare_version
end
def check_version!
warn_about_too_low if too_low?
warn_about_too_high if too_high?
end
private
def too_low?
@comparison_result == :too_low
end
def too_high?
@comparison_result == :too_high
end
def warn_about_too_low
warn_in_red "You are using #{@library_name} #{@library_version}. " +
"WebMock supports version #{version_requirement}."
end
def warn_about_too_high
warn_in_red "You are using #{@library_name} #{@library_version}. " +
"WebMock is known to work with #{@library_name} #{version_requirement}. " +
"It may not work with this version."
end
def warn_in_red(text)
Kernel.warn colorize(text, "\e[31m")
end
def compare_version
case
when @major < @min_major then :too_low
when @max_major && @major > @max_major then :too_high
when @major > @min_major then :ok
when @minor < @min_minor then :too_low
when @max_minor && @minor > @max_minor then :too_high
when @minor > @min_minor then :ok
when @patch < @min_patch then :too_low
end
end
def version_requirement
req = ">= #{@min_patch_level}"
req += ", < #{@max_major}.#{@max_minor + 1}" if @max_minor
req
end
def parse_version(version)
version.split('.').map { |v| v.to_i }
end
def colorize(text, color_code)
"#{color_code}#{text}\e[0m"
end
end
end
webmock-1.22.6/lib/webmock/util/hash_counter.rb 0000644 0000041 0000041 00000001176 12646134265 021460 0 ustar www-data www-data require 'thread'
module WebMock
module Util
class Util::HashCounter
attr_accessor :hash
def initialize
self.hash = {}
@order = {}
@max = 0
@lock = ::Mutex.new
end
def put key, num=1
@lock.synchronize do
hash[key] = (hash[key] || 0) + num
@order[key] = @max = @max + 1
end
end
def get key
@lock.synchronize do
hash[key] || 0
end
end
def each(&block)
@order.to_a.sort {|a, b| a[1] <=> b[1]}.each do |a|
block.call(a[0], hash[a[0]])
end
end
end
end
end
webmock-1.22.6/lib/webmock/rspec/ 0000755 0000041 0000041 00000000000 12646134265 016603 5 ustar www-data www-data webmock-1.22.6/lib/webmock/rspec/matchers.rb 0000644 0000041 0000041 00000001131 12646134265 020732 0 ustar www-data www-data require 'webmock'
require 'webmock/rspec/matchers/request_pattern_matcher'
require 'webmock/rspec/matchers/webmock_matcher'
module WebMock
module Matchers
def have_been_made
WebMock::RequestPatternMatcher.new
end
def have_been_requested
WebMock::RequestPatternMatcher.new
end
def have_not_been_made
WebMock::RequestPatternMatcher.new.times(0)
end
def have_requested(method, uri)
WebMock::WebMockMatcher.new(method, uri)
end
def have_not_requested(method, uri)
WebMock::WebMockMatcher.new(method, uri).times(0)
end
end
end
webmock-1.22.6/lib/webmock/rspec/matchers/ 0000755 0000041 0000041 00000000000 12646134265 020411 5 ustar www-data www-data webmock-1.22.6/lib/webmock/rspec/matchers/request_pattern_matcher.rb 0000644 0000041 0000041 00000003406 12646134265 025671 0 ustar www-data www-data module WebMock
class RequestPatternMatcher
def initialize
@request_execution_verifier = RequestExecutionVerifier.new
end
def once
@request_execution_verifier.expected_times_executed = 1
self
end
def twice
@request_execution_verifier.expected_times_executed = 2
self
end
def times(times)
@request_execution_verifier.expected_times_executed = times.to_i
self
end
def at_least_once
@request_execution_verifier.at_least_times_executed = 1
self
end
def at_least_twice
@request_execution_verifier.at_least_times_executed = 2
self
end
def at_least_times(times)
@request_execution_verifier.at_least_times_executed = times.to_i
self
end
def at_most_once
@request_execution_verifier.at_most_times_executed = 1
self
end
def at_most_twice
@request_execution_verifier.at_most_times_executed = 2
self
end
def at_most_times(times)
@request_execution_verifier.at_most_times_executed = times.to_i
self
end
def matches?(request_pattern)
@request_execution_verifier.request_pattern = request_pattern
@request_execution_verifier.matches?
end
def does_not_match?(request_pattern)
@request_execution_verifier.request_pattern = request_pattern
@request_execution_verifier.does_not_match?
end
def failure_message
@request_execution_verifier.failure_message
end
def failure_message_when_negated
@request_execution_verifier.failure_message_when_negated
end
def description
@request_execution_verifier.description
end
# RSpec 2 compatibility:
alias_method :negative_failure_message, :failure_message_when_negated
end
end
webmock-1.22.6/lib/webmock/rspec/matchers/webmock_matcher.rb 0000644 0000041 0000041 00000002271 12646134265 024072 0 ustar www-data www-data module WebMock
class WebMockMatcher
def initialize(method, uri)
@request_execution_verifier = RequestExecutionVerifier.new
@request_execution_verifier.request_pattern = RequestPattern.new(method, uri)
end
def once
@request_execution_verifier.expected_times_executed = 1
self
end
def twice
@request_execution_verifier.expected_times_executed = 2
self
end
def with(options = {}, &block)
@request_execution_verifier.request_pattern.with(options, &block)
self
end
def times(times)
@request_execution_verifier.expected_times_executed = times.to_i
self
end
def matches?(webmock)
@request_execution_verifier.matches?
end
def does_not_match?(webmock)
@request_execution_verifier.does_not_match?
end
def failure_message
@request_execution_verifier.failure_message
end
def failure_message_when_negated
@request_execution_verifier.failure_message_when_negated
end
def description
@request_execution_verifier.description
end
# RSpec 2 compatibility:
alias_method :negative_failure_message, :failure_message_when_negated
end
end
webmock-1.22.6/lib/webmock/rspec.rb 0000644 0000041 0000041 00000001413 12646134265 017127 0 ustar www-data www-data require 'webmock'
# RSpec 1.x and 2.x compatibility
if defined?(RSpec::Expectations::ExpectationNotMetError)
RSPEC_NAMESPACE = RSPEC_CONFIGURER = RSpec
elsif defined?(Spec) && defined?(Spec.configure)
RSPEC_NAMESPACE = Spec
RSPEC_CONFIGURER = Spec::Runner
else
begin
require 'rspec/core'
require 'rspec/expectations'
RSPEC_NAMESPACE = RSPEC_CONFIGURER = RSpec
rescue LoadError
require 'spec'
RSPEC_NAMESPACE = Spec
RSPEC_CONFIGURER = Spec::Runner
end
end
require 'webmock/rspec/matchers'
RSPEC_CONFIGURER.configure { |config|
config.include WebMock::API
config.include WebMock::Matchers
config.after(:each) do
WebMock.reset!
end
}
WebMock::AssertionFailure.error_class = RSPEC_NAMESPACE::Expectations::ExpectationNotMetError
webmock-1.22.6/lib/webmock/request_stub.rb 0000644 0000041 0000041 00000005220 12646134265 020540 0 ustar www-data www-data module WebMock
class RequestStub
attr_accessor :request_pattern
def initialize(method, uri)
@request_pattern = RequestPattern.new(method, uri)
@responses_sequences = []
self
end
def with(params = {}, &block)
@request_pattern.with(params, &block)
self
end
def to_return(*response_hashes, &block)
if block
@responses_sequences << ResponsesSequence.new([ResponseFactory.response_for(block)])
else
@responses_sequences << ResponsesSequence.new([*response_hashes].flatten.map {|r| ResponseFactory.response_for(r)})
end
self
end
alias_method :and_return, :to_return
def to_rack(app, options={})
@responses_sequences << ResponsesSequence.new([RackResponse.new(app)])
end
def to_raise(*exceptions)
@responses_sequences << ResponsesSequence.new([*exceptions].flatten.map {|e|
ResponseFactory.response_for(:exception => e)
})
self
end
alias_method :and_raise, :to_raise
def to_timeout
@responses_sequences << ResponsesSequence.new([ResponseFactory.response_for(:should_timeout => true)])
self
end
alias_method :and_timeout, :to_timeout
def response
if @responses_sequences.empty?
WebMock::Response.new
elsif @responses_sequences.length > 1
@responses_sequences.shift if @responses_sequences.first.end?
@responses_sequences.first.next_response
else
@responses_sequences[0].next_response
end
end
def has_responses?
!@responses_sequences.empty?
end
def then
self
end
def times(number)
raise "times(N) accepts integers >= 1 only" if !number.is_a?(Fixnum) || number < 1
if @responses_sequences.empty?
raise "Invalid WebMock stub declaration." +
" times(N) can be declared only after response declaration."
end
@responses_sequences.last.times_to_repeat += number-1
self
end
def matches?(request_signature)
self.request_pattern.matches?(request_signature)
end
def to_s
self.request_pattern.to_s
end
def self.from_request_signature(signature)
stub = self.new(signature.method.to_sym, signature.uri.to_s)
if signature.body.to_s != ''
body = if signature.url_encoded?
WebMock::Util::QueryMapper.query_to_values(signature.body, :notation => Config.instance.query_values_notation)
else
signature.body
end
stub.with(:body => body)
end
if (signature.headers && !signature.headers.empty?)
stub.with(:headers => signature.headers)
end
stub
end
end
end
webmock-1.22.6/lib/webmock/request_signature.rb 0000644 0000041 0000041 00000002453 12646134265 021571 0 ustar www-data www-data module WebMock
class RequestSignature
attr_accessor :method, :uri, :body
attr_reader :headers
def initialize(method, uri, options = {})
self.method = method.to_sym
self.uri = uri.is_a?(Addressable::URI) ? uri : WebMock::Util::URI.normalize_uri(uri)
assign_options(options)
end
def to_s
string = "#{self.method.to_s.upcase}"
string << " #{WebMock::Util::URI.strip_default_port_from_uri_string(self.uri.to_s)}"
string << " with body '#{body.to_s}'" if body && body.to_s != ''
if headers && !headers.empty?
string << " with headers #{WebMock::Util::Headers.sorted_headers_string(headers)}"
end
string
end
def headers=(headers)
@headers = WebMock::Util::Headers.normalize_headers(headers)
end
def hash
self.to_s.hash
end
def eql?(other)
self.to_s == other.to_s
end
alias == eql?
def url_encoded?
!!(headers && headers['Content-Type'] == 'application/x-www-form-urlencoded')
end
def json_headers?
!!(headers && headers['Content-Type'] == 'application/json')
end
private
def assign_options(options)
self.body = options[:body] if options.has_key?(:body)
self.headers = options[:headers] if options.has_key?(:headers)
end
end
end
webmock-1.22.6/lib/webmock.rb 0000644 0000041 0000041 00000003704 12646134265 016020 0 ustar www-data www-data require 'singleton'
require 'addressable/uri'
require 'addressable/template'
require 'crack/xml'
require 'webmock/deprecation'
require 'webmock/version'
require 'webmock/errors'
require 'webmock/util/query_mapper'
require 'webmock/util/uri'
require 'webmock/util/headers'
require 'webmock/util/hash_counter'
require 'webmock/util/hash_keys_stringifier'
require 'webmock/util/json'
require 'webmock/util/version_checker'
require 'webmock/util/hash_validator'
require 'webmock/matchers/hash_including_matcher'
require 'webmock/request_pattern'
require 'webmock/request_signature'
require 'webmock/responses_sequence'
require 'webmock/request_stub'
require 'webmock/response'
require 'webmock/rack_response'
require 'webmock/stub_request_snippet'
require 'webmock/request_signature_snippet'
require 'webmock/request_body_diff'
require 'webmock/assertion_failure'
require 'webmock/request_execution_verifier'
require 'webmock/config'
require 'webmock/callback_registry'
require 'webmock/request_registry'
require 'webmock/stub_registry'
require 'webmock/api'
require 'webmock/http_lib_adapters/http_lib_adapter_registry'
require 'webmock/http_lib_adapters/http_lib_adapter'
require 'webmock/http_lib_adapters/net_http'
require 'webmock/http_lib_adapters/http_rb_adapter'
require 'webmock/http_lib_adapters/httpclient_adapter'
require 'webmock/http_lib_adapters/patron_adapter'
require 'webmock/http_lib_adapters/curb_adapter'
require 'webmock/http_lib_adapters/em_http_request_adapter'
require 'webmock/http_lib_adapters/typhoeus_hydra_adapter'
require 'webmock/http_lib_adapters/excon_adapter'
require 'webmock/http_lib_adapters/manticore_adapter'
require 'webmock/webmock'
if RUBY_VERSION <= "1.8.7" && Addressable::VERSION::STRING >= "2.4.0"
raise StandardError,
<<-ERR
\n\e[31m
Addressable dropped support for Ruby 1.8.7 on version 2.4.0,
please add the following to your Gemfile to be able to use WebMock:
gem 'addressable', '< 2.4.0'\e[0m\n
ERR
end
webmock-1.22.6/gemfiles/ 0000755 0000041 0000041 00000000000 12646134265 015065 5 ustar www-data www-data webmock-1.22.6/gemfiles/ruby_1_8.gemfile 0000644 0000041 0000041 00000000425 12646134265 020050 0 ustar www-data www-data # This file was generated by Appraisal
source "http://rubygems.org/"
gem "addressable", ">= 2.3.6", "< 2.4.0"
group :development do
gem "rake"
end
group :test do
gem "minitest_tu_shim", "1.3.2"
end
platforms :jruby do
gem "jruby-openssl"
end
gemspec :path => "../"
webmock-1.22.6/metadata.yml 0000644 0000041 0000041 00000030317 12646134265 015601 0 ustar www-data www-data --- !ruby/object:Gem::Specification
name: webmock
version: !ruby/object:Gem::Version
version: 1.22.6
platform: ruby
authors:
- Bartosz Blimke
autorequire:
bindir: bin
cert_chain: []
date: 2016-01-10 00:00:00 Z
dependencies:
- !ruby/object:Gem::Dependency
name: addressable
prerelease: false
requirement: &id001 !ruby/object:Gem::Requirement
requirements:
- - ">="
- !ruby/object:Gem::Version
version: 2.3.6
type: :runtime
version_requirements: *id001
- !ruby/object:Gem::Dependency
name: crack
prerelease: false
requirement: &id002 !ruby/object:Gem::Requirement
requirements:
- - ">="
- !ruby/object:Gem::Version
version: 0.3.2
type: :runtime
version_requirements: *id002
- !ruby/object:Gem::Dependency
name: hashdiff
prerelease: false
requirement: &id003 !ruby/object:Gem::Requirement
requirements:
- &id014
- ">="
- !ruby/object:Gem::Version
version: "0"
type: :runtime
version_requirements: *id003
- !ruby/object:Gem::Dependency
name: rspec
prerelease: false
requirement: &id004 !ruby/object:Gem::Requirement
requirements:
- - ">="
- !ruby/object:Gem::Version
version: 3.1.0
type: :development
version_requirements: *id004
- !ruby/object:Gem::Dependency
name: httpclient
prerelease: false
requirement: &id005 !ruby/object:Gem::Requirement
requirements:
- - ">="
- !ruby/object:Gem::Version
version: 2.2.4
type: :development
version_requirements: *id005
- !ruby/object:Gem::Dependency
name: patron
prerelease: false
requirement: &id006 !ruby/object:Gem::Requirement
requirements:
- - "="
- !ruby/object:Gem::Version
version: 0.4.18
type: :development
version_requirements: *id006
- !ruby/object:Gem::Dependency
name: em-http-request
prerelease: false
requirement: &id007 !ruby/object:Gem::Requirement
requirements:
- - ">="
- !ruby/object:Gem::Version
version: 1.0.2
type: :development
version_requirements: *id007
- !ruby/object:Gem::Dependency
name: http
prerelease: false
requirement: &id008 !ruby/object:Gem::Requirement
requirements:
- - "="
- !ruby/object:Gem::Version
version: 0.7.3
type: :development
version_requirements: *id008
- !ruby/object:Gem::Dependency
name: curb
prerelease: false
requirement: &id009 !ruby/object:Gem::Requirement
requirements:
- - <=
- !ruby/object:Gem::Version
version: 0.8.6
type: :development
version_requirements: *id009
- !ruby/object:Gem::Dependency
name: typhoeus
prerelease: false
requirement: &id010 !ruby/object:Gem::Requirement
requirements:
- - ">="
- !ruby/object:Gem::Version
version: 0.5.0
type: :development
version_requirements: *id010
- !ruby/object:Gem::Dependency
name: excon
prerelease: false
requirement: &id011 !ruby/object:Gem::Requirement
requirements:
- - ">="
- !ruby/object:Gem::Version
version: 0.27.5
type: :development
version_requirements: *id011
- !ruby/object:Gem::Dependency
name: minitest
prerelease: false
requirement: &id012 !ruby/object:Gem::Requirement
requirements:
- - ~>
- !ruby/object:Gem::Version
version: 5.0.0
type: :development
version_requirements: *id012
- !ruby/object:Gem::Dependency
name: rdoc
prerelease: false
requirement: &id013 !ruby/object:Gem::Requirement
requirements:
- - ">"
- !ruby/object:Gem::Version
version: 3.5.0
type: :development
version_requirements: *id013
- !ruby/object:Gem::Dependency
name: rack
prerelease: false
requirement: &id015 !ruby/object:Gem::Requirement
requirements:
- *id014
type: :development
version_requirements: *id015
- !ruby/object:Gem::Dependency
name: appraisal
prerelease: false
requirement: &id016 !ruby/object:Gem::Requirement
requirements:
- - ~>
- !ruby/object:Gem::Version
version: "2.0"
type: :development
version_requirements: *id016
description: WebMock allows stubbing HTTP requests and setting expectations on HTTP requests.
email:
- bartosz.blimke@gmail.com
executables: []
extensions: []
extra_rdoc_files: []
files:
- .gemtest
- .gitignore
- .rspec-tm
- .travis.yml
- Appraisals
- CHANGELOG.md
- Gemfile
- LICENSE
- README.md
- Rakefile
- gemfiles/ruby_1_8.gemfile
- lib/webmock.rb
- lib/webmock/api.rb
- lib/webmock/assertion_failure.rb
- lib/webmock/callback_registry.rb
- lib/webmock/config.rb
- lib/webmock/cucumber.rb
- lib/webmock/deprecation.rb
- lib/webmock/errors.rb
- lib/webmock/http_lib_adapters/curb_adapter.rb
- lib/webmock/http_lib_adapters/em_http_request/em_http_request_0_x.rb
- lib/webmock/http_lib_adapters/em_http_request/em_http_request_1_x.rb
- lib/webmock/http_lib_adapters/em_http_request_adapter.rb
- lib/webmock/http_lib_adapters/excon_adapter.rb
- lib/webmock/http_lib_adapters/http_lib_adapter.rb
- lib/webmock/http_lib_adapters/http_lib_adapter_registry.rb
- lib/webmock/http_lib_adapters/http_rb/client.rb
- lib/webmock/http_lib_adapters/http_rb/request.rb
- lib/webmock/http_lib_adapters/http_rb/response.rb
- lib/webmock/http_lib_adapters/http_rb/streamer.rb
- lib/webmock/http_lib_adapters/http_rb/webmock.rb
- lib/webmock/http_lib_adapters/http_rb_adapter.rb
- lib/webmock/http_lib_adapters/httpclient_adapter.rb
- lib/webmock/http_lib_adapters/manticore_adapter.rb
- lib/webmock/http_lib_adapters/net_http.rb
- lib/webmock/http_lib_adapters/net_http_response.rb
- lib/webmock/http_lib_adapters/patron_adapter.rb
- lib/webmock/http_lib_adapters/typhoeus_hydra_adapter.rb
- lib/webmock/matchers/hash_including_matcher.rb
- lib/webmock/minitest.rb
- lib/webmock/rack_response.rb
- lib/webmock/request_body_diff.rb
- lib/webmock/request_execution_verifier.rb
- lib/webmock/request_pattern.rb
- lib/webmock/request_registry.rb
- lib/webmock/request_signature.rb
- lib/webmock/request_signature_snippet.rb
- lib/webmock/request_stub.rb
- lib/webmock/response.rb
- lib/webmock/responses_sequence.rb
- lib/webmock/rspec.rb
- lib/webmock/rspec/matchers.rb
- lib/webmock/rspec/matchers/request_pattern_matcher.rb
- lib/webmock/rspec/matchers/webmock_matcher.rb
- lib/webmock/stub_registry.rb
- lib/webmock/stub_request_snippet.rb
- lib/webmock/test_unit.rb
- lib/webmock/util/hash_counter.rb
- lib/webmock/util/hash_keys_stringifier.rb
- lib/webmock/util/hash_validator.rb
- lib/webmock/util/headers.rb
- lib/webmock/util/json.rb
- lib/webmock/util/query_mapper.rb
- lib/webmock/util/uri.rb
- lib/webmock/util/version_checker.rb
- lib/webmock/version.rb
- lib/webmock/webmock.rb
- minitest/test_helper.rb
- minitest/test_webmock.rb
- minitest/webmock_spec.rb
- spec/acceptance/curb/curb_spec.rb
- spec/acceptance/curb/curb_spec_helper.rb
- spec/acceptance/em_http_request/em_http_request_spec.rb
- spec/acceptance/em_http_request/em_http_request_spec_helper.rb
- spec/acceptance/excon/excon_spec.rb
- spec/acceptance/excon/excon_spec_helper.rb
- spec/acceptance/http_rb/http_rb_spec.rb
- spec/acceptance/http_rb/http_rb_spec_helper.rb
- spec/acceptance/httpclient/httpclient_spec.rb
- spec/acceptance/httpclient/httpclient_spec_helper.rb
- spec/acceptance/manticore/manticore_spec.rb
- spec/acceptance/manticore/manticore_spec_helper.rb
- spec/acceptance/net_http/net_http_shared.rb
- spec/acceptance/net_http/net_http_spec.rb
- spec/acceptance/net_http/net_http_spec_helper.rb
- spec/acceptance/net_http/real_net_http_spec.rb
- spec/acceptance/patron/patron_spec.rb
- spec/acceptance/patron/patron_spec_helper.rb
- spec/acceptance/shared/allowing_and_disabling_net_connect.rb
- spec/acceptance/shared/callbacks.rb
- spec/acceptance/shared/complex_cross_concern_behaviors.rb
- spec/acceptance/shared/enabling_and_disabling_webmock.rb
- spec/acceptance/shared/precedence_of_stubs.rb
- spec/acceptance/shared/request_expectations.rb
- spec/acceptance/shared/returning_declared_responses.rb
- spec/acceptance/shared/stubbing_requests.rb
- spec/acceptance/typhoeus/typhoeus_hydra_spec.rb
- spec/acceptance/typhoeus/typhoeus_hydra_spec_helper.rb
- spec/acceptance/webmock_shared.rb
- spec/quality_spec.rb
- spec/spec_helper.rb
- spec/support/example_curl_output.txt
- spec/support/my_rack_app.rb
- spec/support/network_connection.rb
- spec/support/webmock_server.rb
- spec/unit/api_spec.rb
- spec/unit/errors_spec.rb
- spec/unit/http_lib_adapters/http_lib_adapter_registry_spec.rb
- spec/unit/http_lib_adapters/http_lib_adapter_spec.rb
- spec/unit/matchers/hash_including_matcher_spec.rb
- spec/unit/rack_response_spec.rb
- spec/unit/request_body_diff_spec.rb
- spec/unit/request_execution_verifier_spec.rb
- spec/unit/request_pattern_spec.rb
- spec/unit/request_registry_spec.rb
- spec/unit/request_signature_snippet_spec.rb
- spec/unit/request_signature_spec.rb
- spec/unit/request_stub_spec.rb
- spec/unit/response_spec.rb
- spec/unit/stub_registry_spec.rb
- spec/unit/stub_request_snippet_spec.rb
- spec/unit/util/hash_counter_spec.rb
- spec/unit/util/hash_keys_stringifier_spec.rb
- spec/unit/util/headers_spec.rb
- spec/unit/util/json_spec.rb
- spec/unit/util/query_mapper_spec.rb
- spec/unit/util/uri_spec.rb
- spec/unit/util/version_checker_spec.rb
- spec/unit/webmock_spec.rb
- test/http_request.rb
- test/shared_test.rb
- test/test_helper.rb
- test/test_webmock.rb
- webmock.gemspec
homepage: http://github.com/bblimke/webmock
licenses:
- MIT
metadata: {}
post_install_message:
rdoc_options: []
require_paths:
- lib
required_ruby_version: !ruby/object:Gem::Requirement
requirements:
- *id014
required_rubygems_version: !ruby/object:Gem::Requirement
requirements:
- *id014
requirements: []
rubyforge_project: webmock
rubygems_version: 2.0.17
signing_key:
specification_version: 4
summary: Library for stubbing HTTP requests in Ruby.
test_files:
- spec/acceptance/curb/curb_spec.rb
- spec/acceptance/curb/curb_spec_helper.rb
- spec/acceptance/em_http_request/em_http_request_spec.rb
- spec/acceptance/em_http_request/em_http_request_spec_helper.rb
- spec/acceptance/excon/excon_spec.rb
- spec/acceptance/excon/excon_spec_helper.rb
- spec/acceptance/http_rb/http_rb_spec.rb
- spec/acceptance/http_rb/http_rb_spec_helper.rb
- spec/acceptance/httpclient/httpclient_spec.rb
- spec/acceptance/httpclient/httpclient_spec_helper.rb
- spec/acceptance/manticore/manticore_spec.rb
- spec/acceptance/manticore/manticore_spec_helper.rb
- spec/acceptance/net_http/net_http_shared.rb
- spec/acceptance/net_http/net_http_spec.rb
- spec/acceptance/net_http/net_http_spec_helper.rb
- spec/acceptance/net_http/real_net_http_spec.rb
- spec/acceptance/patron/patron_spec.rb
- spec/acceptance/patron/patron_spec_helper.rb
- spec/acceptance/shared/allowing_and_disabling_net_connect.rb
- spec/acceptance/shared/callbacks.rb
- spec/acceptance/shared/complex_cross_concern_behaviors.rb
- spec/acceptance/shared/enabling_and_disabling_webmock.rb
- spec/acceptance/shared/precedence_of_stubs.rb
- spec/acceptance/shared/request_expectations.rb
- spec/acceptance/shared/returning_declared_responses.rb
- spec/acceptance/shared/stubbing_requests.rb
- spec/acceptance/typhoeus/typhoeus_hydra_spec.rb
- spec/acceptance/typhoeus/typhoeus_hydra_spec_helper.rb
- spec/acceptance/webmock_shared.rb
- spec/quality_spec.rb
- spec/spec_helper.rb
- spec/support/example_curl_output.txt
- spec/support/my_rack_app.rb
- spec/support/network_connection.rb
- spec/support/webmock_server.rb
- spec/unit/api_spec.rb
- spec/unit/errors_spec.rb
- spec/unit/http_lib_adapters/http_lib_adapter_registry_spec.rb
- spec/unit/http_lib_adapters/http_lib_adapter_spec.rb
- spec/unit/matchers/hash_including_matcher_spec.rb
- spec/unit/rack_response_spec.rb
- spec/unit/request_body_diff_spec.rb
- spec/unit/request_execution_verifier_spec.rb
- spec/unit/request_pattern_spec.rb
- spec/unit/request_registry_spec.rb
- spec/unit/request_signature_snippet_spec.rb
- spec/unit/request_signature_spec.rb
- spec/unit/request_stub_spec.rb
- spec/unit/response_spec.rb
- spec/unit/stub_registry_spec.rb
- spec/unit/stub_request_snippet_spec.rb
- spec/unit/util/hash_counter_spec.rb
- spec/unit/util/hash_keys_stringifier_spec.rb
- spec/unit/util/headers_spec.rb
- spec/unit/util/json_spec.rb
- spec/unit/util/query_mapper_spec.rb
- spec/unit/util/uri_spec.rb
- spec/unit/util/version_checker_spec.rb
- spec/unit/webmock_spec.rb
- test/http_request.rb
- test/shared_test.rb
- test/test_helper.rb
- test/test_webmock.rb
webmock-1.22.6/test/ 0000755 0000041 0000041 00000000000 12646134265 014251 5 ustar www-data www-data webmock-1.22.6/test/http_request.rb 0000644 0000041 0000041 00000001323 12646134265 017324 0 ustar www-data www-data require 'ostruct'
module HttpRequestTestHelper
def http_request(method, uri, options = {})
begin
uri = URI.parse(uri)
rescue
uri = Addressable::URI.heuristic_parse(uri)
end
response = nil
clazz = ::Net::HTTP.const_get("#{method.to_s.capitalize}")
req = clazz.new("#{uri.path}#{uri.query ? '?' : ''}#{uri.query}", options[:headers])
req.basic_auth uri.user, uri.password if uri.user
http = ::Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true if uri.scheme == "https"
response = http.start {|http|
http.request(req, options[:body])
}
OpenStruct.new({
:body => response.body,
:headers => response,
:status => response.code })
end
end webmock-1.22.6/test/test_webmock.rb 0000644 0000041 0000041 00000000307 12646134265 017264 0 ustar www-data www-data require File.expand_path(File.dirname(__FILE__) + '/test_helper')
require File.expand_path(File.dirname(__FILE__) + '/shared_test')
class TestWebMock < Test::Unit::TestCase
include SharedTest
end
webmock-1.22.6/test/test_helper.rb 0000644 0000041 0000041 00000001157 12646134265 017120 0 ustar www-data www-data require 'rubygems'
$LOAD_PATH.unshift(File.dirname(__FILE__))
$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
require 'webmock/test_unit'
require 'test/unit'
class Test::Unit::TestCase
AssertionFailedError = Test::Unit::AssertionFailedError rescue MiniTest::Assertion
def assert_raise_with_message(e, message, &block)
e = assert_raises(e, &block)
if message.is_a?(Regexp)
assert_match(message, e.message)
else
assert_equal(message, e.message)
end
end
def assert_fail(message, &block)
assert_raise_with_message(AssertionFailedError, message, &block)
end
end
webmock-1.22.6/test/shared_test.rb 0000644 0000041 0000041 00000007460 12646134265 017112 0 ustar www-data www-data require File.expand_path(File.dirname(__FILE__) + '/http_request')
module SharedTest
include HttpRequestTestHelper
def setup
super
@stub_http = stub_http_request(:any, "http://www.example.com")
@stub_https = stub_http_request(:any, "https://www.example.com")
end
def test_assert_requested_with_stub_and_block_raises_error
assert_raises ArgumentError do
assert_requested(@stub_http) {}
end
end
def test_assert_not_requested_with_stub_and_block_raises_error
assert_raises ArgumentError do
assert_not_requested(@stub_http) {}
end
end
def test_error_on_non_stubbed_request
default_ruby_headers = (RUBY_VERSION >= "1.9.1") ? "{'Accept'=>'*/*', 'User-Agent'=>'Ruby'}" : "{'Accept'=>'*/*'}"
assert_raise_with_message(WebMock::NetConnectNotAllowedError, %r{Real HTTP connections are disabled. Unregistered request: GET http://www.example.net/ with headers}) do
http_request(:get, "http://www.example.net/")
end
end
def test_verification_that_expected_request_occured
http_request(:get, "http://www.example.com/")
assert_requested(:get, "http://www.example.com", :times => 1)
assert_requested(:get, "http://www.example.com")
end
def test_verification_that_expected_stub_occured
http_request(:get, "http://www.example.com/")
assert_requested(@stub_http, :times => 1)
assert_requested(@stub_http)
end
def test_verification_that_expected_request_didnt_occur
expected_message = "The request GET http://www.example.com/ was expected to execute 1 time but it executed 0 times"
expected_message << "\n\nThe following requests were made:\n\nNo requests were made.\n============================================================"
assert_fail(expected_message) do
assert_requested(:get, "http://www.example.com")
end
end
def test_verification_that_expected_request_didnt_occur
expected_message = "The request ANY http://www.example.com/ was expected to execute 1 time but it executed 0 times"
expected_message << "\n\nThe following requests were made:\n\nNo requests were made.\n============================================================"
assert_fail(expected_message) do
assert_requested(@stub_http)
end
end
def test_verification_that_expected_request_occured_with_body_and_headers
http_request(:get, "http://www.example.com/",
:body => "abc", :headers => {'A' => 'a'})
assert_requested(:get, "http://www.example.com",
:body => "abc", :headers => {'A' => 'a'})
end
def test_verification_that_expected_request_occured_with_query_params
stub_request(:any, "http://www.example.com").with(:query => hash_including({"a" => ["b", "c"]}))
http_request(:get, "http://www.example.com/?a[]=b&a[]=c&x=1")
assert_requested(:get, "http://www.example.com",
:query => hash_including({"a" => ["b", "c"]}))
end
def test_verification_that_non_expected_request_didnt_occur
expected_message = %r(The request GET http://www.example.com/ was not expected to execute but it executed 1 time\n\nThe following requests were made:\n\nGET http://www.example.com/ with headers .+ was made 1 time\n\n============================================================)
assert_fail(expected_message) do
http_request(:get, "http://www.example.com/")
assert_not_requested(:get, "http://www.example.com")
end
end
def test_verification_that_non_expected_stub_didnt_occur
expected_message = %r(The request ANY http://www.example.com/ was not expected to execute but it executed 1 time\n\nThe following requests were made:\n\nGET http://www.example.com/ with headers .+ was made 1 time\n\n============================================================)
assert_fail(expected_message) do
http_request(:get, "http://www.example.com/")
assert_not_requested(@stub_http)
end
end
end
webmock-1.22.6/.gitignore 0000644 0000041 0000041 00000000434 12646134265 015263 0 ustar www-data www-data ## MAC OS
.DS_Store
## TEXTMATE
*.tmproj
tmtags
## EMACS
*~
\#*
.\#*
## VIM
.*.sw[a-z]
## RubyMine and related
.idea
## PROJECT::GENERAL
coverage
rdoc
pkg
## PROJECT::SPECIFIC
*.gem
.bundle
Gemfile.lock
gemfiles/*.gemfile.lock
pkg/*
tmp/*
*.rbc
*.rbx
.ruby-gemset
.ruby-version
webmock-1.22.6/.rspec-tm 0000644 0000041 0000041 00000000037 12646134265 015025 0 ustar www-data www-data --rspec-version 2.0.0
--bundler webmock-1.22.6/LICENSE 0000644 0000041 0000041 00000002047 12646134265 014302 0 ustar www-data www-data Copyright (c) 2009-2010 Bartosz Blimke
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.
webmock-1.22.6/Appraisals 0000644 0000041 0000041 00000000106 12646134265 015311 0 ustar www-data www-data appraise "ruby_1_8" do
gem "addressable", ">= 2.3.6", "< 2.4.0"
end
webmock-1.22.6/CHANGELOG.md 0000644 0000041 0000041 00000132501 12646134265 015105 0 ustar www-data www-data # Changelog
## 1.22.6
* Fixes [issue](https://github.com/bblimke/webmock/issues/568) around
WebMock restricting [Addressable](https://github.com/sporkmonger/addressable)
version, based on Ruby 1.8.7 for all versions of Ruby.
This change inverts that, and forces Ruby 1.8.7 users to specify in thier
Gemfile an Addressable version < 2.4.0.
Thanks to [PikachuEXE](https://github.com/PikachuEXE) and
[Matthew Rudy Jacobs](https://github.com/matthewrudy).
## 1.22.5
* Fixes [bug](https://github.com/bblimke/webmock/issues/565) where WebMock tries
to alias a method that is deprecated in Ruby Versions > 1.9.2 ('sysread' for class 'StringIO')
Thanks to [Marcos Acosta](https://github.com/mmaa) for discovering this bug.
## 1.22.4
* Adds support for JSONClient (a subclass of HTTPClient)
Thanks to [Andrew Kozin](https://github.com/nepalez)
* Adds support for Ruby 2.3.0
Thanks to [Charles Pence](https://github.com/cpence)
* Adds support for [http](https://github.com/httprb/http) versions >= 1.0.0
Thanks to [Alexey Zapparov](https://github.com/ixti)
* Fixes support for Ruby 1.8.7 by restrciting Addressable version < 2.4.0
Thanks to [Matthew Rudy Jacobs](https://github.com/matthewrudy)
## 1.22.3
* Return "effective_url" attribute in Typhoeus::Response
Thanks to [Senya](https://github.com/cmrd-senya)
## 1.22.2
* Fix: prevents adding an extra =true to urls with parameters without values
Thanks to [David Begin](https://github.com/davidbegin)
## 1.22.1
* Adds Rack as a development dependency and removes require rack/utils in main lib.
Thanks to [Keenan Brock](https://github.com/kbrock)
## 1.22.0
All the credit for preparing this release go to [David Begin](https://github.com/davidbegin)!
* Adds [Manticore](https://github.com/cheald/manticore) support.
Thanks to [Mike Knepper](https://github.com/mikeknep), [David Abdemoulaie](https://github.com/hobodave)
* Update to Show a hash diff for requests that have stubs with a body.
Thanks to [yurivm](https://github.com/yurivm)
* Update to mirror Net::HTTP handling of headers as symbols
* Update to ignore non-comparable-values error when sorting
query values, because sorting is just a convience.
Thanks to [Magne Land](https://github.com/magneland)
* Covert Boolean values to Strings when using them to define
the body of a request.
Thanks to [Krzysztof Rygielski](https://github.com/riggy)
* Fixes WebMock's parsing Multibyte characters
Thanks to [Zhao Wen](https://github.com/VincentZhao)
* Updates to be compatible with httpclient 2.6.0
* Converts keys from symbols to strings when for QueryMapper.to_query
Thanks to [Ramon Tayag](https://github.com/ramontayag)
* Restricts http.rb version to 0.7.3 for Ruby 1.8.7
* Fixes issue emulating em-http-request's handling of multiple requests.
Thanks to [Matt Palmer](https://github.com/mpalmer)
* WebMock requires only the necessary parts of crack to avoid pulling in safe_yaml
Thanks to [Johannes Schlumberger](https://github.com/spjsschl)
## 1.21.0
* Support for http.rb >= 0.8.0
Thanks to [Zachary Anker](https://github.com/zanker), [Aleksey V. Zapparov](https://github.com/ixti)
* Support for http.rb 0.7.0
Thanks to [Mattias Putman](https://github.com/challengee)
* Added support for RSpec3-like `and_return`, `and_raise`, `and_timeout` syntax.
Thanks to [Franky Wahl](https://github.com/frankywahl)
* Restricted Curb support up to version 0.8.6. WebMock specs fail with Curb 0.8.7.
## 1.20.4
* Fixed support for `hash_including` matcher in RSpec 3
## 1.20.3
* `with` method raises error if provided without options hash and without block
* `with` and `to_return` raise an error if invoked with invalid keys in options hash.
## 1.20.2
* WebMock provides a helpful error message if an incompatible object is given as response body.
Thanks to [Mark Lorenz](https://github.com/dapplebeforedawn)
## 1.20.1
* `assert_requested` and `assert_not_requested` accept `at_least_times` and `at_most_times` options
Thanks to [Dan Buettner](https://github.com/Capncavedan)
* Silenced `instance variable undefined` warnings in Curb adapted.
Thanks to [Sven Riedel](https://github.com/sriedel)
## 1.20.0
* Add support for on_missing callback of Curb::Easy
Thanks to [Tasos Stathopoulos](https://github.com/astathopoulos)
* Add at_least_times and at_most_times matchers
Thanks to [Dan Buettner](https://github.com/Capncavedan)
## 1.19.0
* Fixed issue with Excon adapter giving warning message when redirects middleware was enabled.
Thanks to [Theo Hultberg](https://github.com/iconara) for reporting that.
* Fixed issue with `undefined method 'valid_request_keys' for Excon::Utils:Module`
Thanks to [Pablo Jairala](https://github.com/davidjairala)
* Fixed query mapper to encode `'one' => ['1','2']` as `'one[]=1&one[]=2'`.
Thanks to [Insoo Buzz Jung](https://github.com/insoul)
* Improved cookies support for em-http-request
Thanks to [Carlos Alonso Pérez](https://github.com/calonso)
* Fix HTTP Gem adapter to ensure uri attribute is set on response object.
Thanks to [Aleksey V. Zapparov](https://github.com/ixti)
* Fixed HTTPClient adapter. The response header now receives `request_method`, `request_uri`, and `request_query` transferred from request header
Thanks to [trlorenz](https://github.com/trlorenz)
* Query mapper supports nested data structures i.e. `{"first" => [{"two" => [{"three" => "four"}, "five"]}]}`
Thanks to [Alexander Simonov](https://github.com/simonoff)
* Fixed compatibility with latest versions of Excon which don't define `VALID_REQUEST_KEYS` anymore.
Thanks to [Pablo Jairala](https://github.com/davidjairala)
* Request method is always a symbol is request signatures. This fixes the issue of WebMock not matching Typhoeus requests with request method defined as string.
Thanks to [Thorbjørn Hermanse](https://github.com/thhermansen)
* Stubbing instructions which are displayed when no matching stub is found, can be disabled with `Config.instance.show_stubbing_instructions = false`
Thanks to [Mark Lorenz](https://github.com/dapplebeforedawn)
* Notation used for mapping query strings to data structure can be configured i.e. `WebMock::Config.instance.query_values_notation = :subscript`. This allows setting `:flat_array` notation which supports duplicated parameter names in query string.
Thanks to [tjsousa](https://github.com/tjsousa)
## 1.18.0
* Updated dependency on Addressable to versions >= 2.3.6
* Added support for matching uris using RFC 6570 (URI Templates)
uri_template = Addressable::Template.new "www.example.com/{id}/"
stub_request(:any, uri_template)
Thanks to [Max Lincoln](https://github.com/maxlinc)
* Fixed content length calculation for Rack responses with UTF8 body
Thanks to [Oleg Gritsenko](https://github.com/Claster)
* Add missing Curl::Easy aliases
Thanks to [Hwan-Joon Choi](https://github.com/hc5duke)
* HTTP Gem >= 0.6.0 compatibility
Thanks to [Aleksey V. Zapparov](https://github.com/ixti)
* Minitest 4 and 5 compatibility.
Thanks to [SHIBATA Hiroshi](https://github.com/hsbt)
## 1.17.4
* Update matchers for RSpec 3's matcher protocol
Thanks to [Rob Olson](https://github.com/robolson)
## 1.17.3
* Fixed issue with Rack response removing 'Content-Type' header
Thanks to [Bo Jeanes](https://github.com/bjeanes) and [Matthew Conway](https://github.com/mattonrails)
## 1.17.2
* Support for chunked responses in Curb
Thanks to [Zachary Belzer](https://github.com/zbelzer)
* Fixed handling of request body passed as a hash to `Typhoeus.post`
Thanks to [Mason Chang](https://github.com/changmason) for reporting.
## 1.17.1
* Added missing license statements.
Thanks to [Praveen Arimbrathodiyil](https://github.com/pravi)
## 1.17.0
* HTTP gem support!
Thanks to [Aleksey V. Zapparov](https://github.com/ixti)
* Limited Excon gem requirement to version < 0.30 until the compatibility with version > 0.30.0 is fixed.
Thanks to [Aleksey V. Zapparov](https://github.com/ixti)
* Fixed issue where empty query key caused a `TypeError`
Thanks to [Jon Rowe](https://github.com/JonRowe)
* Handling Typhoeus `on_headers` and `on_body` params.
Thanks to [Matt Burke](https://github.com/spraints)
## 1.16.1
* Fixed "NameError: uninitialized constant WebMock::Response::Pathname" issue.
Thanks to [Alex Stupakow and Karen Wang](https://github.com/stupakov) for the fix.
## 1.16.0
* Allow a Pathname to be passed as a Response body
stub_request(:get, /example.com/).to_return(
body: Rails.root.join('test/fixtures/foo.txt')
)
Thanks to [Ben Pickles](https://github.com/benpickles)
* `hash_including` matcher can be initialized with empty keys to match any values.
stub_request(:post, "www.example.com").with(:body => hash_including(:a, :b => {'c'}))
RestClient.post('www.example.com', '{"a":"1","b":"c"}', :content_type => 'application/json')
Thanks to [Stefano Uliari](https://github.com/steookk)
## 1.15.2
* Fixed `hash_including` to accept a splat of solitary keys.
Thanks to [Tamir Duberstein](https://github.com/tamird) and [https://github.com/strongriley](https://github.com/strongriley)
## 1.15.0
* Excon >= 0.27.5 compatibility.
Thanks to [Brian D. Burns](https://github.com/burns)
## 1.14.0
* Handling non UTF-8 characters in query params.
Thanks to [Florian Dütsch](https://github.com/der-flo) for reporting the issue.
* Added support for `request_block` param in Excon
Thanks to [Dmitry Gutov](https://github.com/dgutov) for reporting the issue.
* Fixed compatibility with latest Curb
Thanks to [Ian Lesperance](https://github.com/elliterate) and [Matthew Horan](https://github.com/mhoran)
* Triggering errbacks assynchronously in em-http-request adapter.
Thanks to [Ian Lesperance](https://github.com/elliterate) and [Matthew Horan](https://github.com/mhoran)
* Handling query params with a hashes nested inside arrays.
Thanks to [Ian Asaff](https://github.com/montague)
* Changed NetConnectNotAllowedError to inherit from Exception to allow it to bubble up into a test suite.
Thanks to [Daniel van Hoesel](https://github.com/s0meone)
* HTTPClient adapter is thread safe.
Thanks to [Tom Beauvais](https://github.com/tbeauvais)
## 1.13.0
* Net::HTTP::Persistent compatibility.
WebMock doesn't disconnect previously started connections upon a request anymore.
## 1.12.3
* Fixed issue with handling Addressable::URI with query params passed to `Net::HTTP.get_response`
Thanks to [Leif Bladt](https://github.com/leifbladt)
* Fixed HTTPClient adapter to not raise an error if a request with multipart body is executed.
## 1.12.2
* Fixed issue with handling request.path when Addressable::URI is passed to #request instead of URI with Ruby 2.0.
Thanks to [Leif Bladt](https://github.com/leifbladt)
* Accept integers as query param values in request stubs
i.e. `stub_request(:get, /.*/).with(:query => {"a" => 1})`
Thanks to [Mitsutaka Mimura](https://github.com/takkanm)
## 1.12.1
* Fixed Minitest < 5.0 compatibility
Thanks to [Alex Tomlins](https://github.com/alext) for reporting the issue.
## 1.12.0
* Not using Gem spec anymore to check loaded Curb version.
* `WebMock.disable_net_connect!` now accepts array of regexps as allow param:
i.e. `WebMock.disable_net_connect!(:allow => [/google.com/, /yahoo.com/])`
Thanks to [Bastien Vaucher](https://github.com/bastien)
* Fixed `on_header` Curb callback behaviour in Curb adapter
Thanks to [Joel Chippindale](https://github.com/mocoso)
* Fixed aws-sdk compatibility with Ruby 2.0, by supporting `continue_timeout` accessor on Net::HTTP socket.
Thanks to [Lin Jen-Shin](https://github.com/godfat)
* Fixed WebMock::Server to not give "log writing failed. can't be called from trap context" warning with Ruby 2.0
Thanks to [Murahashi Sanemat Kenichi](https://github.com/sanemat)
* Added support for EM-HTTP-Request streaming data off disk feature.
Thanks to [Lin Jen-Shin](https://github.com/godfat)
* Added compatibility with Minitest 5
Thanks to [Tim Kurvers](https://github.com/timkurvers)
* Excon >= 0.22 compatibility.
* README has nice sytnax hightlighting and fixed code styling!
Thanks to [Ilya Vassilevsky](https://github.com/vassilevsky)
* Compatibility with Rails 4 `rack.session.options`
Thanks to [gotwalt](https://github.com/gotwalt)
## 1.11.0
* Excon >= 0.17 support.
Thanks to [Nathan Sutton](https://github.com/nate) for reporting this issue and to [Wesley Beary](https://github.com/geemus) and [Myron Marston](https://github.com/myronmarston) for help.
## 1.10.2
* '+' in request path is treated as plus, but in query params always as a space.
## 1.10.1
* '+' in request body is still treated as a space. This fixes a bug introduced in previous version.
Thanks to [Erik Michaels-Ober](https://github.com/sferik) for reporting this problem.
* Fixed issue: response body declared as Proc was not evaluated again on subsequent requests.
Thanks to [Rick Fletcher](https://github.com/rfletcher) for reporting this issue.
## 1.10.0
* '+' in query params is not treated as space anymore and is encoded as %2B
Thanks to [goblin](https://github.com/goblin) for reporting this issue.
* added `remove_request_stub` method to the api to allow removing unused stubs i.e.
stub_get = stub_request(:get, "www.example.com")
remove_request_stub(stub_get)
* `assert_requested` and `assert_not_requested` raise an error if a stub object is provided together with a block.
## 1.9.3
* Fixed issue with unavailable constant Mutex in Ruby < 1.9
Thanks to [Lucas Dohmen](https://github.com/moonglum) for reporting this issue.
## 1.9.2
* Added support for Excon's :response_block parameter
Thanks to [Myron Marston](https://github.com/myronmarston) for reporting this issue.
## 1.9.1
* Fix 'rack.errors' not being set for Rack apps
Thanks to [Alex Grant](https://github.com/grantovich)
* Added support for minitest assertions count
Thanks to [Mokevnin Kirill](https://github.com/mokevnin)
* Fixed issues with registering http requests in multi-threaded environments
Thanks to [Tom Beauvais](https://github.com/tbeauvais)
* Bumped Crack version to >=0.3.2
Thanks to [Jake Benilov](https://github.com/benilovj)
* Fixed issues in Typhoeus 0.6. Defaulted method to GET when no method specified.
Thanks to [Hans Hasselberg](https://github.com/i0rek)
* Add license information to the gemspec
Thanks to [Jordi Massaguer Pla](https://github.com/jordimassaguerpla) and [Murahashi Sanemat Kenichi](https://github.com/sanemat)
* Added support for :expects option in Excon adapter
Thanks to [Evgeniy Dolzhenko](https://github.com/dolzenko)
* Fixed Faye compatibility by treating StringIO in Net::HTTP adapter properly
Thanks to [Pavel Forkert](https://github.com/fxposter)
* Updated VCR link
Thanks to [Rex Feng](https://github.com/xta)
## 1.9.0
* Added support for Typhoeus >= 0.5.0 and removed support for Typhoeus < 0.5.0.
Thanks to [Hans Hasselberg](https://github.com/i0rek)
## 1.8.11
* Fix excon adapter to handle `:body => some_file_object`
Thanks to [Myron Marston](https://github.com/myronmarston)
## 1.8.10
* em-http-request fix. After request callbacks are correctly invoked for 3xx responses,
when :redirects option is set.
Thanks to [Myron Marston](https://github.com/myronmarston) for reporting that issue.
* Fixed compatibility with Net::HTTP::DigestAuth
Thanks to [Jonathan Hyman](https://github.com/jonhyman) for reporting that issue.
* Fixed problem in em-http-request 0.x appending the query to the client URI twice.
Thanks to [Paweł Pierzchała](https://github.com/wrozka)
## 1.8.9
* Fixed problem with caching nil responses when the same HTTPClient instance is used.
Thanks to [Myron Marston](https://github.com/myronmarston)
* Added support for Addressable >= 2.3.0. Addressable 2.3.0 removed support for multiple query value notations and broke backwards compatibility.
https://github.com/sporkmonger/addressable/commit/f51e290b5f68a98293327a7da84eb9e2d5f21c62
https://github.com/sporkmonger/addressable/issues/77
## 1.8.8
* Fixed Net::HTTP adapter so that it returns `nil` for an empty body response.
Thanks to [Myron Marston](https://github.com/myronmarston)
* Gemspec defines compatibility with Addressable ~> 2.2.8, not >= 2.3.0
* Specs compatibility with Typhoeus 0.4.0
Thanks to [Hans Hasselberg](https://github.com/i0rek)
* Handling content types that specify a charset
Thanks to [Kevin Glowacz](https://github.com/kjg)
* Fixed em-http-request adapter to correctly fetch authorization header from a request
Thanks to [Julien Boyer](https://github.com/chatgris)
* Fixing travis-ci image to report master's status
Thanks to [Ryan Schlesinger](https://github.com/ryansch)
* Fixed problem with em-http-request callback triggering if there were other EM::Deferred callbacks registered
Thanks to [Jon Leighton](https://github.com/jonleighton)
* Fixed problem with em-http-request appending the query to the URI a second time, and
the parameters are repeated.
Thanks to [Jon Leighton](https://github.com/jonleighton)
## 1.8.7
* Compatibility with RSpec >= 2.10
Thanks to [erwanlr](https://github.com/erwanlr) for reporting this issue.
* Add missing required rack environment variable SCRIPT_NAME
Thanks to [Eric Oestrich](https://github.com/oestrich)
* Fixed warnings due to @query_params not being initialized
Thanks to [Ben Bleything](https://github.com/bleything)
## 1.8.6
* Pass through SERVER_PORT when stubbing to rack
Thanks to [Eric Oestrich](https://github.com/oestrich)
* Fixed problem with missing parenthesis in `WebMock#net_connect_allowed?` conditions.
Thanks to [aindustries](https://github.com/aindustries)
## 1.8.5
* WebMock::RackResponse supports basic auth
Thanks to [jugyo](https://github.com/jugyo)
## 1.8.4
* Warning message is printed when an unsupported version of a http library is loaded.
Thanks to [Alexander Staubo](https://github.com/alexstaubo) for reporting the problem and to [Myron Marston](https://github.com/myronmarston) for a help with solution.
## 1.8.3
* Fixed compatibility with latest em-http-request
Thanks to [Paul Cortens](https://github.com/thoughtless)
## 1.8.2
* Prevent Webmock `hash_including` from overriding RSpec version 1 `hash_including` method.
Thanks to [Joe Karayusuf](https://github.com/karayusuf)
* Ensured WebMock handles RSpec 1 `hash_including` matcher for matching query params and body.
## 1.8.1
* Ensured WebMock doesn't interfere with `em-synchrony`, when `em-synchrony/em-http` is not included.
Thanks to [Nick Recobra](https://github.com/oruen)
* Improved README
Thanks to [Jordan Elver](https://github.com/jordelver)
## 1.8.0
* Matching request body against partial hash.
stub_http_request(:post, "www.example.com").
with(:body => hash_including({:data => {:a => '1', :b => 'five'}}))
RestClient.post('www.example.com', "data[a]=1&data[b]=five&x=1",
:content_type => 'application/x-www-form-urlencoded') # ===> Success
request(:post, "www.example.com").
with(:body => hash_including({:data => {:a => '1', :b => 'five'}}),
:headers => 'Content-Type' => 'application/json').should have_been_made # ===> Success
Thanks to [Marnen Laibow-Koser](https://github.com/marnen) for help with this solution
* Matching request query params against partial hash.
stub_http_request(:get, "www.example.com").with(:query => hash_including({"a" => ["b", "c"]}))
RestClient.get("http://www.example.com/?a[]=b&a[]=c&x=1") # ===> Success
request(:get, "www.example.com").
with(:query => hash_including({"a" => ["b", "c"]})).should have_been_made # ===> Success
* Added support for Excon.
Thanks to [Dimitrij Denissenko](https://github.com/dim)
* Added support for setting expectations on the request stub with `assert_requested`
stub_get = stub_request(:get, "www.example.com")
stub_post = stub_request(:post, "www.example.com")
Net::HTTP.get('www.example.com', '/')
assert_requested(stub_get)
assert_not_requested(stub_post)
Thanks to [Nicolas Fouché](https://github.com/nfo)
* `WebMock.disable_net_connect!` accepts `RegExp` as `:allow` parameter
Thanks to [Frank Schumacher](https://github.com/thenoseman)
* Ensure multiple values for the same header can be recorded and played back
Thanks to [Myron Marston](https://github.com/myronmarston)
* Updated dependency on Addressable to version >= 2.2.7 to handle nested hash query values. I.e. `?one[two][three][]=four&one[two][three][]=five`
* Fixed compatibility with Curb >= 0.7.16 This breaks compatibility with Curb < 0.7.16
* Fix #to_rack to handle non-array response bodies.
Thanks to [Tammer Saleh](https://github.com/tsaleh)
* Added `read_timeout` accessor to StubSocket which fixes compatibility with aws-sdk
Thanks to [Lin Jen-Shin](https://github.com/godfat)
* Fix warning "instance variable @query_params not initialized"
Thanks to [Joe Van Dyk](https://github.com/joevandyk)
* Using bytesize of message instead of its length for content-length header in em-http-request adapter.
This fixes a problem with messages getting truncated in Ruby >= 1.9
Thanks to [Mark Abramov](https://github.com/markiz)
* Fixed problem with body params being matched even if params were different.
Thanks to [Evgeniy Dolzhenko](https://github.com/dolzenko) for reporting this issue.
## 1.7.10
* Yanked 1.7.9 and rebuilt gem on 1.8.7 to deal with syck/psych incompatibilties in gemspec.
## 1.7.9
* Fixed support for native Typhoeus timeouts.
Thanks to [Albert Llop](https://github.com/mrsimo)
* Fixed problem with WebMock and RSpec compatibility on TeamCity servers. See [this article](http://www.coding4streetcred.com/blog/post/Issue-RubyMine-31-Webmock-162-and-%E2%80%9CSpecconfigure%E2%80%9D-curse.aspx) for more details.
Thanks to [Christopher Pickslay](https://github.com/chrispix) from [Two Bit Labs](https://github.com/twobitlabs)
## 1.7.8
* Fix each adapter so that it calls a `stub.with` block only once per
request. Previously, the block would be called two or three times per
request [Myron Marston](https://github.com/myronmarston).
## 1.7.7 - RuPy 2011 release
* Passing response object to a block passed to `HTTPClient#do_get_block`. This fixes `HTTPClient.get_content` failures. [issue 130](https://github.com/bblimke/webmock/pull/130)
Thanks to [Chris McGrath](https://github.com/chrismcg)
* Cleaned up ruby warnings when running WebMock code with `-w`.
Thanks to [Stephen Celis](https://github.com/stephencelis)
* Curb adapter now correctly calls on_failure for 4xx response codes.
Thanks to [Eugene Pimenov](https://github.com/libc)
## 1.7.6
* Support for the HTTPClient's request_filter feature
Thanks to [Roman Shterenzon](https://github.com/romanbsd)
## 1.7.5
* Added support for Patron 0.4.15. This change is not backward compatible so please upgrade Patron to version >= 0.4.15 if you want to use it with WebMock.
Thanks to [Andreas Garnæs](https://github.com/andreas)
## 1.7.4
* Added support for matching EM-HTTP-Request requests with body declared as a Hash
Thanks to [David Yeu](https://github.com/daveyeu)
## 1.7.3
* Added `Get`, `Post`, `Delete`, `Put`, `Head`, `Option` constants to replaced `Net::HTTP` to make it possible to marshal objects with these constants assigned to properties. This fixed problem with `tvdb_party` gem which serializes HTTParty responses.
Thanks to [Klaus Hartl](https://github.com/carhartl) for reporting this issue.
## 1.7.2
* Redefined `const_get` and `constants` methods on the replaced `Net::HTTP` to return same values as original `Net::HTTP`
## 1.7.1
* Redefined `const_defined?` on the replaced `Net::HTTP` so that it returns true if constant is defined on the original `Net::HTTP`. This fixes problems with `"Net::HTTP::Get".constantize`.
Thanks to [Cássio Marques](https://github.com/cassiomarques) for reporting the issue and to [Myron Marston](https://github.com/myronmarston) for help with the solution.
## 1.7.0
* Fixed Net::HTTP adapter to not break normal Net::HTTP behaviour when network connections are allowed. This fixes **selenium-webdriver compatibility**!!!
* Added support for EM-HTTP-Request 1.0.x and EM-Synchrony. Thanks to [Steve Hull](https://github.com/sdhull)
* Added support for setting expectations to on a stub itself i.e.
stub = stub_request(:get, "www.example.com")
# ... make requests ...
stub.should have_been_requested
Thanks to [Aidan Feldman](https://github.com/afeld)
* Minitest support! Thanks to [Peter Higgins](https://github.com/phiggins)
* Added support for Typhoeus::Hydra
* Added support for `Curb::Easy#http_post` and `Curb::Easy#http_post` with multiple arguments. Thanks to [Salvador Fuentes Jr](https://github.com/fuentesjr) and [Alex Rothenberg](https://github.com/alexrothenberg)
* Rack support. Requests can be stubbed to respond with a Rack app i.e.
class MyRackApp
def self.call(env)
[200, {}, ["Hello"]]
end
end
stub_request(:get, "www.example.com").to_rack(MyRackApp)
RestClient.get("www.example.com") # ===> "Hello"
Thanks to [Jay Adkisson](https://github.com/jayferd)
* Added support for selective disabling and enabling of http lib adapters
WebMock.disable! #disable WebMock (all adapters)
WebMock.disable!(:except => [:net_http]) #disable WebMock for all libs except Net::HTTP
WebMock.enable! #enable WebMock (all adapters)
WebMock.enable!(:except => [:patron]) #enable WebMock for all libs except Patron
* The error message on an unstubbed request shows a code snippet with body as a hash when it was in url encoded form.
> RestClient.post('www.example.com', "data[a]=1&data[b]=2", :content_type => 'application/x-www-form-urlencoded')
WebMock::NetConnectNotAllowedError: Real HTTP connections are disabled....
You can stub this request with the following snippet:
stub_request(:post, "http://www.example.com/").
with(:body => {"data"=>{"a"=>"1", "b"=>"2"}},
:headers => { 'Content-Type'=>'application/x-www-form-urlencoded' }).
to_return(:status => 200, :body => "", :headers => {})
Thanks to [Alex Rothenberg](https://github.com/alexrothenberg)
* The error message on an unstubbed request shows currently registered request stubs.
> stub_request(:get, "www.example.net")
> stub_request(:get, "www.example.org")
> RestClient.get("www.example.com")
WebMock::NetConnectNotAllowedError: Real HTTP connections are disabled....
You can stub this request with the following snippet:
stub_request(:get, "http://www.example.com/").
to_return(:status => 200, :body => "", :headers => {})
registered request stubs:
stub_request(:get, "http://www.example.net/")
stub_request(:get, "http://www.example.org/")
Thanks to [Lin Jen-Shin](https://github.com/godfat) for suggesting this feature.
* Fixed problem with matching requests with json body, when json strings have date format. Thanks to [Joakim Ekberg](https://github.com/kalasjocke) for reporting this issue.
* WebMock now attempts to require each http library before monkey patching it. This is to avoid problem when http library is required after WebMock is required. Thanks to [Myron Marston](https://github.com/myronmarston) for suggesting this change.
* External requests can be disabled while allowing selected ports on selected hosts
WebMock.disable_net_connect!(:allow => "www.example.com:8080")
RestClient.get("www.example.com:80") # ===> Failure
RestClient.get("www.example.com:8080") # ===> Allowed.
Thanks to [Zach Dennis](https://github.com/zdennis)
* Fixed syntax error in README examples, showing the ways of setting request expectations. Thanks to [Nikita Fedyashev](https://github.com/nfedyashev)
**Many thanks to WebMock co-maintainer [James Conroy-Finn](https://github.com/jcf) who did a great job maintaining WebMock on his own for the last couple of months.**
## 1.6.4
This is a quick slip release to regenerate the gemspec. Apparently
jeweler inserts dependencies twice if you use the `gemspec` method in
your Gemfile and declare gem dependencies in your gemspec.
https://github.com/technicalpickles/jeweler/issues/154
josevalim:
> This just bit me. I just released a gem with the wrong dependencies
> because I have updated jeweler. This should have been opt-in,
> otherwise a bunch of people using jeweler are going to release gems
> with the wrong dependencies because you are automatically importing
> from the Gemfile.
## 1.6.3
* Update the dependency on addressable to get around an issue in v2.2.5.
Thanks to [Peter Higgins](https://github.com/phiggins).
* Add support for matching parameter values using a regular expression
as well as a string. Thanks to [Oleg M Prozorov](https://github.com/oleg).
* Fix integration with httpclient as the internal API has changed.
Thanks to [Frank Prößdorf](https://github.com/endor).
* Ensure Curl::Easy#content_type is always set. Thanks to [Peter
Higgins](https://github.com/phiggins).
* Fix bug with em-http-request adapter stubbing responses that have a
chunked transfer encoding. Thanks to [Myron
Marston](https://github.com/myronmarston).
* Fix a load of spec failures with Patron, httpclient, and specs that
depended on the behaviour of example.com. Thanks to [Alex
Grigorovich](https://github.com/grig).
## 1.6.2
* Em-http-request adapter sets `last_effective_url` property. Thanks to [Sam Stokes](https://github.com/samstokes).
* Curb adapter supports `Curb::Easy#http_post` and `Curb::Easy#http_put` without arguments (by setting `post_body` or `put_data` beforehand). Thanks to [Eugene Bolshakov](https://github.com/eugenebolshakov)
## 1.6.1
* Fixed issue with `webmock/rspec` which didn't load correctly if `rspec/core` was already required but `rspec/expectations` not.
## 1.6.0
* Simplified integration with Test::Unit, RSpec and Cucumber. Now only a single file has to be required i.e.
require 'webmock/test_unit'
require 'webmock/rspec'
require 'webmock/cucumber'
* The error message on unstubbed request now contains code snippet which can be used to stub this request. Thanks to Martyn Loughran for suggesting this feature.
* The expectation failure message now contains a list of made requests. Thanks to Martyn Loughran for suggesting this feature.
* Added `WebMock.print_executed_requests` method which can be useful to find out what requests were made until a given point.
* em-http-request adapter is now activated by replacing EventMachine::HttpRequest constant, instead of monkeypatching the original class.
This technique is borrowed from em-http-request native mocking module. It allows switching WebMock adapter on an off, and using it interchangeably with em-http-request native mocking i.e:
EventMachine::WebMockHttpRequest.activate!
EventMachine::WebMockHttpRequest.deactivate!
Thanks to Martyn Loughran for suggesting this feature.
* `WebMock.reset_webmock` is deprecated in favour of new `WebMock.reset!`
* Fixed integration with Cucumber. Previously documented example didn't work with new versions of Cucumber.
* Fixed stubbing requests with body declared as a hash. Thanks to Erik Michaels-Ober for reporting the issue.
* Fixed issue with em-http-request adapter which didn't work when :query option value was passed as a string, not a hash. Thanks to Chee Yeo for reporting the issue.
* Fixed problem with assert_requested which didn't work if used outside rspec or test/unit
* Removed dependency on json gem
## 1.5.0
* Support for dynamically evaluated raw responses recorded with `curl -is`
i.e.
`curl -is www.example.com > /tmp/www.example.com.txt`
stub_request(:get, "www.example.com").to_return(lambda { |request| File.new("/tmp/#{request.uri.host.to_s}.txt" }))
* `:net_http_connect_on_start` option can be passed to `WebMock.allow_net_connect!` and `WebMock.disable_net_connect!` methods, i.e.
WebMock.allow_net_connect!(:net_http_connect_on_start => true)
This forces WebMock Net::HTTP adapter to always connect on `Net::HTTP.start`. Check 'Connecting on Net::HTTP.start' in README for more information.
Thanks to Alastair Brunton for reporting the issue and for fix suggestions.
* Fixed an issue where Patron spec tried to remove system temporary directory.
Thanks to Hans de Graaff
* WebMock specs now use RSpec 2
* `rake spec NO_CONNECTION=true` can now be used to only run WebMock specs which do not make real network connections
## 1.4.0
* Curb support!!! Thanks to the awesome work of Pete Higgins!
* `include WebMock` is now deprecated to avoid method and constant name conflicts. Please `include WebMock::API` instead.
* `WebMock::API#request` is renamed to `WebMock::API#a_request` to prevent method name conflicts with i.e. Rails controller specs.
WebMock.request is still available.
* Deprecated `WebMock#request`, `WebMock#allow_net_connect!`, `WebMock#net_connect_allowed?`, `WebMock#registered_request?`, `WebMock#reset_callbacks`, `WebMock#after_request` instance methods. These methods are still available, but only as WebMock class methods.
* Removed `WebMock.response_for_request` and `WebMock.assertion_failure` which were only used internally and were not documented.
* :allow_localhost => true' now permits 0.0.0.0 in addition to 127.0.0.1 and 'localhost'. Thanks to Myron Marston and Mike Gehard for suggesting this.
* Fixed issue with both RSpec 1.x and 2.x being available.
WebMock now tries to use already loaded version of RSpec (1.x or 2.x). Previously it was loading RSpec 2.0 if available, even if RSpec 1.3 was already loaded.
Thanks to Hans de Graaff for reporting this.
* Changed runtime dependency on Addressable version 2.2.2 which fixes handling of percent-escaped '+'
## 1.3.5
* External requests can be disabled while allowing selected hosts. Thanks to Charles Li and Ryan Bigg
This feature was available before only for localhost with `:allow_localhost => true`
WebMock.disable_net_connect!(:allow => "www.example.org")
Net::HTTP.get('www.something.com', '/') # ===> Failure
Net::HTTP.get('www.example.org', '/') # ===> Allowed.
* Fixed Net::HTTP adapter so that it preserves the original behavior of Net::HTTP.
When making a request with a block that calls #read_body on the request,
Net::HTTP causes the body to be set to a Net::ReadAdapter, but WebMock was causing the body to be set to a string.
## 1.3.4
* Fixed Net::HTTP adapter to handle cases where a block with `read_body` call is passed to `request`.
This fixes compatibility with `open-uri`. Thanks to Mark Evans for reporting the issue.
## 1.3.3
* Fixed handling of multiple values for the same response header for Net::HTTP. Thanks to Myron Marston for reporting the issue.
## 1.3.2
* Fixed compatibility with EM-HTTP-Request >= 0.2.9. Thanks to Myron Marston for reporting the issue.
## 1.3.1
* The less hacky way to get the stream behaviour working for em-http-request. Thanks to Martyn Loughran
* Fixed issues where Net::HTTP was not accepting valid nil response body. Thanks to Muness Alrubaie
## 1.3.0
* Added support for [em-http-request](http://github.com/igrigorik/em-http-request)
* Matching query params using a hash
stub_http_request(:get, "www.example.com").with(:query => {"a" => ["b", "c"]})
RestClient.get("http://www.example.com/?a[]=b&a[]=c") # ===> Success
request(:get, "www.example.com").with(:query => {"a" => ["b", "c"]}).should have_been_made # ===> Success
* Matching request body against a hash. Body can be URL-Encoded, JSON or XML.
(Thanks to Steve Tooke for the idea and a solution for url-encoded bodies)
stub_http_request(:post, "www.example.com").
with(:body => {:data => {:a => '1', :b => 'five'}})
RestClient.post('www.example.com', "data[a]=1&data[b]=five",
:content_type => 'application/x-www-form-urlencoded') # ===> Success
RestClient.post('www.example.com', '{"data":{"a":"1","b":"five"}}',
:content_type => 'application/json') # ===> Success
RestClient.post('www.example.com', '',
:content_type => 'application/xml' ) # ===> Success
request(:post, "www.example.com").
with(:body => {:data => {:a => '1', :b => 'five'}},
:headers => 'Content-Type' => 'application/json').should have_been_made # ===> Success
* Request callbacks (Thanks to Myron Marston for all suggestions)
WebMock can now invoke callbacks for stubbed or real requests:
WebMock.after_request do |request_signature, response|
puts "Request #{request_signature} was made and #{response} was returned"
end
invoke callbacks for real requests only and except requests made with Patron client
WebMock.after_request(:except => [:patron], :real_requests_only => true) do |request_signature, response|
puts "Request #{request_signature} was made and #{response} was returned"
end
* `to_raise()` now accepts an exception instance or a string as argument in addition to an exception class
stub_request(:any, 'www.example.net').to_raise(StandardError.new("some error"))
stub_request(:any, 'www.example.net').to_raise("some error")
* Matching requests based on a URI is 30% faster
* Fixed constant namespace issues in HTTPClient adapter. Thanks to Nathaniel Bibler for submitting a patch.
## 1.2.2
* Fixed problem where ArgumentError was raised if query params were made up of an array e.g. data[]=a&data[]=b. Thanks to Steve Tooke
## 1.2.1
* Changed license from GPL to MIT
* Fixed gemspec file. Thanks to Razic
## 1.2.0
* RSpec 2 compatibility. Thanks to Sam Phillips!
* :allow_localhost => true' now permits 127.0.0.1 as well as 'localhost'. Thanks to Mack Earnhardt
* Request URI matching in now 2x faster!
## 1.1.0
* [VCR](http://github.com/myronmarston/vcr/) compatibility. Many thanks to Myron Marston for all suggestions.
* Support for stubbing requests and returning responses with multiple headers with the same name. i.e multiple Accept headers.
stub_http_request(:get, 'www.example.com').
with(:headers => {'Accept' => ['image/png', 'image/jpeg']}).
to_return(:body => 'abc')
RestClient.get('www.example.com',
{"Accept" => ['image/png', 'image/jpeg']}) # ===> "abc\n"
* When real net connections are disabled and unstubbed request is made, WebMock throws WebMock::NetConnectNotAllowedError instead of assertion error or StandardError.
* Added WebMock.version()
## 1.0.0
* Added support for [Patron](http://toland.github.com/patron/)
* Responses dynamically evaluated from block (idea and implementation by Tom Ward)
stub_request(:any, 'www.example.net').
to_return { |request| {:body => request.body} }
RestClient.post('www.example.net', 'abc') # ===> "abc\n"
* Responses dynamically evaluated from lambda (idea and implementation by Tom Ward)
stub_request(:any, 'www.example.net').
to_return(lambda { |request| {:body => request.body} })
RestClient.post('www.example.net', 'abc') # ===> "abc\n"
* Response with custom status message
stub_request(:any, "www.example.com").to_return(:status => [500, "Internal Server Error"])
req = Net::HTTP::Get.new("/")
Net::HTTP.start("www.example.com") { |http| http.request(req) }.message # ===> "Internal Server Error"
* Raising timeout errors (suggested by Jeffrey Jones) (compatibility with Ruby 1.8.6 by Mack Earnhardt)
stub_request(:any, 'www.example.net').to_timeout
RestClient.post('www.example.net', 'abc') # ===> RestClient::RequestTimeout
* External requests can be disabled while allowing localhost (idea and implementation by Mack Earnhardt)
WebMock.disable_net_connect!(:allow_localhost => true)
Net::HTTP.get('www.something.com', '/') # ===> Failure
Net::HTTP.get('localhost:9887', '/') # ===> Allowed. Perhaps to Selenium?
### Bug fixes
* Fixed issue where Net::HTTP adapter didn't work for requests with body responding to read (reported by Tekin Suleyman)
* Fixed issue where request stub with headers declared as nil was matching requests with non empty headers
## 0.9.1
* Fixed issue where response status code was not read from raw (curl -is) responses
## 0.9.0
* Matching requests against provided block (by Sergio Gil)
stub_request(:post, "www.example.com").with { |request| request.body == "abc" }.to_return(:body => "def")
RestClient.post('www.example.com', 'abc') # ===> "def\n"
request(:post, "www.example.com").with { |req| req.body == "abc" }.should have_been_made
#or
assert_requested(:post, "www.example.com") { |req| req.body == "abc" }
* Matching request body against regular expressions (suggested by Ben Pickles)
stub_request(:post, "www.example.com").with(:body => /^.*world$/).to_return(:body => "abc")
RestClient.post('www.example.com', 'hello world') # ===> "abc\n"
* Matching request headers against regular expressions (suggested by Ben Pickles)
stub_request(:post, "www.example.com").with(:headers => {"Content-Type" => /image\/.+/}).to_return(:body => "abc")
RestClient.post('www.example.com', '', {'Content-Type' => 'image/png'}) # ===> "abc\n"
* Replaying raw responses recorded with `curl -is`
`curl -is www.example.com > /tmp/example_curl_-is_output.txt`
raw_response_file = File.new("/tmp/example_curl_-is_output.txt")
from file
stub_request(:get, "www.example.com").to_return(raw_response_file)
or string
stub_request(:get, "www.example.com").to_return(raw_response_file.read)
* Multiple responses for repeated requests
stub_request(:get, "www.example.com").to_return({:body => "abc"}, {:body => "def"})
Net::HTTP.get('www.example.com', '/') # ===> "abc\n"
Net::HTTP.get('www.example.com', '/') # ===> "def\n"
* Multiple responses using chained `to_return()` or `to_raise()` declarations
stub_request(:get, "www.example.com").
to_return({:body => "abc"}).then. #then() just is a syntactic sugar
to_return({:body => "def"}).then.
to_raise(MyException)
Net::HTTP.get('www.example.com', '/') # ===> "abc\n"
Net::HTTP.get('www.example.com', '/') # ===> "def\n"
Net::HTTP.get('www.example.com', '/') # ===> MyException raised
* Specifying number of times given response should be returned
stub_request(:get, "www.example.com").
to_return({:body => "abc"}).times(2).then.
to_return({:body => "def"})
Net::HTTP.get('www.example.com', '/') # ===> "abc\n"
Net::HTTP.get('www.example.com', '/') # ===> "abc\n"
Net::HTTP.get('www.example.com', '/') # ===> "def\n"
* Added support for `Net::HTTP::Post#body_stream`
This fixes compatibility with new versions of RestClient
* WebMock doesn't suppress default request headers added by http clients anymore.
i.e. Net::HTTP adds `'Accept'=>'*/*'` to all requests by default
## 0.8.2
* Fixed issue where WebMock was not closing IO object passed as response body after reading it.
* Ruby 1.9.2 compat: Use `File#expand_path` for require path because "." is not be included in LOAD_PATH since Ruby 1.9.2
## 0.8.1
* Fixed HTTPClient adapter compatibility with Ruby 1.8.6 (reported by Piotr Usewicz)
* Net:HTTP adapter now handles request body assigned as Net::HTTP::Post#body attribute (fixed by Mack Earnhardt)
* Fixed issue where requests were not matching stubs with Accept header set.(reported by Piotr Usewicz)
* Fixed compatibility with Ruby 1.9.1, 1.9.2 and JRuby 1.3.1 (reported by Diego E. “Flameeyes” Pettenò)
* Fixed issue with response body declared as IO object and multiple requests (reported by Niels Meersschaert)
* Fixed "undefined method `assertion_failure'" error (reported by Nick Plante)
## 0.8.0
* Support for HTTPClient (sync and async requests)
* Support for dynamic responses. Response body and headers can be now declared as lambda.
(Thanks to Ivan Vega ( @ivanyv ) for suggesting this feature)
* Support for stubbing and expecting requests with empty body
* Executing non-stubbed request leads to failed expectation instead of error
### Bug fixes
* Basic authentication now works correctly
* Fixed problem where WebMock didn't call a block with the response when block was provided
* Fixed problem where uris with single slash were not matching uris without path provided
## 0.7.3
* Clarified documentation
* Fixed some issues with loading of Webmock classes
* Test::Unit and RSpec adapters have to be required separately
## 0.7.2
* Added support for matching escaped and non escaped URLs
webmock-1.22.6/README.md 0000644 0000041 0000041 00000064467 12646134265 014572 0 ustar www-data www-data WebMock
=======
[](http://badge.fury.io/rb/webmock) [](http://travis-ci.org/bblimke/webmock) [](http://gemnasium.com/bblimke/webmock) [](https://codeclimate.com/github/bblimke/webmock) [](http://inch-ci.org/github/bblimke/webmock)
Library for stubbing and setting expectations on HTTP requests in Ruby.
Features
--------
* Stubbing HTTP requests at low http client lib level (no need to change tests when you change HTTP library)
* Setting and verifying expectations on HTTP requests
* Matching requests based on method, URI, headers and body
* Smart matching of the same URIs in different representations (also encoded and non encoded forms)
* Smart matching of the same headers in different representations.
* Support for Test::Unit
* Support for RSpec
* Support for MiniTest
Supported HTTP libraries
------------------------
* Net::HTTP and libraries based on Net::HTTP (i.e RightHttpConnection, REST Client, HTTParty)
* HTTPClient
* Patron
* EM-HTTP-Request
* Curb (currently only Curb::Easy)
* Typhoeus (currently only Typhoeus::Hydra)
* Excon
* HTTP Gem
* Manticore
Supported Ruby Interpreters
---------------------------
* MRI 1.8.7
* MRI 1.9.1
* MRI 1.9.2
* MRI 1.9.3
* MRI 2.0.0
* MRI 2.1
* MRI 2.2
* MRI 2.3
* REE 1.8.7
* JRuby
* Rubinius
## Installation
gem install webmock
### or to install the latest development version from github master
git clone http://github.com/bblimke/webmock.git
cd webmock
rake install
### Test::Unit
Add the following code to `test/test_helper.rb`
```ruby
require 'webmock/test_unit'
```
### RSpec
Add the following code to `spec/spec_helper`:
```ruby
require 'webmock/rspec'
```
### MiniTest
Add the following code to `test/test_helper`:
```ruby
require 'webmock/minitest'
```
### Cucumber
Create a file `features/support/webmock.rb` with the following contents:
```ruby
require 'webmock/cucumber'
```
### Outside a test framework
You can also use WebMock outside a test framework:
```ruby
require 'webmock'
include WebMock::API
```
## Examples
## Stubbing
### Stubbed request based on uri only and with the default response
```ruby
stub_request(:any, "www.example.com")
Net::HTTP.get("www.example.com", "/") # ===> Success
```
### Stubbing requests based on method, uri, body and headers
```ruby
stub_request(:post, "www.example.com").
with(:body => "abc", :headers => { 'Content-Length' => 3 })
uri = URI.parse("http://www.example.com/")
req = Net::HTTP::Post.new(uri.path)
req['Content-Length'] = 3
res = Net::HTTP.start(uri.host, uri.port) do |http|
http.request(req, "abc")
end # ===> Success
```
### Matching request body and headers against regular expressions
```ruby
stub_request(:post, "www.example.com").
with(:body => /^.*world$/, :headers => {"Content-Type" => /image\/.+/}).
to_return(:body => "abc")
uri = URI.parse('http://www.example.com/')
req = Net::HTTP::Post.new(uri.path)
req['Content-Type'] = 'image/png'
res = Net::HTTP.start(uri.host, uri.port) do |http|
http.request(req, 'hello world')
end # ===> Success
```
### Matching request body against a hash. Body can be URL-Encoded, JSON or XML.
```ruby
stub_request(:post, "www.example.com").
with(:body => {:data => {:a => '1', :b => 'five'}})
RestClient.post('www.example.com', "data[a]=1&data[b]=five",
:content_type => 'application/x-www-form-urlencoded') # ===> Success
RestClient.post('www.example.com', '{"data":{"a":"1","b":"five"}}',
:content_type => 'application/json') # ===> Success
RestClient.post('www.example.com', '',
:content_type => 'application/xml') # ===> Success
```
### Matching request body against partial hash.
```ruby
stub_request(:post, "www.example.com").
with(:body => hash_including({:data => {:a => '1', :b => 'five'}}))
RestClient.post('www.example.com', "data[a]=1&data[b]=five&x=1",
:content_type => 'application/x-www-form-urlencoded') # ===> Success
```
### Matching custom request headers
```ruby
stub_request(:any, "www.example.com").
with(:headers=>{ 'Header-Name' => 'Header-Value' })
uri = URI.parse('http://www.example.com/')
req = Net::HTTP::Post.new(uri.path)
req['Header-Name'] = 'Header-Value'
res = Net::HTTP.start(uri.host, uri.port) do |http|
http.request(req, 'abc')
end # ===> Success
```
### Matching multiple headers with the same name
```ruby
stub_request(:get, 'www.example.com').
with(:headers => {'Accept' => ['image/jpeg', 'image/png'] })
req = Net::HTTP::Get.new("/")
req['Accept'] = ['image/png']
req.add_field('Accept', 'image/jpeg')
Net::HTTP.start("www.example.com") {|http| http.request(req) } # ===> Success
```
### Matching requests against provided block
```ruby
stub_request(:post, "www.example.com").with { |request| request.body == "abc" }
RestClient.post('www.example.com', 'abc') # ===> Success
```
### Request with basic authentication
```ruby
stub_request(:get, "user:pass@www.example.com")
Net::HTTP.start('www.example.com') do |http|
req = Net::HTTP::Get.new('/')
req.basic_auth 'user', 'pass'
http.request(req)
end # ===> Success
```
### Matching uris using regular expressions
```ruby
stub_request(:any, /.*example.*/)
Net::HTTP.get('www.example.com', '/') # ===> Success
```
### Matching uris using RFC 6570 - Basic Example
```ruby
uri_template = Addressable::Template.new "www.example.com/{id}/"
stub_request(:any, uri_template)
Net::HTTP.get('www.example.com', '/webmock/') # ===> Success
```
### Matching uris using RFC 6570 - Advanced Example
```ruby
uri_template =
Addressable::Template.new "www.example.com/thing/{id}.json{?x,y,z}{&other*}"
stub_request(:any, uri_template)
Net::HTTP.get('www.example.com',
'/thing/5.json?x=1&y=2&z=3&anyParam=4') # ===> Success
```
### Matching query params using hash
```ruby
stub_request(:get, "www.example.com").with(:query => {"a" => ["b", "c"]})
RestClient.get("http://www.example.com/?a[]=b&a[]=c") # ===> Success
```
### Matching partial query params using hash
```ruby
stub_request(:get, "www.example.com").
with(:query => hash_including({"a" => ["b", "c"]}))
RestClient.get("http://www.example.com/?a[]=b&a[]=c&x=1") # ===> Success
```
### Stubbing with custom response
```ruby
stub_request(:any, "www.example.com").
to_return(:body => "abc", :status => 200,
:headers => { 'Content-Length' => 3 })
Net::HTTP.get("www.example.com", '/') # ===> "abc"
```
### Response with body specified as IO object
```ruby
File.open('/tmp/response_body.txt', 'w') { |f| f.puts 'abc' }
stub_request(:any, "www.example.com").
to_return(:body => File.new('/tmp/response_body.txt'), :status => 200)
Net::HTTP.get('www.example.com', '/') # ===> "abc\n"
```
### Response with custom status message
```ruby
stub_request(:any, "www.example.com").
to_return(:status => [500, "Internal Server Error"])
req = Net::HTTP::Get.new("/")
Net::HTTP.start("www.example.com") { |http| http.request(req) }.
message # ===> "Internal Server Error"
```
### Replaying raw responses recorded with `curl -is`
```
curl -is www.example.com > /tmp/example_curl_-is_output.txt
```
```ruby
raw_response_file = File.new("/tmp/example_curl_-is_output.txt")
```
from file
```ruby
stub_request(:get, "www.example.com").to_return(raw_response_file)
```
or string
```ruby
stub_request(:get, "www.example.com").to_return(raw_response_file.read)
```
### Responses dynamically evaluated from block
```ruby
stub_request(:any, 'www.example.net').
to_return { |request| {:body => request.body} }
RestClient.post('www.example.net', 'abc') # ===> "abc\n"
```
### Responses dynamically evaluated from lambda
```ruby
stub_request(:any, 'www.example.net').
to_return(lambda { |request| {:body => request.body} })
RestClient.post('www.example.net', 'abc') # ===> "abc\n"
```
### Dynamically evaluated raw responses recorded with `curl -is`
`curl -is www.example.com > /tmp/www.example.com.txt`
```ruby
stub_request(:get, "www.example.com").
to_return(lambda { |request| File.new("/tmp/#{request.uri.host.to_s}.txt") })
```
### Responses with dynamically evaluated parts
```ruby
stub_request(:any, 'www.example.net').
to_return(:body => lambda { |request| request.body })
RestClient.post('www.example.net', 'abc') # ===> "abc\n"
```
### Rack responses
```ruby
class MyRackApp
def self.call(env)
[200, {}, ["Hello"]]
end
end
stub_request(:get, "www.example.com").to_rack(MyRackApp)
RestClient.post('www.example.com') # ===> "Hello"
```
### Raising errors
#### Exception declared by class
```ruby
stub_request(:any, 'www.example.net').to_raise(StandardError)
RestClient.post('www.example.net', 'abc') # ===> StandardError
```
#### or by exception instance
```ruby
stub_request(:any, 'www.example.net').to_raise(StandardError.new("some error"))
```
#### or by string
```ruby
stub_request(:any, 'www.example.net').to_raise("some error")
```
### Raising timeout errors
```ruby
stub_request(:any, 'www.example.net').to_timeout
RestClient.post('www.example.net', 'abc') # ===> RestClient::RequestTimeout
```
### Multiple responses for repeated requests
```ruby
stub_request(:get, "www.example.com").
to_return({:body => "abc"}, {:body => "def"})
Net::HTTP.get('www.example.com', '/') # ===> "abc\n"
Net::HTTP.get('www.example.com', '/') # ===> "def\n"
#after all responses are used the last response will be returned infinitely
Net::HTTP.get('www.example.com', '/') # ===> "def\n"
```
### Multiple responses using chained `to_return()`, `to_raise()` or `to_timeout` declarations
```ruby
stub_request(:get, "www.example.com").
to_return({:body => "abc"}).then. #then() is just a syntactic sugar
to_return({:body => "def"}).then.
to_raise(MyException)
Net::HTTP.get('www.example.com', '/') # ===> "abc\n"
Net::HTTP.get('www.example.com', '/') # ===> "def\n"
Net::HTTP.get('www.example.com', '/') # ===> MyException raised
```
### Specifying number of times given response should be returned
```ruby
stub_request(:get, "www.example.com").
to_return({:body => "abc"}).times(2).then.
to_return({:body => "def"})
Net::HTTP.get('www.example.com', '/') # ===> "abc\n"
Net::HTTP.get('www.example.com', '/') # ===> "abc\n"
Net::HTTP.get('www.example.com', '/') # ===> "def\n"
```
### Removing unused stubs
```ruby
stub_get = stub_request(:get, "www.example.com")
remove_request_stub(stub_get)
```
### Real requests to network can be allowed or disabled
```ruby
WebMock.allow_net_connect!
stub_request(:any, "www.example.com").to_return(:body => "abc")
Net::HTTP.get('www.example.com', '/') # ===> "abc"
Net::HTTP.get('www.something.com', '/') # ===> /.+Something.+/
WebMock.disable_net_connect!
Net::HTTP.get('www.something.com', '/') # ===> Failure
```
### External requests can be disabled while allowing localhost
```ruby
WebMock.disable_net_connect!(:allow_localhost => true)
Net::HTTP.get('www.something.com', '/') # ===> Failure
Net::HTTP.get('localhost:9887', '/') # ===> Allowed. Perhaps to Selenium?
```
### External requests can be disabled while allowing any hostname or port or parts thereof
```ruby
WebMock.disable_net_connect!(:allow => "www.example.org:8080")
RestClient.get('www.something.com', '/') # ===> Failure
RestClient.get('www.example.org', '/') # ===> Failure.
RestClient.get('www.example.org:8080', '/') # ===> Allowed
WebMock.disable_net_connect!(:allow => /ample.org/)
WebMock.disable_net_connect!(:allow => [/ample.org/, /googl/])
RestClient.get('www.example.org', '/') # ===> Allowed
```
## Connecting on Net::HTTP.start
HTTP protocol has 3 steps: connect, request and response (or 4 with close). Most Ruby HTTP client libraries
treat connect as a part of request step, with the exception of `Net::HTTP` which
allows opening connection to the server separately to the request, by using `Net::HTTP.start`.
WebMock API was also designed with connect being part of request step, and it only allows stubbing
requests, not connections. When `Net::HTTP.start` is called, WebMock doesn't know yet whether
a request is stubbed or not. WebMock by default delays a connection until the request is invoked,
so when there is no request, `Net::HTTP.start` doesn't do anything.
**This means that WebMock breaks the Net::HTTP behaviour by default!**
To workaround this issue, WebMock offers `:net_http_connect_on_start` option,
which can be passed to `WebMock.allow_net_connect!` and `WebMock#disable_net_connect!` methods, i.e.
```ruby
WebMock.allow_net_connect!(:net_http_connect_on_start => true)
```
This forces WebMock Net::HTTP adapter to always connect on `Net::HTTP.start`.
## Setting Expectations
### Setting expectations in Test::Unit
```ruby
require 'webmock/test_unit'
stub_request(:any, "www.example.com")
uri = URI.parse('http://www.example.com/')
req = Net::HTTP::Post.new(uri.path)
req['Content-Length'] = 3
res = Net::HTTP.start(uri.host, uri.port) do |http|
http.request(req, 'abc')
end
assert_requested :post, "http://www.example.com",
:headers => {'Content-Length' => 3}, :body => "abc",
:times => 1 # ===> Success
assert_not_requested :get, "http://www.something.com" # ===> Success
assert_requested(:post, "http://www.example.com",
:times => 1) { |req| req.body == "abc" }
```
### Expecting real (not stubbed) requests
```ruby
WebMock.allow_net_connect!
Net::HTTP.get('www.example.com', '/') # ===> Success
assert_requested :get, "http://www.example.com" # ===> Success
```
### Setting expectations in Test::Unit on the stub
```ruby
stub_get = stub_request(:get, "www.example.com")
stub_post = stub_request(:post, "www.example.com")
Net::HTTP.get('www.example.com', '/')
assert_requested(stub_get)
assert_not_requested(stub_post)
```
### Setting expectations in RSpec on `WebMock` module
This style is borrowed from [fakeweb-matcher](http://github.com/pat/fakeweb-matcher)
```ruby
require 'webmock/rspec'
expect(WebMock).to have_requested(:get, "www.example.com").
with(:body => "abc", :headers => {'Content-Length' => 3}).twice
expect(WebMock).not_to have_requested(:get, "www.something.com")
expect(WebMock).to have_requested(:post, "www.example.com").
with { |req| req.body == "abc" }
# Note that the block with `do ... end` instead of curly brackets won't work!
# Why? See this comment https://github.com/bblimke/webmock/issues/174#issuecomment-34908908
expect(WebMock).to have_requested(:get, "www.example.com").
with(:query => {"a" => ["b", "c"]})
expect(WebMock).to have_requested(:get, "www.example.com").
with(:query => hash_including({"a" => ["b", "c"]}))
expect(WebMock).to have_requested(:get, "www.example.com").
with(:body => {"a" => ["b", "c"]},
:headers => {'Content-Type' => 'application/json'})
```
### Setting expectations in RSpec with `a_request`
```ruby
expect(a_request(:post, "www.example.com").
with(:body => "abc", :headers => {'Content-Length' => 3})).
to have_been_made.once
expect(a_request(:post, "www.something.com")).to have_been_made.times(3)
expect(a_request(:post, "www.something.com")).to have_been_made.at_least_once
expect(a_request(:post, "www.something.com")).
to have_been_made.at_least_times(3)
expect(a_request(:post, "www.something.com")).to have_been_made.at_most_twice
expect(a_request(:post, "www.something.com")).to have_been_made.at_most_times(3)
expect(a_request(:any, "www.example.com")).not_to have_been_made
expect(a_request(:post, "www.example.com").with { |req| req.body == "abc" }).
to have_been_made
expect(a_request(:get, "www.example.com").with(:query => {"a" => ["b", "c"]})).
to have_been_made
expect(a_request(:get, "www.example.com").
with(:query => hash_including({"a" => ["b", "c"]}))).to have_been_made
expect(a_request(:post, "www.example.com").
with(:body => {"a" => ["b", "c"]},
:headers => {'Content-Type' => 'application/json'})).to have_been_made
```
### Setting expectations in RSpec on the stub
```ruby
stub = stub_request(:get, "www.example.com")
# ... make requests ...
expect(stub).to have_been_requested
```
## Clearing stubs and request history
If you want to reset all current stubs and history of requests use `WebMock.reset!`
```ruby
stub_request(:any, "www.example.com")
Net::HTTP.get('www.example.com', '/') # ===> Success
WebMock.reset!
Net::HTTP.get('www.example.com', '/') # ===> Failure
assert_not_requested :get, "www.example.com" # ===> Success
```
## Disabling and enabling WebMock or only some http client adapters
```ruby
# Disable WebMock (all adapters)
WebMock.disable!
# Disable WebMock for all libs except Net::HTTP
WebMock.disable!(:except => [:net_http])
# Enable WebMock (all adapters)
WebMock.enable!
# Enable WebMock for all libs except Patron
WebMock.enable!(:except => [:patron])
```
## Matching requests
An executed request matches stubbed request if it passes following criteria:
- When request URI matches stubbed request URI string, Regexp pattern or RFC 6570 URI Template
- And request method is the same as stubbed request method or stubbed request method is :any
- And request body is the same as stubbed request body or stubbed request body is not specified
- And request headers match stubbed request headers, or stubbed request headers match a subset of request headers, or stubbed request headers are not specified
- And request matches provided block or block is not provided
## Precedence of stubs
Always the last declared stub matching the request will be applied i.e:
```ruby
stub_request(:get, "www.example.com").to_return(:body => "abc")
stub_request(:get, "www.example.com").to_return(:body => "def")
Net::HTTP.get('www.example.com', '/') # ====> "def"
```
## Matching URIs
WebMock will match all different representations of the same URI.
I.e all the following representations of the URI are equal:
```ruby
"www.example.com"
"www.example.com/"
"www.example.com:80"
"www.example.com:80/"
"http://www.example.com"
"http://www.example.com/"
"http://www.example.com:80"
"http://www.example.com:80/"
```
The following URIs with basic authentication are also equal for WebMock
```ruby
"a b:pass@www.example.com"
"a b:pass@www.example.com/"
"a b:pass@www.example.com:80"
"a b:pass@www.example.com:80/"
"http://a b:pass@www.example.com"
"http://a b:pass@www.example.com/"
"http://a b:pass@www.example.com:80"
"http://a b:pass@www.example.com:80/"
"a%20b:pass@www.example.com"
"a%20b:pass@www.example.com/"
"a%20b:pass@www.example.com:80"
"a%20b:pass@www.example.com:80/"
"http://a%20b:pass@www.example.com"
"http://a%20b:pass@www.example.com/"
"http://a%20b:pass@www.example.com:80"
"http://a%20b:pass@www.example.com:80/"
```
or these
```ruby
"www.example.com/my path/?a=my param&b=c"
"www.example.com/my%20path/?a=my%20param&b=c"
"www.example.com:80/my path/?a=my param&b=c"
"www.example.com:80/my%20path/?a=my%20param&b=c"
"http://www.example.com/my path/?a=my param&b=c"
"http://www.example.com/my%20path/?a=my%20param&b=c"
"http://www.example.com:80/my path/?a=my param&b=c"
"http://www.example.com:80/my%20path/?a=my%20param&b=c"
```
If you provide Regexp to match URI, WebMock will try to match it against every valid form of the same url.
I.e `/.*my path.*/` will match `www.example.com/my%20path` because it is equivalent of `www.example.com/my path`
## Matching with URI Templates
If you use [Addressable::Template](https://github.com/sporkmonger/addressable#uri-templates) for matching, then WebMock will defer the matching rules to Addressable, which complies with [RFC 6570](http://tools.ietf.org/html/rfc6570).
If you use any of the WebMock methods for matching query params, then Addressable will be used to match the base URI and WebMock will match the query params. If you do not, then WebMock will let Addressable match the full URI.
## Matching headers
WebMock will match request headers against stubbed request headers in the following situations:
1. Stubbed request has headers specified and request headers are the same as stubbed headers
i.e stubbed headers: `{ 'Header1' => 'Value1', 'Header2' => 'Value2' }`, requested: `{ 'Header1' => 'Value1', 'Header2' => 'Value2' }`
2. Stubbed request has headers specified and stubbed request headers are a subset of request headers
i.e stubbed headers: `{ 'Header1' => 'Value1' }`, requested: `{ 'Header1' => 'Value1', 'Header2' => 'Value2' }`
3. Stubbed request has no headers
i.e stubbed headers: `nil`, requested: `{ 'Header1' => 'Value1', 'Header2' => 'Value2' }`
WebMock normalises headers and treats all forms of same headers as equal:
i.e the following two sets of headers are equal:
`{ "Header1" => "value1", :content_length => 123, :X_CuStOm_hEAder => :value }`
`{ :header1 => "value1", "Content-Length" => 123, "x-cuSTOM-HeAder" => "value" }`
## Recording real requests and responses and replaying them later
To record your application's real HTTP interactions and replay them later in tests you can use [VCR](https://github.com/vcr/vcr) with WebMock.
## Request callbacks
#### WebMock can invoke callbacks stubbed or real requests:
```ruby
WebMock.after_request do |request_signature, response|
puts "Request #{request_signature} was made and #{response} was returned"
end
```
#### invoke callbacks for real requests only and except requests made with Patron
```ruby
WebMock.after_request(:except => [:patron],
:real_requests_only => true) do |req_signature, response|
puts "Request #{req_signature} was made and #{response} was returned"
end
```
## Bugs and Issues
Please submit them here [http://github.com/bblimke/webmock/issues](http://github.com/bblimke/webmock/issues)
## Suggestions
If you have any suggestions on how to improve WebMock please send an email to the mailing list [groups.google.com/group/webmock-users](http://groups.google.com/group/webmock-users)
I'm particularly interested in how the DSL could be improved.
## Development
In order to work on Webmock you first need to fork and clone the repo.
Please do any work on a dedicated branch and rebase against master
before sending a pull request.
#### Running Tests
We use RVM in order to test WebMock against 1.8.6, REE, 1.8.7, 1.9.2 and
jRuby. You can get RVM setup for WebMock development using the
following commands (if you don't have these version of Ruby installed
use `rvm install` to install each of them).
rvm use --create 1.8.6@webmock
gem install jeweler bundler
bundle install
rvm use --create ree@webmock
gem install jeweler bundler
bundle install
rvm use --create 1.8.7@webmock
gem install jeweler bundler
bundle install
rvm use --create 1.9.2@webmock
gem install jeweler bundler
bundle install
rvm use --create jruby@webmock
gem install jeweler bundler
bundle install
These commands will create a gemset named WebMock for each of the
supported versions of Ruby and `bundle install` all dependencies.
With the supported versions of Ruby installed RVM will run specs across
all version with just one command.
bundle exec rvm 1.8.6@webmock,ree@webmock,1.8.7@webmock,1.9.2@webmock,jruby@webmock rspec spec/**/*_spec.rb
This command is wrapped up in to a rake task and can be invoked like so:
rake rvm:specs
## Credits
The initial lines of this project were written during New Bamboo [Hack Day](http://blog.new-bamboo.co.uk/2009/11/13/hackday-results)
Thanks to my fellow [Bambinos](http://new-bamboo.co.uk/) for all the great suggestions!
People who submitted patches and new features or suggested improvements. Many thanks to these people:
* Ben Pickles
* Mark Evans
* Ivan Vega
* Piotr Usewicz
* Nick Plante
* Nick Quaranto
* Diego E. "Flameeyes" Pettenò
* Niels Meersschaert
* Mack Earnhardt
* Arvicco
* Sergio Gil
* Jeffrey Jones
* Tekin Suleyman
* Tom Ward
* Nadim Bitar
* Myron Marston
* Sam Phillips
* Jose Angel Cortinas
* Razic
* Steve Tooke
* Nathaniel Bibler
* Martyn Loughran
* Muness Alrubaie
* Charles Li
* Ryan Bigg
* Pete Higgins
* Hans de Graaff
* Alastair Brunton
* Sam Stokes
* Eugene Bolshakov
* James Conroy-Finn
* Salvador Fuentes Jr
* Alex Rothenberg
* Aidan Feldman
* Steve Hull
* Jay Adkisson
* Zach Dennis
* Nikita Fedyashev
* Lin Jen-Shin
* David Yeu
* Andreas Garnæs
* Roman Shterenzon
* Chris McGrath
* Stephen Celis
* Eugene Pimenov
* Albert Llop
* Christopher Pickslay
* Tammer Saleh
* Nicolas Fouché
* Joe Van Dyk
* Mark Abramov
* Frank Schumacher
* Dimitrij Denissenko
* Marnen Laibow-Koser
* Evgeniy Dolzhenko
* Nick Recobra
* Jordan Elver
* Joe Karayusuf
* Paul Cortens
* jugyo
* aindustries
* Eric Oestrich
* erwanlr
* Ben Bleything
* Jon Leighton
* Ryan Schlesinger
* Julien Boyer
* Kevin Glowacz
* Hans Hasselberg
* Andrew France
* Jonathan Hyman
* Rex Feng
* Pavel Forkert
* Jordi Massaguer Pla
* Jake Benilov
* Tom Beauvais
* Mokevnin Kirill
* Alex Grant
* Lucas Dohmen
* Bastien Vaucher
* Joost Baaij
* Joel Chippindale
* Murahashi Sanemat Kenichi
* Tim Kurvers
* Ilya Vassilevsky
* gotwalt
* Leif Bladt
* Alex Tomlins
* Mitsutaka Mimura
* Tomy Kaira
* Daniel van Hoesel
* Ian Asaff
* Ian Lesperance
* Matthew Horan
* Dmitry Gutov
* Florian Dütsch
* Manuel Meurer
* Brian D. Burns
* Riley Strong
* Tamir Duberstein
* Stefano Uliari
* Alex Stupakov
* Karen Wang
* Matt Burke
* Jon Rowe
* Aleksey V. Zapparov
* Praveen Arimbrathodiyil
* Bo Jeanes
* Matthew Conway
* Rob Olson
* Max Lincoln
* Oleg Gritsenko
* Hwan-Joon Choi
* SHIBATA Hiroshi
* Caleb Thompson
* Theo Hultberg
* Pablo Jairala
* Insoo Buzz Jung
* Carlos Alonso Pérez
* trlorenz
* Alexander Simonov
* Thorbjørn Hermanse
* Mark Lorenz
* tjsousa
* Tasos Stathopoulos
* Dan Buettner
* Sven Riedel
* Mark Lorenz
* Dávid Kovács
* fishermand46
* Franky Wahl
* ChaYoung You
* Simon Russell
* Steve Mitchell
* Mattias Putman
* Zachary Anker
* Emmanuel Sambo
* Ramon Tayag
* Johannes Schlumberger
* Siôn Le Roux
* Matt Palmer
* Zhao Wen
* Krzysztof Rygielski
* Magne Land
* yurivm
* Mike Knepper
* Charles Pence
* Alexey Zapparov
For a full list of contributors you can visit the
[contributors](https://github.com/bblimke/webmock/contributors) page.
## Background
Thank you Fakeweb! This library was inspired by [FakeWeb](http://fakeweb.rubyforge.org).
I imported some solutions from that project to WebMock. I also copied some code i.e Net:HTTP adapter.
Fakeweb architecture unfortunately didn't allow me to extend it easily with the features I needed.
I also preferred some things to work differently i.e request stub precedence.
## Copyright
Copyright (c) 2009-2010 Bartosz Blimke. See LICENSE for details.
webmock-1.22.6/minitest/ 0000755 0000041 0000041 00000000000 12646134265 015126 5 ustar www-data www-data webmock-1.22.6/minitest/test_webmock.rb 0000644 0000041 0000041 00000000435 12646134265 020143 0 ustar www-data www-data require File.expand_path(File.dirname(__FILE__) + '/test_helper')
require File.expand_path(File.dirname(__FILE__) + '/../test/shared_test')
test_class = defined?(MiniTest::Test) ? MiniTest::Test : MiniTest::Unit::TestCase
class MiniTestWebMock < test_class
include SharedTest
end
webmock-1.22.6/minitest/test_helper.rb 0000644 0000041 0000041 00000001437 12646134265 017776 0 ustar www-data www-data require 'rubygems'
$LOAD_PATH.unshift(File.dirname(__FILE__))
$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
require File.expand_path(File.dirname(__FILE__) + '/../test/http_request')
gem 'minitest'
require 'minitest/autorun'
require 'webmock/minitest'
test_class = defined?(MiniTest::Test) ? MiniTest::Test : MiniTest::Unit::TestCase
test_class.class_eval do
def assert_raise(*exp, &block)
assert_raises(*exp, &block)
end
def assert_raise_with_message(e, message, &block)
e = assert_raises(e, &block)
if message.is_a?(Regexp)
assert_match(message, e.message)
else
assert_equal(message, e.message)
end
end
def assert_fail(message, &block)
assert_raise_with_message(MiniTest::Assertion, message, &block)
end
end
webmock-1.22.6/minitest/webmock_spec.rb 0000644 0000041 0000041 00000004376 12646134265 020126 0 ustar www-data www-data require File.expand_path(File.dirname(__FILE__) + '/test_helper')
describe "Webmock" do
include HttpRequestTestHelper
before do
@stub_http = stub_http_request(:any, "http://www.example.com")
@stub_https = stub_http_request(:any, "https://www.example.com")
end
it "should update assertions count" do
assert_equal 0, assertions
http_request(:get, "http://www.example.com/")
assert_requested(@stub_http)
assert_equal 2, assertions
assert_not_requested(:post, "http://www.example.com")
assert_equal 4, assertions
end
it "should raise error on non stubbed request" do
lambda { http_request(:get, "http://www.example.net/") }.must_raise(WebMock::NetConnectNotAllowedError)
end
it "should verify that expected request occured" do
http_request(:get, "http://www.example.com/")
assert_requested(:get, "http://www.example.com", :times => 1)
assert_requested(:get, "http://www.example.com")
end
it "should verify that expected http stub occured" do
http_request(:get, "http://www.example.com/")
assert_requested(@stub_http, :times => 1)
assert_requested(@stub_http)
end
it "should verify that expected https stub occured" do
http_request(:get, "https://www.example.com/")
http_request(:get, "https://www.example.com/")
assert_requested(@stub_https, :times => 2)
end
it "should verify that expect request didn't occur" do
expected_message = "The request GET http://www.example.com/ was expected to execute 1 time but it executed 0 times"
expected_message << "\n\nThe following requests were made:\n\nNo requests were made.\n============================================================"
assert_fail(expected_message) do
assert_requested(:get, "http://www.example.com")
end
end
it "should verify that expect stub didn't occur" do
expected_message = "The request ANY http://www.example.com/ was expected to execute 1 time but it executed 0 times"
expected_message << "\n\nThe following requests were made:\n\nNo requests were made.\n============================================================"
assert_fail(expected_message) do
assert_requested(@stub_http)
end
end
end