holoserve 0.3.0 → 0.3.1

data/lib/holoserve/fixture/importer.rb

@@ -1,19 +1,15 @@
 
 class Holoserve::Fixture::Importer
 
+  attr_accessor :hash
   attr_accessor :fixtures
 
   def initialize(hash, fixtures)
-    @fixtures = fixtures
-    self.hash = hash
+    @hash, @fixtures = hash, fixtures
   end
 
-  def hash=(value)
-    @imports = value.respond_to?(:delete) && value.delete(:imports) || [ ]
-    @hash = value
-  end
-
-  def hash
+  def result
+    @result = { }
     import
     merge
     @result
@@ -22,23 +18,30 @@ class Holoserve::Fixture::Importer
   private
 
   def import
-    @imports.each do |import|
-      path = import[:path]
-      as = import[:as] || path
-      only = import[:only]
+    imports.each do |import|
+      path, as, only, except = *import.values_at(:path, :as, :only, :except)
 
       value = Holoserve::Tool::DataPath.new(path, @fixtures).fetch
 
-      value.delete_if do |key, v|
-        ![ only ].flatten.compact.include?(key.to_s)
-      end if only.respond_to?(:include?) && value.respond_to?(:delete_if)
+      if value.respond_to?(:reject)
+        value = value.reject{ |key, v| ![ only ].flatten.compact.include?(key.to_s) } if only
+        value = value.reject{ |key, v| [ except ].flatten.compact.include?(key.to_s) } if except
+      end
 
       @result = Holoserve::Tool::DataPath.new(as, @result || { }).store value
     end
   end
 
   def merge
-    @result = Holoserve::Tool::Merger.new(@result, @hash).result if @hash
+    @result = Holoserve::Tool::Merger.new(@result, hash_without_imports).result
+  end
+
+  def hash_without_imports
+    @hash.reject{ |key, v| key == :imports }
+  end
+
+  def imports
+    @hash[:imports] || [ ]
   end
 
 end

data/lib/holoserve/interface/control.rb

@@ -8,13 +8,20 @@ class Holoserve::Interface::Control < Sinatra::Base
   mime_type :json, "application/json"
 
   post "/_control/pairs" do
-    load_file_into(pairs) ?
-      acknowledgement :
+    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
 
   get "/_control/pairs/:id.:format" do |id, format|
-    pair = pairs[id.to_sym]
+    pair = (params["evaluate"] ? evaluated_pairs : pairs)[id.to_sym]
     if pair
       respond_formatted pair, format
     else
@@ -27,9 +34,12 @@ class Holoserve::Interface::Control < Sinatra::Base
   end
 
   post "/_control/fixtures" do
-    load_file_into(fixtures) ?
-      acknowledgement :
+    if fixture_id = load_file_into(fixtures)
+      logger.info "loaded fixture #{fixture_id}"
+      acknowledgement
+    else
       bad_request
+    end
   end
 
   get "/_control/fixtures/:id.:format" do |id, format|
@@ -47,6 +57,7 @@ class Holoserve::Interface::Control < Sinatra::Base
 
   put "/_control/situation" do
     configuration[:situation] = params[:name]
+    logger.info "set situation to #{params[:name]}"
     respond_json_acknowledgement
   end
 
@@ -111,10 +122,10 @@ class Holoserve::Interface::Control < Sinatra::Base
 
   def load_file_into(hash)
     data = load_file params["file"][:tempfile]
-    return false unless data
+    return nil unless data
     id = File.basename params["file"][:filename], ".*"
     hash[id.to_sym] = Holoserve::Tool::Hash::KeySymbolizer.new(data).hash
-    true
+    id.to_sym
   end
 
   def load_file(filename)
@@ -127,6 +138,19 @@ class Holoserve::Interface::Control < Sinatra::Base
     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
+    end
+    result
+  end
+
   def pairs
     configuration[:pairs]
   end
@@ -147,4 +171,8 @@ class Holoserve::Interface::Control < Sinatra::Base
     Holoserve.instance.configuration
   end
 
+  def logger
+    Holoserve.instance.logger
+  end
+
 end

data/lib/holoserve/request/matcher.rb

@@ -3,7 +3,7 @@ class Holoserve::Request::Matcher
 
   def initialize(request, request_subset, fixtures)
     @request = request
-    @request_subset = Holoserve::Fixture::Importer.new(request_subset, fixtures).hash
+    @request_subset = Holoserve::Fixture::Importer.new(request_subset, fixtures).result
   end
 
   def match?

data/lib/holoserve/response/combiner.rb

@@ -13,13 +13,13 @@ class Holoserve::Response::Combiner
 
   def default_response
     @responses[:default] ?
-      Holoserve::Fixture::Importer.new(@responses[:default], fixtures).hash :
+      Holoserve::Fixture::Importer.new(@responses[:default], fixtures).result :
       { }
   end
 
   def situation_response
     situation && @responses[situation.to_sym] ?
-      Holoserve::Fixture::Importer.new(@responses[situation.to_sym], fixtures).hash :
+      Holoserve::Fixture::Importer.new(@responses[situation.to_sym], fixtures).result :
       { }
   end
   

data/lib/holoserve/response/composer.rb

@@ -13,7 +13,7 @@ class Holoserve::Response::Composer
   private
 
   def status
-    @response[:status]
+    @response[:status] || 200
   end
 
   def headers

data/lib/holoserve/runner.rb

@@ -65,7 +65,8 @@ class Holoserve::Runner
 
   def set_situation
     Transport::JSON.request :put,
-                            "http://localhost:#{port}/_control/situation/#{@situation}",
+                            "http://localhost:#{port}/_control/situation",
+                            :parameters => { :name => @situation },
                             :expected_status_code => 200
     nil
   end

data/lib/holoserve/tool/data_path.rb

@@ -30,9 +30,9 @@ class Holoserve::Tool::DataPath
 
   def store(value)
     path = @path ? @path.split(PATH_SEPARATOR) : [ ]
-    return value if path.empty?
+    return Holoserve::Tool::Merger.new(@data, value).result if path.empty?
 
-    selected = @data
+    result = selected = clone @data
     key = parse_key path.shift
 
     while path.length > 0
@@ -44,7 +44,7 @@ class Holoserve::Tool::DataPath
     end
 
     selected[key] = value
-    @data
+    result
   end
 
   private
@@ -53,4 +53,8 @@ class Holoserve::Tool::DataPath
     key =~ /^\d+$/ ? key.to_i : key.to_sym
   end
 
+  def clone(object)
+    Marshal.load Marshal.dump(object)
+  end
+
 end

data/spec/lib/holoserve/fixture/importer_spec.rb

@@ -2,7 +2,13 @@ require File.expand_path(File.join(File.dirname(__FILE__), "..", "..", "..", "he
 
 describe Holoserve::Fixture::Importer do
 
-  let(:fixtures) { { :test => { :nested => "value", :second => "value" }, :another => "value" } }
+  let(:fixtures) do
+    {
+      :one => { :first => 1, :second => 2 }.freeze,
+      :two => 3,
+      :three => { :third => 4 }.freeze
+    }.freeze
+  end
 
   subject { described_class.new nil, fixtures }
 
@@ -12,66 +18,102 @@ describe Holoserve::Fixture::Importer do
       subject.hash = {
         :test => "value"
       }
-      subject.hash.should == { :test => "value" }
+      subject.result.should == { :test => "value" }
     end
 
     it "should return a hash with imported fixtures" do
       subject.hash = {
         :imports => [
-          { :path => "test.nested" }
+          { :path => "one" }
         ]
       }
-      subject.hash.should == { :test => { :nested => "value" } }
+      subject.result.should == { :first => 1, :second => 2 }
     end
 
     it "should return a hash with imported fixtures at a target path" do
       subject.hash = {
         :imports => [
-          { :path => "test.nested", :as => "test" }
+          { :path => "one.first", :as => "test" }
         ]
       }
-      subject.hash.should == { :test => "value" }
+      subject.result.should == { :test => 1 }
     end
 
-    it "should return a hash with imported and filtered fixtures" do
+    it "should return a hash with imported and white-list filtered fixtures" do
       subject.hash = {
         :imports => [
-          { :path => "test", :as => "test", :only => [ "second" ] }
+          { :path => "one", :as => "test", :only => "second" }
         ]
       }
-      subject.hash.should == { :test => { :second => "value" } }
+      subject.result.should == { :test => { :second => 2 } }
+    end
+
+    it "should return a hash with imported and black-list filtered fixtures" do
+      subject.hash = {
+        :imports => [
+          { :path => "one", :as => "test", :except => [ "second" ] }
+        ]
+      }
+      subject.result.should == { :test => { :first => 1 } }
     end
 
     it "should return a hash where all the imports are imported" do
       subject.hash = {
         :imports => [
-          { :path => "test.nested", :as => "test" },
-          { :path => "another", :as => "another.test" }
+          { :path => "one.first", :as => "test" },
+          { :path => "two", :as => "another.test" }
+        ]
+      }
+      subject.result.should == { :test => 1, :another => { :test => 3 } }
+    end
+
+    it "should return a hash where all the imports are merged together" do
+      subject.hash = {
+        :imports => [
+          { :path => "one" },
+          { :path => "three" }
         ]
       }
-      subject.hash.should == { :test => "value", :another => { :test => "value" } }
+      subject.result.should == { :first => 1, :second => 2, :third => 4 }
     end
 
     it "should return a hash where the data is merged with the imports" do
       subject.hash = {
         :imports => [
-          { :path => "test.nested", :as => "test" }
+          { :path => "one.first", :as => "test" }
         ],
         :another => "value"
       }
-      subject.hash.should == { :test => "value", :another => "value" }
+      subject.result.should == { :test => 1, :another => "value" }
     end
 
     it "should return a hash where the data is deep merged with the imports" do
       subject.hash = {
         :imports => [
-          { :path => "test.nested", :as => "test.nested" }
+          { :path => "one.first", :as => "test.nested" }
         ],
         :test => {
           :another => "value"
         }
       }
-      subject.hash.should == { :test => { :nested => "value", :another => "value" } }
+      subject.result.should == { :test => { :nested => 1, :another => "value" } }
+    end
+
+    it "should not destroy the original hash and stay repeatable" do
+      hash = {
+        :imports => [
+          { :path => "three" },
+          { :path => "one.first", :as => "test.nested" }
+        ],
+        :test => {
+          :another => "value"
+        }
+      }
+      subject.hash = hash
+      subject.result.should == { :third => 4, :test => { :nested => 1, :another => "value" } }
+
+      importer = described_class.new hash, fixtures
+      importer.result.should == { :third => 4, :test => { :nested => 1, :another => "value" } }
     end
 
   end

data/spec/lib/holoserve/tool/data_path_spec.rb

@@ -8,37 +8,37 @@ describe Holoserve::Tool::DataPath do
 
     it "should return the given data if no path is specified" do
       subject.path = nil
-      subject.data = { :test => "value" }
+      subject.data = { :test => "value" }.freeze
       subject.fetch.should == { :test => "value" }
     end
 
     it "should return the value specified by the given path" do
       subject.path = "test"
-      subject.data = { :test => "value" }
+      subject.data = { :test => "value" }.freeze
       subject.fetch.should == "value"
     end
 
     it "should return the nested value specified by the given path" do
       subject.path = "test.nested"
-      subject.data = { :test => { :nested => "value" } }
+      subject.data = { :test => { :nested => "value" }.freeze }.freeze
       subject.fetch.should == "value"
     end
 
     it "should return nil if the path points to nowhere" do
       subject.path = "test.nested"
-      subject.data = { :test => true }
+      subject.data = { :test => true }.freeze
       subject.fetch.should be_nil
     end
 
     it "should return nil if the last path element doesn't exists'" do
       subject.path = "test.nested"
-      subject.data = { :test => { :another => "value" } }
+      subject.data = { :test => { :another => "value" }.freeze }.freeze
       subject.fetch.should be_nil
     end
 
     it "should return in an array nested value specified by the given path" do
       subject.path = "test.1.nested"
-      subject.data = { :test => [ { }, { :nested => "value" } ] }
+      subject.data = { :test => [ { }.freeze, { :nested => "value" }.freeze ].freeze }.freeze
       subject.fetch.should == "value"
     end
 
@@ -46,27 +46,33 @@ describe Holoserve::Tool::DataPath do
 
   describe "store" do
 
-    it "should return the given value if no path is specified" do
+    it "should merge the given value with the root element if no path is given" do
       subject.path = nil
-      subject.data = { :test => "value" }
+      subject.data = { :test => "value" }.freeze
+      subject.store(:another => "value").should == { :test => "value", :another => "value" }
+    end
+
+    it "should return the value if no path is given and value is not mergeable" do
+      subject.path = nil
+      subject.data = { :test => "value" }.freeze
       subject.store("value").should == "value"
     end
 
     it "should store the given value at the specified path" do
       subject.path = "another"
-      subject.data = { :test => "value" }
+      subject.data = { :test => "value" }.freeze
       subject.store("value").should == { :test => "value", :another => "value" }
     end
 
     it "should store the given value in a nested hash" do
       subject.path = "test.another"
-      subject.data = { :test => { :nested => "value" } }
+      subject.data = { :test => { :nested => "value" }.freeze }.freeze
       subject.store("value").should == { :test => { :nested => "value", :another => "value" } }
     end
 
     it "should store the given value at the specified path and create it if missing" do
       subject.path = "another.test"
-      subject.data = { :test => "value" }
+      subject.data = { :test => "value" }.freeze
       subject.store("value").should == { :test => "value", :another => { :test => "value" } }
     end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: holoserve
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.3.1
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-02-09 00:00:00.000000000 Z
+date: 2012-02-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rack
-  requirement: &70132546243580 !ruby/object:Gem::Requirement
+  requirement: &70159532631360 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -21,10 +21,10 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *70132546243580
+  version_requirements: *70159532631360
 - !ruby/object:Gem::Dependency
   name: sinatra
-  requirement: &70132546257040 !ruby/object:Gem::Requirement
+  requirement: &70159532629620 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -32,10 +32,10 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *70132546257040
+  version_requirements: *70159532629620
 - !ruby/object:Gem::Dependency
   name: unicorn
-  requirement: &70132546255800 !ruby/object:Gem::Requirement
+  requirement: &70159532627220 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -43,10 +43,10 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *70132546255800
+  version_requirements: *70159532627220
 - !ruby/object:Gem::Dependency
   name: transport
-  requirement: &70132546254300 !ruby/object:Gem::Requirement
+  requirement: &70159532638140 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -54,10 +54,10 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *70132546254300
+  version_requirements: *70159532638140
 - !ruby/object:Gem::Dependency
   name: cucumber
-  requirement: &70132546252800 !ruby/object:Gem::Requirement
+  requirement: &70159532632680 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -65,10 +65,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70132546252800
+  version_requirements: *70159532632680
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &70132546265600 !ruby/object:Gem::Requirement
+  requirement: &70159532646160 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -76,10 +76,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70132546265600
+  version_requirements: *70159532646160
 - !ruby/object:Gem::Dependency
   name: transport
-  requirement: &70132546264780 !ruby/object:Gem::Requirement
+  requirement: &70159532643660 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -87,10 +87,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70132546264780
+  version_requirements: *70159532643660
 - !ruby/object:Gem::Dependency
   name: oauth
-  requirement: &70132546263580 !ruby/object:Gem::Requirement
+  requirement: &70159532640540 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -98,7 +98,7 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70132546263580
+  version_requirements: *70159532640540
 description: This tool can be used to fake webservice APIs for testing proposals.
 email: philipp.bruell@skrill.com
 executables:
@@ -150,7 +150,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 4596962680025174660
+      hash: -2968421100355071724
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements: