dnclabs-fakeweb-matcher 1.1.0

data/LICENSE

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

data/README.textile

@@ -0,0 +1,35 @@
+h1. FakeWeb Matcher
+
+An RSpec matcher for the Fakeweb HTTP stubbing library, allowing you to use RSpec syntax to check if requests to particular URIs have been made.
+
+h2. Installing
+
+First, install the gem
+<pre><code>gem install fakeweb-matcher --source http://gemcutter.org</code></pre>
+
+Then, in your @spec/spec_helper.rb@ file, you'll need to require the library _after_ you have required "FakeWeb":http://fakeweb.rubyforge.org and "RSpec":http://rspec.info. It should end up looking something like this:
+
+<pre><code>require 'spec'
+require 'fakeweb'
+require 'fakeweb_matcher'</code></pre>
+
+This ensures that the matcher is automatically loaded into RSpec for you.
+
+h2. Usage
+
+<pre><code>FakeWeb.should have_requested(:get, 'http://example.com')
+FakeWeb.should have_requested(:any, 'http://example.com')
+FakeWeb.should have_requested(:post, /http:\/\/example.com\/)
+FakeWeb.should_not have_requested(:put, 'http://example.com')</code></pre>
+
+h2. Contribution
+
+Unsurprisingly, this library is tested using RSpec, and relies upon FakeWeb. It also uses "YARD":http://yard.soen.ca/ for documentation, so if you're submitting patches (which are most definitely welcome!) please use YARD syntax and have valid specs.
+
+h2. Contributors
+
+* "Thilo Utke":http://github.com/thilo (Regex URL matching)
+
+h2. Copyright
+
+Copyright (c) 2009 Pat Allan, released under an MIT Licence

data/Rakefile

@@ -0,0 +1,4 @@
+require 'tasks/distribution'
+require 'tasks/testing'
+
+task :default => :spec

data/VERSION.yml

@@ -0,0 +1,4 @@
+--- 
+:major: 1
+:minor: 1
+:patch: 0

data/lib/fake_web_matcher.rb

@@ -0,0 +1,37 @@
+require 'fake_web_matcher/extension'
+require 'fake_web_matcher/matchers'
+require 'fake_web_matcher/request_matcher'
+
+# An RSpec matcher for the Fakeweb HTTP stubbing library, allowing you to use
+# RSpec syntax to check if requests to particular URIs have been made.
+# 
+# The matcher is automatically included into RSpec's set, and can be used as
+# follows:
+# 
+# @example
+#   FakeWeb.should have_requested(:get, 'http://example.com')
+#   FakeWeb.should have_requested(:any, 'http://example.com')
+#   FakeWeb.should_not have_requested(:put, 'http://example.com')
+# 
+# @see FakeWebMatcher::Matchers
+# @see http://fakeweb.rubyforge.org
+# @author Pat Allan
+# 
+module FakeWebMatcher
+  #
+end
+
+FakeWeb::Registry.class_eval do
+  # Don't like doing this, but need some way to track the requests
+  include FakeWebMatcher::Extension
+end
+
+Spec::Runner.configure { |config|
+  # Adding the custom matcher to the default set
+  config.include FakeWebMatcher::Matchers
+  
+  # Ensuring the request list gets cleared after each spec
+  config.before :each do
+    FakeWeb::Registry.instance.clear_requests
+  end
+}

data/lib/fake_web_matcher/extension.rb

@@ -0,0 +1,43 @@
+module FakeWebMatcher
+  # Extension for FakeWeb::Registry, to track requests made for given URIs. The
+  # code that includes this into FakeWeb is in the base FakeWebMatcher module.
+  # 
+  # @see http://fakeweb.rubyforge.org
+  # 
+  module Extension
+    def self.included(base)
+      base.class_eval do
+        # Keep the original response_for method
+        alias_method :response_without_request_tracking, :response_for
+        
+        # Overwrites the existing FakeWeb::Registry#response method, to ensure
+        # requests are tracked. Returns the usual stubbed response.
+        # 
+        # @param [Symbol] method HTTP method
+        # @param [String] uri URI requested
+        # @param [Proc] block The block passed into Net::HTTP requests
+        # @return [String] The stubbed page response
+        # 
+        def response_for(method, uri, &block)
+          requests << [method, uri]
+          response_without_request_tracking(method, uri, &block)
+        end
+      end
+    end
+    
+    # A list of the requests, kept as an array of arrays, where each child array
+    # has two values - the method and the URI.
+    # 
+    # @return [Array] Recorded requests
+    # 
+    def requests
+      @requests ||= []
+    end
+    
+    # Clears the stored request list
+    # 
+    def clear_requests
+      requests.clear
+    end
+  end
+end

data/lib/fake_web_matcher/matchers.rb

@@ -0,0 +1,22 @@
+# An RSpec matcher for the Fakeweb HTTP stubbing library, allowing you to use
+# RSpec syntax to check if requests to particular URIs have been made.
+# 
+# @see FakeWebMatcher::Matchers
+# @see http://fakeweb.rubyforge.org
+# @author Pat Allan
+# 
+module FakeWebMatcher
+  # Custom matcher holder for RSpec
+  # 
+  module Matchers
+    # Returns a new matcher instance.
+    # 
+    # @param [Symbol] method The HTTP method
+    # @param [String] uri The URI to check for
+    # @return [FakeWebMatcher::RequestMatcher]
+    # 
+    def have_requested(method, uri)
+      FakeWebMatcher::RequestMatcher.new(method, uri)
+    end
+  end
+end

data/lib/fake_web_matcher/request_matcher.rb

@@ -0,0 +1,139 @@
+module FakeWebMatcher
+  # Matcher class, following RSpec's expectations. Used to confirm whether a
+  # request has been made on a given method and URI.
+  # 
+  
+  # Monkey patch to add a normalize! method to the URI::HTTP class.
+  # It doesn't currently sort the query params which means two URLs
+  # that are equivalent except for a different order of query params
+  # will be !=. This isn't how FakeWeb works, so we patch it here.
+  class ::URI::HTTP
+
+    # Normalize an HTTP URI so that query param order differences don't
+    # affect equality.
+    def normalize!
+      if query
+        query_array = self.query.split('&')
+        set_query(query_array.sort.join('&'))
+      end
+      super
+    end
+  end
+
+  class RequestMatcher
+    attr_reader :url, :method
+    
+    # Create a new matcher.
+    # 
+    # @param [Symbol] method The HTTP method. Defaults to :any if not supplied.
+    # @param [String, Regexp] uri The URI to check for
+    # 
+    def initialize(*args)
+      @method, @url = args_split(*args)
+    end
+    
+    # Indication of whether there's a match on the URI from given requests.
+    # 
+    # @param [Module] FakeWeb Module, necessary for RSpec, although not
+    #   required internally.
+    # @return [Boolean] true if the URI was requested, otherwise false.
+    # 
+    def matches?(fakeweb)
+      !FakeWeb::Registry.instance.requests.detect { |req|
+        method, url = args_split(*req)
+        match_method(method) && match_url(url)
+      }.nil?
+    end
+    
+    # Failure message if the URI should have been requested.
+    # 
+    # @return [String] failure message
+    # 
+    def failure_message
+      regex?(@url) ? regex_failure_message : url_failure_message
+    end
+    
+    # Failure message if the URI should not have been requested.
+    # 
+    # @return [String] failure message
+    #
+    def negative_failure_message
+      regex?(@url) ? regex_negative_failure_message : url_negative_failure_message
+    end
+    
+    private
+    
+    def regex_negative_failure_message
+      "A URL that matches #{@url.inspect} was requested#{failure_message_method} and should not have been."
+    end
+    
+    def url_negative_failure_message
+      "The URL #{@url} was requested#{failure_message_method} and should not have been."
+    end
+    
+    def regex_failure_message
+        "A URL that matches #{@url.inspect} was not requested#{failure_message_method}."
+    end
+    
+    def url_failure_message
+        "The URL #{@url} was not requested#{failure_message_method}."
+    end
+    
+    def failure_message_method
+      " using #{formatted_method}" unless @method == :any
+    end
+    
+    # Compares methods, or ignores if either side of the comparison is :any.
+    # 
+    # @param [Symbol] method HTTP method
+    # @return [Boolean] true if methods match or either is :any.
+    # 
+    def match_method(method)
+      @method == :any || method == :any || method == @method
+    end
+    
+    # Compares the url either by match it agains a regular expression or 
+    # by simple comparison
+    # 
+    # @param [String] url the called URI
+    # @return [Boolean] true if exprexted URI and called URI match.
+    # 
+    def match_url(url)
+      return @url.match(url.to_s) if regex?(@url)
+      @url == url
+    end
+    
+    # Expected method formatted to be an uppercase string. Example: :get becomes
+    # "GET".
+    # 
+    # @return [String] uppercase method
+    # 
+    def formatted_method
+      @method.to_s.upcase
+    end
+    
+    # Interprets given arguments to a method and URI instance. The URI, as a
+    # string, is required, but the method is not (will default to :any).
+    # 
+    # @param [Array] args
+    # @return [Array] Two items: method and URI instance or regular expression
+    # 
+    def args_split(*args)
+      method  = :any
+      uri     = nil
+      
+      case args.length
+      when 1 then uri         = args[0]
+      when 2 then method, uri = args[0], args[1]
+      else
+        raise ArgumentError.new("wrong number of arguments")
+      end
+      uri = URI.parse(uri) unless regex?(uri)
+      return method, uri
+    end
+    
+    def regex?(object)
+      object.is_a?(Regexp)
+    end
+  end
+end

data/lib/fakeweb_matcher.rb

@@ -0,0 +1 @@
+require 'fake_web_matcher'

data/spec/lib/fake_web_matcher/extension_spec.rb

@@ -0,0 +1,42 @@
+require 'spec/spec_helper'
+
+describe FakeWebMatcher::Extension do
+  it "should be included into the FakeWeb::Registry class" do
+    FakeWeb::Registry.included_modules.should include(FakeWebMatcher::Extension)
+  end
+  
+  describe '#requests' do
+    it "should return an empty Array by default" do
+      FakeWeb::Registry.instance.requests.should == []
+    end
+  end
+  
+  describe '#clear_requests' do
+    it "should clear the requests array" do
+      registry = FakeWeb::Registry.instance
+      registry.requests << :something
+      registry.requests.should == [:something]
+      
+      registry.clear_requests
+      registry.requests.should == []
+    end
+  end
+  
+  describe '#response_for' do
+    before :each do
+      @registry = FakeWeb::Registry.instance
+    end
+    
+    it "should track request" do
+      @registry.response_for(:any, 'http://uri.com')
+      
+      @registry.requests.should == [[:any, 'http://uri.com']]
+    end
+    
+    it "should return the underlying response from response_without_request_tracking" do
+      @registry.stub!(:response_without_request_tracking => :response)
+      
+      @registry.response_for(:any, 'http://uri.com').should == :response
+    end
+  end
+end

data/spec/lib/fake_web_matcher/matchers_spec.rb

@@ -0,0 +1,42 @@
+require 'spec/spec_helper'
+
+describe FakeWebMatcher::Matchers do
+  describe '#have_requested' do
+    before :each do
+      class Matchbox
+        include FakeWebMatcher::Matchers
+      end
+      
+      @matcher = Matchbox.new.have_requested(:put, 'http://url.com')
+    end
+    
+    it "should return an instance of RequestMatcher" do
+      @matcher.should be_a(FakeWebMatcher::RequestMatcher)
+    end
+    
+    it "should set the url and method using the matcher arguments" do
+      @matcher.url.to_s.should  == 'http://url.com'
+      @matcher.method.should    == :put
+    end
+  end
+  
+  it "should pass if the request has been made" do
+    FakeWeb.register_uri(:get, 'http://example.com/', :body => 'foo')
+    open('http://example.com/')
+    
+    FakeWeb.should have_requested(:get, 'http://example.com')
+  end
+  
+  it "should pass if the request has not been made" do
+    FakeWeb.register_uri(:get, 'http://example.com/', :body => 'foo')
+    
+    FakeWeb.should_not have_requested(:get, 'http://example.com')
+  end
+
+  it "should not care about the order of the query parameters" do
+    FakeWeb.register_uri(:get, URI.parse('http://example.com/page?foo=bar&baz=qux'), :body => 'foo')
+    open('http://example.com/page?baz=qux&foo=bar')
+
+    FakeWeb.should have_requested(:get, 'http://example.com/page?foo=bar&baz=qux')
+  end
+end

data/spec/lib/fake_web_matcher/request_matcher_spec.rb

@@ -0,0 +1,123 @@
+require 'spec/spec_helper'
+
+describe FakeWebMatcher::RequestMatcher do
+  describe '#initialize' do
+    it "should set the url if no method is supplied" do
+      matcher = FakeWebMatcher::RequestMatcher.new('http://example.com')
+      matcher.url.to_s.should == 'http://example.com'
+    end
+    
+    it "set the url if a method is explicitly supplied" do
+      matcher = FakeWebMatcher::RequestMatcher.new(:get, 'http://example.com')
+      matcher.url.to_s.should == 'http://example.com'
+    end
+    
+    it "should set the method to any if not supplied" do
+      matcher = FakeWebMatcher::RequestMatcher.new('http://example.com')
+      matcher.method.should == :any
+    end
+    
+    it "set the method if explicitly supplied" do
+      matcher = FakeWebMatcher::RequestMatcher.new(:get, 'http://example.com')
+      matcher.method.should == :get
+    end
+  end
+  
+  describe '#matches?' do
+    before :each do
+      FakeWeb.register_uri(:get, 'http://example.com/', :body => 'foo')
+      open('http://example.com/')
+    end
+    
+    it "should return true if same url and any method" do
+      matcher = FakeWebMatcher::RequestMatcher.new('http://example.com')
+      matcher.matches?(FakeWeb).should be_true
+    end
+    
+    it "should return true if same url and same explicit method" do
+      matcher = FakeWebMatcher::RequestMatcher.new(:get, 'http://example.com')
+      matcher.matches?(FakeWeb).should be_true
+    end
+    
+    it "should return false if same url and different explicit method" do
+      matcher = FakeWebMatcher::RequestMatcher.new(:post, 'http://example.com')
+      matcher.matches?(FakeWeb).should be_false
+    end
+    
+    it "should return false if different url and same method" do
+      matcher = FakeWebMatcher::RequestMatcher.new(:get, 'http://domain.com')
+      matcher.matches?(FakeWeb).should be_false
+    end
+    
+    it "should return false if different url and different explicit method" do
+      matcher = FakeWebMatcher::RequestMatcher.new(:post, 'http://domain.com')
+      matcher.matches?(FakeWeb).should be_false
+    end
+    
+    describe "matching url is regular expression" do
+      it "should return true if expression matches" do
+        matcher = FakeWebMatcher::RequestMatcher.new(:get, /example/)
+        matcher.matches?(FakeWeb).should be_true
+      end
+      
+      it "should return false if don't match" do
+        matcher = FakeWebMatcher::RequestMatcher.new(:get, /domain/)
+        matcher.matches?(FakeWeb).should be_false
+      end
+      
+    end
+  end
+  
+  describe '#failure_message' do
+    it "should mention the method if explicitly set" do
+      matcher = FakeWebMatcher::RequestMatcher.new(:get, 'http://example.com')
+      matcher.failure_message.
+        should == 'The URL http://example.com was not requested using GET.'
+    end
+    
+    it "should not mention the method if not explicitly set" do
+      matcher = FakeWebMatcher::RequestMatcher.new('http://example.com')
+      matcher.failure_message.
+        should == 'The URL http://example.com was not requested.'
+    end
+    
+    it "should mention failing match" do
+      matcher = FakeWebMatcher::RequestMatcher.new(/example.com/)
+      matcher.failure_message.
+          should == 'A URL that matches /example.com/ was not requested.'
+    end
+    
+    it "should mention failing match with method if set" do
+      matcher = FakeWebMatcher::RequestMatcher.new(:get, /example.com/)
+      matcher.failure_message.
+         should == 'A URL that matches /example.com/ was not requested using GET.'
+    end
+  end
+  
+  describe '#negative_failure_message' do
+    it "should mention the method if explicitly set" do
+      matcher = FakeWebMatcher::RequestMatcher.new(:get, 'http://example.com')
+      matcher.negative_failure_message.
+        should == 'The URL http://example.com was requested using GET and should not have been.'
+    end
+    
+    it "should not mention the method if not explicitly set" do
+      matcher = FakeWebMatcher::RequestMatcher.new('http://example.com')
+      matcher.negative_failure_message.
+        should == 'The URL http://example.com was requested and should not have been.'
+    end
+    
+    it "should mention unexpected match" do
+      matcher = FakeWebMatcher::RequestMatcher.new(/example.com/)
+      matcher.negative_failure_message.
+          should == 'A URL that matches /example.com/ was requested and should not have been.'
+    end
+    
+    it "should mention unexpected match with method if set" do
+      matcher = FakeWebMatcher::RequestMatcher.new(:get, /example.com/)
+      matcher.negative_failure_message.
+         should == 'A URL that matches /example.com/ was requested using GET and should not have been.'
+    end
+    
+  end
+end

data/spec/lib/fake_web_matcher_spec.rb

@@ -0,0 +1,5 @@
+require 'spec/spec_helper'
+
+describe FakeWebMatcher do
+  #
+end

data/spec/spec_helper.rb

@@ -0,0 +1,11 @@
+$:.unshift File.dirname(__FILE__) + '/../lib'
+
+require 'rubygems'
+require 'open-uri'
+require 'spec'
+require 'fake_web'
+require 'fake_web_matcher'
+
+Spec::Runner.configure do |config|
+  #
+end

metadata

@@ -0,0 +1,119 @@
+--- !ruby/object:Gem::Specification 
+name: dnclabs-fakeweb-matcher
+version: !ruby/object:Gem::Version 
+  hash: 19
+  prerelease: false
+  segments: 
+  - 1
+  - 1
+  - 0
+  version: 1.1.0
+platform: ruby
+authors: 
+- Pat Allan
+- Wes Morgan
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-10-23 00:00:00 -04:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: fakeweb
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 21
+        segments: 
+        - 1
+        - 2
+        - 5
+        version: 1.2.5
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 31
+        segments: 
+        - 1
+        - 2
+        - 0
+        version: 1.2.0
+  type: :runtime
+  version_requirements: *id002
+description: 
+email: 
+- pat@freelancing-gods.com
+- morganw@dnc.org
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.textile
+files: 
+- LICENSE
+- README.textile
+- Rakefile
+- VERSION.yml
+- lib/fake_web_matcher.rb
+- lib/fake_web_matcher/extension.rb
+- lib/fake_web_matcher/matchers.rb
+- lib/fake_web_matcher/request_matcher.rb
+- lib/fakeweb_matcher.rb
+- spec/lib/fake_web_matcher/extension_spec.rb
+- spec/lib/fake_web_matcher/matchers_spec.rb
+- spec/lib/fake_web_matcher/request_matcher_spec.rb
+- spec/lib/fake_web_matcher_spec.rb
+- spec/spec_helper.rb
+has_rdoc: true
+homepage: http://github.com/dnclabs/fakeweb-matcher
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: RSpec matcher for the FakeWeb library
+test_files: 
+- spec/lib/fake_web_matcher/extension_spec.rb
+- spec/lib/fake_web_matcher/matchers_spec.rb
+- spec/lib/fake_web_matcher/request_matcher_spec.rb
+- spec/lib/fake_web_matcher_spec.rb
+- spec/spec_helper.rb