request_interceptor 0.3.0 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 15e0184221194d0cd9222006c1739e23f7c81a89
-  data.tar.gz: 5bb90d1e9b0b9b4d0eee2cadb6015e324db86e42
+  metadata.gz: 0c6e50636bc572fbc38345fc4b43857d64190bf8
+  data.tar.gz: 05df14491c1257858527465fbad1aca49dddb04f
 SHA512:
-  metadata.gz: e36776a7b15b8994100a480d5ebda2d12373d09b54d9cd48c22c2488b2623d3143b19f078f1bd067a8a90956b1d3be853388f5875616ffcbc8d8061e4c0576a2
-  data.tar.gz: 74d7a949efa97b601324b38ef7666741294ee5a00e6bad56d328d2e53f923a79cd3d3bdb0801bf66ec1242b0129b58ad415f0a589cccc227ccd9a3afa4e67233
+  metadata.gz: 1a4382a22cba58d5554447300619e3d84ea6d980ebc87a6cc2f95842f912b06f8a25f62175104bff61f4efbe47c91d5a3c8ba89d8ef4b92a0e6d33cbd4a502b6
+  data.tar.gz: 65cbed11f12a44a98d8b4ccca0085e6092c2ab5858e486c19df1772c5b546bddd4e9948311a3f08280f3eaf40d729c36cbe9a9eb7c368cfb141e60781e385701

data/README.md

@@ -121,6 +121,78 @@ multilingual_app.intercept do
 end
 ```
 
+### RSpec Integration
+
+Request Interceptor has built in support for RSpec.
+The matcher that ships with the gem supports matching
+
+* the request method,
+* the path
+* the query parameters and
+* the request body.
+
+Unless otherwise specified, the matcher uses RSpec's own equality matcher for all comparisons:
+
+```ruby
+hello_world_app = RequestInterceptor.define do
+  host "example.com"
+  
+  get "/" do
+    # ...
+  end
+  
+  post "/articles" do
+    # ...
+  end
+end
+
+log = hello_world_app.intercept do
+  Net::HTTP.get(URI("http://example.com/"))
+end
+
+expect(log).to contain_intercepted_request(:get, "/")
+```
+
+The example above only succeeds if the path is exactly `"/"`.
+While this is generally desired for matching the path or the request method, it can be too restrictive when matching against the query or the request body.
+The example below demonstrates how to use `with_body` in conjunction with RSpec's own `including` matcher to match against a subset of the request body.
+
+```ruby
+log = hello_world_app.intercept do
+  uri = URI("http://example.com/")
+  client = Net::HTTP.new(uri.host, uri.port)
+  request = Net::HTTP::Post.new(uri.path, "Content-Type" => "application/json")
+  request.body = "{title: \"Hello World!\", content: \"Some irrelevant content.\"}"
+  client.request(request)
+end
+
+expect(log).to contain_intercepted_request(:post, "/articles").with_body(including(title: "Hello World!"))
+```
+
+As the example above indicates, Request Interceptor automatically parses JSON request bodies to make matching easier.
+
+Similar to `with_body`, the RSpec matcher also provides a `with_query` method, to match against query parameters:
+
+```ruby
+log = hello_world_app.intercept do
+  Net::HTTP.get(URI("http://example.com/?q=hello+world"))
+end
+
+expect(log).to contain_intercepted_request(:get, "/").with_query(q: "hello+world")
+```
+
+Lastly, `count` can be used to specify the number of times a particular request is to be expected.
+It takes an integer or a range as its argument.
+
+```ruby
+log = hello_world_app.intercept do
+  Net::HTTP.get(URI("http://example.com/"))
+  Net::HTTP.get(URI("http://example.com/"))
+end
+
+expect(log).to contain_intercepted_request(:get, "/").count(2)
+```
+
 ## Contributing
 
 Bug reports and pull requests are welcome on GitHub at (t6d/request_interceptor)[https://github.com/t6d/request_interceptor].

data/lib/request_interceptor.rb

@@ -1,25 +1,13 @@
 require "request_interceptor/version"
 
+require "active_support/core_ext/hash"
+require "active_support/json"
+require "rack"
+require "smart_properties"
 require "webmock"
-require "uri"
 
-class RequestInterceptor
-  Transaction = Struct.new(:request, :response)
-
-  module RequestBackwardsCompatibility
-    def path
-      uri.request_uri
-    end
-
-    def uri
-      URI.parse(super.to_s)
-    end
-
-    def method
-      super.to_s.upcase
-    end
-  end
 
+class RequestInterceptor
   class ApplicationWrapper < SimpleDelegator
     attr_reader :pattern
 
@@ -75,8 +63,19 @@ class RequestInterceptor
 
     request_logging = ->(request, response) do
       next unless applications.any? { |application| application.intercepts?(request.uri) }
-      request.extend(RequestBackwardsCompatibility)
-      transactions << Transaction.new(request, response)
+      transactions << Transaction.new(
+        request: Transaction::Request.new(
+          method: request.method,
+          uri: URI(request.uri.to_s),
+          headers: request.headers,
+          body: request.body
+        ),
+        response: Transaction::Response.new(
+          status_code: response.status,
+          headers: response.headers,
+          body: response.body
+        )
+      )
     end
 
     WebMockManager.new(applications, request_logging).run_simulation(&simulation)
@@ -86,6 +85,8 @@ class RequestInterceptor
 end
 
 require_relative "request_interceptor/application"
+require_relative "request_interceptor/matchers" if defined? RSpec
+require_relative "request_interceptor/transaction"
 require_relative "request_interceptor/webmock_manager"
 require_relative "request_interceptor/webmock_patches"
 

data/lib/request_interceptor/matchers.rb

@@ -0,0 +1,159 @@
+module RequestInterceptor::Matchers
+  class MatcherWrapper < SimpleDelegator
+    def ===(object)
+      matches?(object)
+    end
+
+    def to_s
+      description
+    end
+  end
+
+  class InterceptedRequest
+    attr_reader :method
+    attr_reader :path
+    attr_reader :query
+    attr_reader :body
+    attr_reader :transactions
+
+    def initialize(method, path)
+      @method = method
+      @path = path
+      @count = (1..Float::INFINITY)
+      @transactions = []
+    end
+
+    ##
+    # Chains
+    ##
+
+    def count(count = nil)
+      return @count if count.nil?
+
+      @count =
+        case count
+        when Integer
+          (count .. count)
+        when Range
+          count
+        else
+          raise ArgumentError
+        end
+
+      self
+    end
+
+    def with_query(query)
+      query_matcher =
+        if query.respond_to?(:matches?) && query.respond_to?(:failure_message)
+          query
+        else
+          RSpec::Matchers::BuiltIn::Eq.new(query)
+        end
+
+      @query = MatcherWrapper.new(query_matcher)
+
+      self
+    end
+
+    def with_body(body)
+      body_matcher =
+        if body.respond_to?(:matches?) && body.respond_to?(:failure_message)
+          body
+        else
+          RSpec::Matchers::BuiltIn::Eq.new(body)
+        end
+
+      @body = MatcherWrapper.new(body_matcher)
+
+      self
+    end
+
+    ##
+    # Rspec Matcher Protocol
+    ##
+
+    def matches?(transactions)
+      @transactions = transactions
+      count.cover?(matching_transactions.count)
+    end
+
+    def failure_message
+      expected_request = "#{format_method(method)} #{path}"
+      expected_request += " with query #{format_object(query)}" if query
+      expected_request += " and" if query && body
+      expected_request += " with body #{format_object(body)}" if body
+
+      similar_intercepted_requests = similar_transactions.map.with_index do |transaction, index|
+        method = format_method(transaction.request.method)
+        path = transaction.request.path
+        query = transaction.request.query
+        body = transaction.request.body
+        indentation_required = index != 0
+
+        message = "#{method} #{path}"
+        message += (query.nil? || query.empty?) ? " with no query" : " with query #{format_object(query)}"
+        message += (body.nil? || body.empty?) ? " and with no body" : " and with body #{format_object(body)}"
+        message = " " * 10 + message if indentation_required
+        message
+      end
+
+      similar_intercepted_requests = ["none"] if similar_intercepted_requests.none?
+
+      "\nexpected: #{expected_request}" \
+        "\n     got: #{similar_intercepted_requests.join("\n")}"
+    end
+
+    def failure_message_when_negated
+      message = "intercepted a #{format_method(method)} request to #{path}"
+      message += " with query #{format_object(query)}" if query
+      message += " and" if query && body
+      message += " with body #{format_object(body)}" if body
+      message
+    end
+
+    def description
+      "should intercept a #{format_method(method)} request to #{path}"
+    end
+
+    ##
+    # Helper methods
+    ##
+
+    private
+
+    def format_method(method)
+      method.to_s.upcase
+    end
+
+    def format_object(object)
+      RSpec::Support::ObjectFormatter.format(object)
+    end
+
+    def matching_transactions
+      transactions.select do |transaction|
+        request = transaction.request
+        request.method?(method) &&
+          request.path?(path) &&
+          request.query?(query) &&
+          request.body?(body)
+      end
+    end
+
+    def similar_transactions
+      transactions.select do |transaction|
+        request = transaction.request
+        request.method?(method) && request.path?(path)
+      end
+    end
+  end
+
+  def have_intercepted_request(*args)
+    InterceptedRequest.new(*args)
+  end
+  alias contain_intercepted_request have_intercepted_request
+end
+
+RSpec.configure do |config|
+  config.include(RequestInterceptor::Matchers)
+end

data/lib/request_interceptor/transaction.rb

@@ -0,0 +1,83 @@
+class RequestInterceptor::Transaction
+  class HTTPMessage
+    include SmartProperties
+    property :body
+
+    def initialize(*args, headers: {}, **kwargs)
+      @headers = headers.dup
+      super(*args, **kwargs)
+    end
+
+    def [](name)
+      @headers[name]
+    end
+
+    def []=(name, value)
+      @headers[name] = value
+    end
+
+    def headers
+      @headers.dup
+    end
+  end
+
+  class Request < HTTPMessage
+    property :method, converts: ->(method) { method.to_s.upcase.freeze }, required: true
+    property :uri, accepts: URI, converts: ->(uri) { URI(uri.to_s) }, required: true
+    property :body
+
+    def method?(method)
+      normalized_method = method.to_s.upcase
+      normalized_method == self.method
+    end
+
+    def path?(path)
+      path === self.path
+    end
+
+    def path
+      uri.path
+    end
+
+    def request_uri?(request_uri)
+      request_uri === self.request_uri
+    end
+
+    def request_uri
+      uri.request_uri
+    end
+
+    def query
+      Rack::Utils.parse_nested_query(uri.query).deep_symbolize_keys!
+    end
+
+    def query?(query_matcher)
+      return true if query_matcher.nil?
+      query_matcher === self.query
+    end
+
+    def body?(body_matcher)
+      return true if body_matcher.nil?
+
+      body = case self["Content-Type"]
+      when "application/json"
+        ActiveSupport::JSON.decode(self.body).deep_symbolize_keys!
+      else
+        self.body
+      end
+
+      body_matcher === body
+    end
+  end
+
+  class Response < HTTPMessage
+    property :status_code, required: true
+    property :body
+  end
+
+  include SmartProperties
+
+  property :request, accepts: Request
+  property :response, accepts: Response
+end
+

data/lib/request_interceptor/version.rb

@@ -1,3 +1,3 @@
 class RequestInterceptor
-  VERSION = "0.3.0"
+  VERSION = "1.0.0"
 end

data/request_interceptor.gemspec

@@ -21,6 +21,8 @@ Gem::Specification.new do |spec|
   spec.add_runtime_dependency "sinatra"
   spec.add_runtime_dependency "rack"
   spec.add_runtime_dependency "webmock", "~> 3.0"
+  spec.add_runtime_dependency "smart_properties", "~> 1.0"
+  spec.add_runtime_dependency "activesupport", ">= 4.0"
 
   spec.add_development_dependency "bundler", "~> 1.9"
   spec.add_development_dependency "rake", "~> 10.0"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: request_interceptor
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 1.0.0
 platform: ruby
 authors:
 - Konstantin Tennhard
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-05-08 00:00:00.000000000 Z
+date: 2017-10-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sinatra
@@ -53,6 +53,34 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: smart_properties
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.0'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -129,6 +157,8 @@ files:
 - circle.yml
 - lib/request_interceptor.rb
 - lib/request_interceptor/application.rb
+- lib/request_interceptor/matchers.rb
+- lib/request_interceptor/transaction.rb
 - lib/request_interceptor/version.rb
 - lib/request_interceptor/webmock_manager.rb
 - lib/request_interceptor/webmock_patches.rb