orchestrate 0.5.1 → 0.6.0

data/lib/orchestrate/version.rb

@@ -1,3 +1,3 @@
 module Orchestrate
-  VERSION = "0.5.1"
+  VERSION = "0.6.0"
 end

data/lib/orchestrate.rb

@@ -1,46 +1,9 @@
 require "orchestrate/api"
 require "orchestrate/client"
-require "orchestrate/configuration"
-require "orchestrate/helpers"
 require "orchestrate/version"
 
 #
 # A library for supporting connections to the \Orchestrate API.
 #
 module Orchestrate
-
-  # Configuration ------------------------------------------------------------
-
-  class << self
-
-    #
-    # An instance of Configuration containing the current library
-    # configuration options.
-    #
-    attr_accessor :config
-
-    #
-    # Lazily initialize and return the Configuration instance.
-    #
-    def config # :nodoc:
-      @config ||= Configuration.new
-    end
-
-    #
-    # Configure the Orchestrate library. This method should be called during
-    # application or script initialization. At a bare minimum, the Orchestrate
-    # library will require that an API key is provided.
-    #
-    # ==== Example
-    #
-    #   Orchestrate.configure do |config|
-    #     config.api_key = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx"
-    #   end
-    #
-    def configure
-      yield config
-    end
-
-  end
-
 end

data/test/orchestrate/api/collections_test.rb

@@ -18,10 +18,13 @@ class CollectionTest < MiniTest::Unit::TestCase
     response = @client.delete_collection(@collection)
     assert_equal 204, response.status
     assert_equal '', response.body
+    assert_equal response.headers['X-Orchestrate-Req-Id'], response.request_id
   end
 
   def test_lists_collection_without_params
-    body = {"count" => 0, "results" => [], "next" => ""}
+    body = {"count" => 1, "results" => [
+      { "value" => {"value" => "one"}, "path" => {}, "reftime" => "" }
+    ], "next" => "/v0/#{@collection}?afterKey=one"}
 
     @stubs.get("/v0/#{@collection}") do |env|
       assert_authorization @basic_auth, env
@@ -32,10 +35,14 @@ class CollectionTest < MiniTest::Unit::TestCase
     response = @client.list(@collection)
     assert_equal 200, response.status
     assert_equal body, response.body
+    assert_equal response.headers['X-Orchestrate-Req-Id'], response.request_id
+    assert_equal body['count'], response.count
+    assert_equal body['results'], response.results
+    assert_equal body['next'], response.next_link
   end
 
   def test_lists_collections_with_params_passes_them
-    body = {"count" => 0, "results" => [], "next" => ""}
+    body = {"count" => 0, "results" => []}
     @stubs.get("/v0/#{@collection}") do |env|
       assert_authorization @basic_auth, env
       assert_accepts_json env
@@ -48,11 +55,13 @@ class CollectionTest < MiniTest::Unit::TestCase
     response = @client.list(@collection, {limit:1, start: 'foo'})
     assert_equal 200, response.status
     assert_equal body, response.body
+    assert_nil response.next_link
   end
 
   def test_search_with_simple_query
     query = 'text:"The Right Way" and go'
-    body = { "results" => [], "count" => 0, "total_count" => 10, "next" => "", "prev" => "" }
+    body = {  "count" => 1, "total_count" => 1,
+              "results" => [{"path" => {}, "score" => 0.5 }] }
 
     @stubs.get("/v0/#{@collection}") do |env|
       assert_authorization @basic_auth, env
@@ -64,24 +73,37 @@ class CollectionTest < MiniTest::Unit::TestCase
     response = @client.search(@collection, query)
     assert_equal 200, response.status
     assert_equal body, response.body
+    assert_equal body['count'], response.count
+    assert_equal body['total_count'], response.total_count
+    assert_equal body['results'], response.results
+    assert_nil response.next_link
+    assert_nil response.prev_link
   end
 
   def test_search_with_extra_params
     query = 'text:"The Right Way" and go'
-    body = { "results" => [], "count" => 0, "total_count" => 10, "next" => "", "prev" => "" }
+    body = { "results" => [{"value" => {}, "path" => {}, "score" => 0.5}],
+             "count" => 1, "total_count" => 10,
+             "next" => "/v0/#{@collection}?limit=1&offset=4&query=__query__",
+             "prev" => "/v0/#{@collection}?limit=1&offset=2&query=__query__" }
 
     @stubs.get("/v0/#{@collection}") do |env|
       assert_authorization @basic_auth, env
       assert_accepts_json env
       assert_equal query, env.params['query']
       assert_equal '3', env.params['offset']
-      assert_equal '10', env.params['limit']
+      assert_equal '1', env.params['limit']
       [ 200, response_headers, body.to_json]
     end
 
-    response = @client.search(@collection, query, {offset: 3, limit: 10})
+    response = @client.search(@collection, query, {offset: 3, limit: 1})
     assert_equal 200, response.status
     assert_equal body, response.body
+    assert_equal body['results'], response.results
+    assert_equal body['count'], response.count
+    assert_equal body['total_count'], response.total_count
+    assert_equal body['next'], response.next_link
+    assert_equal body['prev'], response.prev_link
   end
 
 end

data/test/orchestrate/api/event_test.rb

@@ -7,70 +7,125 @@ class EventTest < MiniTest::Unit::TestCase
     @key = 'instance'
     @client, @stubs, @basic_auth = make_client_and_artifacts
     @event_type = "commits"
-    @timestamp = (Time.now.to_f * 1000).to_i
+    @time = Time.now
+    @timestamp = (@time.to_f * 1000).to_i
     @ordinal = 5
   end
 
   def test_get_event
-    body = { "path" => {}, "value" => {"msg" => "hello"}, "timestamp" => @timestamp, "ordinal" => @ordinal }
-    @stubs.get("/v0/#{@collection}/#{@key}/events/#{@event_type}/#{@timestamp}/#{@ordinal}") do |env|
+    ref = "12345"
+    value = {"msg" => "hello"}
+    path = { "collection" => @collection, "key" => @key, "type" => @event_type,
+             "ref" => "\"#{ref}\"", "timestamp" => @timestamp, "ordinal" => @ordinal }
+    body = { "path" => path, "value" => value, "timestamp" => @timestamp, "ordinal" => @ordinal }
+    location = ["/v0", @collection, @key, "events", @event_type, @timestamp, @ordinal].join('/')
+    @stubs.get(location) do |env|
       assert_authorization @basic_auth, env
       assert_accepts_json env
-      [200, response_headers, body.to_json]
+      headers = { "Etag" => "\"#{ref}\"" }
+      [200, response_headers(headers), body.to_json]
     end
 
     response = @client.get_event(@collection, @key, @event_type, @timestamp, @ordinal)
     assert_equal 200, response.status
     assert_equal body, response.body
+    assert_equal ref, response.ref
+    # assert_equal location, response.location
+    assert_equal Time.parse(response.headers['Date']), response.request_time
+    assert_equal response.headers['X-Orchestrate-Req-Id'], response.request_id
+  end
+
+  def test_get_event_with_time
+    time = Time.now
+    ts = (time.getutc.to_f * 1000).to_i
+    @stubs.get("/v0/#{@collection}/#{@key}/events/#{@event_type}/#{ts}/#{@ordinal}") do |env|
+      assert_authorization @basic_auth, env
+      assert_accepts_json env
+      [ 200, response_headers, {}.to_json ]
+    end
+
+    response = @client.get_event(@collection, @key, @event_type, time, @ordinal)
+    assert_equal 200, response.status
+  end
+
+  def test_get_event_with_datetime
+    time = DateTime.now
+    ts = (time.to_time.getutc.to_f * 1000).to_i
+    @stubs.get("/v0/#{@collection}/#{@key}/events/#{@event_type}/#{ts}/#{@ordinal}") do |env|
+      assert_authorization @basic_auth, env
+      assert_accepts_json env
+      [ 200, response_headers, {}.to_json ]
+    end
+    response = @client.get_event(@collection, @key, @event_type, time, @ordinal)
+    assert_equal 200, response.status
   end
 
   def test_post_event_without_timestamp
     event = {"msg" => "hello"}
+    ref = "12345"
+    location = ["/v0",@collection,@key,'events',@event_type,@timestamp,@ordinal].join('/')
     @stubs.post("/v0/#{@collection}/#{@key}/events/#{@event_type}") do |env|
       assert_authorization @basic_auth, env
       assert_equal event.to_json, env.body
-      [204, response_headers, '']
+      headers = { "Etag" => "\"#{ref}\"", "Location" => location }
+      [204, response_headers(headers), '']
     end
 
     response = @client.post_event(@collection, @key, @event_type, event)
     assert_equal 204, response.status
+    assert_equal location, response.location
+    assert_equal ref, response.ref
   end
 
   def test_post_event_with_timestamp
     event = {"msg" => "hello"}
+    ref = "12345"
+    location = ["/v0",@collection,@key,'events',@event_type,@timestamp,@ordinal].join('/')
     @stubs.post("/v0/#{@collection}/#{@key}/events/#{@event_type}/#{@timestamp}") do |env|
       assert_authorization @basic_auth, env
       assert_equal event.to_json, env.body
-      [204, response_headers, '']
+      headers = { "Etag" => "\"#{ref}\"", "Location" => location }
+      [204, response_headers(headers), '']
     end
 
-    response = @client.post_event(@collection, @key, @event_type, event, @timestamp)
+    response = @client.post_event(@collection, @key, @event_type, event, @time)
     assert_equal 204, response.status
+    assert_equal location, response.location
+    assert_equal ref, response.ref
   end
 
   def test_put_event_without_ref
     event = {"msg" => "hello"}
+    ref = "12345"
+    location = ["/v0",@collection,@key,'events',@event_type,@timestamp,@ordinal].join('/')
     @stubs.put("/v0/#{@collection}/#{@key}/events/#{@event_type}/#{@timestamp}/#{@ordinal}") do |env|
       assert_authorization @basic_auth, env
       assert_equal event.to_json, env.body
-      [204, response_headers, '']
+      headers = { "Etag" => "\"#{ref}\"", "Location" => location }
+      [204, response_headers(headers), '']
     end
-    response = @client.put_event(@collection, @key, @event_type, @timestamp, @ordinal, event)
+    response = @client.put_event(@collection, @key, @event_type, @time, @ordinal, event)
     assert_equal 204, response.status
+    assert_equal location, response.location
+    assert_equal ref, response.ref
   end
 
   def test_put_event_with_ref
     event = {"msg" => "hello"}
     ref = "12345"
-    path = ['v0', @collection, @key, 'events', @event_type, @timestamp, @ordinal]
+    new_ref = "abcde"
+    path = ['/v0', @collection, @key, 'events', @event_type, @timestamp, @ordinal]
     @stubs.put(path.join("/")) do |env|
       assert_authorization @basic_auth, env
       assert_header 'If-Match', "\"#{ref}\"", env
       assert_equal event.to_json, env.body
-      [204, response_headers, '']
+      headers = { "Etag" => "\"#{new_ref}\"", "Location" => path.join('/') }
+      [204, response_headers(headers), '']
     end
-    response = @client.put_event(@collection, @key, @event_type, @timestamp, @ordinal, event, ref)
+    response = @client.put_event(@collection, @key, @event_type, @time, @ordinal, event, ref)
     assert_equal 204, response.status
+    assert_equal new_ref, response.ref
+    assert_equal path.join('/'), response.location
   end
 
   def test_purge_event_without_ref
@@ -80,8 +135,9 @@ class EventTest < MiniTest::Unit::TestCase
       assert_equal 'true', env.params['purge']
       [204, response_headers, '']
     end
-    response = @client.purge_event(@collection, @key, @event_type, @timestamp, @ordinal)
+    response = @client.purge_event(@collection, @key, @event_type, @time, @ordinal)
     assert_equal 204, response.status
+    assert_equal response.headers['X-Orchestrate-Req-Id'], response.request_id
   end
 
   def test_purge_event_with_ref
@@ -93,12 +149,14 @@ class EventTest < MiniTest::Unit::TestCase
       assert_equal 'true', env.params['purge']
       [204, response_headers, '']
     end
-    response = @client.purge_event(@collection, @key, @event_type, @timestamp, @ordinal, ref)
+    response = @client.purge_event(@collection, @key, @event_type, @time, @ordinal, ref)
     assert_equal 204, response.status
+    assert_equal response.headers['X-Orchestrate-Req-Id'], response.request_id
   end
 
   def test_list_events_without_timestamp
-    body = { "results" => [], "count" => 0, "next" => "" }
+    body = { "results" => [{"path"=>{}, "value"=>{}, "timestamp"=>"", "ordinal"=>0}],
+             "count" => 0, "next" => "__NEXT__" }
     @stubs.get("/v0/#{@collection}/#{@key}/events/#{@event_type}") do |env|
       assert_authorization @basic_auth, env
       assert_accepts_json env
@@ -108,26 +166,33 @@ class EventTest < MiniTest::Unit::TestCase
     response = @client.list_events(@collection, @key, @event_type)
     assert_equal 200, response.status
     assert_equal body, response.body
+    assert_equal body['count'], response.count
+    assert_equal body['results'], response.results
+    assert_equal body['next'], response.next_link
   end
 
   def test_list_events_with_timestamp
     end_time = Time.now
     start_time = end_time - (24 * 3600)
-    body = { "results" => [], "count" => 0, "next" => "" }
+    body = { "results" => [{"path"=>{}, "value"=>{}, "timestamp"=>"", "ordinal"=>0}],
+             "count" => 1, "next" => "__NEXT__" }
 
     @stubs.get("/v0/#{@collection}/#{@key}/events/#{@event_type}") do |env|
       assert_authorization @basic_auth, env
       assert_accepts_json env
-      assert_equal start_time.to_i.to_s, env.params['startEvent']
-      assert_equal end_time.to_i.to_s, env.params['endEvent']
+      assert_equal (start_time.to_f * 1000).to_i.to_s, env.params['startEvent']
+      assert_equal (end_time.to_f * 1000).to_i.to_s, env.params['endEvent']
       assert_equal ['startEvent', 'endEvent'].sort, env.params.keys.sort
       [200, response_headers, body.to_json]
     end
     response = @client.list_events(@collection, @key, @event_type,
-      { start: start_time.to_i, end: end_time.to_i }
-    )
+                { start: start_time, end: end_time })
     assert_equal 200, response.status
     assert_equal body, response.body
+    assert_equal body['results'], response.results
+    assert_equal body['count'], response.count
+    assert_equal body['next'], response.next_link
+    assert_nil response.prev_link
   end
 
 end

data/test/orchestrate/api/exceptions_test.rb

@@ -0,0 +1,172 @@
+require_relative '../../test_helper'
+
+class ExceptionsTest < MiniTest::Unit::TestCase
+  def setup
+    @client, @stubs, @basic_auth = make_client_and_artifacts
+  end
+
+  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 ]
+    end
+    assert_raises Orchestrate::API::Unauthorized do
+      @client.list(:foo)
+    end
+  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
+      @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
+    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
+    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
+    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
+    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
+    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
+    assert_raises Orchestrate::API::AlreadyPresent do
+      @client.put_if_absent(:foo, 'bar', {foo:'bar'})
+    end
+  end
+
+  def test_raises_on_unexpected_response_error
+    @stubs.get("/v0/teapot/spout") do |env|
+      [ 418, response_headers, {
+        message: "I'm a little teapot",
+        code: "teapot"
+      }.to_json ]
+    end
+    assert_raises Orchestrate::API::RequestError do
+      @client.get(:teapot, "spout")
+    end
+  end
+
+  def test_raises_on_security_authentication
+    @stubs.get("/v0/test/123") do |env|
+      [ 500, response_headers, {
+        message: "An error occurred while trying to authenticate.",
+        code: "security_authentication"
+      }.to_json ]
+    end
+    assert_raises Orchestrate::API::SecurityAuthentication do
+      @client.get(:test, '123')
+    end
+  end
+
+  def test_raises_on_search_index_not_found
+    @stubs.get("/v0/test") do |env|
+      [ 500, response_headers, {
+        message: "Index could not be queried for this application.",
+        code: "search_index_not_found"
+      }.to_json ]
+    end
+    assert_raises Orchestrate::API::SearchIndexNotFound do
+      @client.search(:test, '123')
+    end
+  end
+
+  def test_raises_on_internal_error
+    @stubs.get("/v0/test/123") do |env|
+      [ 500, response_headers, {
+        message: "Internal Error.",
+        code: "internal_error"
+      }.to_json ]
+    end
+    assert_raises Orchestrate::API::InternalError do
+      @client.get(:test, '123')
+    end
+  end
+
+  def test_raises_on_generic_500_error
+    body = "The bees, they're in my eyes"
+    @stubs.get("/v0/test/123") do |env|
+      [ 500, {}, body ]
+    end
+    err = assert_raises Orchestrate::API::ServiceError do
+      @client.get(:test, '123')
+    end
+    assert_equal body, err.message
+  end
+end
+

data/test/orchestrate/api/graph_test.rb

@@ -21,6 +21,8 @@ class GraphTest < MiniTest::Unit::TestCase
     response = @client.get_relations(@collection, @key, @kind, @kind)
     assert_equal 200, response.status
     assert_equal body, response.body
+    assert_equal body['count'], response.count
+    assert_equal body['results'], response.results
   end
 
   def test_put_graph
@@ -30,6 +32,7 @@ class GraphTest < MiniTest::Unit::TestCase
     end
     response = @client.put_relation(@collection, @key, @kind, @target_collection, @target_key)
     assert_equal 204, response.status
+    assert_equal response.headers['X-Orchestrate-Req-Id'], response.request_id
   end
 
   def test_delete_graph
@@ -40,5 +43,6 @@ class GraphTest < MiniTest::Unit::TestCase
     end
     response = @client.delete_relation(@collection, @key, @kind, @target_collection, @target_key)
     assert_equal 204, response.status
+    assert_equal response.headers['X-Orchestrate-Req-Id'], response.request_id
   end
 end

data/test/orchestrate/api/key_value_test.rb

@@ -27,6 +27,11 @@ class KeyValueTest < MiniTest::Unit::TestCase
 
     assert_equal "\"#{ref}\"", response.headers['Etag']
     assert_equal ref_url, response.headers['Content-Location']
+
+    assert_equal ref_url, response.location
+    assert_equal ref, response.ref
+    assert_equal Time.parse(response.headers['Date']), response.request_time
+    assert_equal response.headers['X-Orchestrate-Req-Id'], response.request_id
   end
 
   def test_gets_key_value_is_404_when_does_not_exist
@@ -36,22 +41,28 @@ class KeyValueTest < MiniTest::Unit::TestCase
       [ 404, response_headers(), response_not_found({collection:@collection, key:@key}) ]
     end
 
-    response = @client.get(@collection, @key)
-    assert_equal 404, response.status
-    assert_equal 'items_not_found', response.body['code']
+    assert_raises Orchestrate::API::NotFound do
+      @client.get(@collection, @key)
+    end
   end
 
   def test_puts_key_value_without_ref
     body={"foo" => "bar"}
-    @stubs.put("/v0/#{@collection}/#{@key}") do |env|
+    ref = "12345"
+    base_location = "/v0/#{@collection}/#{@key}"
+    @stubs.put(base_location) do |env|
       assert_authorization @basic_auth, env
       assert_header 'Content-Type', 'application/json', env
       assert_equal body.to_json, env.body
-      [ 201, response_headers, '' ]
+      headers = { "Location" => "#{base_location}/refs/#{ref}", 
+                  "Etag" => "\"#{ref}\"" }
+      [ 201, response_headers(headers), '' ]
     end
 
     response = @client.put(@collection, @key, body)
     assert_equal 201, response.status
+    assert_equal ref, response.ref
+    assert_equal "#{base_location}/refs/#{ref}", response.location
   end
 
   def test_puts_key_value_with_specific_ref
@@ -122,6 +133,7 @@ class KeyValueTest < MiniTest::Unit::TestCase
     end
     response = @client.delete(@collection, @key)
     assert_equal 204, response.status
+    assert_equal response.headers['X-Orchestrate-Req-Id'], response.request_id
   end
 
   def test_delete_key_value_with_condition
@@ -154,20 +166,53 @@ class KeyValueTest < MiniTest::Unit::TestCase
     end
     response = @client.purge(@collection, @key)
     assert_equal 204, response.status
+    assert_equal response.headers['X-Orchestrate-Req-Id'], response.request_id
   end
 
   def test_gets_ref
     body = {"key" => "value"}
     ref = '123456'
-    @stubs.get("/v0/#{@collection}/#{@key}/refs/#{ref}") do |env|
+    ref_url = "/v0/#{@collection}/#{@key}/refs/#{ref}"
+    @stubs.get(ref_url) do |env|
       assert_authorization @basic_auth, env
       assert_accepts_json env
-      [ 200, response_headers, body.to_json ]
+      headers = {
+        'Content-Location' => ref_url,
+        'Etag' => "\"#{ref}\""
+      }
+      [ 200, response_headers(headers), body.to_json ]
     end
 
     response = @client.get(@collection, @key, ref)
     assert_equal 200, response.status
     assert_equal body, response.body
+
+    assert_equal ref_url, response.location
+    assert_equal ref, response.ref
+    assert_equal Time.parse(response.headers['Date']), response.request_time
+    assert_equal response.headers['X-Orchestrate-Req-Id'], response.request_id
+  end
+
+  def test_list_refs
+    reflist = (1..3).map do |i|
+      { "path" => {}, "reftime" => Time.now.to_i - (-2 * i * 3600 * 1000) }
+    end
+    body = { "results" => reflist, "count" => 3, "prev" => "__PREV__" }
+
+    @stubs.get("/v0/#{@collection}/#{@key}/refs") do |env|
+      assert_authorization @basic_auth, env
+      assert_accepts_json env
+      assert_equal "10", env.params['offset']
+      [ 200, response_headers, body.to_json ]
+    end
+
+    response = @client.list_refs(@collection, @key, {offset: 10})
+    assert_equal 200, response.status
+    assert_equal body, response.body
+    assert_equal body['count'], response.count
+    assert_equal body['results'], response.results
+    assert_equal body['prev'], response.prev_link
+    assert_nil response.next_link
   end
 
 end