orchestrate 0.6.3 → 0.7.0

data/lib/orchestrate/version.rb

@@ -1,3 +1,4 @@
 module Orchestrate
-  VERSION = "0.6.3"
+  # @return [String] The version number of the Orchestrate Gem
+  VERSION = "0.7.0"
 end

data/orchestrate.gemspec

@@ -18,7 +18,7 @@ Gem::Specification.new do |s|
 	s.require_paths = ["lib"]
 
   s.add_dependency "faraday", "~> 0.9"
-  s.add_dependency "faraday_middleware", "~> 0.9", ">= 0.9.1"
+  s.add_dependency "net-http-persistent", "~> 2.9"
   s.add_development_dependency "bundler", "~> 1.6"
   s.add_development_dependency "rake"
   s.add_development_dependency "typhoeus"

data/test/orchestrate/api/{collections_test.rb → collections_api_test.rb}

@@ -1,6 +1,6 @@
 require_relative '../../test_helper'
 
-class CollectionTest < MiniTest::Unit::TestCase
+class CollectionAPITest < MiniTest::Unit::TestCase
   def setup
     @collection = 'test'
     @client, @stubs, @basic_auth = make_client_and_artifacts

data/test/orchestrate/api/exceptions_test.rb

@@ -8,10 +8,7 @@ class ExceptionsTest < MiniTest::Unit::TestCase
   def test_raises_on_unauthroized
     @stubs.get("/v0/foo") do |env|
       assert_authorization @basic_auth, env
-      [ 401, response_headers, {
-        "message" => "Valid credentials are required.",
-        "code" => "security_unauthorized"
-      }.to_json ]
+      error_response(:unauthorized)
     end
     assert_raises Orchestrate::API::Unauthorized do
       @client.list(:foo)
@@ -19,92 +16,49 @@ class ExceptionsTest < MiniTest::Unit::TestCase
   end
 
   def test_raises_on_bad_request
-    message = "Invalid value for header 'If-Match'."
-    @stubs.put("/v0/foo/bar") do |env|
-      [400, response_headers, {
-        message: message,
-        code: "api_bad_request"
-      }.to_json ]
-    end
-    err = assert_raises Orchestrate::API::BadRequest do
+    @stubs.put("/v0/foo/bar") { error_response(:bad_request) }
+    assert_raises Orchestrate::API::BadRequest do
       @client.put(:foo, "bar", {}, "'foo'")
     end
-    assert_equal message, err.message
   end
 
   def test_raises_on_malformed_search_query
-    @stubs.get("/v0/foo") do |env|
-      [ 400, response_headers, {
-        message: "The search query provided is invalid.",
-        code: "search_query_malformed"
-      }.to_json ]
-    end
+    @stubs.get("/v0/foo") { error_response(:search_query_malformed) }
     assert_raises Orchestrate::API::MalformedSearch do
       @client.search(:foo, "foo=\"no")
     end
   end
 
   def test_raises_on_invalid_search_param
-    @stubs.get("/v0/foo") do |env|
-      [ 400, response_headers, {
-        message: "A provided search query param is invalid.",
-        details: { query: "Query is empty." },
-        code: "search_param_invalid"
-      }.to_json ]
-    end
+    @stubs.get("/v0/foo") { error_response(:invalid_search_param) }
     assert_raises Orchestrate::API::InvalidSearchParam do
       @client.search(:foo, '')
     end
   end
 
   def test_raises_on_malformed_ref
-    @stubs.put("/v0/foo/bar") do |env|
-      [ 400, response_headers, {
-        message: "The provided Item Ref is malformed.",
-        details: { ref: "blerg" },
-        code: "item_ref_malformed"
-      }.to_json ]
-    end
+    @stubs.put("/v0/foo/bar") { error_response(:malformed_ref) }
     assert_raises Orchestrate::API::MalformedRef do
       @client.put(:foo, "bar", {:blerg => 'blerg'}, "blerg")
     end
   end
 
   def test_raises_on_indexing_conflict
-    @stubs.put("/v0/foo/bar") do |env|
-      [ 409, response_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: "/v0/test/one/refs/f8a86a25029a907b/conflicts"
-        },
-        code: "indexing_conflict"
-      }.to_json ]
-    end
+    @stubs.put("/v0/foo/bar") { error_response(:indexing_conflict) }
     assert_raises Orchestrate::API::IndexingConflict do
       @client.put(:foo, 'bar', {count: "foo"})
     end
   end
 
   def test_raises_on_version_mismatch
-    @stubs.put("/v0/foo/bar") do |env|
-      [ 412, response_headers, {
-        message: "The version of the item does not match.",
-        code: "item_version_mismatch"
-      }.to_json ]
-    end
+    @stubs.put("/v0/foo/bar") { error_response(:version_mismatch) }
     assert_raises Orchestrate::API::VersionMismatch do
       @client.put(:foo, 'bar', {foo:'bar'}, "7ae8635207acbb2f")
     end
   end
 
   def test_raises_on_item_already_present
-    @stubs.put("/v0/foo/bar") do |env|
-      [ 412, response_headers, {
-        message: "The item is already present.",
-        code: "item_already_present"
-      }.to_json ]
-    end
+    @stubs.put("/v0/foo/bar") { error_response(:already_present) }
     assert_raises Orchestrate::API::AlreadyPresent do
       @client.put_if_absent(:foo, 'bar', {foo:'bar'})
     end

data/test/orchestrate/api/{key_value_test.rb → key_value_api_test.rb}

@@ -1,6 +1,6 @@
 require_relative "../../test_helper"
 
-class KeyValueTest < MiniTest::Unit::TestCase
+class KeyValueAPITest < MiniTest::Unit::TestCase
   def setup
     @collection = 'test'
     @key = 'keyname'

data/test/orchestrate/application_test.rb

@@ -0,0 +1,44 @@
+require "test_helper"
+
+class ApplicationTest < MiniTest::Unit::TestCase
+
+  def test_instantianes_with_api_key
+    stubs = Faraday::Adapter::Test::Stubs.new
+    pinged = false
+    stubs.head('/v0') do |env|
+      pinged = true
+      [200, response_headers, '']
+    end
+
+    app = Orchestrate::Application.new("api_key") do |conn|
+      conn.adapter :test, stubs
+    end
+
+    assert_equal "api_key", app.api_key
+    assert_kind_of Orchestrate::Client, app.client
+    assert pinged, "API wasn't pinged"
+  end
+
+  def test_instantiates_with_client
+    client, stubs = make_client_and_artifacts
+    pinged = false
+    stubs.head('/v0') do |env|
+      pinged = true
+      [ 200, response_headers, '' ]
+    end
+
+    app = Orchestrate::Application.new(client)
+    assert_equal client.api_key, app.api_key
+    assert_equal client, app.client
+    assert pinged, "API wasn't pinged"
+  end
+
+  def test_collection_accessor
+    app, stubs = make_application
+    users = app[:users]
+    assert_kind_of Orchestrate::Collection, users
+    assert_equal app, users.app
+    assert_equal 'users', users.name
+  end
+
+end

data/test/orchestrate/client_test.rb

@@ -1,34 +1,36 @@
 require "test_helper"
 
-describe Orchestrate::Client do
+class ClientTest < MiniTest::Unit::TestCase
 
-  it "should initialize" do
+  def test_initialization
     client = Orchestrate::Client.new('8c3')
-    client.must_be_kind_of Orchestrate::Client
+    assert_equal '8c3', client.api_key
   end
 
-  it "handles parallel requests" do
-    client, stubs = make_client_and_artifacts
+  def test_parallelism
+    thing_body = {"foo" => "bar"}
+    list_body = {"count" => 1, "results" => [{"value"=>{"a" => "b"}, "path" => {}, "reftime" => ""}] }
+    client, stubs = make_client_and_artifacts(true)
     stubs.get("/v0/foo") do |env|
-      [ 200, response_headers, {}.to_json ]
+      [ 200, response_headers, list_body.to_json ]
     end
-    stubs.get("/v0/users/mattly") do |env|
-      [ 200, response_headers, {}.to_json ]
+    stubs.get("/v0/things/foo") do |env|
+      [ 200, response_headers, thing_body.to_json ]
     end
     responses = nil
-    capture_warnings do
-      responses = client.in_parallel do |r|
-        r[:list] = client.list(:foo)
-        r[:user] = client.get(:users, "mattly")
-      end
+    responses = client.in_parallel do |r|
+      r[:list] = client.list(:foo)
+      r[:thing] = client.get(:things, "foo")
     end
     assert responses[:list]
     assert_equal 200, responses[:list].status
-    assert responses[:user]
-    assert_equal 200, responses[:user].status
+    assert_equal list_body, responses[:list].body
+    assert responses[:thing]
+    assert_equal 200, responses[:thing].status
+    assert_equal thing_body, responses[:thing].body
   end
 
-  it "handles ping request" do
+  def test_ping_request_success
     client, stubs = make_client_and_artifacts
     stubs.head("/v0") do |env|
       [ 200, response_headers, '' ]
@@ -36,7 +38,7 @@ describe Orchestrate::Client do
     client.ping
   end
 
-  it "handles ping with invalid api_key and raises Unauthorized" do
+  def test_ping_request_unauthorized
     client, stubs = make_client_and_artifacts
     headers = response_headers
     stubs.head("/v0") { [ 401, headers, '' ] }

data/test/orchestrate/collection_enumeration_test.rb

@@ -0,0 +1,116 @@
+require "test_helper"
+
+class CollectionEnumerationTest < MiniTest::Unit::TestCase
+
+  def test_enumerates_over_all
+    app, stubs = make_application
+    stubs.get("/v0/items") do |env|
+      assert_equal "100", env.params['limit']
+      body = case env.params['afterKey']
+      when nil
+        { "results" => 100.times.map {|x| make_kv_listing(:items, key: "key-#{x}") },
+          "next" => "/v0/items?afterKey=key-99&limit=100", "count" => 100 }
+      when 'key-99'
+        { "results" => 4.times.map {|x| make_kv_listing(:items, key: "key-#{100+x}")},
+          "count" => 4 }
+      else
+        raise ArgumentError.new("unexpected afterKey: #{env.params['afterKey']}")
+      end
+      [ 200, response_headers, body.to_json ]
+    end
+    items = app[:items].map {|item| item }
+    assert_equal 104, items.length
+    items.each_with_index do |item, index|
+      assert_equal "key-#{index}", item.key
+      assert item.ref
+      assert item.reftime
+      assert item.value
+      assert_equal "key-#{index}", item[:key]
+      assert_in_delta Time.now.to_f, item.last_request_time.to_f, 1.1
+    end
+  end
+
+  def test_enumerator_in_parallel
+    app, stubs = make_application({parallel:true})
+    stubs.get("/v0/items") do |env|
+      body = case env.params['afterKey']
+      when nil
+        { "results" => 10.times.map {|x| make_kv_listing(:items, key: "key-#{x}") },
+          "next" => "/v0/items?afterKey=key-9", "count" => 10 }
+      when 'key-9'
+        { "results" => 4.times.map {|x| make_kv_listing(:items, key: "key-#{10+x}")},
+          "count" => 4 }
+      else
+        raise ArgumentError.new("unexpected afterKey: #{env.params['afterKey']}")
+      end
+      [ 200, response_headers, body.to_json ]
+    end
+    items=nil
+    assert_raises Orchestrate::ResultsNotReady do
+      app.in_parallel { app[:items].take(5) }
+    end
+    if app[:items].respond_to?(:lazy)
+      app.in_parallel do
+        items = app[:items].lazy.map {|item| item }
+      end
+      items = items.force
+      assert_equal 14, items.length
+      items.each_with_index do |item, index|
+        assert_equal "key-#{index}", item.key
+        assert item.ref
+        assert item.reftime
+        assert item.value
+        assert_equal "key-#{index}", item[:key]
+        assert_in_delta Time.now.to_f, item.last_request_time.to_f, 1.1
+      end
+    end
+  end
+
+  def test_enumerates_as_needed
+    app, stubs = make_application
+    stubs.get("/v0/items") do |env|
+      assert_equal "5", env.params["limit"]
+      if env.params['afterKey'] != nil
+        raise ArgumentError.new("unexpected afterKey: #{env.params['afterKey']}")
+      else
+        body = { "results" => 5.times.map {|x| make_kv_listing(:items, key: "key-#{x}")},
+                 "next" => "/v0/items?afterKey=key-4&limit=5", "count" => 5 }
+        [ 200, response_headers, body.to_json ]
+      end
+    end
+    items = app[:items].take(5).map {|item| item }
+    assert_equal 5, items.length
+  end
+
+  def test_enumerates_with_range_start_and_end
+    keys = %w[bar bat bee cat dog ear foo]
+    app, stubs = make_application
+    stubs.get("/v0/items") do |env|
+      assert_equal "bar", env.params['startKey']
+      assert_equal "foo", env.params['endKey']
+      body = { "results" => keys.map {|k| make_kv_listing(:items, key: k)},
+               "count" => keys.length }
+      [ 200, response_headers, body.to_json ]
+    end
+    items = app[:items].start(:bar).end(:foo).take(5).map {|item| item.key }
+    assert_equal 5, items.length
+    assert_equal %w[bar bat bee cat dog], items
+  end
+
+  def test_enumerates_with_range_after_and_before
+    keys = %w[bar bat bee cat dog ear foo]
+    app, stubs = make_application
+    stubs.get("/v0/items") do |env|
+      assert_equal "bar", env.params['afterKey']
+      assert_equal "goo", env.params['beforeKey']
+      body = { "results" => keys.drop(1).map {|k| make_kv_listing(:items, key: k)},
+               "count" => keys.length }
+      [ 200, response_headers, body.to_json ]
+    end
+    items = app[:items].after(:bar).before(:goo).take(5).map {|item| item.key }
+    assert_equal 5, items.length
+    assert_equal %w[bat bee cat dog ear], items
+  end
+
+end
+

data/test/orchestrate/collection_kv_accessors_test.rb

@@ -0,0 +1,145 @@
+require "test_helper"
+
+class Collection_KV_Accessors_Test < MiniTest::Unit::TestCase
+  def setup
+    @app, @stubs = make_application
+    @items = @app[:items]
+  end
+
+  def test_kv_getter_when_present
+    body = {"hello" => "world"}
+    @stubs.get("/v0/items/hello") do |env|
+      [200, response_headers, body.to_json]
+    end
+    hello = @items[:hello]
+    assert_kind_of Orchestrate::KeyValue, hello
+  end
+
+  def test_kv_getter_when_absent
+    @stubs.get("/v0/items/absent") do |env|
+      [404, response_headers, response_not_found('absent')]
+    end
+    assert_nil @items[:absent]
+  end
+
+  def test_kv_setter
+    body = { "hello" => "world" }
+    ref = nil
+    @stubs.put("/v0/items/newitem") do |env|
+      assert_header "If-Match", nil, env
+      assert_header "If-None-Match", nil, env
+      assert_equal body, JSON.parse(env.body)
+      ref = make_ref
+      [ 201, response_headers({'Etag' => %|"#{ref}"|, 'Location' => "/v0/items/newitem/refs/#{ref}"}), '' ]
+    end
+    @items[:newitem] = body
+    assert ref
+  end
+
+  def test_set_performs_put
+    body = { "hello" => "world" }
+    ref = nil
+    @stubs.put("/v0/items/newitem") do |env|
+      assert_header "If-Match", nil, env
+      assert_header "If-None-Match", nil, env
+      assert_equal body, JSON.parse(env.body)
+      ref = make_ref
+      [ 201, response_headers({'Etag' => %|"#{ref}"|, 'Location' => "/v0/items/newitem/refs/#{ref}"}), '' ]
+    end
+    kv = @items.set(:newitem, body)
+    assert_equal ref, kv.ref
+    assert_equal "newitem", kv.key
+    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_append_operator_performs_post
+    body = { "hello" => "world" }
+    key = nil
+    ref = nil
+    @stubs.post("/v0/items") do |env|
+      assert_header 'Content-Type', 'application/json', env
+      assert_equal body, JSON.parse(env.body)
+      ref = make_ref
+      key = SecureRandom.hex(16)
+      [ 201, response_headers({
+        'Etag' => %|"#{ref}"|, "Location" => "/v0/items/#{key}/refs/#{ref}"
+      }), '' ]
+    end
+    kv = @items << body
+    assert kv
+    assert_equal key, kv.key
+    assert_equal ref, kv.ref
+    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_create_performs_post_with_one_arg
+    body = { "hello" => "world" }
+    key = nil
+    ref = nil
+    @stubs.post("/v0/items") do |env|
+      assert_header 'Content-Type', 'application/json', env
+      assert_equal body, JSON.parse(env.body)
+      ref = make_ref
+      key = SecureRandom.hex(16)
+      [ 201, response_headers({
+        'Etag' => %|"#{ref}"|, "Location" => "/v0/items/#{key}/refs/#{ref}"
+      }), '' ]
+    end
+    kv = @items.create(body)
+    assert kv
+    assert_equal key, kv.key
+    assert_equal ref, kv.ref
+    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_create_performs_put_if_absent_with_two_args
+    body = { "hello" => "world" }
+    ref = nil
+    @stubs.put("/v0/items/newitem") do |env|
+      assert_header "If-Match", nil, env
+      assert_header "If-None-Match", '"*"', env
+      assert_equal body, JSON.parse(env.body)
+      ref = make_ref
+      [ 201, response_headers({"Etag" => %|"#{ref}"|, "Location" => "/v0/items/newitem/refs/#{ref}"}), '' ]
+    end
+    kv = @items.create(:newitem, body)
+    assert_equal @items, kv.collection
+    assert_equal "newitem", kv.key
+    assert_equal ref, kv.ref
+    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_create_performs_put_if_absent_with_two_args_returns_false_on_already_exists
+    @stubs.put("/v0/items/newitem") do |env|
+      assert_header "If-Match", nil, env
+      assert_header "If-None-Match", '"*"', env
+      error_response(:already_present)
+    end
+    assert_equal false, @items.create(:newitem, {"hello" => "world"})
+  end
+
+  def test_delete_performs_delete
+    @stubs.delete("/v0/items/olditem") do |env|
+      assert_nil env.params['purge']
+      [ 204, response_headers, '' ]
+    end
+    assert_equal true, @items.delete(:olditem)
+  end
+
+  def test_purge_performs_purge
+    @stubs.delete("/v0/items/olditem") do |env|
+      assert_equal "true", env.params['purge']
+      [ 204, response_headers, '' ]
+    end
+    assert_equal true, @items.purge(:olditem)
+  end
+end
+