mimic2 2.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: e90ca1fced2c9d223f2208fbd0aebca0aee0838c
+  data.tar.gz: 4d8d6ffe8e8e788b39cb5aaeb7444d43052af5ef
+SHA512:
+  metadata.gz: 4b806edf1ee478b42be8aa49fee1f479216906928a9c87ad574e604b2e7c9e0a72ba25d7c7ea575d30ac7a8cae19136c7e72cde28ecc74ef2583f683412fb587
+  data.tar.gz: dc3f1bf7023bce28245dae4017aabfa8d68c045e1d6b35dc5fe122f791aa387350cb06c80c66e677ee332c999c83b93860f25788f0f727927bbcd1195e8559df

data/CHANGES

@@ -0,0 +1,31 @@
+## 0.4.3
+
+* Added request logging support.
+
+## 0.4.2
+
+* Remove unnecessary signal traps.
+
+## 0.4.1
+
+* Fixed bug where stubs wouldn't actually be cleared correctly.
+
+## 0.4.0
+
+* Mimic can now be run in it's own process and configured externally using a REST API.
+* Mimic can be run using the Daemons gem safely (pass :fork => false to disable built-in forking).
+* All existing stubs can be cleared.
+
+## 0.3.0
+
+* All verb methods (get, post etc.) can take blocks
+
+## 0.2.0
+
+* Added support for using Rack middleware
+* Removed host file modification feature
+* Refactor code top build on top of Sinatra::Base
+
+## 0.1.0
+
+* Initial release

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2010 Luke Redpath
+
+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.md

@@ -0,0 +1,107 @@
+# Mimic, simple web service stubs for testing [![Build Status](https://secure.travis-ci.org/lukeredpath/mimic.png)](https://secure.travis-ci.org/lukeredpath/mimic)
+
+## What is Mimic?
+Mimic is a testing tool that lets you set create a fake stand-in for an external web service to be used when writing integration/end-to-end tests for applications or libraries that access these services.
+
+## Why not stub?
+There are already some good tools, like [FakeWeb](http://fakeweb.rubyforge.org/) which let you stub requests at a low-level which is fine for unit and functional tests but when exercising our code through integration or end-to-end tests we want to exercise as much of the stack as possible.
+
+Mimic aims to make it possible to test your networking code without actually hitting the real services by starting up a real web server and responding to HTTP requests. This lets you test your application against canned responses in an as-close-to-the-real-thing-as-possible way.
+
+Also, because Mimic responds to real HTTP requests, it can be used when testing non-Ruby applications too.
+
+## Examples
+Registering to a single request stub:
+```
+Mimic.mimic.get("/some/path").returning("hello world")
+```  
+And the result, using RestClient:
+```
+$ RestClient.get("http://www.example.com:11988/some/path") # => 200 | hello world
+```
+Registering multiple request stubs; note that you can stub the same path with different HTTP methods separately.
+```
+Mimic.mimic do
+  get("/some/path").returning("Hello World", 200)
+  get("/some/other/path").returning("Redirecting...", 301, {"Location" => "somewhere else"})
+  post("/some/path").returning("Created!", 201)
+end
+```  
+You can even use Rack middlewares, e.g. to handle common testing scenarios such as authentication:
+```
+Mimic.mimic do
+  use Rack::Auth::Basic do |user, pass|
+    user == 'theuser' and pass == 'thepass'
+  end
+
+  get("/some/path")
+end
+```    
+Finally, because Mimic is built on top of Sinatra for the core request handling, you can create your stubbed requests like you would in any Sinatra app:
+```
+Mimic.mimic do
+  get "/some/path" do
+    [200, {}, "hello world"]
+  end
+end
+```
+
+## Using Mimic with non-Ruby processes
+Mimic has a built-in REST API that lets you configure your request stubs over HTTP. This makes it possible to use Mimic from other processes that can perform HTTP requests.
+
+First of all, you'll need to run Mimic as a daemon. You can do this with a simple Ruby script and the [daemons](http://daemons.rubyforge.org/) gem:
+```
+#!/usr/bin/env ruby
+require 'mimic'
+require 'daemons'
+
+Daemons.run_proc("mimic") do
+  Mimic.mimic(:port => 11988, :fork => false, :remote_configuration_path => '/api') do
+    # configure your stubs here
+  end
+end
+```
+
+Give the script executable permissions and then start it:
+```
+$ your_mimic_script.rb start (or run)
+```    
+The remote configuration path is where the API endpoints will be mounted - this is configurable as you will not be able this path or any paths below it in your stubs, so choose one that doesn't conflict with the paths you need to stub.
+
+The API supports both JSON and Plist payloads, defaulting to JSON. Set the request Content-Type header to application/plist for Plist requests.
+
+For the following Mimic configuration (using the Ruby DSL):
+```
+Mimic.mimic.get("/some/path").returning("hello world")
+```
+
+The equivalent stub can be configured using the REST API as follows:
+```
+$ curl -d'{"path":"/some/path", "body":"hello world"}' http://localhost:11988/api/get
+```
+
+Likewise, a POST request to the same path could be stubbed like so:
+```
+$ curl -d'{"path":"/some/path", "body":"hello world"}' http://localhost:11988/api/post
+```
+
+The end-point of the API is the HTTP verb you are stubbing, the path, response body, code and headers are specified in the POST data (a hash in JSON or Plist format). See the HTTP API Cucumber features for more examples.
+
+An [Objective-C wrapper](http://github.com/lukeredpath/LRMimic) for the REST API is available, allowing you to use mimic for your OSX and iOS apps.
+
+## Binding mimic to all ip addresses
+For security mimic only binds to localhost, should you require access from another computer you can tell mimic to bind to a particular or all ip addresses.
+```
+Mimic.mimic(:Host => '0.0.0.0', :port => 11988) do
+  # configure your stubs here
+end
+```
+
+## Contributors
+
+* [James Fairbairn](http://github.com/jfairbairn)
+* [Marcello Barnaba](https://github.com/vjt)
+
+## License
+
+As usual, the code is released under the MIT license which is included in the repository.

data/Rakefile

@@ -0,0 +1,100 @@
+require 'rubygems'
+require 'cucumber'
+require 'cucumber/rake/task'
+require 'rspec/core/rake_task'
+
+ENV["MIMIC_TEST_PROXY"] = nil
+
+desc "Run all Cucumber features"
+Cucumber::Rake::Task.new(:features) do |t|
+  t.cucumber_opts = "features --format pretty"
+end
+
+desc "Run all specs"
+RSpec::Core::RakeTask.new(:spec) do |t|
+end
+
+task :default => :spec
+task :all => [:spec, :features]
+
+require "rubygems/package_task"
+require "rdoc/task"
+
+# This builds the actual gem. For details of what all these options
+# mean, and other ones you can add, check the documentation here:
+#
+#   http://rubygems.org/read/chapter/20
+#
+spec = Gem::Specification.new do |s|
+
+  # Change these as appropriate
+  s.name              = "mimic2"
+  s.version           = "2.0.0"
+  s.summary           = "A Ruby gem for faking external web services for testing, forked and updated version of Luke Redpath's mimic"
+  s.authors           = "Luke Redpath, Nic Jackson"
+  s.email             = "jackson.nic@gmail.com, luke@lukeredpath.co.uk"
+  s.homepage          = "https://github.com/nicholasjackson/mimic"
+
+  s.has_rdoc          = true
+  s.extra_rdoc_files  = %w(README.md)
+  s.rdoc_options      = %w(--main README.md)
+
+  # Add any extra files to include in the gem
+  s.files             = %w(LICENSE CHANGES Rakefile README.md) + Dir.glob("{spec,lib/**/*}")
+  s.require_paths     = ["lib"]
+
+  # If you want to depend on other gems, add them here, along with any
+  # relevant versions
+  s.add_dependency("rack")
+  s.add_dependency("sinatra")
+  s.add_dependency("thin")
+  s.add_dependency("json")
+  s.add_dependency("plist", "~> 3.1.0")
+
+  # If your tests use any gems, include them here
+  s.add_development_dependency("rspec", "~> 3.3.0")
+  s.add_development_dependency("cucumber", "~> 2.0.2")
+  s.add_development_dependency("mocha")
+  s.add_development_dependency("rest-client")
+end
+
+# This task actually builds the gem. We also regenerate a static
+# .gemspec file, which is useful if something (i.e. GitHub) will
+# be automatically building a gem for this project. If you're not
+# using GitHub, edit as appropriate.
+#
+# To publish your gem online, install the 'gemcutter' gem; Read more
+# about that here: http://gemcutter.org/pages/gem_docs
+Gem::PackageTask.new(spec) do |pkg|
+  pkg.gem_spec = spec
+end
+
+desc "Build the gemspec file #{spec.name}.gemspec"
+task :gemspec do
+  file = File.dirname(__FILE__) + "/#{spec.name}.gemspec"
+  File.open(file, "w") {|f| f << spec.to_ruby }
+end
+
+task :package => :gemspec
+
+# Generate documentation
+RDoc::Task.new do |rd|
+  rd.main = "README.md"
+  rd.rdoc_files.include("README.md", "lib/**/*.rb")
+  rd.rdoc_dir = "rdoc"
+end
+
+desc 'Clear out RDoc and generated packages'
+task :clean => [:clobber_rdoc, :clobber_package] do
+  rm "#{spec.name}.gemspec" if File.exists? "#{spec.name}.gemspec"
+end
+
+task 'Release if all specs pass'
+task :release => [:clean, :bundle, :spec, :features, :package] do
+  system("gem push pkg/#{spec.name}-#{spec.version}.gem")
+end
+
+desc 'Install all gem dependencies'
+task :bundle => :gemspec do
+  system("bundle")
+end

data/lib/helpers/helpers.rb

@@ -0,0 +1,7 @@
+require 'helpers/request_echo'
+
+module Helpers
+  def echo_request!(format)
+    RequestEcho.new(request).response_as(format)
+  end
+end

data/lib/helpers/request_echo.rb

@@ -0,0 +1,42 @@
+module Helpers
+  class RequestEcho
+    def initialize(request)
+      @request = request
+    end
+
+    def response_as(format)
+      content_type = case format
+      when :json, :plist
+        "application/#{format.to_s.downcase}"
+      else
+        "text/plain"
+      end
+      [200, {"Content-Type" => content_type}, to_s(format)]
+    end
+
+    def to_s(format)
+      case format
+        when :json
+          to_hash.to_json
+        when :plist
+          to_hash.to_plist
+        when :text
+          to_hash.inspect
+      end
+    end
+
+    def to_hash
+      {"echo" => {
+        "params" => @request.params,
+        "env"    => env_without_rack_and_async_env,
+        "body"   => @request.body.read
+      }}
+    end
+
+    private
+
+    def env_without_rack_and_async_env
+      Hash[*@request.env.select { |key, value| key !~ /^(rack|async)/i }.flatten]
+    end
+  end
+end

data/lib/mimic.rb

@@ -0,0 +1,40 @@
+require 'mimic/fake_host'
+require 'singleton'
+require 'rack'
+require 'logger'
+
+module Mimic
+  MIMIC_DEFAULT_PORT = 11988
+
+  MIMIC_DEFAULT_OPTIONS = {
+    :hostname => 'localhost',
+    :port => MIMIC_DEFAULT_PORT,
+    :remote_configuration_path => nil,
+    :fork => true,
+    :log => nil
+  }
+
+  def self.mimic(options = {}, &block)
+    options = MIMIC_DEFAULT_OPTIONS.merge(options)
+    host = FakeHost.new(options)
+    host.instance_eval(&block) if block_given?
+
+    Server.instance.serve(host, options)
+
+    add_host(host)
+  end
+
+  def self.cleanup!
+    Mimic::Server.instance.shutdown
+  end
+
+  def self.reset_all!
+    @hosts.each { |h| h.clear }
+  end
+
+  private
+
+  def self.add_host(host)
+    host.tap { |h| (@hosts ||= []) << h }
+  end
+end

data/lib/mimic/api.rb

@@ -0,0 +1,65 @@
+require 'json'
+require 'plist'
+require 'mimic/api_request'
+
+module Mimic
+  class API < Sinatra::Base
+    class << self
+      attr_accessor :host
+    end
+
+    def host
+      self.class.host
+    end
+
+    post "/get" do
+      process_request request, 'get'
+    end
+
+    post "/post" do
+      process_request request, 'post'
+    end
+
+    post "/put" do
+      process_request request, 'put'
+    end
+
+    post "/delete" do
+      process_request request, 'delete'
+    end
+
+    post "/head" do
+      process_request request, 'head'
+    end
+
+    post "/multi" do
+      api_request = APIRequest.from_request(request)
+      api_request.setup_stubs_on(host)
+      [201, {"Content-Type" => api_request.request_content_type}, api_request.response]
+    end
+
+    post "/clear" do
+      response_body = self.host.inspect
+      self.host.clear
+      [200, {}, "Cleared stubs: #{response_body}"]
+    end
+
+    get "/ping" do
+      [200, {}, "OK"]
+    end
+
+    get "/debug" do
+      [200, {}, self.host.inspect]
+    end
+
+    get "/requests" do
+      [200, {"Content-Type" => "application/json"}, {"requests" => host.received_requests.map(&:to_hash)}.to_json]
+    end
+
+    def process_request request, verb
+      api_request = APIRequest.from_request(request, verb)
+      api_request.setup_stubs_on(host)
+      [201, {"Content-Type" => api_request.request_content_type}, api_request.response]
+    end
+  end
+end

data/lib/mimic/api_request.rb

@@ -0,0 +1,51 @@
+require 'mimic/stub'
+
+module Mimic
+  class APIRequest
+    attr_reader :request_content_type
+
+    def initialize(data, method = nil, request_content_type = '')
+      @data = data
+      @method = (method || "GET")
+      @stubs = []
+      @request_content_type = request_content_type
+    end
+
+    def to_s
+      @data.inspect
+    end
+
+    def response
+      response = {"stubs" => @stubs.map(&:to_hash)}
+
+      case request_content_type
+      when /json/
+        response.to_json
+      when /plist/
+        response.to_plist
+      else
+        response.to_json
+      end
+    end
+
+    def self.from_request(request, method = nil)
+      case request.content_type
+        when /json/
+          data = JSON.parse(request.body.string)
+        when /plist/
+          data = Plist.parse_xml(request.body.string)
+        else
+          data = request.body.string && request.body.string.length >= 2 ? JSON.parse(request.body.string) : {}
+      end
+
+      new(data, method, request.content_type)
+    end
+
+    def setup_stubs_on(host)
+      (@data["stubs"] || [@data]).each do |stub_data|
+        @stubs << Stub.new(stub_data, stub_data['method'] || @method).on(host)
+      end
+    end
+
+  end
+end

data/lib/mimic/fake_host.rb

@@ -0,0 +1,105 @@
+require 'sinatra/base'
+require 'mimic/api'
+require 'mimic/server'
+require 'mimic/stubbed_request'
+require 'helpers/helpers'
+
+module Mimic
+  class FakeHost
+    attr_reader :hostname, :url_map
+    attr_accessor :log
+
+    def initialize(options = {})
+      @hostname = options[:hostname]
+      @remote_configuration_path = options[:remote_configuration_path]
+      @log = options[:log]
+      @imports = []
+      setup_sinatra
+      build_url_map!
+    end
+
+    def received_requests
+      @stubs.select { |s| s.received }
+    end
+
+    def get(path, &block)
+      setup_request_stub("GET", path, &block)
+    end
+
+    def post(path, &block)
+      setup_request_stub("POST", path, &block)
+    end
+
+    def put(path, &block)
+      setup_request_stub("PUT", path, &block)
+    end
+
+    def delete(path, &block)
+      setup_request_stub("DELETE", path, &block)
+    end
+
+    def head(path, &block)
+      setup_request_stub("HEAD", path, &block)
+    end
+
+    def import(path)
+      if File.exists?(path)
+        @imports << path unless @imports.include?(path)
+        instance_eval(File.read(path))
+      else
+        raise "Could not locate file for stub import: #{path}"
+      end
+    end
+
+    def call(env)
+      @stubs.each(&:build)
+      @app.call(env) # call next middleware in chain
+    end
+
+    def setup_sinatra
+      @stubs = []
+      @app = Sinatra.new
+      @app.use Rack::CommonLogger, self.log if self.log
+      @app.not_found do
+        [404, {}, ""]
+      end
+      @app.helpers do
+        include Helpers
+      end
+      @imports.each { |file| import(file) }
+    end
+
+    def clear
+      setup_sinatra
+    end
+
+    def inspect
+      @stubs.inspect
+    end
+
+    private
+    def method_missing(method, *args, &block)
+      @app.send(method, *args, &block)
+    end
+
+    def setup_request_stub(method, path, &block)
+      if block_given?
+        @app.send(method.downcase, path, &block)
+      else
+        @stubs << StubbedRequest.new(@app, method, path)
+        @stubs.last
+      end
+    end
+
+    def build_url_map!
+      routes = {'/' => self}
+
+      if @remote_configuration_path
+        API.host = self
+        routes[@remote_configuration_path] = API
+      end
+
+      @url_map = Rack::URLMap.new(routes)
+    end
+  end
+end

data/lib/mimic/server.rb

@@ -0,0 +1,61 @@
+require 'singleton'
+
+module Mimic
+  class Server
+    include Singleton
+
+    def logger
+      @logger ||= Logger.new(StringIO.new)
+    end
+
+    def serve(app, options)
+      if options[:fork]
+        @thread = Thread.fork do
+          start_service(app, options)
+        end
+
+        wait_for_service(app.hostname, options[:port])
+
+      else
+        start_service(app, options)
+      end
+    end
+
+    def start_service(app, options)
+      Rack::Handler::Thin.run(app.url_map, {
+        :Host       => options[:Host] || 'localhost',
+        :Port       => options[:port],
+        :Logger     => logger,
+        :AccessLog  => logger
+      })
+    end
+
+    def shutdown
+      Thread.kill(@thread) if @thread
+    end
+
+    # courtesy of http://is.gd/eoYho
+
+    def listening?(host, port)
+      begin
+        socket = TCPSocket.new(host, port)
+        socket.close unless socket.nil?
+        true
+      rescue Errno::ECONNREFUSED, SocketError,
+        Errno::EBADF,           # Windows
+        Errno::EADDRNOTAVAIL    # Windows
+        false
+      end
+    end
+
+    def wait_for_service(host, port, timeout = 5)
+      start_time = Time.now
+
+      until listening?(host, port)
+        if timeout && (Time.now > (start_time + timeout))
+          raise SocketError.new("Socket did not open within #{timeout} seconds")
+        end
+      end
+    end
+  end
+end

data/lib/mimic/stub.rb

@@ -0,0 +1,44 @@
+module Mimic
+  class Stub
+    def initialize(data, method = nil)
+      @data = data
+      @method = method
+    end
+
+    def on(host)
+      get_stub(host).tap do |stub|
+        stub.returning(body, code, headers)
+        stub.with_query_parameters(params)
+        stub.echo_request!(echo_format)
+      end
+    end
+
+    def get_stub(host)
+      host.send(@method.downcase.to_sym, path)
+    end
+
+    def echo_format
+      @data['echo'].to_sym rescue nil
+    end
+
+    def path
+      @data['path'] || '/'
+    end
+
+    def body
+      @data['body'] || ''
+    end
+
+    def code
+      @data['code'] || 200
+    end
+
+    def headers
+      @data['headers'] || {}
+    end
+
+    def params
+      @data['params'] || {}
+    end
+  end
+end

data/lib/mimic/stubbed_request.rb

@@ -0,0 +1,73 @@
+require 'helpers/request_echo'
+
+module Mimic
+  class StubbedRequest
+    attr_accessor :received
+
+    def initialize(app, method, path)
+      @method, @path = method, path
+      @code = 200
+      @headers = {}
+      @params = {}
+      @body = ""
+      @app = app
+      @received = false
+    end
+
+    def to_hash
+      token = "#{@method} #{@path}"
+      Digest::MD5.hexdigest(token)
+    end
+
+    def returning(body, code = 200, headers = {})
+      tap do
+        @body = body
+        @code = code
+        @headers = headers
+      end
+    end
+
+    def with_query_parameters(params)
+      tap do
+        @params = params
+      end
+    end
+
+    def echo_request!(format = :json)
+      @echo_request_format = format
+    end
+
+    def matches?(request)
+      if @params.any?
+        request.params == @params
+      else
+        true
+      end
+    end
+
+    def matched_response
+      [@code, @headers, @body]
+    end
+
+    def unmatched_response
+      [404, {}, ""]
+    end
+
+    def response_for_request(request)
+      if @echo_request_format
+        @body = Helpers::RequestEcho.new(request).to_s(@echo_request_format)
+      end
+
+      matches?(request) ? matched_response : unmatched_response
+    end
+
+    def build
+      stub = self
+
+      @app.send(@method.downcase, @path) do
+        stub.received = true
+        stub.response_for_request(request)
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,185 @@
+--- !ruby/object:Gem::Specification
+name: mimic2
+version: !ruby/object:Gem::Version
+  version: 2.0.0
+platform: ruby
+authors:
+- Luke Redpath, Nic Jackson
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-09-07 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rack
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: sinatra
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: thin
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: plist
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.1.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.1.0
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.3.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.3.0
+- !ruby/object:Gem::Dependency
+  name: cucumber
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.0.2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.0.2
+- !ruby/object:Gem::Dependency
+  name: mocha
+  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: rest-client
+  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: 
+email: jackson.nic@gmail.com, luke@lukeredpath.co.uk
+executables: []
+extensions: []
+extra_rdoc_files:
+- README.md
+files:
+- CHANGES
+- LICENSE
+- README.md
+- Rakefile
+- lib/helpers/helpers.rb
+- lib/helpers/request_echo.rb
+- lib/mimic.rb
+- lib/mimic/api.rb
+- lib/mimic/api_request.rb
+- lib/mimic/fake_host.rb
+- lib/mimic/server.rb
+- lib/mimic/stub.rb
+- lib/mimic/stubbed_request.rb
+homepage: https://github.com/nicholasjackson/mimic
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options:
+- "--main"
+- README.md
+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.2.2
+signing_key: 
+specification_version: 4
+summary: A Ruby gem for faking external web services for testing, forked and updated
+  version of Luke Redpath's mimic
+test_files: []