request_interceptor 0.2.1 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 244056547ed0ff2bc1acaeb6fa12f6aec7eb7fb7
-  data.tar.gz: 8b0719757447a76119044afefb543020ed1718a8
+  metadata.gz: 15e0184221194d0cd9222006c1739e23f7c81a89
+  data.tar.gz: 5bb90d1e9b0b9b4d0eee2cadb6015e324db86e42
 SHA512:
-  metadata.gz: 98452c1e2592dbdb2746a1eea5bf4627bd135743b0074864a1aab8b553bef146b0190950ac1d57311f492fe685697e757e24cffb5ecb8ba18c6569914c318731
-  data.tar.gz: 398a7146eb773b04749296906832216b93587aa05a279374df7c692b0def45a60fdbcf05b26bb0e7d88f8f32e151ad52023ae6886ef0621d766b2628412c1f87
+  metadata.gz: e36776a7b15b8994100a480d5ebda2d12373d09b54d9cd48c22c2488b2623d3143b19f078f1bd067a8a90956b1d3be853388f5875616ffcbc8d8061e4c0576a2
+  data.tar.gz: 74d7a949efa97b601324b38ef7666741294ee5a00e6bad56d328d2e53f923a79cd3d3bdb0801bf66ec1242b0129b58ad415f0a589cccc227ccd9a3afa4e67233

data/lib/request_interceptor/application.rb

@@ -1,18 +1,22 @@
 require "sinatra/base"
 
 class RequestInterceptor::Application < Sinatra::Base
-  def self.customize(&customizations)
-    RequestInterceptor.define(self, &customizations)
-  end
+  class << self
+    def customize(&customizations)
+      RequestInterceptor.define(self, &customizations)
+    end
 
-  def self.intercept(host, *args, &test)
-    RequestInterceptor.run(host => self.new(*args), &test)
-  end
+    def intercept(pattern, *args, &test)
+      RequestInterceptor.run(pattern => self.new(*args), &test)
+    end
 
-  def self.host(host)
-    define_singleton_method(:intercept) do |*args, &test|
-      super(host, *args, &test)
+    def match(pattern)
+      define_singleton_method(:intercept) do |*args, &test|
+        super(pattern, *args, &test)
+      end
     end
+
+    alias host match
   end
 
   configure do

data/lib/request_interceptor/version.rb

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

data/lib/request_interceptor/webmock_manager.rb

@@ -0,0 +1,60 @@
+class RequestInterceptor::WebMockManager
+  WebMockConfigurationCache = Struct.new(:request_stubs, :callbacks, :allow_net_connect, :allow_localhost, :show_body_diff, :show_stubbing_instructions, :enabled_previously)
+
+  def initialize(applications, callback = nil)
+    @applications = applications
+    @callback = callback
+  end
+
+  def run_simulation
+    original_webmock_configuration = setup
+
+    yield
+  ensure
+    teardown(original_webmock_configuration)
+  end
+
+  protected
+
+  attr_reader :callback
+  attr_reader :applications
+
+  private
+
+  def setup
+    original_configuration = WebMockConfigurationCache.new
+    original_configuration.enabled_previously = WebMock.enabled?
+    original_configuration.request_stubs = WebMock::StubRegistry.instance.request_stubs.dup || []
+    original_configuration.callbacks = WebMock::CallbackRegistry.callbacks.dup || []
+    original_configuration.allow_net_connect = WebMock::Config.instance.allow_net_connect
+    original_configuration.allow_localhost = WebMock::Config.instance.allow_localhost
+    original_configuration.show_body_diff = WebMock::Config.instance.show_body_diff
+    original_configuration.show_stubbing_instructions = WebMock::Config.instance.show_stubbing_instructions
+
+    WebMock.after_request(&callback) unless callback.nil?
+
+    applications.each do |application|
+      WebMock.stub_request(:any, application.pattern).to_rack(application)
+    end
+
+    WebMock.allow_net_connect!
+    WebMock.hide_body_diff!
+    WebMock.hide_stubbing_instructions!
+    WebMock.enable!
+
+    original_configuration
+  end
+
+  def teardown(original_configuration)
+    WebMock::Config.instance.allow_net_connect = original_configuration.allow_net_connect
+    WebMock::Config.instance.allow_localhost = original_configuration.allow_localhost
+    WebMock::Config.instance.show_body_diff = original_configuration.show_body_diff
+    WebMock::Config.instance.show_stubbing_instructions = original_configuration.show_stubbing_instructions
+    WebMock::CallbackRegistry.reset
+    original_configuration.callbacks.each do |callback_settings|
+      WebMock.after_request(callback_settings[:options], &callback_settings[:block])
+    end
+    WebMock::StubRegistry.instance.request_stubs = original_configuration.request_stubs
+    WebMock.disable! unless original_configuration.enabled_previously
+  end
+end

data/lib/request_interceptor/webmock_patches.rb

@@ -0,0 +1,19 @@
+module RequestInterceptor::WebMockPatches
+  def enable!
+    @enabled = true
+    super
+  end
+
+  def disable!
+    @enabled = false
+    super
+  end
+
+  def enabled?
+    !!@enabled
+  end
+
+  def disabled?
+    !enabled
+  end
+end

data/lib/request_interceptor.rb

@@ -1,22 +1,44 @@
 require "request_interceptor/version"
 
-require "net/http"
-require "rack/mock"
+require "webmock"
+require "uri"
 
 class RequestInterceptor
   Transaction = Struct.new(:request, :response)
 
-  Restart = Struct.new(:required, :instructions) do
-    protected :required
-    def required?
-      !!required
+  module RequestBackwardsCompatibility
+    def path
+      uri.request_uri
+    end
+
+    def uri
+      URI.parse(super.to_s)
+    end
+
+    def method
+      super.to_s.upcase
     end
   end
 
-  GET = "GET".freeze
-  POST = "POST".freeze
-  PUT = "PUT".freeze
-  DELETE = "DELETE".freeze
+  class ApplicationWrapper < SimpleDelegator
+    attr_reader :pattern
+
+    def initialize(pattern, application)
+      @pattern =
+        case pattern
+        when String
+          %r{://#{Regexp.escape(pattern)}/}
+        else
+          pattern
+        end
+
+      super(application)
+    end
+
+    def intercepts?(uri)
+      !!pattern.match(uri.normalize.to_s)
+    end
+  end
 
   def self.template=(template)
     @template =
@@ -36,173 +58,35 @@ class RequestInterceptor
     Class.new(super_class || template, &application_definition)
   end
 
-  def self.run(*args, &simulation)
-    new(*args).run(&simulation)
+  def self.run(applications, &simulation)
+    new(applications).run(&simulation)
   end
 
   attr_reader :applications
   attr_reader :transactions
 
   def initialize(applications)
-    @applications = {}
+    @applications = applications.map { |pattern, application| ApplicationWrapper.new(pattern, application) }
     @transactions = []
-
-    applications.each { |pattern, application| self[pattern] = application }
-  end
-
-  def [](pattern)
-    @applications[pattern]
-  end
-
-  def []=(pattern, application)
-    @applications[pattern] = application
   end
 
   def run(&simulation)
-    clear_transaction_log
-    cache_original_net_http_methods
-    override_net_http_methods
-    simulation.call
-    transactions
-  ensure
-    restore_net_http_methods
-  end
-
-  def request(http_context, request, body, &block)
-    # use Net::HTTP set_body_internal to
-    # keep the same behaviour as Net::HTTP
-    request.set_body_internal(body)
-    response = nil
-
-    if mock_request = mock_request_for_application(http_context, request)
-      mock_response = dispatch_mock_request(request, mock_request)
-
-      # create response
-      status = RequestInterceptor::Status.from_code(mock_response.status)
-      response = status.response_class.new("1.1", status.value, status.description)
-
-      # copy header to response
-      mock_response.original_headers.each do |k, v|
-        response.add_field(k, v)
-      end
-
-      # copy uri
-      response.uri = request.uri
-
-      # copy body to response
-      response.body = mock_response.body
-
-      # replace Net::HTTP::Response#read_body
-      def response.read_body(_, &block)
-        block.call(@body) unless block.nil?
-        @body
-      end
-
-      # yield the response because Net::HTTP#request does
-      block.call(response) unless block.nil?
-
-      # log intercepted transaction
-      log_transaction(request, response)
-    else
-      response = real_request(http_context, request, body, &block)
-    end
-
-    response
-  end
+    transactions = []
 
-  def start(http_context, &block)
-    self.restart = Restart.new(true, block)
-    http_context.instance_variable_set(:@started, true)
-    return block.call(http_context) if block
-    http_context
-  end
-
-  def finish(http_context)
-    http_context.instance_variable_set(:@started, false)
-    nil
-  end
-
-  protected
-
-  attr_writer :restart
-
-  def restart
-    @restart || Restart.new(false)
-  end
-
-  private
-
-  def clear_transaction_log
-    @transactions = []
-  end
-
-  def cache_original_net_http_methods
-    @original_request_method = Net::HTTP.instance_method(:request)
-    @original_start_method = Net::HTTP.instance_method(:start)
-    @original_finish_method = Net::HTTP.instance_method(:finish)
-  end
-
-  def override_net_http_methods
-    runner = self
-
-    Net::HTTP.class_eval do
-      define_method(:start) { |&block| runner.start(self, &block) }
-      define_method(:finish) { runner.finish(self) }
-      define_method(:request) { |request, body = nil, &block| runner.request(self, request, body, &block) }
+    request_logging = ->(request, response) do
+      next unless applications.any? { |application| application.intercepts?(request.uri) }
+      request.extend(RequestBackwardsCompatibility)
+      transactions << Transaction.new(request, response)
     end
-  end
 
-  def real_request(http_context, request, body, &block)
-    http_context.finish if restart.required?
+    WebMockManager.new(applications, request_logging).run_simulation(&simulation)
 
-    restore_net_http_methods(http_context)
-
-    if restart.required?
-      http_context.start(&restart.instructions)
-      self.restart = nil
-    end
-
-    http_context.request(request, body, &block)
-  end
-
-  def restore_net_http_methods(instance = nil)
-    if instance.nil?
-      Net::HTTP.send(:define_method, :request, @original_request_method)
-      Net::HTTP.send(:define_method, :start, @original_start_method)
-      Net::HTTP.send(:define_method, :finish, @original_finish_method)
-    else
-      instance.define_singleton_method(:request, @original_request_method)
-      instance.define_singleton_method(:start, @original_start_method)
-      instance.define_singleton_method(:finish, @original_finish_method)
-    end
-  end
-
-  def mock_request_for_application(http_context, request)
-    _, application = applications.find { |pattern, _| pattern === http_context.address }
-    Rack::MockRequest.new(application) if application
-  end
-
-  def dispatch_mock_request(request, mock_request)
-    rack_env = request.to_hash
-
-    case request.method
-    when GET
-      mock_request.get(request.path, rack_env)
-    when POST
-      mock_request.post(request.path, rack_env.merge(input: request.body))
-    when PUT
-      mock_request.put(request.path, rack_env.merge(input: request.body))
-    when DELETE
-      mock_request.delete(request.path, rack_env)
-    else
-      raise NotImplementedError, "Simulating #{request.method} is not supported"
-    end
-  end
-
-  def log_transaction(request, response)
-    transactions << RequestInterceptor::Transaction.new(request, response)
+    transactions
   end
 end
 
-require "request_interceptor/application"
-require "request_interceptor/status"
+require_relative "request_interceptor/application"
+require_relative "request_interceptor/webmock_manager"
+require_relative "request_interceptor/webmock_patches"
+
+WebMock.singleton_class.prepend(RequestInterceptor::WebMockPatches)

data/request_interceptor.gemspec

@@ -20,6 +20,7 @@ Gem::Specification.new do |spec|
 
   spec.add_runtime_dependency "sinatra"
   spec.add_runtime_dependency "rack"
+  spec.add_runtime_dependency "webmock", "~> 3.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.2.1
+  version: 0.3.0
 platform: ruby
 authors:
 - Konstantin Tennhard
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-04-18 00:00:00.000000000 Z
+date: 2017-05-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sinatra
@@ -39,6 +39,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: webmock
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -115,8 +129,9 @@ files:
 - circle.yml
 - lib/request_interceptor.rb
 - lib/request_interceptor/application.rb
-- lib/request_interceptor/status.rb
 - lib/request_interceptor/version.rb
+- lib/request_interceptor/webmock_manager.rb
+- lib/request_interceptor/webmock_patches.rb
 - request_interceptor.gemspec
 homepage: http://github.com/t6d/request_interceptor
 licenses:

data/lib/request_interceptor/status.rb

@@ -1,34 +0,0 @@
-require 'rack/utils'
-
-class RequestInterceptor::Status < Struct.new(:value, :description)
-  STATUSES = Rack::Utils::HTTP_STATUS_CODES
-
-  def self.from_code(code, description = nil)
-    description = STATUSES.fetch(code.to_i, "Unknown") if description.nil?
-    new(code.to_s, description)
-  end
-
-  def response_class
-    self.class.response_class(value)
-  end
-
-  def self.response_class(code)
-    @response_classes ||=
-      begin
-        wrapped_classes = Hash.new {  Net::HTTPUnknownResponse }
-        Net::HTTPResponse::CODE_TO_OBJ.inject(wrapped_classes) do |classes, (code, original_class)|
-          new_class = Class.new(original_class) do
-            attr_accessor :body
-          end
-
-          new_class.define_singleton_method(:name) { original_class.name }
-          new_class.define_singleton_method(:to_s) { original_class.name }
-
-          classes[code] = new_class
-          classes
-        end
-      end
-
-    @response_classes[code]
-  end
-end