anmo2 0.0.31

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: c7310ced86159b67bd2c3341222a7e33b2a135f0
+  data.tar.gz: bfb7d3107fc3e36ddd6f65daaa84e91ae8ae8474
+SHA512:
+  metadata.gz: 88d83b15443d8152dd009b7501a3e4c2f0b13dd1dfcb418826236a474b30184cf7bf1a9339b166c9e48e616c049e5d7a6a79f3269adac3bf342bc60069d76bb0
+  data.tar.gz: 00e8186c8d03d2fd29fb3b8fa7dab14a56ab7d9a54007726083a76cec88c3349b286a604707ddddd38f0080d31bbd64a545534abbf888b785fd84277a980363d

data/.gitignore

@@ -0,0 +1,5 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*
+.vimlocal

data/.rubocop.yml

@@ -0,0 +1,112 @@
+Lint/SpaceBeforeFirstArg:
+  Severity: fatal
+  Enabled: true
+
+Lint/RescueException:
+  Severity: fatal
+  Enabled: true
+
+Lint/UnusedBlockArgument:
+  Severity: fatal
+  Enabled: true
+
+Metrics/LineLength:
+  Severity: fatal
+  Enabled: true
+
+Metrics/MethodLength:
+  Severity: convention
+  Enabled: true
+  Max: 5
+
+Style/AlignHash:
+  Severity: fatal
+  Enabled: true
+  EnforcedHashRocketStyle: table
+
+Style/AlignParameters:
+  Severity: fatal
+  Enabled: true
+  EnforcedStyle: with_fixed_indentation
+
+Style/BracesAroundHashParameters:
+  Severity: fatal
+  Enabled: true
+
+Style/ConstantName:
+  Severity: fatal
+  Enabled: true
+
+Style/Documentation:
+  Enabled: false
+
+Style/EmptyLinesAroundClassBody:
+  Severity: fatal
+  Enabled: true
+
+Style/ExtraSpacing:
+  Enabled: false
+
+Style/FileName:
+  Enabled: false
+
+Style/HashSyntax:
+  Severity: fatal
+  Enabled: true
+  EnforcedStyle: hash_rockets
+
+Style/IndentationConsistency:
+  Severity: fatal
+  Enabled: true
+
+Style/IndentationWidth:
+  Severity: fatal
+  Enabled: true
+
+Style/IndentHash:
+  Severity: fatal
+  Enabled: true
+
+Style/InlineComment:
+  Severity: fatal
+  Enabled: true
+
+Style/LineEndConcatenation:
+  Severity: fatal
+  Enabled: true
+
+Style/MethodName:
+  Severity: fatal
+  Enabled: true
+
+Style/MultilineTernaryOperator:
+  Enabled: false
+
+Style/NegatedIf:
+  Severity: fatal
+  Enabled: true
+
+Style/Not:
+  Severity: fatal
+  Enabled: true
+
+Style/SpaceInsideHashLiteralBraces:
+  Severity: fatal
+  Enabled: true
+
+Style/StringLiterals:
+  Severity: fatal
+  Enabled: true
+  EnforcedStyle: double_quotes
+
+Style/TrailingBlankLines:
+  Severity: fatal
+  Enabled: true
+
+Style/TrailingWhitespace:
+  Severity: fatal
+  Enabled: true
+
+Style/VariableName:
+  Severity: fatal
+  Enabled: true

data/.ruby-version

@@ -0,0 +1 @@
+2.1.2

data/.rvmrc

@@ -0,0 +1 @@
+rvm ruby-1.9.2-p318

data/.travis.yml

@@ -0,0 +1,4 @@
+rvm:
+  - 1.8.7
+  - 1.9.2
+  - 1.9.3

data/Dockerfile

@@ -0,0 +1,9 @@
+FROM ruby
+
+RUN gem install anmo
+ADD run.sh /run.sh
+RUN chmod u+x /run.sh
+
+EXPOSE 9999
+
+CMD ["./run.sh"]

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in anmo.gemspec
+gemspec

data/README.md

@@ -0,0 +1,41 @@
+Anmo
+====
+
+[![Build status](https://secure.travis-ci.org/sthulbourn/anmo.png)](https://travis-ci.org/sthulbourn/anmo)
+
+What?
+-----
+Anmo acts as a mock api and can be used to store arbitrary pieces of data for integration testing flaky APIs.
+This is generally *not a good idea*, but where you can't use [VCR](https://github.com/myronmarston/vcr) anmo is now an option.
+
+How?
+----
+
+```
+require "anmo"
+
+Thread.new { Anmo.launch_server }
+
+Anmo.create_request({
+  :path => "/lookatmyhorse",
+  :body => "my horse is amazing"
+})
+```
+
+```
+curl http://localhost:8787/lookatmyhorse
+my horse is amazing
+```
+
+Docker
+----
+
+To run using docker containers, start memcached and then start anmo.
+
+```sh
+
+docker run --name memcache -d memcached
+
+docker run --link memcache:memcache -d -p 9999:9999 bbcnews/anmo
+
+```

data/Rakefile

@@ -0,0 +1,20 @@
+require "bundler/gem_tasks"
+require "cucumber"
+require "cucumber/rake/task"
+
+task :default => [:test, :features]
+
+task :test do
+  Dir.glob("test/**/*_test.rb").each do |f|
+    require File.expand_path(File.join(File.dirname(__FILE__), f))
+  end
+end
+
+task :run do
+  require "anmo"
+  Anmo.launch_server 1234
+end
+
+Cucumber::Rake::Task.new(:features) do |t|
+  t.cucumber_opts = "features --format pretty"
+end

data/anmo.gemspec

@@ -0,0 +1,31 @@
+# -*- encoding: utf-8 -*-
+$LOAD_PATH.push File.expand_path("../lib", __FILE__)
+require "anmo/version"
+
+Gem::Specification.new do |s|
+  s.name        = "anmo2"
+  s.version     = Anmo::VERSION
+  s.authors     = ["Andrew Vos"]
+  s.email       = ["andrew.vos@gmail.com"]
+  s.homepage    = ""
+  s.summary     = ""
+  s.description = ""
+
+  s.rubyforge_project = "anmo"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map { |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_runtime_dependency "rack"
+  s.add_runtime_dependency "thin", "1.6.3"
+  s.add_runtime_dependency "httparty"
+  s.add_runtime_dependency "dalli"
+
+  s.add_development_dependency "rake"
+  s.add_development_dependency "minitest"
+  s.add_development_dependency "rack-test"
+  s.add_development_dependency "cucumber"
+  s.add_development_dependency "rspec"
+end

data/features/api.feature

@@ -0,0 +1,204 @@
+Feature: API
+  In order to test applications against stable APIs
+  As a developer
+  I want to be able to mock http endpoints
+
+  Scenario: Launch a server
+    When I execute the following code in a new thread
+    """
+    Anmo.launch_server
+    """
+    Then I see an anmo server on port 8787
+
+  Scenario: Launch a server with a port
+    When I execute the following code in a new thread
+    """
+    Anmo.launch_server 9393
+    """
+    Then I see an anmo server on port 9393
+
+  Scenario: Create a request
+    Given an anmo server
+    When I execute the code
+    """
+    Anmo.server = "http://localhost:8787"
+    Anmo.create_request({
+      :path             => "/lollll",
+      :body             => "can't think of anything",
+      :required_headers => {"meh" => "bleh", "blah" => "blah"}
+    })
+    """
+    And I request the uri "http://localhost:8787/lollll" with the headers
+    """
+    {
+      "meh": "bleh",
+      "blah": "blah"
+    }
+    """
+    Then I see the response body "can't think of anything"
+
+  Scenario: Save object
+    Given an anmo server
+    When I execute the code
+    """
+    Anmo.server = "http://localhost:8787"
+    Anmo.create_request({
+      :path             => "/some/object",
+      :body             => "some data"
+    })
+    """
+    And I request the uri "http://localhost:8787/some/object"
+    Then I see the response body "some data"
+
+  Scenario: Request only returns object if it has correct query parameters
+    Given an anmo server
+    When I execute the code
+    """
+    Anmo.server = "http://localhost:8787"
+    Anmo.create_request({
+      :path             => "/path?monkeys=12",
+      :body             => "some data"
+    })
+    """
+    When I request the uri "http://localhost:8787/path?monkeys=12"
+    Then I see the response code 200
+    And I see the response body "some data"
+
+  Scenario: Save object with http status code
+    Given an anmo server
+    When I execute the code
+    """
+    Anmo.server = "http://localhost:8787"
+    Anmo.create_request({
+      :path             => "/some/object",
+      :status           => 123
+    })
+    """
+    And I request the uri "http://localhost:8787/some/object"
+    Then I see the response code 123
+
+  Scenario: Save object with specific method
+    Given an anmo server
+    When I execute the code
+    """
+    Anmo.server = "http://localhost:8787"
+    Anmo.create_request({
+      :path             => "/some/object",
+      :body             => "some data",
+      :method           => :put
+    })
+    """
+    And I issue a put request to the uri "http://localhost:8787/some/object"
+    Then I see the response body "some data"
+    And I issue a get request to the uri "http://localhost:8787/some/object"
+    Then I see the response code 404
+
+  Scenario: Request without required headers 404s
+    Given an anmo server
+    When I execute the code
+    """
+    Anmo.server = "http://localhost:8787"
+    Anmo.create_request({
+      :path             => "/some/object",
+      :required_headers => {:meh => "bleh", :durp => "derp"}
+    })
+    """
+    And I request the uri "http://localhost:8787/some/object"
+    Then I see the response code 404
+
+  Scenario: Request with required headers
+    Given an anmo server
+    When I execute the code
+    """
+    Anmo.server = "http://localhost:8787"
+    Anmo.create_request({
+      :path             => "/some/object",
+      :body             => "helloow",
+      :required_headers => {:meh => "bleh", :durp => "derp"}
+    })
+    """
+    And I request the uri "http://localhost:8787/some/object" with the headers
+    """
+    {
+      "meh": "bleh",
+      "durp": "derp"
+    }
+    """
+    Then I see the response body "helloow"
+    And I see the response code 200
+
+  Scenario: Delete all saved objects
+    Given an anmo server
+    When I execute the code
+    """
+    Anmo.server = "http://localhost:8787"
+    Anmo.create_request({
+      :path             => "/some/object",
+      :body             => "some data"
+    })
+    """
+    And I execute the code
+    """
+    Anmo.delete_all
+    """
+    And I request the uri "http://localhost:8787/some/object"
+    Then I see the response code 404
+
+  Scenario: Store all requests
+    Given an anmo server
+    When I request the uri "http://localhost:8787/some/object"
+    Then that request should be stored
+
+  Scenario: Delete all requests
+    Given an anmo server
+    When I request the uri "http://localhost:8787/some/object"
+    And I execute the code
+    """
+    Anmo.server = "http://localhost:8787"
+    Anmo.delete_all_requests
+    """
+    Then there should be no stored requests
+
+  Scenario: List all saved objects
+    Given an anmo server
+    When I execute the code
+    """
+    Anmo.server = "http://localhost:8787"
+    Anmo.create_request({
+      :path             => "/some/object",
+      :body             => "some data"
+    })
+
+    @result = Anmo.stored_objects
+    """
+    Then I should see the value
+    """
+    [
+      {"path" => "/some/object", "body" => "some data"}
+    ]
+    """
+
+  Scenario: Anmo knows if a server is not running
+    When I execute the code
+    """
+    Anmo.server = "http://localhost:8459"
+    @result = Anmo.running?
+    """
+    Then I see that the anmo server is not running
+
+  Scenario: Anmo knows if a server is running
+    Given an anmo server
+    When I execute the code
+    """
+    Anmo.server = "http://localhost:8787"
+    @result = Anmo.running?
+    """
+    Then I see that the anmo server is running
+
+  Scenario: Anmo knows what version the server is running
+    Given an anmo server
+    When I execute the code
+    """
+    Anmo.server_version
+    """
+    Then I see the anmo version

data/features/step_definitions/api_steps.rb

@@ -0,0 +1,87 @@
+require "stringio"
+
+When /^I execute the following code in a new thread$/ do |code|
+  Thread.new do
+    eval code
+  end
+end
+
+When /^I execute the code$/ do |code|
+  @result = eval code
+end
+
+Then /^I see an anmo server on port (\d+)$/ do |port|
+  response = nil
+
+  timeout 5 do
+    while response.nil?
+      response = HTTParty.get("http://localhost:#{port}") rescue nil
+    end
+  end
+
+  response.body.should include "Not Found"
+end
+
+Given /^an anmo server$/ do
+  Thread.new do
+    Anmo.launch_server
+  end
+
+  timeout 5 do
+    response = nil
+    while response.nil?
+      response = HTTParty.get("http://localhost:8787") rescue nil
+    end
+    sleep 0.1
+  end
+end
+
+Then /^I issue a get request to the uri "([^"]*)"$/ do |uri|
+  @response = HTTParty.get(uri)
+end
+
+When /^I issue a put request to the uri "([^"]*)"$/ do |uri|
+  @response = HTTParty.put(uri)
+end
+
+When /^I request the uri "([^"]*)"$/ do |uri|
+  @requested_uri = uri
+  @response = HTTParty.get(uri)
+end
+
+When /^I request the uri "([^"]*)" with the headers$/ do |uri, headers|
+  headers = JSON.parse(headers)
+  @response = HTTParty.get(uri, :headers => headers)
+end
+
+Then /^I see the response body "([^"]*)"$/ do |body|
+  @response.body.should == body
+end
+
+Then /^I see the response code (\d+)$/ do |code|
+  @response.code.should == code.to_i
+end
+
+Then /^that request should be stored$/ do
+  Anmo.requests.last["PATH_INFO"].should == @requested_uri.gsub("http://localhost:8787", "")
+end
+
+Then /^there should be no stored requests$/ do
+  Anmo.requests.size.should == 0
+end
+
+Then /^I should see the value$/ do |code|
+  @result.should == eval(code)
+end
+
+Then /^I see that the anmo server is not running$/ do
+  @result.should == false
+end
+
+Then /^I see that the anmo server is running$/ do
+  @result.should == true
+end
+
+Then /^I see the anmo version$/ do
+  @result.should == Anmo::VERSION
+end

data/features/support/env.rb

@@ -0,0 +1,13 @@
+require "rack"
+require "rack/test"
+require "httparty"
+
+$LOAD_PATH.unshift(File.expand_path(File.join(File.dirname(__FILE__), "../../lib")))
+require "anmo"
+require "anmo/application"
+
+World(Rack::Test::Methods)
+
+def app
+  Anmo::Application.new
+end

data/lib/anmo.rb

@@ -0,0 +1,57 @@
+require "anmo/version"
+require "anmo/application"
+require "thin"
+require "httparty"
+require "json"
+
+module Anmo
+  def self.server
+    @server ||= "http://localhost:#{@port}"
+  end
+
+  class << self
+    attr_writer :server
+  end
+
+  def self.server_version
+    HTTParty.get(anmo_url("__VERSION__")).body
+  end
+
+  def self.launch_server(port = 8787)
+    @port = port
+    Thin::Server.start("0.0.0.0", port, Anmo::Application.new)
+  end
+
+  def self.create_request(options)
+    HTTParty.post(anmo_url("__CREATE_OBJECT__"), :body => options.to_json, :headers => { "Content-Type" => "application/json" })
+  end
+
+  def self.delete_all
+    HTTParty.post(anmo_url("__DELETE_ALL_OBJECTS__"))
+  end
+
+  def self.requests
+    json = HTTParty.get(anmo_url("__REQUESTS__"))
+    JSON.parse(json.body)
+  end
+
+  def self.delete_all_requests
+    HTTParty.post(anmo_url("__DELETE_ALL_REQUESTS__"))
+  end
+
+  def self.stored_objects
+    json = HTTParty.get(anmo_url("__OBJECTS__"))
+    JSON.parse(json.body)
+  end
+
+  def self.running?
+    HTTParty.get(anmo_url("__ALIVE__")).code == 200 rescue false
+  end
+
+  private
+
+  def self.anmo_url(path)
+    "#{server}/#{path}"
+    # URI.join(server, path).to_s
+  end
+end

data/lib/anmo/application.rb

@@ -0,0 +1,212 @@
+require "dalli"
+require "uri"
+
+module Anmo
+  class ApplicationDataStore
+    TTL = 1_000_000
+    def self.objects
+      cached_objects = server.get("objects")
+      return JSON.load(cached_objects) if cached_objects
+      []
+    end
+
+    def self.requests
+      cached_requests = server.get("requests")
+      return JSON.load(cached_requests) if cached_requests
+      []
+    end
+
+    def self.insert_object(object)
+      all_objects = objects
+      all_objects.unshift(object)
+      server.set("objects", JSON.dump(all_objects), TTL)
+    end
+
+    def self.save_request(request)
+      all_requests = requests
+      all_requests << request
+      server.set("requests", JSON.dump(all_requests), TTL)
+    end
+
+    def self.clear_objects
+      server.delete("objects")
+    end
+
+    def self.clear_requests
+      server.delete("requests")
+    end
+
+    def self.find(path, query_string)
+      objects.each do |object|
+        object_path = object["path"].gsub(/(\?.*)$/, "")
+        if path == object_path
+          object_query_string = Rack::Utils.parse_query(object["path"].gsub(/(.*?)\?/, ""))
+
+          if query_string == object_query_string
+            p object
+            return object
+          end
+        end
+      end
+    end
+
+    private
+
+    def self.server
+      @server ||= if ENV["MEMCACHE_SERVERS"]
+                    Dalli::Client.new(ENV["MEMCACHE_SERVERS"],
+                      :username  => ENV["MEMCACHE_USERNAME"],
+                      :password  => ENV["MEMCACHE_PASSWORD"],
+                      :namespace => Process.pid.to_s
+                    )
+                  else
+                    Dalli::Client.new "127.0.0.1:11211", :namespace => Process.pid.to_s
+      end
+    end
+  end
+
+  class Application
+    def initialize
+      ApplicationDataStore.clear_objects
+      ApplicationDataStore.clear_requests
+    end
+
+    def call(env)
+      request = Rack::Request.new(env)
+
+      if request.request_method.upcase == "OPTIONS"
+        return [
+          200,
+          {
+            "Access-Control-Allow-Origin"  => "*",
+            "Access-Control-Allow-Methods" => "*",
+            "Access-Control-Allow-Headers" => "X-Requested-With,Content-Type,Authorization"
+          },
+          ""
+        ]
+      end
+
+      controller_methods = [
+        :alive,
+        :version,
+        :create_object,
+        :objects,
+        :requests,
+        :delete_all_objects,
+        :delete_all_requests
+      ]
+
+      method = controller_methods.find { |m| request.path_info =~ /\/?__#{m.to_s.upcase}__\/?/ }
+      method ||= :process_normal_request
+      send(method, request)
+    end
+
+    private
+
+    def text(text, status = 200)
+      [status, { "Content-Type" => "text/html", "Access-Control-Allow-Origin" => "*" }, [text]]
+    end
+
+    def json(json, status = 200)
+      [status, { "Content-Type" => "application/json", "Access-Control-Allow-Origin" => "*" }, [json]]
+    end
+
+    def alive(_request)
+      text "<h1>anmo is alive</h1>"
+    end
+
+    def version(_request)
+      text Anmo::VERSION
+    end
+
+    def create_object(request)
+      request_info = JSON.parse(read_request_body(request))
+      ApplicationDataStore.insert_object(request_info)
+      text "", 201
+    end
+
+    def delete_all_objects(_request)
+      ApplicationDataStore.clear_objects
+      text ""
+    end
+
+    def process_normal_request(request)
+      ApplicationDataStore.save_request(request.env)
+
+      if found_request = find_stored_request(request)
+        text found_request["body"], Integer(found_request["status"] || 200)
+      else
+        text "Not Found", 404
+      end
+    end
+
+    def requests(_request)
+      json ApplicationDataStore.requests.to_json
+    end
+
+    def delete_all_requests(_request)
+      ApplicationDataStore.clear_requests
+      text ""
+    end
+
+    def objects(_request)
+      json ApplicationDataStore.objects.to_json
+    end
+
+    def find_stored_request(actual_request)
+      actual_request_query = Rack::Utils.parse_query(actual_request.query_string)
+
+      suspected_request = ApplicationDataStore.objects.find do |r|
+        uri = URI(r["path"])
+
+        query = Rack::Utils.parse_query(uri.query)
+        method = r["method"] || "GET"
+
+        if uri.query.nil?
+          uri.path == actual_request.path_info && method.upcase == actual_request.request_method.upcase
+        else
+          uri.path == actual_request.path_info && query == actual_request_query && method.upcase == actual_request.request_method.upcase
+        end
+      end
+
+      unless suspected_request.nil?
+        return unless request_has_required_headers(actual_request, suspected_request)
+      end
+
+      suspected_request
+    end
+
+    def request_has_same_method(initial_request, suspected_request)
+      return true if suspected_request["method"].nil?
+      suspected_request["method"].upcase == initial_request.request_method
+    end
+
+    def request_has_same_query(initial_request, suspected_request)
+      return true if suspected_request["path"].include?("?") == false
+      query = Rack::Utils.parse_query(suspected_request["path"].gsub(/.*\?/, ""))
+      query == Rack::Utils.parse_query(initial_request.query_string)
+    end
+
+    def request_has_required_headers(initial_request, suspected_request)
+      required_headers = suspected_request["required_headers"] || {}
+      required_headers.each do |name, value|
+        if initial_request.env[convert_header_name_to_rack_style_name(name)] != value
+          return false
+        end
+      end
+      true
+    end
+
+    def convert_header_name_to_rack_style_name(name)
+      name = "HTTP_#{name}"
+      name.gsub!("-", "_")
+      name.upcase!
+      name
+    end
+
+    def read_request_body(request)
+      request.body.rewind
+      request.body.read
+    end
+  end
+end

data/lib/anmo/version.rb

@@ -0,0 +1,3 @@
+module Anmo
+  VERSION = "0.0.31"
+end

data/run.sh

@@ -0,0 +1,8 @@
+#! /usr/bin/env ruby
+
+require "anmo"
+
+ENV['MEMCACHE_SERVERS'] = "#{ENV['MEMCACHE_PORT_11211_TCP_ADDR']}:11211"
+
+Anmo.server = "0.0.0.0"
+Anmo.launch_server 9999

data/test/anmo/application_test.rb

@@ -0,0 +1,201 @@
+require "minitest/pride"
+require "minitest/autorun"
+require "minitest/unit"
+require "rack/test"
+require "json"
+require File.expand_path(File.join(File.dirname(__FILE__), "../../lib/anmo/application"))
+
+module Anmo
+  class ApplicationTest < MiniTest::Unit::TestCase
+    include Rack::Test::Methods
+
+    def app
+      Application.new
+    end
+
+    def setup
+      ApplicationDataStore.clear_objects
+      ApplicationDataStore.clear_requests
+    end
+
+    def save_object(path, body, status, required_headers, method)
+      options = {
+        :path             => path,
+        :body             => body,
+        :status           => status,
+        :required_headers => required_headers
+      }
+      options[:method] = method if method
+
+      put "__CREATE_OBJECT__", options.to_json
+    end
+
+    def test_404s_if_object_does_not_exist
+      get "/bla/bla/bla.json"
+      assert_equal "Not Found", last_response.body
+      assert last_response.not_found?
+    end
+
+    def test_stores_mock_data
+      save_object "/this/is/the/path.object", "please save this", nil, nil, nil
+      assert_equal 201, last_response.status
+
+      get "/this/is/the/path.object"
+      assert_equal "please save this", last_response.body
+      assert last_response.ok?
+    end
+
+    def test_does_not_return_object_if_request_has_different_query_parameters
+      save_object "/path/?hello=true", "please save this", nil, nil, nil
+      get "/path/?hello=false"
+      assert_equal 404, last_response.status
+      assert_equal "Not Found", last_response.body
+    end
+
+    def test_returns_object_if_request_has_same_query_parameters
+      save_object "/?hello=true&bla=bla", "please save this", nil, nil, nil
+      get "/?hello=true&bla=bla"
+      assert_equal 200, last_response.status
+      assert_equal "please save this", last_response.body
+    end
+
+    def test_returns_object_if_request_has_query_parameters_in_different_order
+      save_object "/?aaa=aaa&bbb=bbb", "please save this", nil, nil, nil
+      get "/?bbb=bbb&aaa=aaa"
+      assert_equal 200, last_response.status
+      assert_equal "please save this", last_response.body
+    end
+
+    def test_stores_status_code
+      save_object "/monkeys", nil, 123, nil, nil
+      get "/monkeys"
+      assert_equal 123, last_response.status
+    end
+
+    def test_similar_query_string
+      save_object "/pulsar/assets?channel=foo.bar.baz.qux.quux.1", "Something", 200, nil, :get
+      save_object "/pulsar/assets?channel=foo.bar.baz.qux.quux.2", "Something else", 200, nil, :get
+
+      get "/pulsar/assets?channel=foo.bar.baz.qux.quux.1"
+
+      assert_equal 200, last_response.status
+    end
+
+    def test_allows_deleting_all_objects
+      save_object "/this/is/the/path.object", "please save this", nil, nil, nil
+
+      get "/this/is/the/path.object"
+      first_response = last_response
+
+      post "__DELETE_ALL_OBJECTS__"
+      assert_equal 200, last_response.status
+
+      get "/this/is/the/path.object"
+      second_response = last_response
+
+      assert_equal "please save this", first_response.body
+      assert_equal "Not Found", second_response.body
+      assert_equal 404, second_response.status
+    end
+
+    def test_404s_if_request_does_not_have_required_headers
+      save_object "/oh/hai", nil, nil, { "ruby" => "hipsters", "meh" => "bleh" }, nil
+      get "/oh/hai"
+      assert_equal 404, last_response.status
+    end
+
+    def test_returns_value_if_request_has_required_headers
+      save_object "/oh/hai", "the content", nil, { "lol-ruby" => "hipsters", "meh" => "bleh" }, nil
+      header "lol-ruby", "hipsters"
+      header "meh", "bleh"
+      get "/oh/hai"
+      assert_equal 200, last_response.status
+      assert_equal "the content", last_response.body
+    end
+
+    def test_404s_if_request_does_not_have_correct_method
+      save_object "/meh", "content", nil, nil, :delete
+      get "/meh"
+      assert_equal 404, last_response.status
+    end
+
+    def test_returns_vaue_if_request_has_correct_method
+      save_object "/meh", "content", nil, nil, :delete
+      delete "/meh"
+      assert_equal 200, last_response.status
+    end
+
+    def test_returns_the_last_added_object_first
+      save_object "/oh/hai", "the first content", nil, nil, nil
+      save_object "/oh/hai", "the second content", nil, nil, nil
+      get "/oh/hai"
+      assert_equal "the second content", last_response.body
+    end
+
+    def test_stores_all_requests
+      get "/hello"
+      get "/hai"
+      get "/__REQUESTS__"
+      json = JSON.parse(last_response.body)
+
+      assert_equal 2, json.size
+      assert_equal "/hello", json.first["PATH_INFO"]
+      assert_equal "/hai", json.last["PATH_INFO"]
+    end
+
+    def test_does_not_store_create_or_delete_requests
+      save_object "/oh/hai", "the first content", nil, nil, nil
+      post "__DELETE_ALL_OBJECTS__"
+      get "/__REQUESTS__"
+      json = JSON.parse(last_response.body)
+      assert_equal 0, json.size
+    end
+
+    def test_returns_requests_as_json
+      get "/hello"
+      get "/__REQUESTS__"
+      json = JSON.parse(last_response.body)
+      assert_equal 1, json.size
+      assert_equal "/hello", json.first["PATH_INFO"]
+    end
+
+    def test_deletes_all_requests
+      get "/hello"
+      get "/__REQUESTS__"
+      json = JSON.parse(last_response.body)
+      assert_equal 1, json.size
+      post "/__DELETE_ALL_REQUESTS__"
+      get "/__REQUESTS__"
+      json = JSON.parse(last_response.body)
+      assert_equal 0, json.size
+    end
+
+    def test_returns_empty_list_of_stored_objects
+      get "/__OBJECTS__"
+      json = JSON.parse(last_response.body)
+      assert_equal "application/json", last_response.content_type
+      assert_equal 0, json.size
+    end
+
+    def test_lists_stored_objects
+      save_object "/some/path", nil, nil, nil, nil
+
+      get "/__OBJECTS__"
+
+      json = JSON.parse(last_response.body)
+      assert_equal 1, json.size
+      assert_equal "/some/path", json.first["path"]
+    end
+
+    def test_shows_that_its_alive
+      get "/__ALIVE__"
+      assert last_response.ok?
+      assert_equal "<h1>anmo is alive</h1>", last_response.body
+    end
+
+    def test_exposes_server_version
+      get "/__VERSION__"
+      assert_equal Anmo::VERSION, last_response.body
+    end
+  end
+end

metadata

@@ -0,0 +1,191 @@
+--- !ruby/object:Gem::Specification
+name: anmo2
+version: !ruby/object:Gem::Version
+  version: 0.0.31
+platform: ruby
+authors:
+- Andrew Vos
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-07-22 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: thin
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.6.3
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.6.3
+- !ruby/object:Gem::Dependency
+  name: httparty
+  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: dalli
+  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: rake
+  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: minitest
+  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: rack-test
+  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: cucumber
+  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: 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'
+description: ''
+email:
+- andrew.vos@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rubocop.yml"
+- ".ruby-version"
+- ".rvmrc"
+- ".travis.yml"
+- Dockerfile
+- Gemfile
+- README.md
+- Rakefile
+- anmo.gemspec
+- features/api.feature
+- features/step_definitions/api_steps.rb
+- features/support/env.rb
+- lib/anmo.rb
+- lib/anmo/application.rb
+- lib/anmo/version.rb
+- run.sh
+- test/anmo/application_test.rb
+homepage: ''
+licenses: []
+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: anmo
+rubygems_version: 2.4.2
+signing_key: 
+specification_version: 4
+summary: ''
+test_files:
+- features/api.feature
+- features/step_definitions/api_steps.rb
+- features/support/env.rb
+- test/anmo/application_test.rb