rummageable 0.6.2 → 1.0.0

data/lib/rummageable/version.rb

@@ -1,3 +1,3 @@
 module Rummageable
-  VERSION = "0.6.2"
+  VERSION = "1.0.0"
 end

data/lib/rummageable.rb

@@ -1,76 +1,97 @@
-require "rest_client"
-require "json"
-require "plek"
+require 'benchmark'
+require 'json'
 
-require "rummageable/implementation"
-require "rummageable/fake"
+require 'multi_json'
+require 'null_logger'
+require 'rest_client'
 
-module Rummageable
 
-  InvalidDocument = Class.new(RuntimeError)
-  CHUNK_SIZE = 20
+module Rummageable
+  class Index
+    def initialize(base_url, index_name, options = {})
+      @index_url = [base_url, index_name.sub(%r{^/}, '')].join('/')
+      @logger = options[:logger] || NullLogger.instance
+      @batch_size = options.fetch(:batch_size, 20)
+      @retry_delay = options.fetch(:retry_delay, 2)
+      @attempts = options.fetch(:attempts, 3)
+    end
 
-  attr_writer :rummager_service_name
-  def rummager_service_name
-    @rummager_service_name || "search"
-  end
+    def add(entry)
+      repeatedly do
+        make_request(:post, documents_url, MultiJson.encode([entry]))
+      end
+    end
 
-  attr_writer :rummager_host
-  def rummager_host
-    @rummager_host || Plek.current.find(rummager_service_name)
-  end
+    def add_batch(entries)
+      entries.each_slice(@batch_size) do |batch|
+        repeatedly do
+          make_request(:post, documents_url, MultiJson.encode(batch))
+        end
+      end
+    end
 
-  attr_writer :default_index
-  def default_index
-    @default_index || ""
-  end
+    def amend(link, changes)
+      repeatedly do
+        make_request(:post, documents_url(link: link), changes)
+      end
+    end
 
-  attr_writer :implementation
-  def implementation
-    @implementation ||= Implementation.new
-  end
+    def delete(link)
+      repeatedly do
+        make_request(:delete, documents_url(link: link))
+      end
+    end
 
-  # documents must be either a hash (for one document) or an array of hashes
-  # (for multiple documents)
-  #
-  def index(documents, index_name = default_index)
-    implementation.index(documents, index_name)
-  end
+    def delete_all
+      repeatedly do
+        make_request(:delete, documents_url + '?delete_all=1')
+      end
+    end
 
-  def delete(link, index_name = default_index)
-    implementation.delete(link, index_name)
-  end
+    def commit
+      repeatedly do
+        make_request(:post, [@index_url, 'commit'].join('/'), MultiJson.encode({}))
+      end
+    end
 
-  def delete_all(index_name = default_index)
-    implementation.delete_all(index_name)
-  end
+    private
+    def repeatedly(&block)
+      @attempts.times do |i|
+        begin
+          return yield
+        rescue RestClient::RequestFailed, RestClient::RequestTimeout, RestClient::ServerBrokeConnection => e
+          @logger.warn e.message
+          raise if @attempts == i + 1
+          @logger.info 'Retrying...'
+          sleep(@retry_delay) if @retry_delay
+        end
+      end
+    end
 
-  def amend(link, amendments, index_name = default_index)
-    implementation.amend(link, amendments, index_name)
-  end
+    def log_request(method, url, payload = nil)
+      @logger.info("Rummageable request: #{method.upcase} #{url}")
+    end
 
-  def commit(index_name = default_index)
-    implementation.commit(index_name)
-  end
+    def log_response(method, url, call_time, response)
+      time = sprintf('%.03f', call_time)
+      result = JSON.parse(response).fetch('result', 'UNKNOWN')
+      @logger.info("Rummageable response: #{method.upcase} #{url} - time: #{time}s, result: #{result}")
+    end
 
-  VALID_KEYS = [
-    %w[title],
-    %w[description],
-    %w[format],
-    %w[section],
-    %w[subsection],
-    %w[subsubsection],
-    %w[link],
-    %w[indexable_content],
-    %w[boost_phrases],
-    %w[additional_links title],
-    %w[additional_links link],
-    %w[additional_links link_order],
-  ]
+    def make_request(method, *args)
+      response = nil
+      log_request(method, *args)
+      call_time = Benchmark.realtime do
+        response = RestClient.send(method, *args, content_type: :json, accept: :json)
+      end
+      log_response(method, args.first, call_time, response)
+      response
+    end
 
-  def validate_structure(hash, parents=[])
-    implementation.validate_structure(hash, parents)
+    def documents_url(options = {})
+      parts = [@index_url, 'documents']
+      parts << CGI.escape(options[:link]) if options[:link]
+      parts.join('/')
+    end
   end
-
-  extend self
 end

data/test/add_test.rb

@@ -0,0 +1,107 @@
+require 'test_helper'
+
+class AddTest < MiniTest::Unit::TestCase
+  def build_document(index)
+    {
+      'title' => "TITLE #{index}",
+      'link' => "/link#{index}"
+    }
+  end
+
+  def one_document
+    build_document(1)
+  end
+
+  def two_documents
+    [one_document] << build_document(2)
+  end
+
+  def stub_successful_request
+    stub_request(:post, documents_url).to_return(status(200))
+  end
+
+  def stub_one_failed_request
+    stub_request(:post, documents_url).
+      to_return(status(502)).times(1).then.to_return(status(200))
+  end
+
+  def stub_repeatedly_failing_requests(failures)
+    stub_request(:post, documents_url).to_return(status(502)).times(failures)
+  end
+
+  def test_add_should_index_a_single_document_by_posting_it_as_json
+    stub_successful_request
+    index = Rummageable::Index.new(rummager_url, index_name)
+    index.add(one_document)
+    assert_requested :post, documents_url, times: 1 do |request|
+      request.body == json_for([one_document]) &&
+        request.headers['Content-Type'] == 'application/json' &&
+        request.headers['Accept'] == 'application/json'
+    end
+  end
+
+  def test_add_batch_should_index_multiple_documents_in_one_request
+    stub_successful_request
+    index = Rummageable::Index.new(rummager_url, index_name)
+    index.add_batch(two_documents)
+    assert_requested :post, documents_url, body: json_for(two_documents)
+  end
+
+  def test_add_batch_should_split_large_batches_into_multiple_requests
+    stub_successful_request
+    documents = (1..3).map { |i| build_document(i) }
+    index = Rummageable::Index.new(rummager_url, index_name, batch_size: 2)
+    index.add_batch(documents)
+    assert_requested :post, documents_url, body: json_for(documents[0, 2])
+    assert_requested :post, documents_url, body: json_for(documents[2, 1])
+  end
+
+  def test_add_should_return_true_when_successful
+    stub_successful_request
+    index = Rummageable::Index.new(rummager_url, index_name)
+    assert index.add(one_document), 'should return true on success'
+  end
+
+  def test_add_should_sleep_and_retry_on_bad_gateway_errors
+    stub_one_failed_request
+    Rummageable::Index.any_instance.expects(:sleep).with(1)
+    index = Rummageable::Index.new(rummager_url, index_name, retry_delay: 1)
+    assert index.add(one_document), 'should return true on success'
+    assert_requested :post, documents_url, times: 2
+  end
+
+  def test_add_should_not_sleep_between_attempts_if_retry_delay_nil
+    stub_one_failed_request
+    Rummageable::Index.any_instance.expects(:sleep).never
+    index = Rummageable::Index.new(rummager_url, index_name, retry_delay: nil)
+    index.add(one_document)
+    assert_requested :post, documents_url, times: 2
+  end
+
+  def test_add_should_propogate_exceptions_after_too_many_failed_attempts
+    failures = attempts = 2
+    stub_repeatedly_failing_requests(failures)
+    Rummageable::Index.any_instance.stubs(:sleep)
+    index = Rummageable::Index.new(rummager_url, index_name, attempts: attempts)
+    assert_raises RestClient::BadGateway do
+      index.add(one_document)
+    end
+  end
+
+  def test_add_should_log_attempts_to_post_to_rummager
+    stub_successful_request
+    logger = stub('logger', debug: true)
+    logger.expects(:info).twice
+    index = Rummageable::Index.new(rummager_url, index_name, logger: logger)
+    index.add(one_document)
+  end
+
+  def test_add_should_log_failures
+    stub_one_failed_request
+    Rummageable::Index.any_instance.stubs(:sleep)
+    logger = stub('logger', debug: true, info: true)
+    logger.expects(:warn).once
+    index = Rummageable::Index.new(rummager_url, index_name, logger: logger)
+    index.add(one_document)
+  end
+end

data/test/amend_test.rb

@@ -0,0 +1,15 @@
+require 'test_helper'
+
+class AmendTest < MiniTest::Unit::TestCase
+  def link
+    '/path'
+  end
+
+  def test_should_post_amendments_to_a_document_by_its_link
+    new_document = { 'title' => 'Cheese', 'indexable_content' => 'Blah' }
+    stub_request(:post, link_url).with(body: new_document).to_return(status(200))
+    index = Rummageable::Index.new(rummager_url, index_name)
+    index.amend(link, { 'title' => 'Cheese', 'indexable_content' => 'Blah' })
+    assert_requested :post, link_url, body: new_document
+  end
+end

data/test/commit_test.rb

@@ -0,0 +1,14 @@
+require 'test_helper'
+
+class CommitTest < MiniTest::Unit::TestCase
+  def commit_url
+    [rummager_url, index_name, 'commit'].join('/')
+  end
+
+  def test_commit_should_post_to_rummager
+    stub_request(:post, commit_url).to_return(status(200))
+    index = Rummageable::Index.new(rummager_url, index_name)
+    index.commit
+    assert_requested :post, commit_url, body: json_for({})
+  end
+end

data/test/delete_test.rb

@@ -0,0 +1,52 @@
+require 'test_helper'
+
+class DeleteTest < MiniTest::Unit::TestCase
+  def link
+    'http://example.com/foo'
+  end
+
+  def stub_successful_delete_request
+    stub_request(:delete, link_url).to_return(status(200))
+  end
+
+  def stub_one_failed_delete_request
+    stub_request(:delete, link_url).
+      to_return(status(502)).times(1).then.to_return(status(200))
+  end
+
+  def test_should_delete_a_document_by_its_link
+    stub_successful_delete_request
+    index = Rummageable::Index.new(rummager_url, index_name)
+    index.delete(link)
+    assert_requested :delete, link_url do |request|
+      request.headers['Content-Type'] == 'application/json' &&
+        request.headers['Accept'] == 'application/json'
+    end
+  end
+
+  def test_should_be_able_to_delete_all_documents
+    stub_request(:delete, /#{documents_url}/).to_return(status(200))
+    index = Rummageable::Index.new(rummager_url, index_name)
+    index.delete_all
+    assert_requested :delete, documents_url, query: { delete_all: 1 } do |request|
+      request.headers['Content-Type'] == 'application/json' &&
+        request.headers['Accept'] == 'application/json'
+    end
+  end
+
+  def test_delete_should_handle_connection_errors
+    stub_one_failed_delete_request
+    Rummageable::Index.any_instance.expects(:sleep).once
+    index = Rummageable::Index.new(rummager_url, index_name)
+    index.delete(link)
+    assert_requested :delete, link_url, times: 2
+  end
+
+  def test_delete_should_log_attempts_to_delete_documents_from_rummager
+    stub_successful_delete_request
+    logger = stub('logger')
+    logger.expects(:info).twice
+    index = Rummageable::Index.new(rummager_url, index_name, logger: logger)
+    index.delete(link)
+  end
+end

metadata

@@ -2,7 +2,7 @@
 name: rummageable
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 0.6.2
+  version: 1.0.0
 platform: ruby
 authors: 
 - GovUK Beta Team
@@ -10,10 +10,10 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2013-01-10 00:00:00 Z
+date: 2013-07-15 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
-  name: json
+  name: multi_json
   requirement: &id001 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
@@ -24,7 +24,7 @@ dependencies:
   prerelease: false
   version_requirements: *id001
 - !ruby/object:Gem::Dependency 
-  name: rest-client
+  name: null_logger
   requirement: &id002 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
@@ -35,29 +35,29 @@ dependencies:
   prerelease: false
   version_requirements: *id002
 - !ruby/object:Gem::Dependency 
-  name: plek
+  name: rest-client
   requirement: &id003 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        version: 0.5.0
+        version: "0"
   type: :runtime
   prerelease: false
   version_requirements: *id003
 - !ruby/object:Gem::Dependency 
-  name: rake
+  name: gem_publisher
   requirement: &id004 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
-    - - ">="
+    - - "="
       - !ruby/object:Gem::Version 
-        version: "0"
+        version: 1.0.0
   type: :development
   prerelease: false
   version_requirements: *id004
 - !ruby/object:Gem::Dependency 
-  name: webmock
+  name: mocha
   requirement: &id005 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
@@ -68,16 +68,38 @@ dependencies:
   prerelease: false
   version_requirements: *id005
 - !ruby/object:Gem::Dependency 
-  name: gem_publisher
+  name: rake
   requirement: &id006 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
-    - - "="
+    - - ">="
       - !ruby/object:Gem::Version 
-        version: 1.0.0
+        version: "0"
   type: :development
   prerelease: false
   version_requirements: *id006
+- !ruby/object:Gem::Dependency 
+  name: webmock
+  requirement: &id007 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :development
+  prerelease: false
+  version_requirements: *id007
+- !ruby/object:Gem::Dependency 
+  name: yajl-ruby
+  requirement: &id008 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - "="
+      - !ruby/object:Gem::Version 
+        version: 1.1.0
+  type: :development
+  prerelease: false
+  version_requirements: *id008
 description: Mediator for apps that want their content to be in the search index
 email: 
 executables: []
@@ -87,11 +109,12 @@ extensions: []
 extra_rdoc_files: []
 
 files: 
-- lib/rummageable/implementation.rb
-- lib/rummageable/fake.rb
 - lib/rummageable/version.rb
 - lib/rummageable.rb
-- test/rummageable_test.rb
+- test/commit_test.rb
+- test/delete_test.rb
+- test/add_test.rb
+- test/amend_test.rb
 homepage: https://github.com/alphagov/rummageable
 licenses: []
 
@@ -105,7 +128,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: -4255739336630407155
+      hash: 3448417689166380779
       segments: 
       - 0
       version: "0"
@@ -114,7 +137,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: -4255739336630407155
+      hash: 3448417689166380779
       segments: 
       - 0
       version: "0"
@@ -126,4 +149,7 @@ signing_key:
 specification_version: 3
 summary: Mediator for apps that want their content to be in the search index
 test_files: 
-- test/rummageable_test.rb
+- test/commit_test.rb
+- test/delete_test.rb
+- test/add_test.rb
+- test/amend_test.rb

data/lib/rummageable/fake.rb

@@ -1,18 +0,0 @@
-module Rummageable
-  class Fake
-    def index(documents, index_name)
-    end
-
-    def delete(link, index_name)
-    end
-
-    def amend(link, amendments, index_name)
-    end
-
-    def commit(index_name)
-    end
-
-    def validate_structure(hash, parents=[])
-    end
-  end
-end

data/lib/rummageable/implementation.rb

@@ -1,64 +0,0 @@
-module Rummageable
-  class Implementation
-    def index(documents, index_name)
-      documents = documents.is_a?(Hash) ? [documents] : documents
-      url = Rummageable.rummager_host + index_name + "/documents"
-      documents.each_slice(CHUNK_SIZE).each do |slice|
-        slice.each do |document|
-          validate_structure document
-        end
-        body = JSON.dump(slice)
-        RestClient.post url, body, content_type: :json, accept: :json
-      end
-    end
-
-    def amend(link, amendments, index_name)
-      validate_structure amendments
-      RestClient.post url_for(link, index_name), amendments
-    end
-
-    def delete(link, index_name)
-      RestClient.delete url_for(link, index_name), content_type: :json, accept: :json
-    end
-
-    def delete_all(index_name)
-      url = Rummageable.rummager_host + index_name + "/documents?delete_all=1"
-      RestClient.delete url, content_type: :json, accept: :json
-    end
-
-    def commit(index_name)
-      url = Rummageable.rummager_host + index_name + "/commit"
-      RestClient.post url, {}
-    end
-
-    def validate_structure(hash, parents=[])
-      hash.each do |key, value|
-        full_key = parents + [key]
-        case value
-        when Array
-          value.each do |el|
-            validate_structure el, full_key
-          end
-        when Hash
-          validate_structure value, full_key
-        else
-          raise InvalidDocument unless VALID_KEYS.include?(full_key)
-        end
-      end
-    end
-
-  private
-
-    def url_components(index_name)
-      [Rummageable.rummager_host, index_name, "/documents/"]
-    end
-
-    def url_for(link, index_name)
-      (url_components(index_name) << CGI.escape(link)).join
-    end
-
-    def unescaped_url_for(link, index_name)
-      (url_components(index_name) << link).join
-    end
-  end
-end

data/test/rummageable_test.rb

@@ -1,227 +0,0 @@
-require "minitest/autorun"
-require "webmock/minitest"
-require "rummageable"
-ENV["RACK_ENV"] = "test"
-
-class RummageableTest < MiniTest::Unit::TestCase
-  API = Plek.current.find("search")
-
-  def test_should_index_a_single_document_by_posting_it_as_json
-    document = {
-      "title" => "TITLE",
-      "description" => "DESCRIPTION",
-      "format" => "NAME OF FORMAT",
-      "section" => "NAME OF SECTION",
-      "subsection" => "NAME OF SUBSECTION",
-      "subsubsection" => "NAME OF SUBSUBSECTION",
-      "link" => "/link",
-      "indexable_content" => "TEXT",
-      "boost_phrases" => "BOOST",
-      "additional_links" => [
-        {"title" => "LINK1", "link" => "/link1"},
-        {"title" => "LINK2", "link" => "/link2"},
-      ]
-    }
-    json = JSON.dump([document])
-
-    stub_request(:post, "#{API}/documents").
-      with(body: json).
-      to_return(status: 200, body: '{"status":"OK"}')
-
-    Rummageable.index(document)
-  end
-
-  def test_should_index_multiple_documents_by_posting_them_as_json
-    documents = [
-      {"title" => "DOC1"},
-      {"title" => "DOC2"}
-    ]
-    json = JSON.dump(documents)
-
-    stub_request(:post, "#{API}/documents").
-      with(body: json).
-      to_return(status: 200, body: '{"status":"OK"}')
-
-    Rummageable.index(documents)
-  end
-
-  def test_should_send_documents_in_batches_of_20
-    documents = 21.times.map { |i| {"title" => "DOC#{i}"} }
-
-    stub_request(:post, "#{API}/documents").
-      to_return(status: 200, body: '{"status":"OK"}')
-
-    Rummageable.index(documents)
-    assert_requested :post, "#{API}/documents", body: JSON.dump(documents[0, 20])
-    assert_requested :post, "#{API}/documents", body: JSON.dump(documents[20, 1])
-  end
-
-  def test_should_raise_an_exception_if_a_document_has_symbol_keys
-    document = {title: "TITLE"}
-    assert_raises Rummageable::InvalidDocument do
-      Rummageable.index(document)
-    end
-  end
-
-  def test_should_raise_an_exception_if_a_document_has_unrecognised_keys
-    document = {"foo" => "bar"}
-    assert_raises Rummageable::InvalidDocument do
-      Rummageable.index(document)
-    end
-  end
-
-  def test_should_raise_an_exception_if_a_document_has_unrecognised_nested_keys
-    document = {
-      "additional_links" => [
-        {"foo" => "bar"}
-      ]
-    }
-    assert_raises Rummageable::InvalidDocument do
-      Rummageable.index(document)
-    end
-  end
-
-  def test_allows_indexing_to_an_alternative_index
-    document = {
-      "title" => "TITLE",
-      "description" => "DESCRIPTION",
-      "format" => "NAME OF FORMAT",
-      "section" => "NAME OF SECTION",
-      "subsection" => "NAME OF SUBSECTION",
-      "link" => "/link",
-      "indexable_content" => "TEXT",
-      "boost_phrases" => "BOOST",
-      "additional_links" => [
-        {"title" => "LINK1", "link" => "/link1"},
-        {"title" => "LINK2", "link" => "/link2"},
-      ]
-    }
-    json = JSON.dump([document])
-
-    stub_request(:post, "#{API}/alternative/documents").
-      with(body: json).
-      to_return(status: 200, body: '{"status":"OK"}')
-
-    Rummageable.index(document, "/alternative")
-  end
-
-  def test_should_post_to_rummageable_host_determined_by_rummager_service_name
-    document = {"title" => "TITLE"}
-    stub_request(:post, "#{API}/documents")
-    stub_request(:post, "#{Plek.current.find("whitehall-search")}/documents")
-    with_rummager_service_name("whitehall-search") do
-      Rummageable.index(document)
-    end
-    assert_not_requested(:post, "#{API}/documents")
-    assert_requested(:post, "#{Plek.current.find("whitehall-search")}/documents")
-  end
-
-  def test_should_delete_a_document_by_its_link
-    link = "http://example.com/foo"
-
-    stub_request(:delete, "#{API}/documents/http:%2F%2Fexample.com%2Ffoo").
-      to_return(status: 200, body: '{"status":"OK"}')
-
-    Rummageable.delete(link)
-  end
-
-  def test_should_allow_deletion_from_an_alternative_index
-    link = "http://example.com/foo"
-
-    stub_request(:delete, "#{API}/alternative/documents/http:%2F%2Fexample.com%2Ffoo").
-      to_return(status: 200, body: '{"status":"OK"}')
-
-    Rummageable.delete(link, '/alternative')
-  end
-
-  def test_should_allow_delete_all
-    stub_request(:delete, "#{API}/documents?delete_all=1").
-      to_return(status: 200, body: '{"status":"OK"}')
-
-    Rummageable.delete_all
-  end
-
-  def test_should_allow_delete_all_from_an_alternative_index
-    stub_request(:delete, "#{API}/alternative/documents?delete_all=1").
-      to_return(status: 200, body: '{"status":"OK"}')
-
-    Rummageable.delete_all('/alternative')
-  end
-
-  def test_should_post_amendments
-    stub_request(:post, "#{API}/documents/%2Ffoobang").
-      with(body: {"title" => "Cheese", "indexable_content" => "Blah"}).
-      to_return(status: 200, body: '{"status":"OK"}')
-
-    Rummageable.amend("/foobang", {"title" => "Cheese", "indexable_content" => "Blah"})
-  end
-
-  def test_should_reject_unknown_amendments
-    stub_request(:post, "#{API}/documents/%2Ffoobang").
-      to_return(status: 200, body: '{"status":"OK"}')
-
-    assert_raises Rummageable::InvalidDocument do
-      Rummageable.amend("/foobang", {"title" => "Cheese", "face" => "Blah"})
-    end
-
-    assert_not_requested :any, "#{API}/documents/%2Ffoobang"
-  end
-
-  def test_should_fail_amendments_with_symbols
-    stub_request(:post, "#{API}/documents/%2Ffoobang").
-      to_return(status: 200, body: '{"status":"OK"}')
-
-    assert_raises Rummageable::InvalidDocument do
-      Rummageable.amend("/foobang", {title: "Cheese"})
-    end
-
-    assert_not_requested :any, "#{API}/documents/%2Ffoobang"
-  end
-
-  def test_should_delete_to_rummageable_host_determined_by_rummager_service_name
-    link = "http://example.com/foo"
-    stub_request(:delete, "#{API}/documents/http:%2F%2Fexample.com%2Ffoo")
-    stub_request(:delete, "#{Plek.current.find("whitehall-search")}/documents/http:%2F%2Fexample.com%2Ffoo")
-    with_rummager_service_name("whitehall-search") do
-      Rummageable.delete(link)
-    end
-    assert_not_requested(:delete, "#{API}/#{API}/documents/http:%2F%2Fexample.com%2Ffoo")
-    assert_requested(:delete, "#{Plek.current.find("whitehall-search")}/documents/http:%2F%2Fexample.com%2Ffoo")
-  end
-
-  def test_should_defer_to_plek_for_the_location_of_the_rummager_host
-    assert_equal Plek.current.find("search"), Rummageable.rummager_host
-  end
-
-  def test_should_allow_the_rummager_host_to_be_set_manually_so_that_we_can_connect_to_rummager_running_at_arbitrary_locations
-    Rummageable.rummager_host = "http://example.com"
-    assert_equal "http://example.com", Rummageable.rummager_host
-    ensure
-      Rummageable.rummager_host = nil
-  end
-
-  def test_should_commit_to_rummmageable_host
-    stub_request(:post, "#{API}/commit").
-      to_return(status: 200, body: '{"result":"OK"}')
-
-    Rummageable.commit
-  end
-
-  def test_should_allow_committing_an_alternative_index
-    stub_request(:post, "#{API}/alternative/commit").
-      to_return(status: 200, body: '{"result":"OK"}')
-
-    Rummageable.commit '/alternative'
-  end
-
-  private
-
-  def with_rummager_service_name(service_name)
-    original_rummager_service_name = Rummageable.rummager_service_name
-    Rummageable.rummager_service_name = "whitehall-search"
-    yield
-  ensure
-    Rummageable.rummager_service_name = original_rummager_service_name
-  end
-
-end