miniproxy 0.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 3f44f0daaa7c8c5897ee86428737bb7bafba78d60935943056d8daed9baa2111
+  data.tar.gz: 4ec7b5cf714b7afe7d81dda425a6a8f3095caefac4c9511405a189678df71910
+SHA512:
+  metadata.gz: 5410429d11d0cdb1f97cf5423d97d8f3d3d88b80a39bab27de5fd265d2bd02e779c5946d7e28d0ac9ab618758afc1900e1cc294b3b9c7f19ff6c800bd96d0c71
+  data.tar.gz: 2c987fde657f840ae2e6c976ea6bae574aa9ec31dfff19a48fe128f348b97d3aa89a6dedc2d2cc82fd8f497183065b3e02fb277ff2da2ffebe63d337a4995f91

data/lib/miniproxy.rb

@@ -0,0 +1,53 @@
+require "drb"
+require "timeout"
+require "miniproxy/remote"
+
+module MiniProxy
+  DRB_SERVICE_TIMEOUT = 5
+
+  def self.reset
+    remote.clear
+  end
+
+  def self.stop
+    remote.stop if Remote.drb_process_alive?
+  end
+
+  def self.port
+    remote.port
+  end
+
+  def self.host
+    "127.0.0.1"
+  end
+
+  def self.ignore_all_requests
+    reset
+
+    %w(GET POST PUT PATCH DELETE).each do |method|
+      stub_request(method: method, url: /.*/)
+    end
+  end
+
+  def self.stub_request(method:, url:, response: {})
+    remote.stub_request(method: method, url: url, response: response)
+  end
+
+  private_class_method def self.remote
+    Timeout.timeout(DRB_SERVICE_TIMEOUT) do
+      begin
+        remote = DRbObject.new(nil, Remote.server)
+
+        until remote.started?
+          sleep 0.01
+        end
+
+        remote.drain_messages.each(&method(:puts))
+
+        remote
+      rescue
+        retry
+      end
+    end
+  end
+end

data/lib/miniproxy/fake_ssl_server.rb

@@ -0,0 +1,38 @@
+require "webrick/https" # This is required to create a HTTPS server
+# https://ruby-doc.org/stdlib-2.0.0/libdoc/webrick/rdoc/WEBrick.html#module-WEBrick-label-HTTPS
+
+module MiniProxy
+  # MiniProxy fake SSL enabled server, which receives relayed requests from the ProxyServer
+  #
+  class FakeSSLServer < WEBrick::HTTPServer
+    ALLOWED_HOSTS = ["127.0.0.1", "localhost"].freeze
+
+    def initialize(config = {}, default = WEBrick::Config::HTTP)
+      config = config.merge({
+        Logger: WEBrick::Log.new(nil, 0), # silence logging
+        AccessLog: [], # silence logging
+        SSLEnable: true,
+        SSLCertificate: OpenSSL::X509::Certificate.new(certificate_file("cert.pem")),
+        SSLPrivateKey: OpenSSL::PKey::RSA.new(certificate_file("cert.key")),
+        SSLVerifyClient: OpenSSL::SSL::VERIFY_NONE,
+      })
+
+      super(config, default)
+    end
+
+    def service(req, res)
+      if ALLOWED_HOSTS.include?(req.host)
+        super(req, res)
+      else
+        self.config[:MockHandlerCallback].call(req, res)
+      end
+    end
+
+    private
+
+    def certificate_file(filename)
+      filename = File.join( File.dirname(__FILE__), "../../ssl/#{filename}")
+      File.open(filename).read
+    end
+  end
+end

data/lib/miniproxy/proxy_server.rb

@@ -0,0 +1,55 @@
+require "webrick/httpproxy"
+
+module MiniProxy
+  # MiniProxy server, which boots a WEBrick proxy server
+  #
+  class ProxyServer < WEBrick::HTTPProxyServer
+    ALLOWED_HOSTS = ["127.0.0.1", "localhost"].freeze
+
+    attr_accessor :requests
+
+    def initialize(config = {}, default = WEBrick::Config::HTTP)
+      config = config.merge({
+        Logger: WEBrick::Log.new(nil, 0), # silence logging
+        AccessLog: [], # silence logging
+      })
+
+      super(config, default)
+    end
+
+    def do_PUT(req, res)
+      perform_proxy_request(req, res) do |http, path, header|
+        http.put(path, req.body || "", header)
+      end
+    end
+
+    def do_DELETE(req, res)
+      perform_proxy_request(req, res) do |http, path, header|
+        http.delete(path, header)
+      end
+    end
+
+    def do_PATCH(req, res)
+      perform_proxy_request(req, res) do |http, path, header|
+        http.patch(path, req.body || "", header)
+      end
+    end
+
+    def service(req, res)
+      if ALLOWED_HOSTS.include?(req.host)
+        super(req, res)
+      else
+        if req.request_method == "CONNECT"
+          # If something is trying to initiate an SSL connection, rewrite
+          # the URI to point to our fake server.
+          req.instance_variable_set(:@unparsed_uri, "localhost:#{self.config[:FakeServerPort]}")
+          super(req, res)
+        else
+          # Otherwise, call our handler to respond with an appropriate
+          # mock for the request.
+          self.config[:MockHandlerCallback].call(req, res)
+        end
+      end
+    end
+  end
+end

data/lib/miniproxy/remote.rb

@@ -0,0 +1,127 @@
+require "miniproxy/stub/request"
+require "miniproxy/stub/response"
+require "miniproxy/proxy_server"
+require "miniproxy/fake_ssl_server"
+
+module MiniProxy
+  # Controls the remote DRb service, which provides a communcation mechanism
+  #
+  class Remote
+    SERVER_DYNAMIC_PORT_RANGE = (12345..32768).to_a.freeze
+    SERVER_START_TIMEOUT = 10
+
+    def self.pid
+      @pid
+    end
+
+    def self.drb_process_alive?
+      pid && Process.kill(0, pid) == 1
+    rescue Errno::ESRCH
+      false
+    end
+
+    def self.server
+      @unix_socket_uri ||= begin
+        tempfile = Tempfile.new("mini_proxy")
+        socket_path = tempfile.path
+        tempfile.close!
+        "drbunix:///#{socket_path}"
+      end
+
+      return @unix_socket_uri if drb_process_alive?
+
+      @pid = fork do
+        remote = Remote.new
+
+        Timeout.timeout(SERVER_START_TIMEOUT) do
+          begin
+            fake_server_port = SERVER_DYNAMIC_PORT_RANGE.sample
+            fake_server = FakeSSLServer.new(
+              Port: fake_server_port,
+              MockHandlerCallback: remote.method(:handler),
+            )
+            Thread.new { fake_server.start }
+          rescue Errno::EADDRINUSE
+            retry
+          end
+
+          begin
+            remote.port = ENV["MINI_PROXY_PORT"] || SERVER_DYNAMIC_PORT_RANGE.sample
+            proxy = MiniProxy::ProxyServer.new(
+              Port: remote.port,
+              FakeServerPort: fake_server_port,
+              MockHandlerCallback: remote.method(:handler),
+            )
+            Thread.new { proxy.start }
+          rescue Errno::EADDRINUSE
+            retry
+          end
+        end
+
+        DRb.start_service(@unix_socket_uri, remote)
+        DRb.thread.join
+
+        Process.exit!
+      end
+
+      Process.detach(@pid)
+      @unix_socket_uri
+    end
+
+    def handler(req, res)
+      if (request = @stubs.detect { |mock_request| mock_request.match?(req) })
+        response = request.response
+        res.status = response.code
+        response.headers.each { |key, value| res[key] = value }
+        res.body = response.body
+      else
+        res.status = 200
+        res.body = ""
+        queue_message "WARN: external request to #{req.host}#{req.path} not mocked"
+        queue_message %Q{Stub with: MiniProxy.stub_request(method: "#{req.request_method}", url: "#{req.host}#{req.path}")}
+      end
+    end
+
+    def stub_request(method:, url:, response:)
+      response = MiniProxy::Stub::Response.new(headers: response[:headers], body: response[:body])
+      request = MiniProxy::Stub::Request.new(method: method, url: url, response: response)
+      @stubs.push(request)
+    end
+
+    def port
+      @port
+    end
+
+    def port=(value)
+      @port = value
+    end
+
+    def stop
+      DRb.stop_service
+    end
+
+    def clear
+      @stubs.clear
+    end
+
+    def drain_messages
+      @messages.slice!(0, @messages.length)
+    end
+
+    def started?
+      current_server = DRb.current_server()
+      current_server && current_server.alive?
+    end
+
+    private
+
+    def queue_message(msg)
+      @messages.push msg
+    end
+
+    def initialize
+      @stubs = []
+      @messages = []
+    end
+  end
+end

data/lib/miniproxy/stub/request.rb

@@ -0,0 +1,24 @@
+module MiniProxy
+  module Stub
+    # MiniProxy stub request to match and stub external URLs with a stubbed response
+    #
+    class Request
+      attr_reader :response
+
+      # @param [String] method
+      # @param [Regexp, String] url
+      # @param [MiniProxy::Response] response
+      def initialize(method:, url:, response:)
+        @method = method
+        @response = response
+        @url = url
+      end
+
+      # @param [WEBrick::HTTPRequest] http_request
+      def match?(http_request)
+        request_uri = http_request.host + http_request.path
+        http_request.request_method == @method && request_uri.match?(@url)
+      end
+    end
+  end
+end

data/lib/miniproxy/stub/response.rb

@@ -0,0 +1,24 @@
+module MiniProxy
+  module Stub
+    # MiniProxy stub response, so stubbed requests can return a custom response
+    #
+    class Response
+      def initialize(headers:, body:)
+        @body = body
+        @headers = headers
+      end
+
+      def body
+        @body || ""
+      end
+
+      def code
+        200
+      end
+
+      def headers
+        @headers || { "Content-Type" => "text/html" }
+      end
+    end
+  end
+end

data/lib/miniproxy/version.rb

@@ -0,0 +1,3 @@
+module MiniProxy
+  VERSION = "0.2.0".freeze
+end

metadata

@@ -0,0 +1,93 @@
+--- !ruby/object:Gem::Specification
+name: miniproxy
+version: !ruby/object:Gem::Version
+  version: 0.2.0
+platform: ruby
+authors:
+- The Conversation Dev Team
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2018-07-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: capybara
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: selenium-webdriver
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: A tool which allows you to easily stub requests to external sites for
+  your browser tests.
+email: 
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/miniproxy.rb
+- lib/miniproxy/fake_ssl_server.rb
+- lib/miniproxy/proxy_server.rb
+- lib/miniproxy/remote.rb
+- lib/miniproxy/stub/request.rb
+- lib/miniproxy/stub/response.rb
+- lib/miniproxy/version.rb
+homepage: https://github.com/conversation/miniproxy
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.7.3
+signing_key: 
+specification_version: 4
+summary: Easily stub external requests for your browser tests.
+test_files: []