simple-client 0.0.2

data/vendor/bundle/ruby/1.8/gems/webmock-1.8.8/spec/acceptance/shared/stubbing_requests.rb

@@ -0,0 +1,447 @@
+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")
+        http_request(:get, "http://www.example.com/hello/?#{ESCAPED_PARAMS}").body.should == "abc"
+      end
+
+      it "should return stubbed response even if request has non escaped params" do
+        stub_request(:get, "www.example.com/hello/?#{ESCAPED_PARAMS}").to_return(:body => "abc")
+        http_request(:get, "http://www.example.com/hello/?#{NOT_ESCAPED_PARAMS}").body.should == "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")
+        http_request(:get, "http://www.example.com/hello/?#{ESCAPED_PARAMS}").body.should == "abc"
+      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", "c"]}).to_return(:body => "abc")
+        http_request(:get, "http://www.example.com/?a[]=b&a[]=c").body.should == "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")
+        http_request(:get, "http://www.example.com/?a[]=b&a[]=c").body.should == "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")
+        http_request(:get, "http://www.example.com/?x=3&a[]=b&a[]=c").body.should == "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")
+        http_request(:get, "http://www.example.com/?a[]=b&a[]=c&b=1").body.should == "abc"
+      end
+    end
+
+    describe "based on method" do
+      it "should return stubbed response" do
+        stub_request(:get, "www.example.com")
+        http_request(:get, "http://www.example.com/").status.should == "200"
+      end
+
+      it "should raise error if stubbed request has different method" do
+        stub_request(:get, "www.example.com")
+        http_request(:get, "http://www.example.com/").status.should == "200"
+        lambda {
+          http_request(:delete, "http://www.example.com/")
+        }.should 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")
+        http_request(
+          :post, "http://www.example.com/",
+        :body => "abc").status.should == "200"
+      end
+
+      it "should match requests if body is not set in the stub" do
+        stub_request(:post, "www.example.com")
+        http_request(
+          :post, "http://www.example.com/",
+        :body => "abc").status.should == "200"
+      end
+
+      it "should not match requests if body is different" do
+        stub_request(:post, "www.example.com").with(:body => "abc")
+        lambda {
+          http_request(:post, "http://www.example.com/", :body => "def")
+        }.should 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$/)
+          http_request(
+            :post, "http://www.example.com/",
+          :body => "123abc").status.should == "200"
+        end
+
+        it "should not match requests if body doesn't match regexp" do
+          stub_request(:post, "www.example.com").with(:body => /^abc/)
+          lambda {
+            http_request(:post, "http://www.example.com/", :body => "xabc")
+          }.should 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', 'c' => {'d' => ['e', 'f']} })
+        end
+
+        describe "for request with url encoded body" do
+          it "should match request if hash matches body" do
+            http_request(
+              :post, "http://www.example.com/",
+            :body => 'a=1&c[d][]=e&c[d][]=f&b=five').status.should == "200"
+          end
+
+          it "should match request if hash matches body in different order of params" do
+            http_request(
+              :post, "http://www.example.com/",
+            :body => 'a=1&c[d][]=e&b=five&c[d][]=f').status.should == "200"
+          end
+
+          it "should not match if hash doesn't match url encoded body" do
+            lambda {
+              http_request(
+                :post, "http://www.example.com/",
+              :body => 'c[d][]=f&a=1&c[d][]=e')
+            }.should 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
+            http_request(
+              :post, "http://www.example.com/", :headers => {'Content-Type' => 'application/json'},
+            :body => "{\"a\":\"1\",\"c\":{\"d\":[\"e\",\"f\"]},\"b\":\"five\"}").status.should == "200"
+          end
+
+          it "should match if hash matches body in different form" do
+            http_request(
+              :post, "http://www.example.com/", :headers => {'Content-Type' => 'application/json'},
+            :body => "{\"a\":\"1\",\"b\":\"five\",\"c\":{\"d\":[\"e\",\"f\"]}}").status.should == "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"})
+            http_request(
+              :post, "http://www.example.com/", :headers => {'Content-Type' => 'application/json'},
+            :body => "{\"foo\":\"2010-01-01\"}").status.should == "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
+            http_request(
+              :post, "http://www.example.com/", :headers => {'Content-Type' => 'application/xml'},
+            :body => "<opt a=\"1\" b=\"five\">\n  <c>\n    <d>e</d>\n    <d>f</d>\n  </c>\n</opt>\n").status.should == "200"
+          end
+
+          it "should match if hash matches body in different form" do
+            http_request(
+              :post, "http://www.example.com/", :headers => {'Content-Type' => 'application/xml'},
+            :body => "<opt b=\"five\" a=\"1\">\n  <c>\n    <d>e</d>\n    <d>f</d>\n  </c>\n</opt>\n").status.should == "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"}})
+            http_request(
+              :post, "http://www.example.com/", :headers => {'Content-Type' => 'application/xml'},
+            :body => "<opt foo=\"2010-01-01\">\n</opt>\n").status.should == "200"
+          end
+        end
+      end
+
+      describe "when body is declared as partial hash matcher" do
+        before(:each) do
+          stub_request(:post, "www.example.com").
+            with(:body => hash_including({:a => '1', 'c' => {'d' => ['e', 'f']} }))
+        end
+
+        describe "for request with url encoded body" do
+          it "should match request if hash matches body" do
+            http_request(
+              :post, "http://www.example.com/",
+            :body => 'a=1&c[d][]=e&c[d][]=f&b=five').status.should == "200"
+          end
+
+          it "should not match if hash doesn't match url encoded body" do
+            lambda {
+              http_request(
+                :post, "http://www.example.com/",
+              :body => 'c[d][]=f&a=1&c[d][]=e').status
+            }.should 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
+            http_request(
+              :post, "http://www.example.com/", :headers => {'Content-Type' => 'application/json'},
+            :body => "{\"a\":\"1\",\"c\":{\"d\":[\"e\",\"f\"]},\"b\":\"five\"}").status.should == "200"
+          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 )
+        http_request(
+          :get, "http://www.example.com/",
+        :headers => SAMPLE_HEADERS).status.should == "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"]} )
+        http_request(
+          :get, "http://www.example.com/",
+        :headers => {"a" => "b"}).status.should == "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"]} )
+          http_request(
+            :get, "http://www.example.com/",
+          :headers => {"a" => ["b", "c"]}).status.should == "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"]} )
+          http_request(
+            :get, "http://www.example.com/",
+          :headers => {"a" => ["c", "b"]}).status.should == "200"
+        end
+
+        it "should not match requests if headers are different" do
+          stub_request(:get, "www.example.com").with(:headers => {"a" => ["b", "c"]})
+
+          lambda {
+            http_request(
+              :get, "http://www.example.com/",
+            :headers => {"a" => ["b", "d"]})
+          }.should 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")
+        http_request(
+          :get, "http://www.example.com/",
+        :headers => SAMPLE_HEADERS).status.should == "200"
+      end
+
+      it "should not match requests if headers are different" do
+        stub_request(:get, "www.example.com").with(:headers => SAMPLE_HEADERS)
+
+        lambda {
+          http_request(
+            :get, "http://www.example.com/",
+          :headers => { 'Content-Length' => '9999'})
+        }.should 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'})
+        lambda {
+          http_request(
+            :get, "http://www.example.com/",
+          :headers => { 'Accept' => 'application/xml'})
+        }.should 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$/ })
+          http_request(
+            :get, "http://www.example.com/",
+          :headers => { 'some-header' => 'MyAppName' }).status.should == "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$/ })
+
+          lambda {
+            http_request(
+              :get, "http://www.example.com/",
+            :headers => { 'some-header' => 'xMyAppName' })
+          }.should 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")
+        http_request(:get, "http://user:pass@www.example.com/").status.should == "200"
+      end
+
+      it "should not match if credentials are different" do
+        stub_request(:get, "user:pass@www.example.com")
+        lambda {
+          http_request(:get, "http://user:pazz@www.example.com/").status.should == "200"
+        }.should 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")
+        lambda {
+          http_request(:get, "http://www.example.com/").status.should == "200"
+        }.should 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")
+        lambda {
+          http_request(:get, "http://user:pazz@www.example.com/").status.should == "200"
+        }.should 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
+
+        http_request(:get, "http://www.example.com/").body.should == "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!
+        http_request(:get, "http://www.example.com/").body.should == "global stub body"
+      end
+
+      it "does not stub the request if the hook does not return anything" do
+        WebMock.globally_stub_request { |r| }
+        lambda {
+          http_request(:get, "http://www.example.com/")
+        }.should 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")
+        passed_request.uri.to_s.should == "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/")
+        call_count.should == 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
+
+        http_request(:get, "http://www.example.com/").body.should == "global stub body"
+        stub_invocation_order.should 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' } })
+            http_request(:get, "http://www.example.com/").body.should == "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 })
+            http_request(:get, "http://www.example.com/").body.should == "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 }
+        http_request(:get, "http://www.example.com/").status.should == "200"
+      end
+
+      it "should not match if block returns false" do
+        stub_request(:get, "www.example.com").with { |request| false }
+        lambda {
+          http_request(:get, "http://www.example.com/")
+        }.should 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" }
+        http_request(
+          :post, "http://www.example.com/",
+        :body => "wadus").status.should == "200"
+        lambda {
+          http_request(:post, "http://www.example.com/", :body => "jander")
+        }.should 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 }
+        http_request(:get, "http://www.example.com/").status.should == "200"
+        call_count.should == 1
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/1.8/gems/webmock-1.8.8/spec/acceptance/typhoeus/typhoeus_hydra_spec.rb

@@ -0,0 +1,74 @@
+require 'spec_helper'
+require 'acceptance/webmock_shared'
+
+unless RUBY_PLATFORM =~ /java/
+  require 'acceptance/typhoeus/typhoeus_hydra_spec_helper'
+
+  describe "Typhoeus::Hydra" do
+    include TyphoeusHydraSpecHelper
+
+    include_context "with WebMock"
+
+    describe "Typhoeus::Hydra features" do
+      before(:each) do
+        WebMock.disable_net_connect!
+        WebMock.reset!
+      end
+
+      describe "when params are used" do
+        it "should take into account params for POST request" do
+          stub_request(:post, "www.example.com").with(:body => {:hello => 'world'})
+          Typhoeus::Request.post("www.example.com", :params => {:hello => 'world'})
+        end
+
+        it "should take into account params for GET request" do
+          stub_request(:get, "http://www.example.com/?hello=world")
+          Typhoeus::Request.get("www.example.com", :params => {:hello => 'world'})
+        end
+      end
+
+      describe "timeouts" do
+        it "should support native typhoeus timeouts" do
+          stub_request(:any, "example.com").to_timeout
+
+          response = Typhoeus::Request.get("http://example.com")
+
+          response.should be_timed_out
+        end
+      end
+
+      describe "callbacks" do
+        before(:each) do
+          @hydra = Typhoeus::Hydra.new
+          @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
+          @hydra.on_complete do |c|
+            test = c.body
+          end
+          @hydra.queue @request
+          @hydra.run
+          test.should == 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
+          @hydra.on_complete do |c|
+            test = c.code
+          end
+          @hydra.queue @request
+          @hydra.run
+          test.should == response_code
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/1.8/gems/webmock-1.8.8/spec/acceptance/typhoeus/typhoeus_hydra_spec_helper.rb

@@ -0,0 +1,56 @@
+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(:initial_pool_size => 0)
+    hydra.queue(request)
+    hydra.run
+    response = request.response
+    raise FakeTyphoeusHydraTimeoutError.new if response.timed_out?
+    raise FakeTyphoeusHydraConnectError.new if response.code == 0
+    OpenStruct.new({
+      :body => response.body,
+      :headers => WebMock::Util::Headers.normalize_headers(join_array_values(response.headers_hash)),
+      :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

data/vendor/bundle/ruby/1.8/gems/webmock-1.8.8/spec/acceptance/webmock_shared.rb

@@ -0,0 +1,41 @@
+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"
+  NOT_ESCAPED_PARAMS = "z='Stop!' said Fred&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

data/vendor/bundle/ruby/1.8/gems/webmock-1.8.8/spec/quality_spec.rb

@@ -0,0 +1,60 @@
+require "spec_helper"
+
+# Borrowed from Bundler
+# https://github.com/carlhuda/bundler/blob/1-0-stable/spec/quality_spec.rb
+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_for_should 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
+    error_messages.compact.should be_well_formed
+  end
+
+  it "can still be built" do
+    Dir.chdir(File.expand_path('../../', __FILE__)) do
+      `gem build webmock.gemspec`
+      $?.should == 0
+
+      # clean up the .gem generated
+      system("rm webmock-#{WebMock.version}.gem")
+    end
+  end
+end