holoserve 0.3.1 → 0.4.0

data/README.rdoc

@@ -6,18 +6,17 @@ run faster and be independent from other API and network problems.
 
 == Concept
 
-HoloServe runs a rack application server, that matches any incoming request to a list of request profiles. These
-profiles are defined in set of request/response-pairs. If a match is found, the defined static response is returned. The
-other half of the matched profile contains a set of responses. One for each situation the faked API can be possibily in.
-The response for the currently set situation will be merged with a default response and returned. The name of the
-matched request/response pair is saved in a request history. If no match is found, a 404 is returned and the request
-data is stored in the bucket for unhandeled requests. These informations can be used to extend the server layout with
-missing request handlers.
+HoloServe runs a Goliath[https://github.com/postrank-labs/goliath] application server, that matches any incoming request
+to a list of request/response pairs. If a match is found, the corresponding response is returned. To do that the
+response is assembeled by a selection of responses. The selection is made by conditions on the current state.
+The name of the matched request/response pair is saved in a request history. If no match is found, a 404 is returned and
+the request data is stored in the bucket for unhandeled requests. These informations can be used to extend the server
+layout with missing request handlers.
 
-To avoid too much duplication in the definition of the request/response-pairs, it is possible upload some fixture data
-that is shared between all pair definitions. The pair can than refer to these fixtures.
+To avoid too much duplication in the definition of the request/response-pairs, it is possible reference some fixture
+data that is shared between all pair definitions.
 
-The pairs, fixtures, situation, history and bucket can be accessed via control routes, which are described below.
+The pairs, state, history and bucket can be accessed via control routes, which are described below.
 
 == Installation
 
@@ -31,56 +30,47 @@ To start up an empty Holoserve instance, type...
 
   holoserve
 
-To load the server with a couple of pairs, fixtures and define a situation during start up, use these parameters.
+To load the server with a couple of pairs, fixtures and define a state during start up, use these parameters.
 
-  holoserve -d path/to/pairs/*.yaml -f path/to/fixtures/*.yaml -s backend_without_users
+  holoserve -f 'path/to/fixtures/*.yaml' -p 'path/to/pairs/*.yaml' -s user_one=missing -s car_one=existing
 
 Notice, that the files must have either the <tt>.yaml</tt> or the <tt>.json</tt> extension.
 
+A full description of all options can be displayed with <tt>holoserve --help</tt>
+
+  -P, --port PORT                  The port holoserve should listen to.
+  -f, --fixture-files PATTERN      Load the specified fixture files on startup.
+  -p, --pair-files PATTERN         Load the specified pair files on startup.
+  -s, --state SETTING              Set a specific state. Use the pattern key=value. Can be applied multiple times.
+  -h, --help                       Shows the help message.
+
 == Control routes
 
 If you're using Ruby, you can control Holoserve via the
 {Holoserve Connector}[https://github.com/skrill/holoserve-connector] gem.
 
-=== POST /_control/pairs
-
-Adds a pair definition to Holoserve. It should receive a parameter named <tt>file</tt> that contains a file with exactly
-one pair. The format of the file should fit the specified format. The format can be <tt>yaml</tt> or <tt>json</tt>. See
-{Pair file format}[rdoc-label:Pair-file-format] below. The basename of the transmitted file will be taken as the pair
-id.
-
-=== GET /_control/pairs/:id.:format
-
-Returns the pair definition in the requested format.
-
-=== DELETE /_control/pairs
+=== GET /_control/pairs
 
-Removes all pairs.
+Returns all pair definitions.
 
-=== POST /_control/fixtures
+=== GET /_control/pairs/:id
 
-Adds fixture data to Holoserve. The request is similar to <tt>POST /_control/pairs</tt>. The upload file can contain any
-yaml or json formatted data. The basename of the file will be taken as the fixture id.
+Returns the specified pair definition.
 
-=== GET /_control/fixtures/:id
+=== PUT /_control/state
 
-Returns the requested fixture.
+Sets the current state with the transmitted parameters.
 
-=== DELETE /_control/fixtures
+=== GET /_control/state
 
-Removes all fixtures.
-
-=== PUT /_control/situation
-
-Sets the current situation with the transmitted <tt>name</tt> parameter.
-
-=== GET /_control/situation
-
-Returns the name of the current situation.
+Returns the current state.
 
 ==== Response example
 
-  backend_without_users
+  {
+    "user_one": "missing",
+    "car_one": "existing"
+  }
 
 === GET /_control/bucket
 
@@ -90,24 +80,18 @@ Returns a list of all requests that has been received, but couldn't be handled.
 
   [
     {
-      "method": "POST",
-      "path": "test",
+      "method": "GET",
+      "path": "/test",
       "headers": {
+        "SERVER_SOFTWARE": "Goliath",
+        "SERVER_NAME": "localhost",
+        "SERVER_PORT": "4250",
         "REMOTE_ADDR": "127.0.0.1",
-        "REQUEST_METHOD": "GET",
-        "REQUEST_PATH": "/test",
-        "PATH_INFO": "/test",
-        "REQUEST_URI": "/test",
-        "SERVER_PROTOCOL": "HTTP/1.1",
-        "HTTP_VERSION": "HTTP/1.1",
         "HTTP_ACCEPT": "*/*",
         "HTTP_USER_AGENT": "Ruby",
-        "HTTP_HOST": "localhost:8080",
-        "SERVER_NAME": "localhost",
-        "SERVER_PORT": "8080",
-        "QUERY_STRING": "",
-        "SCRIPT_NAME": "",
-        "SERVER_SOFTWARE": "Unicorn 4.1.1"
+        "HTTP_HOST": "localhost:4250",
+        "HTTP_VERSION": "1.1",
+        "SCRIPT_NAME": "/test"
       }
     }
   ]
@@ -142,11 +126,11 @@ The request/response pair file should have the following format.
     responses:
       default:
         status: 200
-      user_exists:
+      "user_one == :existing":
         imports:
           - path: "test_fixture.users.0"
             as: "json.user"
-      user_is_missing:
+      "user_one == :missing":
         json:
           message: "user not found"
   - request:
@@ -163,11 +147,11 @@ The request/response pair file should have the following format.
       oauth:
         oauth_token: "12345"
     responses:
-      user_exists:
+      "user_one == :existing":
         status: 401
         json:
           message: "invalid password"
-      user_is_missing:
+      "user_one == :missing":
         status: 200
         json:
           message: "user not found"
@@ -183,6 +167,6 @@ This example defines two request/response pairs and two situations. The two pair
 match against. The first one handles the case in which the parameters <tt>username=one</tt> and <tt>password=valid</tt>
 are posted and the second one reacts on the transmission of <tt>username=one</tt> and <tt>password=invalid</tt>.
 
-If the situation is set to <tt>user_exists</tt>, the first situation would return the complete user object encoded as
-json, while the second one would reply the message "invalid password". In the situation "user_is_missing", both requests
-would be replied with the message "user not found".
+If the state includes <tt>user_one == :existing</tt>, the first response would return the complete user object encoded
+as json, while the second one would reply the message "invalid password". In the state includes
+<tt>user_one == :missing</tt>, both requests would be replied with the message "user not found".

data/Rakefile

@@ -1,60 +1,8 @@
 require 'rubygems'
 require 'bundler/setup'
 
-desc "Runs the unicorn interface server."
-task :server do
-  system "bundle exec unicorn"
-end
-
-desc "Runs the shotgun interface server."
-task :shotgun do
-  system "bundle exec shotgun"
-end
-
-begin
-  require 'cucumber'
-  require 'cucumber/rake/task'
-
-  Cucumber::Rake::Task.new(:features) do |task|
-    task.cucumber_opts = "features --format pretty"
-  end
-
-  namespace :features do
-    Cucumber::Rake::Task.new(:wip) do |task|
-      task.cucumber_opts = "features --format pretty --tags @wip"
-    end
-  end
-rescue LoadError
-end
-
-begin
-  require 'rspec/core/rake_task'
-
-  RSpec::Core::RakeTask.new
-rescue LoadError
-end
-
-begin
-  require 'rdoc'
-  require 'rdoc/task'
-
-  Rake::RDocTask.new do |rdoc|
-    rdoc.main = "README.rdoc"
-    rdoc.rdoc_files.include("README.rdoc", "lib/**/*.rb")
-  end
-rescue LoadError
-end
-
-namespace :gem do
-
-  desc "Builds the gem"
-  task :build do
-    system "gem build *.gemspec && mkdir -p pkg/ && mv *.gem pkg/"
-  end
-
-  desc "Builds and installs the gem"
-  task :install => :build do
-    system "gem install pkg/"
-  end
-
-end
+load File.join(File.dirname(__FILE__), "tasks", "features.rake")
+load File.join(File.dirname(__FILE__), "tasks", "gem.rake")
+load File.join(File.dirname(__FILE__), "tasks", "goliath.rake")
+load File.join(File.dirname(__FILE__), "tasks", "rdoc.rake")
+load File.join(File.dirname(__FILE__), "tasks", "spec.rake")

data/bin/holoserve

@@ -6,22 +6,23 @@ require 'optparse'
 
 require File.expand_path(File.join(File.dirname(__FILE__), "..", "lib", "holoserve"))
 
-options = { }
+options = { :state => { } }
 OptionParser.new do |parser|
   parser.banner = "Usage: holoserve [options]"
   parser.separator ""
   parser.separator "Options:"
-  parser.on("-p", "--port PORT", Integer, "The port holoserve should listen to.") do |value|
+  parser.on("-P", "--port PORT", Integer, "The port holoserve should listen to.") do |value|
     options[:port] = value
   end
   parser.on("-f", "--fixture-files PATTERN", "Load the specified fixture files on startup.") do |value|
     options[:fixture_file_pattern] = value
   end
-  parser.on("-d", "--pair-files PATTERN", "Load the specified pair files on startup.") do |value|
+  parser.on("-p", "--pair-files PATTERN", "Load the specified pair files on startup.") do |value|
     options[:pair_file_pattern] = value
   end
-  parser.on("-s", "--situation SITUATION", "Sets the situation.") do |value|
-    options[:situation] = value
+  parser.on("-s", "--state SETTING", "Set a specific state. Use the pattern key=value. Can be applied multiple times.") do |value|
+    resource, state = *value.split("=").map(&:strip)
+    options[:state][resource] = state
   end
   parser.on_tail("-h", "--help", "Shows the help message.") do
     puts parser
@@ -29,5 +30,5 @@ OptionParser.new do |parser|
   end
 end.parse!(ARGV)
 
-runner = Holoserve::Runner.new options
-runner.run
+holoserve = Holoserve.new options
+holoserve.run

data/lib/holoserve/interface/control/bucket.rb

@@ -0,0 +1,24 @@
+require 'goliath/api'
+
+module Holoserve::Interface::Control::Bucket
+
+  class Fetch < Goliath::API
+    include Holoserve::Interface::Control::Helper
+
+    def response(environment)
+      respond_json bucket
+    end
+
+  end
+
+  class Delete < Goliath::API
+    include Holoserve::Interface::Control::Helper
+
+    def response(environment)
+      bucket.clear
+      respond_json_acknowledgement
+    end
+
+  end
+
+end

data/lib/holoserve/interface/control/history.rb

@@ -0,0 +1,24 @@
+require 'goliath/api'
+
+module Holoserve::Interface::Control::History
+
+  class Fetch < Goliath::API
+    include Holoserve::Interface::Control::Helper
+
+    def response(environment)
+      respond_json history
+    end
+
+  end
+
+  class Delete < Goliath::API
+    include Holoserve::Interface::Control::Helper
+
+    def response(environment)
+      history.clear
+      respond_json_acknowledgement
+    end
+
+  end
+
+end

data/lib/holoserve/interface/control/pair.rb

@@ -0,0 +1,24 @@
+require 'goliath/api'
+
+module Holoserve::Interface::Control::Pair
+
+  class Index < Goliath::API
+    include Holoserve::Interface::Control::Helper
+
+    def response(environment)
+      respond_json pairs
+    end
+
+  end
+
+  class Fetch < Goliath::API
+    include Holoserve::Interface::Control::Helper
+
+    def response(environment)
+      pair = pairs[params[:id]]
+      respond_json pair
+    end
+
+  end
+
+end

data/lib/holoserve/interface/control/state.rb

@@ -0,0 +1,38 @@
+require 'goliath/api'
+
+module Holoserve::Interface::Control::State
+
+  class Update < Goliath::API
+    include Holoserve::Interface::Control::Helper
+
+    use Goliath::Rack::Params
+
+    def response(environment)
+      state.merge! params
+      logger.info "set state to '#{state.inspect}'"
+      respond_json_acknowledgement
+    end
+
+  end
+
+  class Fetch < Goliath::API
+    include Holoserve::Interface::Control::Helper
+
+    def response(environment)
+      respond_json state
+    end
+
+  end
+
+  class Delete < Goliath::API
+    include Holoserve::Interface::Control::Helper
+
+    def response(environment)
+      state.clear
+      logger.info "state cleared"
+      respond_json_acknowledgement
+    end
+
+  end
+
+end

data/lib/holoserve/interface/control.rb

@@ -1,178 +1,46 @@
-require 'sinatra'
-require 'yaml'
 require 'json'
 
-class Holoserve::Interface::Control < Sinatra::Base
+module Holoserve::Interface::Control
 
-  mime_type :yaml, "application/x-yaml"
-  mime_type :json, "application/json"
+  autoload :Bucket, File.join(File.dirname(__FILE__), "control", "bucket")
+  autoload :History, File.join(File.dirname(__FILE__), "control", "history")
+  autoload :Pair, File.join(File.dirname(__FILE__), "control", "pair")
+  autoload :State, File.join(File.dirname(__FILE__), "control", "state")
 
-  post "/_control/pairs" do
-    if pair_id = load_file_into(pairs)
-      logger.info "loaded pair #{pair_id}"
-      acknowledgement
-    else
-      bad_request
-    end
-  end
-
-  get "/_control/pairs.:format" do |format|
-    respond_formatted params["evaluate"] ? evaluated_pairs : pairs, format
-  end
+  module Helper
 
-  get "/_control/pairs/:id.:format" do |id, format|
-    pair = (params["evaluate"] ? evaluated_pairs : pairs)[id.to_sym]
-    if pair
-      respond_formatted pair, format
-    else
-      not_found
+    def respond_json_acknowledgement
+      respond_json :ok => true
     end
-  end
-
-  delete "/_control/pairs" do
-    pairs.clear
-  end
 
-  post "/_control/fixtures" do
-    if fixture_id = load_file_into(fixtures)
-      logger.info "loaded fixture #{fixture_id}"
-      acknowledgement
-    else
-      bad_request
+    def respond_json(object)
+      ok JSON.dump(object), "application/json"
     end
-  end
 
-  get "/_control/fixtures/:id.:format" do |id, format|
-    fixture = fixtures[id.to_sym]
-    if fixture
-      respond_formatted fixture, format
-    else
-      not_found
+    def ok(content, content_type = "text/plain")
+      [ 200, { "Content-Type" => content_type }, [ content ] ]
     end
-  end
-
-  delete "/_control/fixtures" do
-    fixtures.clear
-  end
-
-  put "/_control/situation" do
-    configuration[:situation] = params[:name]
-    logger.info "set situation to #{params[:name]}"
-    respond_json_acknowledgement
-  end
-
-  get "/_control/situation" do
-    respond_json :name => configuration[:situation]
-  end
-
-  get "/_control/bucket" do
-    respond_json bucket
-  end
-
-  delete "/_control/bucket" do
-    bucket.clear
-  end
-
-  get "/_control/history" do
-    respond_json history
-  end
-
-  delete "/_control/history" do
-    history.clear
-    respond_json_acknowledgement
-  end
-
-  private
-
-  def respond_json_acknowledgement
-    respond_json :ok => true
-  end
 
-  def respond_formatted(data, format)
-    if format == "yaml"
-      respond_yaml data
-    elsif format == "json"
-      respond_json data
-    else
-      bad_request
+    def bad_request
+      [ 400, { }, [ "bad request" ] ]
     end
-  end
-
-  def respond_json(object)
-    content_type :json
-    JSON.dump object
-  end
-
-  def respond_yaml(object)
-    content_type :yaml
-    object.to_yaml
-  end
-
-  def acknowledgement
-    [ 200, { }, [ "" ] ]
-  end
-
-  def bad_request
-    [ 400, { }, [ "bad request" ] ]
-  end
-
-  def not_acceptable
-    [ 406, { }, [ "format not acceptable" ] ]
-  end
-
-  def load_file_into(hash)
-    data = load_file params["file"][:tempfile]
-    return nil unless data
-    id = File.basename params["file"][:filename], ".*"
-    hash[id.to_sym] = Holoserve::Tool::Hash::KeySymbolizer.new(data).hash
-    id.to_sym
-  end
 
-  def load_file(filename)
-    YAML::load_file filename
-  rescue Psych::SyntaxError
-    begin
-      JSON.parse File.read(filename)
-    rescue JSON::ParserError
-      nil
+    def bucket
+      config[:bucket] ||= [ ]
     end
-  end
 
-  def evaluated_pairs
-    result = { }
-    pairs.each do |id, pair|
-      result[id] = { }
-      result[id][:request] = Holoserve::Fixture::Importer.new(pair[:request], fixtures).result
-      result[id][:responses] = { }
-      pair[:responses].each do |situation, response|
-        result[id][:responses][situation] = Holoserve::Fixture::Importer.new(response, fixtures).result
-      end
+    def history
+      config[:history] ||= [ ]
     end
-    result
-  end
-
-  def pairs
-    configuration[:pairs]
-  end
-
-  def fixtures
-    configuration[:fixtures]
-  end
 
-  def bucket
-    configuration[:bucket]
-  end
-
-  def history
-    configuration[:history]
-  end
+    def pairs
+      config[:pairs] ||= options[:pairs]
+    end
 
-  def configuration
-    Holoserve.instance.configuration
-  end
+    def state
+      config[:state] ||= { }
+    end
 
-  def logger
-    Holoserve.instance.logger
   end
 
-end
+end