mocktopus 0.0.4 → 0.0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 5c7dd5e4c53bbd5b1aff16acb47abbffae3be411
-  data.tar.gz: 4517dbbda052ffb494852ec3586f698151e45e00
+  metadata.gz: 28cb7cf89cc2fadda28177ec9b09e8e3e02befde
+  data.tar.gz: a24297d38f8c31cff6f40c7b4df2886bc08303c9
 SHA512:
-  metadata.gz: 072bb9f8221692ce8b2ecf0a8222733096a0584068b4922d2c26be6dec79cfa9411f0e401203f947d93028aad4bacb5f114ad7643534ba0196fa482c99295480
-  data.tar.gz: 4a9c3716d2a2dad0681cc0c5643a4179ad366dad33f78c25c7644ae23753bd2ed82bf91ec694b3520aae5245a6b9c1eebb030ad5fe761078ba23ec7bbc31e334
+  metadata.gz: f77bee53b77b0082bcd392959fe684295ff56399e6b09510953b6c6f7320fee19183a21f7dd002cdf6246c3b276c1664948f99ff443c52a490e8139c7e9799db
+  data.tar.gz: 1939142bd0dd2c5b18992c90bd135af2b3ec32ee2084ccddc11c62a5197c9e22b7a7acf2c139e5ce4e4cab51d0c2082e0c93175b060401873c793cc3dd1e0357

data/mocktopus.gemspec

@@ -2,7 +2,7 @@
 
 Gem::Specification.new do |s|
   s.name        = 'mocktopus'
-  s.version     = '0.0.4'
+  s.version     = '0.0.5'
   s.date        = '2015-03-14'
   s.required_ruby_version = '>= 1.9.3'
 
@@ -12,7 +12,7 @@ Gem::Specification.new do |s|
   s.email       = ['racksburg_automation@lists.rackspace.com']
   s.homepage    = 'https://github.com/rackspaceautomationco/mocktopus'
   
-  s.files = `git ls-files`.split($/)
+  s.files = Dir.glob("{bin,lib}/**/*") + %w(MIT-LICENSE README.md Gemfile mocktopus.gemspec config.ru ascii.rb)
   s.executables = %w(mocktopus)
 
   s.add_dependency 'sinatra', '~> 1.4', '>= 1.4.4'
@@ -20,10 +20,11 @@ Gem::Specification.new do |s|
   s.add_dependency 'thin', '~> 1.6.1', '>= 1.6.1'
   s.add_dependency 'thor', '~> 0.19.1', '>= 0.19.1'
   s.add_dependency 'rack', '~> 1.5.2', '>= 1.5.2'
-  s.add_dependency 'rake', '~> 10.1.0', '>= 10.1.0'
-  s.add_dependency 'minitest', '~> 5.2.0', '>= 5.2.0'
-  s.add_dependency 'fakeweb', '~> 1.3.0', '>= 1.3.0'
-  s.add_dependency 'mocha', '~> 0.14.0', '>= 0.14.0'
-  s.add_dependency 'simplecov', '~> 0.9.2', '>= 0.9.2'
-  s.add_dependency 'coveralls', '~> 0.7.11', '>= 0.7.11'
+  
+  s.add_development_dependency 'rake', '~> 10.1.0', '>= 10.1.0'
+  s.add_development_dependency 'minitest', '~> 5.2.0', '>= 5.2.0'
+  s.add_development_dependency 'fakeweb', '~> 1.3.0', '>= 1.3.0'
+  s.add_development_dependency 'mocha', '~> 0.14.0', '>= 0.14.0'
+  s.add_development_dependency 'simplecov', '~> 0.9.2', '>= 0.9.2'
+  s.add_development_dependency 'coveralls', '~> 0.7.11', '>= 0.7.11'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: mocktopus
 version: !ruby/object:Gem::Version
-  version: 0.0.4
+  version: 0.0.5
 platform: ruby
 authors:
 - Rackspace
@@ -120,7 +120,7 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 10.1.0
-  type: :runtime
+  type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
@@ -140,7 +140,7 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 5.2.0
-  type: :runtime
+  type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
@@ -160,7 +160,7 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 1.3.0
-  type: :runtime
+  type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
@@ -180,7 +180,7 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 0.14.0
-  type: :runtime
+  type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
@@ -200,7 +200,7 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 0.9.2
-  type: :runtime
+  type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
@@ -220,7 +220,7 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 0.7.11
-  type: :runtime
+  type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
@@ -239,13 +239,9 @@ executables:
 extensions: []
 extra_rdoc_files: []
 files:
-- ".coveralls.yml"
-- ".gitignore"
-- ".travis.yml"
 - Gemfile
 - MIT-LICENSE
 - README.md
-- Rakefile
 - ascii.rb
 - bin/mocktopus
 - config.ru
@@ -258,14 +254,6 @@ files:
 - lib/mocktopus/mock_api_call_container.rb
 - lib/mocktopus/response.rb
 - mocktopus.gemspec
-- test/app_test.rb
-- test/cli_test.rb
-- test/input_container_test.rb
-- test/input_test.rb
-- test/mock_api_call_container_test.rb
-- test/mock_api_call_test.rb
-- test/response_test.rb
-- test/test_helper.rb
 homepage: https://github.com/rackspaceautomationco/mocktopus
 licenses: []
 metadata: {}

data/.coveralls.yml

@@ -1 +0,0 @@
-service_name: travis-ci

data/.gitignore

@@ -1,7 +0,0 @@
-*DS_STORE
-/Gemfile.lock
-*.gem
-coverage/
-.ruby-version
-*.log.*
-*.log

data/.travis.yml

@@ -1,9 +0,0 @@
-language: ruby
-rvm:
-  - 2.1.2
-  - 2.0.0
-  - 1.9.3
-notifications:
-  email:
-    - justin.brown@rackspace.com
-script: "rake test"

data/Rakefile

@@ -1,11 +0,0 @@
-require 'rubygems'
-require 'rake'
-require 'bundler/gem_tasks'
-
-require 'rake/testtask'
-Rake::TestTask.new(:test) do |test|
-  test.libs << 'lib' << 'test'
-  test.pattern = 'test/**/*_test.rb'
-end
-
-task :default => [:test]

data/test/app_test.rb

@@ -1,276 +0,0 @@
-# encoding: utf-8
-require 'test_helper'
-
-class AppTest < Mocktopus::Test
-  
-  def setup
-
-  end
-
-  def app
-    Sinatra::Application
-  end
-
-   def test_inputs_nothing_raised
-    body = {
-        'foo' => 'bar'
-      }
-    input_object = create_input('/v0/bar', 'GET', nil, JSON.pretty_generate(body), 200, nil, "")
-
-    response = post '/mocktopus/inputs/test_inputs_nothing_raised', JSON.pretty_generate(input_object)
-    assert_equal(200, response.status)
-  end
-
-  def test_bad_input_returns_400
-    post '/mocktopus/inputs/test_bad_input_returns_400', {}, {}
-    assert_equal 400, last_response.status
-  end
-
-  def test_all_inputs
-    input1 = create_input('/v0/test_all_inputs_foo', 'GET', nil, nil, 200, nil, "")
-    post '/mocktopus/inputs/test_all_inputs_foo', JSON.pretty_generate(input1)
-
-    input2 = create_input('/v0/test_all_inputs_bar', 'GET', nil, nil, 200, nil, "")
-    post '/mocktopus/inputs/test_all_inputs_bar', JSON.pretty_generate(input2)
-
-    inputs_response = get '/mocktopus/inputs'
-    json = JSON.parse(inputs_response.body)
-    refute_nil json['test_all_inputs_foo']
-    refute_nil json['test_all_inputs_bar']
-  end
-
-  def test_match_get
-    response_body_hash = {
-      "key1" => "value1",
-      "key2" => "value2"
-    }
-    input1 = create_input('/v0/test_match_get1', 'GET', { "host"=>"example.org", "cookie"=>"" }, nil, 200, nil, response_body_hash)
-    post '/mocktopus/inputs/test_match_get1', JSON.pretty_generate(input1)
-
-    response = get '/v0/test_match_get1'
-    assert_equal(200, response.status)
-    assert_equal(response_body_hash, JSON.parse(response.body))
-  end
-
-  def test_match_post
-    post_body_hash = {
-      "name" => "John",
-      "email" => "john@127.0.0.1"
-    }
-    response_body_hash = {
-      "response" => "ok!"
-    }
-    input1 = create_input('/v0/test_match_post1', 'POST', { "host"=>"example.org", "cookie"=>"" }, post_body_hash, 202, nil, response_body_hash)
-    post '/mocktopus/inputs/test_match_post1', input1.to_json
-
-    response = post '/v0/test_match_post1', post_body_hash.to_json
-    assert_equal(202, response.status)
-    assert_equal(response_body_hash, JSON.parse(response.body))
-  end
-
-  def test_input_by_name
-    input1 = create_input('/v0/test_input_by_name_foo', 'GET', nil, "", 200, nil, "")
-    post '/mocktopus/inputs/test_input_by_name_foo', input1.to_json
-
-    input2 = create_input('/v0/test_input_by_name_bar', 'GET', nil, "", 200, nil, "")
-    post '/mocktopus/inputs/test_input_by_name_bar', input2.to_json
-
-    input_by_name_response = get '/mocktopus/inputs/test_input_by_name_foo'
-    json = JSON.parse(input_by_name_response.body)
-    refute_nil json
-    assert_equal(input1, json)
-    assert (json != input2)
-  end
-
-  def test_delete_all
-    input1 = create_input('/v0/test_delete_all_foo', 'GET', nil, nil, 200, nil, "")
-    post '/mocktopus/inputs/test_delete_all_foo', JSON.pretty_generate(input1)
-
-    delete '/mocktopus/inputs'
-
-    inputs_response = get'/mocktopus/inputs'
-    json = JSON.parse(inputs_response.body)
-    assert_equal(0, json.size())
-  end
-
-  def test_delete_by_name
-    input1 = create_input('/v0/test_delete_by_name_foo', 'GET', nil, "", 200, nil, "")
-    post '/mocktopus/inputs/test_delete_by_name_foo', JSON.pretty_generate(input1)
-
-    input2 = create_input('/v0/test_delete_by_name_bar', 'GET', nil, "", 200, nil, "")
-    post '/mocktopus/inputs/test_delete_by_name_bar', JSON.pretty_generate(input2)
-
-    delete '/mocktopus/inputs/test_delete_by_name_foo'
-
-    inputs_response = get '/mocktopus/inputs/test_delete_by_name_bar'
-    json = JSON.parse(inputs_response.body)
-    refute_nil json
-    assert_equal(input2, json)
-    assert (json != input1)
-  end
-
-  def test_not_found_matching_input_found
-    input1 = create_input('/test_not_found_matching_input_found/1', 'POST', { "host" => "example.org", "cookie" => "" }, JSON.pretty_generate({ "foo" => "bar" }), 200, { "bar" => "foo" }, JSON.pretty_generate({ "body" => "foobar" }))
-    post '/mocktopus/inputs/test_not_found_matching_input_found', JSON.pretty_generate(input1)
-
-    response = post '/test_not_found_matching_input_found/1', JSON.pretty_generate({"foo" => "bar"})
-
-    assert_equal(200, response.status)
-  end
-
-  def test_mock_api_calls
-    uri = '/test_mock_api_calls/1'
-    verb = 'POST'
-    code = 200
-    body = {
-      "key1" => "value_one",
-      "key2" => "value_two"
-    }
-    input = create_input(uri, verb, body, '', code, {}, '')
-    post "/mocktopus/inputs/#{uri}", input
-
-    post uri, JSON.pretty_generate(body)
-    calls = get '/mocktopus/mock_api_calls'
-    json = JSON.parse(calls.body)
-    this_test_call = json.select{|k| k['path'] == uri }.first
-    refute_nil this_test_call
-    assert_equal(uri, this_test_call['path'])
-    assert_equal(verb, this_test_call['verb'])
-    assert_equal(body, this_test_call['body'])
-  end
-
-  def test_mock_api_calls_with_parameters
-    uri = '/test_mock_api_calls_with_parameters/foo?key=(domain=getstatus.com)&start=0&pageSize=100'
-    verb = 'GET'
-    code = 200
-    input = create_input(uri, verb, {}, '', code, {}, '')
-    post "/mocktopus/inputs/#{uri}", input
-
-    delete '/mocktopus/mock_api_calls'
-
-    get uri
-    calls = JSON.parse(get('/mocktopus/mock_api_calls').body)
-    this_test_call = calls.select{|k| k['path'] == uri }.first
-    refute_nil this_test_call
-    assert_equal(uri, this_test_call['path'])
-    assert_equal(verb, this_test_call['verb'])
-  end
-
-  def test_delete_mock_api_calls
-    uri = '/test_delete_mock_api_calls/1'
-    verb = 'POST'
-    code = 200
-    body = {
-      "key1" => "value_one",
-      "key2" => "value_two"
-    }
-    input = create_input(uri, verb, body, '', code, {}, '')
-    post "/mocktopus/inputs/#{uri}", input
-
-    post uri, JSON.pretty_generate(body)
-    calls = get '/mocktopus/mock_api_calls'
-    json = JSON.parse(calls.body)
-    assert(0 < json.size)
-    delete '/mocktopus/mock_api_calls'
-    calls = get '/mocktopus/mock_api_calls'
-    json = JSON.parse(calls.body)
-    assert(0 == json.size)
-  end
-
-  def test_get_missing_input_returns_405
-    response = get "/mocktopus/inputs/does_not_exist"
-    assert_equal(405, response.status)
-  end
-
-  def test_input_sequencing
-    uri = '/test_input_sequencing'
-    verb = 'GET'
-    code = 200
-    body1 = {
-      "status" => "pending"
-    }
-    body2 = {
-      "status" => "completed"
-    }
-
-    input1 = create_input(uri, verb, {}, nil, code, {}, body1)
-    input2 = create_input(uri, verb, {}, nil, code, {}, body1)
-    input3 = create_input(uri, verb, {}, nil, code, {}, body2)
-
-    post "/mocktopus/inputs/test_input_sequencing_1", JSON.pretty_generate(input1)
-    post "/mocktopus/inputs/test_input_sequencing_2", JSON.pretty_generate(input2)
-    post "/mocktopus/inputs/test_input_sequencing_3", JSON.pretty_generate(input3)
-
-    response = get uri, nil
-    assert_equal(body1, JSON.parse(response.body))
-    response = get uri, nil
-    assert_equal(body1, JSON.parse(response.body))
-    response = get uri, nil
-    assert_equal(body2, JSON.parse(response.body))
-  end
-
-  def test_nil_headers
-    uri = '/test_nil_headers?foo=bar&email=test@test.com'
-    verb = 'GET'
-    code = 200
-    input = create_input(uri, verb, nil, nil, code, nil, {})
-    post '/mocktopus/inputs/test_nil_headers', JSON.pretty_generate(input)
-
-    response = get uri, nil
-    assert_equal(code, response.status)
-  end
-
-  def test_unicode_in_body
-    uri = 'test_unicode'
-    verb = 'POST'
-    body =
-    {
-      "uri" => "¾öäëöäëü",
-      "msg" => "I am the unicöde monster"
-    }
-    code = 200
-    input = create_input(uri, verb, {}, body, code, {}, body)
-    post "/mocktopus/inputs/test_unicode_in_body", JSON.pretty_generate(input)
-
-    response = get "/mocktopus/inputs/test_unicode_in_body"
-    assert_equal(body, JSON.parse(JSON.parse(response.body)['body']))
-  end
-
-  def test_uri_encoding
-    uri = 'test_unicode'
-    verb = 'POST'
-    body =
-    {
-      "uri" => 'https://web.archive.org/web/20060204114947/http://www.googles.com/index_noflash.html'
-    }
-    code = 200
-    input = create_input(uri, verb, {}, body, code, {}, body)
-    post "/mocktopus/inputs/test_uri_encoding", JSON.pretty_generate(input)
-
-    response = get "/mocktopus/inputs/test_uri_encoding"
-    assert_equal(body, JSON.parse(JSON.parse(response.body)['body']))
-  end
-
-  def test_failed_match_returns_json
-    random_uri = "/#{SecureRandom.uuid}"
-    get random_uri
-    assert_equal 428, last_response.status
-    assert_equal random_uri, JSON.parse(last_response.body)['call']['path']
-  end
-
-  private
-  def create_input(uri, verb, headers, body, response_code, response_headers, response_body)
-    input = {}
-    input['uri'] = uri
-    input['headers'] = headers
-    input['body'] = body
-    input['verb'] = verb
-    input['response'] = {
-      "code" => response_code,
-      "headers" => response_headers,
-      "body" => response_body,
-      "delay" => 0
-    }
-    return input
-  end
-end

data/test/cli_test.rb

@@ -1,25 +0,0 @@
-require 'test_helper'
-
-class CLITest < Mocktopus::Test
-  def setup
-    @cli = Mocktopus::CLI.new
-  end
-
-  def test_start_task_starts_mocktopus_with_default_port
-    command = 'bundle exec thin -R config.ru start -p 8081 '
-    @cli.stubs(:run_command).with(command).once
-    @cli.start
-  end
-
-  def test_start_task_starts_mocktopus_with_custom_port
-    command = 'bundle exec thin -R config.ru start -p 7071'
-    @cli.stubs(:run_command).with(command).once
-    @cli.start('-p', '7071')
-  end
-
-  def test_stop_task_stops_mocktopus
-    @cli.stubs(:run_command).with('bundle exec thin stop')
-    @cli.stop
-  end
-
-end

data/test/input_container_test.rb

@@ -1,229 +0,0 @@
-require 'test_helper'
-
-class InputContainerTest < Mocktopus::Test
-
-  def test_initialize_not_nil
-    container = Mocktopus::InputContainer.new
-    refute_nil container
-  end
-
-  def test_all_returns_zero_on_init
-    container = Mocktopus::InputContainer.new
-    all_inputs = container.all()
-    assert_equal(0, all_inputs.size())
-  end
-
-  def test_all_returns_count_after_add
-    container = Mocktopus::InputContainer.new
-    container.add("hash1", {})
-    container.add("hash2", {})
-    all_inputs = container.all()
-    assert_equal(2, all_inputs.size())
-  end
-
-  def test_get_by_returns_existing_input
-    container = Mocktopus::InputContainer.new
-    container.add("hash1", {})
-    hash1 = container.get_by("hash1")
-    refute_nil hash1
-  end
-
-  def test_get_by_returns_nil_for_missing_input
-    container = Mocktopus::InputContainer.new
-    container.add("hash1", {})
-    hash2 = container.get_by("hash2")
-    assert_nil(hash2)
-  end
-
-  def test_delete_all_returns_empty_hash
-    container = Mocktopus::InputContainer.new
-    container.add("hash1", {})
-    container.add("hash2", {})
-    container.delete_all()
-    all_after_delete = container.all()
-    assert_equal(0, all_after_delete.size())
-  end
-
-  def test_delete_by_deletes_input
-    container = Mocktopus::InputContainer.new
-    container.add("hash1", {})
-    container.add("hash2", {})
-    container.delete_by("hash2")
-    all = container.all()
-    assert_equal(1, all.size())
-    hash1 = container.get_by("hash1")
-    refute_nil hash1
-  end
-
-  def test_delete_by_missing_input_does_nothing
-    container = Mocktopus::InputContainer.new
-    container.add("hash1", {})
-    container.delete_by("hash2")
-    all = container.all()
-    assert_equal(1, all.size())
-    hash1 = container.get_by("hash1")
-    refute_nil hash1
-  end
-
-  def test_single_match_returns_match
-    response = Mocktopus::Response.new({
-        "code" => "200",
-        "headers" => {},
-        "body" => {
-          "foo" => "baz"
-        }
-      })
-
-    input = Mocktopus::Input.new({
-      "uri" => "/v0/test_single_match_returns_match",
-      "verb" => "POST",
-      "headers" => {},
-      "body"  => {
-        "foo" => "bar"
-      }
-    }, response)
-
-    container = Mocktopus::InputContainer.new
-    container.add("input1", input)
-    match_result = container.match("/v0/test_single_match_returns_match", "POST", {}, JSON.pretty_generate({"foo" => "bar"}), {})
-    refute_nil match_result
-    assert_equal(response, match_result.response)
-  end
-
-  def test_single_match_returns_match_encoded
-    response = Mocktopus::Response.new({
-        "code" => "200",
-        "headers" => {},
-        "body" => {
-          "key" => "test_single_match_returns_match_encoded"
-        }
-      })
-
-    input = Mocktopus::Input.new({
-      "uri" => "/v0/test_single_match_returns_match_encoded/(key%3Dvalue)",
-      "verb" => "POST",
-      "headers" => {},
-      "body"  => {
-        "key" => "test_single_match_returns_match_encoded"
-      }
-    }, response)
-
-    container = Mocktopus::InputContainer.new
-    container.add("input1", input)
-    match_result = container.match("/v0/test_single_match_returns_match_encoded/(key=value)", "POST", {}, JSON.pretty_generate({"key" => "test_single_match_returns_match_encoded"}), {})
-    refute_nil match_result
-    assert_equal(response, match_result.response)
-  end
-
-  def test_headers_match_returns_single_result_for_dashes
-        response = Mocktopus::Response.new({
-        "code" => "200",
-        "headers" => {},
-        "body" => {
-          "key" => "test_headers_match_returns_single_result_for_dashes"
-        }
-      })
-
-    input = Mocktopus::Input.new({
-      "uri" => "/v0/test_headers_match_returns_single_result_for_dashes",
-      "verb" => "GET",
-      "headers" => { 'g-sub-me' => 'fizz'},
-      'body' => {}
-    }, response)
-
-    container = Mocktopus::InputContainer.new
-    container.add("input1", input)
-    match_result = container.match("/v0/test_headers_match_returns_single_result_for_dashes", "GET", {'g_sub_me' => 'fizz'}, {}, {})
-    refute_nil match_result
-    assert_equal(response, match_result.response)
-  end
-
-  def test_headers_different_value_no_result_for_dashes
-        response = Mocktopus::Response.new({
-        "code" => "200",
-        "headers" => {},
-        "body" => {
-          "key" => "test_headers_different_value_no_result_for_dashes"
-        }
-      })
-
-    input = Mocktopus::Input.new({
-      "uri" => "/v0/test_headers_different_value_no_result_for_dashes",
-      "verb" => "GET",
-      "headers" => { 'g-sub-mez' => 'fizz'},
-      'body' => {}
-    }, response)
-
-    container = Mocktopus::InputContainer.new
-    container.add("input1", input)
-    match_result = container.match("/v0/test_headers_different_value_no_result_for_dashes", "GET", {'g_sub_me' => 'fizz'}, {}, {})
-    assert_nil match_result
-  end
-
-  def test_headers_no_match_returns_nil_result_for_dashes
-        response = Mocktopus::Response.new({
-        "code" => "200",
-        "headers" => {},
-        "body" => {
-          "key" => "test_headers_no_match_returns_nil_result_for_dashes"
-        }
-      })
-
-    input = Mocktopus::Input.new({
-      "uri" => "/v0/test_headers_no_match_returns_nil_result_for_dashes",
-      "verb" => "GET",
-      "headers" => { 'g-sub-me' => 'pop'}
-    }, response)
-
-    container = Mocktopus::InputContainer.new
-    container.add("input1", input)
-    match_result = container.match("/v0/test_headers_no_match_returns_nil_result_for_dashes", "GET", {'g_sub_me' => 'fizz'}, nil, nil)
-    assert_nil match_result
-  end
-
-  def test_single_match_no_inputs_returns_nil
-    container = Mocktopus::InputContainer.new
-    match_result = container.match("/v0/test_single_match_no_inputs_returns_nil", "POST", {}, JSON.pretty_generate({}), {})
-    assert_nil(match_result)
-  end
-
-  def test_multiple_inputs_returns_correct_sequence
-    response1 = Mocktopus::Response.new({
-        "code" => "200",
-        "headers" => {},
-        "body" => {
-          "status" => "pending"
-        }
-      })
-
-    response2 = Mocktopus::Response.new({
-        "code" => "200",
-        "headers" => {},
-        "body" => {
-          "status" => "complete"
-        }
-      })
-
-    input_hash = {
-      "uri" => "/v0/test_multiple_inputs_returns_correct_sequence",
-      "verb" => "GET",
-      "headers" => {},
-      "body" => nil
-    }
-
-    container = Mocktopus::InputContainer.new
-    container.add("first_input", Mocktopus::Input.new(input_hash, response1))
-    container.add("second_input", Mocktopus::Input.new(input_hash, response1))
-    container.add("last_input", Mocktopus::Input.new(input_hash, response2))
-
-    first_match = container.match("/v0/test_multiple_inputs_returns_correct_sequence", "GET", {}, "", {})
-    assert_equal(response1, first_match.response)
-
-    second_match = container.match("/v0/test_multiple_inputs_returns_correct_sequence", "GET", {}, "", {})
-    assert_equal(response1, second_match.response)
-
-    last_match = container.match("/v0/test_multiple_inputs_returns_correct_sequence", "GET", {}, "", {})
-    assert_equal(response2, last_match.response)
-  end
-
-end

data/test/input_test.rb

@@ -1,166 +0,0 @@
-# encoding: utf-8
-require 'test_helper'
-
-class ResponseTest < Mocktopus::Test
-
-  def test_to_hash
-    input = build_input({})
-    hash  = input.to_hash
-
-    assert_equal( '/uri', hash['uri'])
-    assert_equal( 'application/json',     hash['headers']['Content-Type'])
-    assert_equal( '{}',                   hash['body'])
-    assert_equal( {},                     hash['response'])
-  end
-
-  def test_to_hash_extra_fields
-    input = build_input({'nosuch' => 'extra'})
-    hash  = input.to_hash
-
-    assert_equal(hash['nosuch'], nil)
-  end
-
-  def test_validate_input_errors
-    assert_raises Mocktopus::Input::ValidationError do
-      build_input({'uri' => '/[^\-_.!~*\'()a-zA-Z\d;\/?:@&=+$,\[\]]/
-        => /[^\-_.!~*\'()a-zA-Z\d;\/?:@&=+$,\[\]]/
-        irb(main):003:0> p Regexp.union([URI::Parser.new.regexp[:UNSAFE],\'~\',\'@\'])
-        /(?-mix:[^\-_.!~*\'()a-zA-Z\d;\/?:@&=+$,\[\]])|~|@/
-        => /(?-mix:[^\-_.!~*\'()a-zA-Z\d;\/?:@&'})
-    end
-
-    assert_raises Mocktopus::Input::ValidationError do
-      build_input({'uri' => 'irb(main):005:0*'})
-    end
-
-    assert_raises Mocktopus::Input::ValidationError do
-      build_input({'headers' => {nil => nil}})
-    end
-
-    build_input({'body' => nil})
-
-    assert_raises Mocktopus::Input::ValidationError do
-      build_input({}, "Not a response object")
-    end
-
-    assert_raises Mocktopus::Input::ValidationError do
-      build_input({'verb' => SecureRandom.uuid})
-    end
-
-    build_input({}, nil)
-  end
-
-  def test_flexible_uris
-    assert_equal(build_input({'uri' => '%C3%B6%C3%BF%C3%A0%C3%A1%C3%A4'}).to_hash, build_input({'uri' => 'öÿàáä'}).to_hash)
-  end
-
-  def test_to_hash_returns_properties_with_one_param
-    hash = {
-      'uri' => '/test?parameter_one=foo',
-      'headers' => {
-        'Content-Type' => 'appilcation/json'
-      },
-      'body' => {
-        'body_one' => 'uno',
-        'body_two' => {
-          'nested' => 'value'
-        }
-      },
-      'verb' => 'POST'
-    }
-    input = Mocktopus::Input.new(hash, response_with_empty_hash())
-
-    hashed_input = input.to_hash
-    assert_equal(hash['uri'], hashed_input['uri'])
-    assert_equal(hash['headers'], hashed_input['headers'])
-    assert_equal(JSON.pretty_generate(hash['body']), hashed_input['body'])
-    assert_equal(hash['verb'], hashed_input['verb'])
-  end
-
-  def test_to_hash_returns_properties_with_no_params
-    hash = {
-      'uri' => '/test',
-      'headers' => {
-        'Content-Type' => 'appilcation/json'
-      },
-      'body' => {
-        'body_one' => 'uno',
-        'body_two' => {
-          'nested' => 'value'
-        }
-      },
-      'verb' => 'POST'
-    }
-    input = Mocktopus::Input.new(hash, response_with_empty_hash())
-
-    hashed_input = input.to_hash
-    assert_equal(hash['uri'], hashed_input['uri'])
-    assert_equal(hash['headers'], hashed_input['headers'])
-    assert_equal(JSON.pretty_generate(hash['body']), hashed_input['body'])
-    assert_equal(hash['verb'], hashed_input['verb'])
-  end
-
-  def test_to_hash_returns_properties_with_two_params
-    hash = {
-      'uri' => '/test?parameter_one=foo&parameter_two=bar',
-      'headers' => {
-        'Content-Type' => 'appilcation/json'
-      },
-      'body' => {
-        'body_one' => 'uno',
-        'body_two' => {
-          'nested' => 'value'
-        }
-      },
-      'verb' => 'POST'
-    }
-    input = Mocktopus::Input.new(hash, response_with_empty_hash())
-
-    hashed_input = input.to_hash
-    assert_equal(hash['uri'], hashed_input['uri'])
-    assert_equal(hash['headers'], hashed_input['headers'])
-    assert_equal(JSON.pretty_generate(hash['body']), hashed_input['body'])
-    assert_equal(hash['verb'], hashed_input['verb'])
-  end
-
-  def test_to_s
-    hash = {
-      'uri' => '/test/to/s',
-      'verb' => 'GET'
-    }
-    input = Mocktopus::Input.new(hash, response_with_empty_hash())
-    s = input.to_s
-    assert_equal 'String', s.class.name
-    
-  end
-
-  private
-
-  def build_input(hash = {}, response = response_with_empty_hash())
-    input = Mocktopus::Input.new(
-      {
-        'uri'  => 'http://localhost/uri',
-        'headers' => {
-          'Content-Type' => 'application/json'
-        },
-        'body' => '{}',
-        'verb' => 'post'
-      }.merge(hash),
-      response
-    )
-    return input
-  end
-
-  def response_with_empty_hash
-    response = Mocktopus::Response.new({
-      'code' => 200,
-      'headers' => nil,
-      'body' => nil
-    })
-
-    def response.to_hash
-      {}
-    end
-    return response
-  end
-end

data/test/mock_api_call_container_test.rb

@@ -1,26 +0,0 @@
-require 'test_helper'
-
-class MockApiCallContainerTest < Mocktopus::Test
-
-  def test_initialize_not_nil
-    container = Mocktopus::MockApiCallContainer.new
-    refute_nil container
-    assert_equal('Mocktopus::MockApiCallContainer', container.class.name)
-  end
-
-  def test_add
-    container = Mocktopus::MockApiCallContainer.new
-    call = Mocktopus::MockApiCall.new('/foo/bar', 'POST', {"header1" => "header_one"}, {"body1" => "body_one"})
-    container.add(call)
-  end
-
-  def test_all
-    container = Mocktopus::MockApiCallContainer.new
-    10.times do |i|
-      container.add(Mocktopus::MockApiCall.new("/foo/bar/#{i}", 'POST', {"header#{i}" => "header_#{i}"}, {"body#{i}" => "body_#{i}"}))
-    end
-    all = container.all
-    refute_nil all.select{|a| a['path'] == '/foo/bar/0'}.first
-  end
-
-end

data/test/mock_api_call_test.rb

@@ -1,35 +0,0 @@
-require 'test_helper'
-
-class MockApiCallTest < Mocktopus::Test
-
-  def test_constructor
-    path = '/test_constructor/1'
-    verb = 'POST'
-    headers = {}
-    headers['header1'] = 'header1'
-    headers['header2'] = 'header2'
-    body = {}
-    body['one'] = 1
-    body['two'] = 2
-    call = Mocktopus::MockApiCall.new(path, verb, headers, body)
-    refute_nil call
-    assert_equal(path, call.path)
-    assert_equal(verb, call.verb)
-    assert_equal(headers, call.headers)
-    assert_equal(body, call.body)
-  end
-
-  def test_timestamp
-    call = Mocktopus::MockApiCall.new('/foo/bar', 'DELETE', {}, {})
-    refute_nil call.timestamp
-    parsed_time = Time.iso8601(call.timestamp)
-    assert_equal('Time', parsed_time.class.name)
-  end
-
-  def test_to_s
-    call = Mocktopus::MockApiCall.new('/test/to/s', 'GET', {}, {})
-    s = call.to_s
-    assert_equal 'String', s.class.name
-  end
-
-end

data/test/response_test.rb

@@ -1,64 +0,0 @@
-require 'test_helper'
-
-class ResponseTest < Mocktopus::Test
-
-  def test_to_hash
-    input = build_response({})
-    hash  = input.to_hash
-
-    assert_equal(hash['headers']['Content-Type'],  'application/json')
-    assert_equal(hash['body'], '{}')
-    assert_equal(hash['code'], 200)
-  end
-
-  def test_to_hash_extra_fields
-    input = build_response({'nosuch' => 'extra'})
-    hash  = input.to_hash
-
-    assert_equal(hash['nosuch'], nil)
-  end
-
-  def test_validation
-
-    assert_raises Mocktopus::Response::ValidationError do
-      build_response({'headers' => {nil => nil}})
-    end
-
-    assert_raises Mocktopus::Response::ValidationError do
-      build_response({'code' => "Not a code"})
-    end
-    build_response({})
-
-  end
-
-  def test_delay_integer
-    input = build_response({'delay' => 15})
-    hash = input.to_hash
-    assert_equal(15, hash['delay'])
-  end
-
-  def test_delay_float
-    input = build_response({'delay' => 12.54542})
-    hash = input.to_hash
-    assert_equal(12.54542, hash['delay'])
-  end
-
-  def test_delay_invalid
-    input = build_response({'delay' => 'invalid_delay'})
-    hash = input.to_hash
-    assert_equal(0, hash['delay'])
-  end
-
-  def build_response(hash)
-    response = Mocktopus::Response.new(
-      {
-        'code'  => 200,
-        'headers' => {
-          'Content-Type' => 'application/json'
-        },
-        'body' => '{}'
-      }.merge(hash)
-    )
-    return response
-  end
-end

data/test/test_helper.rb

@@ -1,33 +0,0 @@
-require 'simplecov'
-require 'coveralls'
-
-SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter[
-  Coveralls::SimpleCov::Formatter,
-  SimpleCov::Formatter::HTMLFormatter
-]
-
-SimpleCov.start do
-  add_filter '/test/'
-  add_filter '/ascii.rb'
-end
-
-require 'rack/test'
-require 'tmpdir'
-require 'fakeweb'
-require 'minitest/autorun'
-require 'mocha/setup'
-
-require_relative '../lib/mocktopus'
-
-FakeWeb.allow_net_connect = %r[^https?://coveralls.io]
-
-ENV['RACK_ENV'] = 'test'
-WORKING_DIRECTORY = Dir.pwd.freeze
-ARGV.clear
-
-module Mocktopus
-  class Test < Minitest::Test
-    include Rack::Test::Methods
-
-  end
-end