orchestrate 0.6.3 → 0.7.0

data/test/orchestrate/collection_test.rb

@@ -0,0 +1,63 @@
+require "test_helper"
+
+class CollectionTest < MiniTest::Unit::TestCase
+
+  def test_instantiates_with_app_and_name
+    app, stubs = make_application
+    users = Orchestrate::Collection.new(app, :users)
+    assert_equal app, users.app
+    assert_equal 'users', users.name
+  end
+
+  def test_instantiates_with_client_and_name
+    client, stubs = make_client_and_artifacts
+    stubs.head("/v0") { [200, response_headers, ''] }
+    users = Orchestrate::Collection.new(client, :users)
+    assert_equal client, users.app.client
+    assert_equal 'users', users.name
+  end
+
+  def test_destroy
+    app, stubs = make_application
+    users = Orchestrate::Collection.new(app, :users)
+    stubs.delete("/v0/users") do |env|
+      assert_equal "true", env.params["force"]
+      [204, response_headers, '']
+    end
+    assert true, users.destroy!
+  end
+
+  def test_equality
+    app, stubs = make_application
+    app2, stubs = make_application
+    items1 = app[:items]
+    items2 = app[:items]
+    other = app[:other]
+    assert_equal items1, items2
+    refute_equal items1, other
+    refute_equal items1, OpenStruct.new({name: 'items'})
+    refute_equal items1, 3
+    refute_equal items1, app2[:items]
+
+    assert items1.eql?(items2)
+    assert items2.eql?(items1)
+    refute items1.eql?(other)
+    refute other.eql?(items1)
+    refute items1.eql?(app2[:items])
+
+    # equal? is for object identity only
+    refute items1.equal?(items2)
+    refute other.equal?(items1)
+  end
+
+  def test_sorting
+    app, stubs = make_application
+    app2, stubs = make_application
+    assert_equal(-1, app[:users] <=> app[:items])
+    assert_equal  0, app[:items] <=> app[:items]
+    assert_equal  1, app[:items] <=> app[:users]
+    assert_nil 2 <=> app[:items]
+    assert_nil app2[:items] <=> app[:items]
+  end
+end
+

data/test/orchestrate/key_value_persistence_test.rb

@@ -0,0 +1,161 @@
+require "test_helper"
+
+class KeyValuePersistenceTest < MiniTest::Unit::TestCase
+  def setup
+    @app, @stubs = make_application
+    @items = @app[:items]
+    @kv = make_kv_item(@items, @stubs, :loaded => Time.now - 60)
+  end
+
+  def test_save_performs_put_if_match_and_returns_true_on_success
+    @kv[:foo] = "bar"
+    new_ref = nil
+    @stubs.put("/v0/items/#{@kv.key}") do |env|
+      assert_equal @kv.value, JSON.parse(env.body)
+      assert_header 'If-Match', "\"#{@kv.ref}\"", env
+      new_ref = make_ref
+      [ 201, response_headers({'Etag' => new_ref, "Location" => "/v0/items/#{@kv.key}/refs/#{new_ref}"}), '' ]
+    end
+    assert_equal true, @kv.save
+    assert_equal new_ref, @kv.ref
+    assert_in_delta Time.now.to_f, @kv.last_request_time.to_f, 1.1
+    assert_equal "bar", @kv[:foo]
+  end
+
+  def test_save_performs_put_if_match_and_returns_false_on_version_mismatch
+    @stubs.put("/v0/items/#{@kv.key}") do |env|
+      assert_header 'If-Match', "\"#{@kv.ref}\"", env
+      error_response(:version_mismatch)
+    end
+    assert_equal false, @kv.save
+  end
+
+  def test_save_performs_put_if_match_and_returns_true_on_indexing_conflict
+    ref = @kv.ref
+    @stubs.put("/v0/items/#{@kv.key}") do |env|
+      ref = make_ref
+      assert_header 'If-Match', "\"#{@kv.ref}\"", env
+      error_response(:indexing_conflict, {
+        headers: {"Location" => "/v0/items/#{@kv.key}/refs/#{ref}"},
+        conflicts_uri: "/v0/items/#{@kv.key}/refs/#{ref}/conflicts"
+      })
+    end
+    assert_equal true, @kv.save
+    assert_equal ref, @kv.ref
+    assert_in_delta Time.now.to_f, @kv.last_request_time.to_f, 1.1
+  end
+
+  def test_save_returns_false_on_etc_errors
+    @stubs.put("/v0/items/#{@kv.key}") { error_response(:bad_request) }
+    assert_equal false, @kv.save
+
+    @stubs.put("/v0/items/#{@kv.key}") { error_response(:service_error) }
+    assert_equal false, @kv.save
+  end
+
+  def test_save_bang_performs_put_if_match_doesnt_raise_on_success
+    @kv[:foo] = "bar"
+    ref = @kv.ref
+    @stubs.put("/v0/items/#{@kv.key}") do |env|
+      assert_equal @kv.value, JSON.parse(env.body)
+      assert_header 'If-Match', %|"#{ref}"|, env
+      ref = make_ref
+      [201, response_headers({'Etag'=>%|"#{ref}"|, 'Loation'=>"/v0/items/#{@kv.key}/refs/#{ref}"}), '']
+    end
+    @kv.save!
+    assert_equal ref, @kv.ref
+    assert_in_delta Time.now.to_f, @kv.last_request_time.to_f, 1.1
+  end
+
+  def test_save_bang_performs_put_if_match_raises_on_version_mismatch
+    @stubs.put("/v0/items/#{@kv.key}") do |env|
+      assert_header "If-Match", %|"#{@kv.ref}"|, env
+      error_response(:version_mismatch)
+    end
+    assert_raises Orchestrate::API::VersionMismatch do
+      @kv.save!
+    end
+  end
+
+  def test_save_bang_performs_put_if_match_doesnt_raise_on_indexing_conflict
+    ref = @kv.ref
+    @stubs.put("/v0/items/#{@kv.key}") do |env|
+      ref = make_ref
+      assert_header "If-Match", %|"#{@kv.ref}"|, env
+      error_response(:indexing_conflict, {
+        headers: {"Location" => "/v0/items/#{@kv.key}/refs/#{ref}"},
+        conflicts_uri: "/v0/items/#{@kv.key}/refs/#{ref}/conflicts"
+      })
+    end
+    @kv.save!
+    assert_equal ref, @kv.ref
+    assert_in_delta Time.now.to_f, @kv.last_request_time.to_f, 1.1
+  end
+
+  def test_save_bang_performs_put_if_match_raises_on_request_error
+    @stubs.put("/v0/items/#{@kv.key}") do |env|
+      assert_header "If-Match", %|"#{@kv.ref}"|, env
+      error_response(:bad_request)
+    end
+    assert_raises Orchestrate::API::BadRequest do
+      @kv.save!
+    end
+  end
+
+  def test_save_bang_performs_put_if_match_raises_on_service_error
+    @stubs.put("/v0/items/#{@kv.key}") { error_response(:service_error) }
+    assert_raises Orchestrate::API::ServiceError do
+      @kv.save!
+    end
+  end
+
+  def test_destroy_performs_delete_if_match_and_returns_true_on_success
+    @stubs.delete("/v0/items/#{@kv.key}") do |env|
+      assert_header 'If-Match', "\"#{@kv.ref}\"", env
+      [204, response_headers, '']
+    end
+    assert_equal true, @kv.destroy
+    assert_nil @kv.ref
+    assert_in_delta Time.now.to_f, @kv.last_request_time.to_f, 1.1
+  end
+
+  def test_destroy_performs_delete_if_match_and_returns_false_on_error
+    @stubs.delete("/v0/items/#{@kv.key}") { error_response(:version_mismatch) }
+    assert_equal false, @kv.destroy
+  end
+
+  def test_destroy_bang_performs_delete_raises_on_error
+    @stubs.delete("/v0/items/#{@kv.key}") { error_response(:version_mismatch) }
+    assert_raises Orchestrate::API::VersionMismatch do
+      @kv.destroy!
+    end
+  end
+
+  def test_purge_performs_purge_if_match_and_returns_true_on_success
+    @stubs.delete("/v0/items/#{@kv.key}") do |env|
+      assert_header 'If-Match', %|"#{@kv.ref}"|, env
+      assert_equal "true", env.params['purge']
+      [ 204, response_headers, '' ]
+    end
+    assert_equal true, @kv.purge
+    assert_nil @kv.ref
+    assert_in_delta Time.now.to_f, @kv.last_request_time.to_f, 1.1
+  end
+
+  def test_purge_performs_purge_if_match_and_returns_false_on_error
+    @stubs.delete("/v0/items/#{@kv.key}") { error_response(:version_mismatch) }
+    assert_equal false, @kv.purge
+  end
+
+  def test_purge_bang_performs_purge_if_match_and_raises_on_error
+    @stubs.delete("/v0/items/#{@kv.key}") do |env|
+      assert_header 'If-Match', %|"#{@kv.ref}"|, env
+      assert_equal "true", env.params['purge']
+      error_response(:version_mismatch)
+    end
+    assert_raises Orchestrate::API::VersionMismatch do
+      @kv.purge!
+    end
+  end
+
+end

data/test/orchestrate/key_value_test.rb

@@ -0,0 +1,116 @@
+require "test_helper"
+
+class KeyValueTest < MiniTest::Unit::TestCase
+
+  def test_load_with_collection_and_key
+    app, stubs = make_application
+    items = app[:items]
+    ref = "123456"
+    body = {"hello" => "world"}
+    kv = make_kv_item(items, stubs, { key: "hello", ref: ref, body: body })
+    assert_equal "hello", kv.key
+    assert_equal ref, kv.ref
+    assert_equal "items/hello", kv.id
+    assert_equal body, kv.value
+    assert kv.loaded?
+    assert_in_delta Time.now.to_f, kv.last_request_time.to_f, 1.1
+  end
+
+  def test_value_accessors
+    app, stubs = make_application
+    items = app[:items]
+    body = {"hello" => "world", "one" => "two"}
+    kv = make_kv_item(items, stubs, {body: body})
+    assert_equal body["hello"], kv["hello"]
+    assert_equal body["hello"], kv[:hello]
+    assert_equal body["one"], kv["one"]
+    assert_equal body["one"], kv[:one]
+
+    kv[:one] = 1
+    assert_equal 1, kv["one"]
+    kv[:two] = "Two"
+    assert_equal "Two", kv[:two]
+    kv["three"] = "Tres"
+    assert_equal "Tres", kv[:three]
+    kv["four"] = "IV"
+    assert_equal "IV", kv["four"]
+  end
+
+  def test_instantiates_from_parallel_request
+    app, stubs = make_application({parallel: true})
+    items = app[:items]
+    body = {"hello" => "foo"}
+    ref = make_ref
+    stubs.get("/v0/items/foo") { [200, response_headers(ref_headers(:items, :foo, ref)), body.to_json] }
+    stubs.put("/v0/items/bar") { [201, response_headers(ref_headers(:items, :bar, make_ref)), ''] }
+    results = app.in_parallel do |r|
+      r[:foo] = items[:foo]
+      r[:bar] = items.create(:bar, {})
+    end
+    assert_equal 'foo', results[:foo].key
+    assert_equal ref, results[:foo].ref
+    assert_equal body, results[:foo].value
+    assert_equal 'bar', results[:bar].key
+  end
+
+  def test_instantiates_without_loading
+    app, stubs = make_application
+    items = app[:items]
+    kv = Orchestrate::KeyValue.new(items, 'keyname')
+    assert_equal 'keyname', kv.key
+    assert_equal items, kv.collection
+    assert ! kv.loaded?
+  end
+
+  def test_instantiates_from_collection_and_listing
+    app, stubs = make_application
+    listing = make_kv_listing('items', {key: "foo"})
+    kv = Orchestrate::KeyValue.new(app[:items], listing, Time.now)
+    assert_equal 'items', kv.collection_name
+    assert_equal "foo", kv.key
+    assert_equal listing['path']['ref'], kv.ref
+    assert_equal listing['value'], kv.value
+    assert_in_delta Time.at(listing['reftime'] / 1000), kv.reftime, 1.1
+    assert_in_delta Time.now.to_f, kv.last_request_time.to_f, 1.1
+  end
+
+  def test_equality
+    app, stubs = make_application
+    app2, stubs = make_application
+    items = app[:items]
+
+    foo = Orchestrate::KeyValue.new(items, :foo)
+
+    assert_equal foo, Orchestrate::KeyValue.new(items, :foo)
+    refute_equal foo, Orchestrate::KeyValue.new(items, :bar)
+    refute_equal foo, Orchestrate::KeyValue.new(app[:users], :foo)
+    refute_equal foo, Orchestrate::KeyValue.new(app2[:items], :foo)
+    refute_equal foo, :foo
+
+    assert foo.eql?(Orchestrate::KeyValue.new(items, :foo))
+    refute foo.eql?(Orchestrate::KeyValue.new(items, :bar))
+    refute foo.eql?(Orchestrate::KeyValue.new(app[:users], :foo))
+    refute foo.eql?(Orchestrate::KeyValue.new(app2[:items], :foo))
+    refute foo.eql?(:foo)
+
+    # equal? is for Object equality
+    assert foo.equal?(foo)
+    refute foo.equal?(Orchestrate::KeyValue.new(items, :foo))
+  end
+
+  def test_sorting
+    app, stubs = make_application
+    app2, stubs = make_application
+
+    foo = Orchestrate::KeyValue.new(app[:items], :foo)
+
+    assert_equal(-1, foo <=> Orchestrate::KeyValue.new(app[:items], :bar))
+    assert_equal  0, foo <=> Orchestrate::KeyValue.new(app[:items], :foo)
+    assert_equal  1, foo <=> Orchestrate::KeyValue.new(app[:items], :zoo)
+    assert_nil foo <=> Orchestrate::KeyValue.new(app[:users], :foo)
+    assert_nil foo <=> Orchestrate::KeyValue.new(app2[:items], :foo)
+    assert_nil foo <=> :foo
+  end
+
+end
+

data/test/test_helper.rb

@@ -7,6 +7,37 @@ require "securerandom"
 require "time"
 require "logger"
 
+class ParallelTest < Faraday::Adapter::Test
+  self.supports_parallel = true
+  extend Faraday::Adapter::Parallelism
+
+  class Manager
+    def initialize
+      @queue = []
+    end
+
+    def queue(env)
+      @queue.push(env)
+    end
+
+    def run
+      @queue.each {|env| env[:response].finish(env) unless env[:response].finished? }
+    end
+  end
+
+  def self.setup_parallel_manager(options={})
+    @mgr ||= Manager.new
+  end
+
+  def call(env)
+    super(env)
+    env[:parallel_manager].queue(env) if env[:parallel_manager]
+    env[:response]
+  end
+end
+
+Faraday::Adapter.register_middleware :parallel_test => :ParallelTest
+
 # Test Helpers ---------------------------------------------------------------
 
 def output_message(name, msg = nil)
@@ -15,17 +46,59 @@ end
 
 # TODO this is a bit messy for now at least but there's a bunch of
 # intermediate state we'd have to deal with in a bunch of other places
-def make_client_and_artifacts
+def make_client_and_artifacts(parallel=false)
   api_key = SecureRandom.hex(24)
   basic_auth = "Basic #{Base64.encode64("#{api_key}:").gsub(/\n/,'')}"
   stubs = Faraday::Adapter::Test::Stubs.new
   client = Orchestrate::Client.new(api_key) do |f|
-    f.adapter :test, stubs
+    if parallel
+      f.adapter :parallel_test, stubs
+    else
+      f.adapter :test, stubs
+    end
     f.response :logger, Logger.new(File.join(File.dirname(__FILE__), "test.log"))
   end
   [client, stubs, basic_auth]
 end
 
+def ref_headers(coll, key, ref)
+  {'Etag' => %|"#{ref}"|, 'Location' => "/v0/#{coll}/#{key}/refs/#{ref}"}
+end
+
+def make_application(opts={})
+  client, stubs = make_client_and_artifacts(opts[:parallel])
+  stubs.head("/v0") { [200, response_headers, ''] }
+  app = Orchestrate::Application.new(client)
+  [app, stubs]
+end
+
+def make_ref
+  SecureRandom.hex(16)
+end
+
+def make_kv_item(collection, stubs, opts={})
+  key = opts[:key] || 'hello'
+  ref = opts[:ref] || "12345"
+  body = opts[:body] || {"hello" => "world"}
+  res_headers = response_headers({
+    'Etag' => "\"#{ref}\"",
+    'Content-Location' => "/v0/#{collection.name}/#{key}/refs/#{ref}"
+  })
+  stubs.get("/v0/items/#{key}") { [200, res_headers, body.to_json] }
+  kv = Orchestrate::KeyValue.load(collection, key)
+  kv.instance_variable_set(:@last_request_time, opts[:loaded]) if opts[:loaded]
+  kv
+end
+
+def make_kv_listing(collection, opts={})
+  key = opts[:key] || "item-#{rand(1_000_000)}"
+  ref = opts[:ref] || make_ref
+  reftime = opts[:reftime] || Time.now.to_f - (rand(24) * 3600_000)
+  body = opts[:body] || {"key" => key}
+  { "path" => { "collection" => collection, "key" => key, "ref" => ref },
+    "reftime" => reftime, "value" => body }
+end
+
 def capture_warnings
   old, $stderr = $stderr, StringIO.new
   begin
@@ -50,12 +123,65 @@ def chunked_encoding_header
 end
 
 def response_not_found(items)
-{ "message" => "The requested items could not be found.",
-  "details" => {
-    "items" => [ items ]
-  },
-  "code" => "items_not_found"
-}.to_json
+  { "message" => "The requested items could not be found.",
+    "details" => {
+      "items" => [ items ]
+    },
+    "code" => "items_not_found"
+  }.to_json
+end
+
+def error_response(error, etc={})
+  headers = response_headers(etc.fetch(:headers, {}))
+  case error
+  when :bad_request
+    [400, headers, {message: "The API request is malformed.", code: "api_bad_request"}.to_json ]
+  when :search_query_malformed
+    [ 400, headers, {
+      message: "The search query provided is invalid.",
+      code: "search_query_malformed"
+    }.to_json ]
+  when :invalid_search_param
+    [ 400, headers, {
+      message: "A provided search query param is invalid.",
+      details: { query: "Query is empty." },
+      code: "search_param_invalid"
+    }.to_json ]
+  when :malformed_ref
+    [ 400, headers, {
+      message: "The provided Item Ref is malformed.",
+      details: { ref: "blerg" },
+      code: "item_ref_malformed"
+    }.to_json ]
+  when :unauthorized
+    [ 401, headers, {
+      "message" => "Valid credentials are required.",
+      "code" => "security_unauthorized"
+    }.to_json ]
+  when :indexing_conflict
+    [409, headers, {
+      message: "The item has been stored but conflicts were detected when indexing. Conflicting fields have not been indexed.",
+      details: {
+        conflicts: { name: { type: "string", expected: "long" } },
+        conflicts_uri: etc[:conflicts_uri]
+      },
+      code: "indexing_conflict"
+    }.to_json ]
+  when :version_mismatch
+    [412, headers, {
+      message: "The version of the item does not match.",
+      code: "item_version_mismatch"
+    }.to_json]
+  when :already_present
+    [ 412, headers, {
+      message: "The item is already present.",
+      code: "item_already_present"
+    }.to_json ]
+  when :service_error
+    headers.delete("Content-Type")
+    [ 500, headers, '' ]
+  else raise ArgumentError.new("unknown error #{error}")
+  end
 end
 
 # Assertion Helpers