swiftype 1.1.0 → 1.2.0

data/spec/client_spec.rb

@@ -13,27 +13,27 @@ describe Swiftype::Client do
       it 'searches all DocumentTypes in the engine' do
         VCR.use_cassette(:engine_search) do
           results = client.search(engine_slug, 'cat')
-          results.document_types.size.should == 2
-          results['videos'].size.should == 2
-          results['channels'].size.should == 1
+          expect(results.document_types.size).to eq(2)
+          expect(results['videos'].size).to eq(2)
+          expect(results['channels'].size).to eq(1)
         end
       end
 
       it 'searches the engine with options' do
         VCR.use_cassette(:engine_search_pagination) do
           results = client.search(engine_slug, 'cat', {:page => 2})
-          results.document_types.size.should == 2
-          results['videos'].size.should == 0
-          results['channels'].size.should == 0
+          expect(results.document_types.size).to eq(2)
+          expect(results['videos'].size).to eq(0)
+          expect(results['channels'].size).to eq(0)
         end
       end
 
       it 'includes facets when requested' do
         VCR.use_cassette(:engine_search_facets) do
           results = client.search(engine_slug, nil, {:facets => {:videos => ['category_id']}})
-          results.document_types.size.should == 2
-          results.facets('channels').should be_empty
-          results.facets('videos')['category_id'].should == {
+          expect(results.document_types.size).to eq(2)
+          expect(results.facets('channels')).to be_empty
+          expect(results.facets('videos')['category_id']).to eq({
             "23" => 4,
             "28" => 2,
             "15" => 2,
@@ -41,7 +41,7 @@ describe Swiftype::Client do
             "22" => 1,
             "2" => 1,
             "10" => 1
-          }
+          })
         end
       end
     end
@@ -52,38 +52,49 @@ describe Swiftype::Client do
       it 'searches only the provided DocumentType' do
         VCR.use_cassette(:document_type_search) do
           results = client.search_document_type(engine_slug, document_type_slug, 'cat')
-          results.document_types.should == ['videos']
-          results['videos'].size.should == 2
+          expect(results.document_types).to eq(['videos'])
+          expect(results['videos'].size).to eq(2)
         end
       end
 
       it 'searches the DocumentType with options' do
         VCR.use_cassette(:document_type_search_pagination) do
           results = client.search_document_type(engine_slug, document_type_slug, 'cat', {:page => 2})
-          results.document_types.should == ['videos']
-          results[document_type_slug].size.should == 0
+          expect(results.document_types).to eq(['videos'])
+          expect(results[document_type_slug].size).to eq(0)
         end
       end
     end
   end
 
+  context 'Options' do
+    let(:options_client) { Swiftype::Client.new(options) }
+
+    context '#request' do
+      let(:options) { { :open_timeout => 3 } }
+      it 'respects the Net::HTTP open_timeout option' do
+        expect(options_client.open_timeout).to eq(3)
+      end
+    end
+  end
+
   context 'Suggest' do
     context '#suggest' do
       it 'does prefix searches for all DocumentTypes in the engine' do
         VCR.use_cassette(:engine_suggest) do
           results = client.suggest(engine_slug, 'goo')
-          results.document_types.size.should == 2
-          results['videos'].size.should == 1
-          results['channels'].size.should == 1
+          expect(results.document_types.size).to eq(2)
+          expect(results['videos'].size).to eq(1)
+          expect(results['channels'].size).to eq(1)
         end
       end
 
       it 'suggests for an engine with options' do
         VCR.use_cassette(:engine_suggest_pagination) do
           results = client.suggest(engine_slug, 'goo', {:page => 2})
-          results.document_types.size.should == 2
-          results['videos'].size.should == 0
-          results['channels'].size.should == 0
+          expect(results.document_types.size).to eq(2)
+          expect(results['videos'].size).to eq(0)
+          expect(results['channels'].size).to eq(0)
         end
       end
     end
@@ -94,16 +105,16 @@ describe Swiftype::Client do
       it 'does a prefix search on the provided DocumentType' do
         VCR.use_cassette(:document_type_suggest) do
           results = client.suggest_document_type(engine_slug, document_type_slug, 'goo')
-          results.document_types.should == ['videos']
-          results['videos'].size.should == 1
+          expect(results.document_types).to eq(['videos'])
+          expect(results['videos'].size).to eq(1)
         end
       end
 
       it 'suggests for a document types with options' do
         VCR.use_cassette(:document_type_suggest_pagination) do
           results = client.suggest_document_type(engine_slug, document_type_slug, 'goo', {:page => 2})
-          results.document_types.should == ['videos']
-          results[document_type_slug].size.should == 0
+          expect(results.document_types).to eq(['videos'])
+          expect(results[document_type_slug].size).to eq(0)
         end
       end
     end
@@ -114,28 +125,28 @@ describe Swiftype::Client do
     it 'gets all engines' do
       VCR.use_cassette(:list_engines) do
         engines = client.engines
-        engines.size.should == 6
+        expect(engines.size).to eq(6)
       end
     end
 
     it 'gets an engine' do
       VCR.use_cassette(:find_engine) do
         engine = client.engine(engine_slug)
-        engine['slug'].should == engine_slug
+        expect(engine['slug']).to eq(engine_slug)
       end
     end
 
     it 'creates engines' do
       VCR.use_cassette(:create_engine) do
         engine = client.create_engine('new engine from spec')
-        engine['slug'].should == 'new-engine-from-spec'
+        expect(engine['slug']).to eq('new-engine-from-spec')
       end
     end
 
     it 'destroys engines' do
       VCR.use_cassette(:destroy_engine) do
         response = client.destroy_engine('new-engine-from-spec')
-        response.should be_nil
+        expect(response).to be_nil
       end
     end
   end
@@ -146,15 +157,15 @@ describe Swiftype::Client do
     it 'gets all document types' do
       VCR.use_cassette(:list_document_type) do
         document_types = client.document_types(engine_slug)
-        document_types.size.should == 2
-        document_types.map { |dt| dt['name'] }.sort.should == ['channels', 'videos']
+        expect(document_types.size).to eq(2)
+        expect(document_types.map { |dt| dt['name'] }.sort).to eq(['channels', 'videos'])
       end
     end
 
     it 'gets a document type' do
       VCR.use_cassette(:find_document_type) do
         document_type = client.document_type(engine_slug, document_type_slug)
-        document_type['slug'].should == document_type_slug
+        expect(document_type['slug']).to eq(document_type_slug)
       end
     end
 
@@ -162,15 +173,15 @@ describe Swiftype::Client do
       VCR.use_cassette(:create_document_type) do
         name = document_type_slug
         document_type = client.create_document_type(engine_slug, 'new_doc_type')
-        document_type['name'].should == 'new_doc_type'
-        document_type['slug'].should == 'new-doc-type'
+        expect(document_type['name']).to eq('new_doc_type')
+        expect(document_type['slug']).to eq('new-doc-type')
       end
     end
 
     it 'destroys document types' do
       VCR.use_cassette(:destroy_document_type) do
         response = client.destroy_document_type(engine_slug, 'new-doc-type')
-        response.should be_nil
+        expect(response).to be_nil
       end
     end
 
@@ -184,6 +195,16 @@ describe Swiftype::Client do
   end
 
   context 'Document' do
+
+    def check_async_response_format(response, options = {})
+      expect(response.keys).to match_array(["document_receipts", "batch_link"])
+      expect(response["document_receipts"]).to be_a_kind_of(Array)
+      expect(response["document_receipts"].first.keys).to match_array(["id", "external_id", "link", "status", "errors"])
+      expect(response["document_receipts"].first["external_id"]).to eq(options[:external_id]) if options[:external_id]
+      expect(response["document_receipts"].first["status"]).to eq(options[:status]) if options[:status]
+      expect(response["document_receipts"].first["errors"]).to eq(options[:errors]) if options[:errors]
+    end
+
     let(:document_type_slug) { 'videos' }
     let(:document_id) { 'FtX8nswnUKU'}
     let(:documents) do
@@ -204,49 +225,49 @@ describe Swiftype::Client do
     it 'lists documents in a document type' do
       VCR.use_cassette(:list_documents) do
         documents = client.documents(engine_slug, document_type_slug)
-        documents.size.should == 2
+        expect(documents.size).to eq(2)
       end
     end
 
     it 'lists documents with pagination' do
       VCR.use_cassette(:list_documents_with_pagination) do
         documents = client.documents(engine_slug, document_type_slug, 2, 2)
-        documents.size.should == 2
+        expect(documents.size).to eq(2)
       end
     end
 
     it 'find a document' do
       VCR.use_cassette(:find_document) do
         document = client.document(engine_slug, document_type_slug, document_id)
-        document['external_id'].should == document_id
+        expect(document['external_id']).to eq(document_id)
       end
     end
 
     it 'creates a document' do
       VCR.use_cassette(:create_document) do
         document = client.create_document(engine_slug, document_type_slug, documents.first)
-        document['external_id'].should == 'INscMGmhmX4'
+        expect(document['external_id']).to eq('INscMGmhmX4')
       end
     end
 
     it 'bulk create multiple documents' do
       VCR.use_cassette(:bulk_create_documents) do
         response = client.create_documents(engine_slug, document_type_slug, documents)
-        response.should == [true, true]
+        expect(response).to eq([true, true])
       end
     end
 
     it 'destroys a document' do
       VCR.use_cassette(:destroy_document) do
         response = client.destroy_document(engine_slug, document_type_slug, 'INscMGmhmX4')
-        response.should be_nil
+        expect(response).to be_nil
       end
     end
 
     it 'destroys multiple documents' do
       VCR.use_cassette(:bulk_destroy_documents) do
         response = client.destroy_documents(engine_slug, document_type_slug, ['INscMGmhmX4', 'XfY9Dsg_DZk'])
-        response.should == [true, true]
+        expect(response).to eq([true, true])
       end
     end
 
@@ -254,16 +275,16 @@ describe Swiftype::Client do
       it 'creates a document' do
         VCR.use_cassette(:create_or_update_document_create) do
           response = client.create_or_update_document(engine_slug, document_type_slug, {:external_id => 'foobar', :fields => [{:type => :string, :name => 'title', :value => 'new document'}]})
-          response['external_id'].should == 'foobar'
-          response['title'].should == 'new document'
+          expect(response['external_id']).to eq('foobar')
+          expect(response['title']).to eq('new document')
         end
       end
 
       it 'updates an existing document' do
         VCR.use_cassette(:create_or_update_document_update) do
           response = client.create_or_update_document(engine_slug, document_type_slug, {:external_id => document_id, :fields => [{:type => :string, :name => 'title', :value => 'new title'}]})
-          response['external_id'].should == document_id
-          response['title'].should == 'new title'
+          expect(response['external_id']).to eq(document_id)
+          expect(response['title']).to eq('new title')
         end
       end
     end
@@ -272,7 +293,7 @@ describe Swiftype::Client do
       it 'returns true for all documents successfully created or updated' do
         VCR.use_cassette(:bulk_create_or_update_documents_success) do
           response = client.create_or_update_documents(engine_slug, document_type_slug, documents)
-          response.should == [true, true]
+          expect(response).to eq([true, true])
         end
       end
 
@@ -281,7 +302,76 @@ describe Swiftype::Client do
 
         VCR.use_cassette(:bulk_create_or_update_documents_failure) do
           response = client.create_or_update_documents(engine_slug, document_type_slug, documents)
-          response.should == [false]
+          expect(response).to eq([false])
+        end
+      end
+    end
+
+    context '#async_create_or_update_documents' do
+      it 'returns true for all documents successfully created or updated' do
+        VCR.use_cassette(:async_create_or_update_document_success) do
+          response = client.async_create_or_update_documents(engine_slug, document_type_slug, documents)
+          check_async_response_format(response, :external_id => documents.first["external_id"], :status => "pending")
+        end
+      end
+
+      it 'returns false if a document cannot be created or updated due to an error' do
+        documents = [{:external_id => 'failed_doc', :fields => [{:type => :string, :name => :title}]}] # missing value
+
+        VCR.use_cassette(:async_create_or_update_document_failure) do
+          response = client.async_create_or_update_documents(engine_slug, document_type_slug, documents)
+          check_async_response_format(response, :external_id => documents.first["external_id"], :status => "failed", :errors => ["Missing required parameter: value"])
+        end
+      end
+    end
+
+    context '#document_receipts' do
+      before :each do
+        def get_receipt_ids
+          receipt_ids = nil
+          VCR.use_cassette(:async_create_or_update_document_success) do
+            response = client.async_create_or_update_documents(engine_slug, document_type_slug, documents)
+            receipt_ids = response["document_receipts"].map { |r| r["id"] }
+          end
+          receipt_ids
+        end
+      end
+
+      it 'returns array of hashes one for each receipt' do
+        VCR.use_cassette(:document_receipts_multiple) do
+          receipt_ids = get_receipt_ids
+          response = client.document_receipts(receipt_ids)
+          expect(response).to eq([{"id" => receipt_ids[0], "status" => "pending"}, {"id" => receipt_ids[1], "status" => "pending"}])
+        end
+      end
+    end
+
+    context '#index_documents' do
+      it 'returns #async_create_or_update_documents format return when async has been passed as true' do
+        VCR.use_cassette(:async_create_or_update_document_success) do
+          response = client.index_documents(engine_slug, document_type_slug, documents, :async => true)
+          check_async_response_format(response, :external_id => documents.first["external_id"], :status => "pending")
+        end
+      end
+
+      it 'returns document_receipts when successfull' do
+        VCR.use_cassette(:async_create_or_update_document_success) do
+          VCR.use_cassette(:document_receipts_multiple_complete) do
+            response = client.index_documents(engine_slug, document_type_slug, documents)
+            # Sort keys for Ruby 1.8.7 compatibility
+            expect(response.map(&:keys).map(&:sort)).to eq([["id", "link", "status"], ["id", "link", "status"]])
+            expect(response.map { |a| a["status"] }).to eq(["complete", "complete"])
+          end
+        end
+      end
+
+      it 'should timeout if the process takes longer than the timeout option passed' do
+        allow(client).to receive(:document_receipts) { sleep 0.05 }
+
+        VCR.use_cassette(:async_create_or_update_document_success) do
+          expect do
+            client.index_documents(engine_slug, document_type_slug, documents, :timeout => 0.01)
+          end.to raise_error(Timeout::Error)
         end
       end
     end
@@ -290,7 +380,7 @@ describe Swiftype::Client do
       it 'returns true for all documents successfully created or updated' do
         VCR.use_cassette(:bulk_create_or_update_documents_verbose_success) do
           response = client.create_or_update_documents_verbose(engine_slug, document_type_slug, documents)
-          response.should == [true, true]
+          expect(response).to eq([true, true])
         end
       end
 
@@ -299,8 +389,8 @@ describe Swiftype::Client do
 
         VCR.use_cassette(:bulk_create_or_update_documents_verbose_failure) do
           response = client.create_or_update_documents_verbose(engine_slug, document_type_slug, documents)
-          response.size.should == 1
-          response.first.should match /^Invalid field definition/
+          expect(response.size).to eq(1)
+          expect(response.first).to match /^Invalid field definition/
         end
       end
     end
@@ -310,9 +400,9 @@ describe Swiftype::Client do
         fields = {:title => 'awesome new title', :channel_id => 'UC5VA5j05FjETg-iLekcyiBw'}
         VCR.use_cassette(:update_document) do
           response = client.update_document(engine_slug, document_type_slug, document_id, fields)
-          response['external_id'].should == document_id
-          response['title'].should == 'awesome new title'
-          response['channel_id'].should == 'UC5VA5j05FjETg-iLekcyiBw'
+          expect(response['external_id']).to eq(document_id)
+          expect(response['title']).to eq('awesome new title')
+          expect(response['channel_id']).to eq('UC5VA5j05FjETg-iLekcyiBw')
         end
       end
 
@@ -333,7 +423,7 @@ describe Swiftype::Client do
 
         VCR.use_cassette(:update_documents_success) do
           response = client.update_documents(engine_slug, document_type_slug, documents)
-          response.should == [true, true]
+          expect(response).to eq([true, true])
         end
       end
 
@@ -342,7 +432,7 @@ describe Swiftype::Client do
 
         VCR.use_cassette(:update_documents_failure_non_existent_document) do
           response = client.update_documents(engine_slug, document_type_slug, documents)
-          response.should == [false]
+          expect(response).to eq([false])
         end
       end
     end
@@ -355,32 +445,32 @@ describe Swiftype::Client do
       it 'returns search counts for the default time frame' do
         VCR.use_cassette(:analytics_searches) do
           searches = client.analytics_searches(engine_slug)
-          searches.size.should == 15 # FIXME: is this a bug in the API?
-          searches.first.should == ['2013-09-13', 0]
+          expect(searches.size).to eq(15) # FIXME: is this a bug in the API?
+          expect(searches.first).to eq(['2013-09-13', 0])
         end
       end
 
       it 'returns search counts for a specified time range' do
         VCR.use_cassette(:analytics_searches_with_time_range) do
           searches = client.analytics_searches(engine_slug, :start_date => '2013-01-01', :end_date => '2013-01-07')
-          searches.size.should == 7
-          searches.first.should == ['2013-01-07', 0]
+          expect(searches.size).to eq(7)
+          expect(searches.first).to eq(['2013-01-07', 0])
         end
       end
 
       it 'returns search counts for a specified DocumentType' do
         VCR.use_cassette(:analytics_searchs_with_document_type) do
           searches = client.analytics_searches(engine_slug, :document_type_id => 'page')
-          searches.size.should == 15
-          searches.first.should == ['2013-09-16', 0]
+          expect(searches.size).to eq(15)
+          expect(searches.first).to eq(['2013-09-16', 0])
         end
       end
 
       it 'returns search counts for a specified DocumentType and time range' do
         VCR.use_cassette(:analytics_searches_with_document_type_and_time_range) do
           searches = client.analytics_autoselects(engine_slug, :document_type_id => 'page', :start_date => '2013-07-01', :end_date => '2013-07-07')
-          searches.size.should == 7
-          searches.first.should == ['2013-07-07', 0]
+          expect(searches.size).to eq(7)
+          expect(searches.first).to eq(['2013-07-07', 0])
         end
       end
     end
@@ -389,29 +479,29 @@ describe Swiftype::Client do
       it 'returns autoselect counts for the default time frame' do
         VCR.use_cassette(:analytics_autoselects) do
           autoselects = client.analytics_autoselects(engine_slug)
-          autoselects.size.should == 15
-          autoselects.first.should == ['2013-09-13', 0]
+          expect(autoselects.size).to eq(15)
+          expect(autoselects.first).to eq(['2013-09-13', 0])
         end
       end
 
       it 'returns autoselects counts for a specified time range' do
         VCR.use_cassette(:analytics_autoselects_with_time_range) do
           autoselects = client.analytics_autoselects(engine_slug, :start_date => '2013-07-01', :end_date => '2013-07-07')
-          autoselects.size.should == 7
+          expect(autoselects.size).to eq(7)
         end
       end
 
       it 'returns autoselect counts for a specified DocumentType' do
         VCR.use_cassette(:analytics_autoselects_with_document_type) do
           autoselects = client.analytics_autoselects(engine_slug, :document_type_id => 'page')
-          autoselects.size.should == 15
+          expect(autoselects.size).to eq(15)
         end
       end
 
       it 'returns autoselect counts for a specified DocumentType and time range' do
         VCR.use_cassette(:analytics_autoselects_with_document_type_and_time_range) do
           autoselects = client.analytics_autoselects(engine_slug, :document_type_id => 'page', :start_date => '2013-07-01', :end_date => '2013-07-07')
-          autoselects.size.should == 7
+          expect(autoselects.size).to eq(7)
         end
       end
     end
@@ -420,31 +510,31 @@ describe Swiftype::Client do
       it 'returns click counts for the default time frame' do
         VCR.use_cassette(:analytics_clicks) do
           clicks = client.analytics_clicks(engine_slug)
-          clicks.size.should == 15
-          clicks.first.should == ['2013-09-17', 0]
+          expect(clicks.size).to eq(15)
+          expect(clicks.first).to eq(['2013-09-17', 0])
         end
       end
 
       it 'returns clicks counts for a specified time range' do
         VCR.use_cassette(:analytics_clicks_with_time_range) do
           clicks = client.analytics_clicks(engine_slug, :start_date => '2013-07-01', :end_date => '2013-07-07')
-          clicks.size.should == 7
-          clicks.first.should == ['2013-07-07', 0]
+          expect(clicks.size).to eq(7)
+          expect(clicks.first).to eq(['2013-07-07', 0])
         end
       end
 
       it 'returns click counts for a specified DocumentType' do
         VCR.use_cassette(:analytics_clicks_with_document_type) do
           clicks = client.analytics_clicks(engine_slug, :document_type_id => 'page')
-          clicks.size.should == 15
+          expect(clicks.size).to eq(15)
         end
       end
 
       it 'returns click counts for a specified DocumentType and time range' do
         VCR.use_cassette(:analytics_clicks_with_document_type_and_time_range) do
           clicks = client.analytics_clicks(engine_slug, :document_type_id => 'page', :start_date => '2013-07-01', :end_date => '2013-07-07')
-          clicks.size.should == 7
-          clicks.first.should == ['2013-07-07', 0]
+          expect(clicks.size).to eq(7)
+          expect(clicks.first).to eq(['2013-07-07', 0])
         end
       end
     end
@@ -453,16 +543,16 @@ describe Swiftype::Client do
       it 'returns top queries' do
         VCR.use_cassette(:analytics_top_queries) do
           top_queries = client.analytics_top_queries(engine_slug)
-          top_queries.size.should == 3
-          top_queries.first.should == ['"fire watch"', 1]
+          expect(top_queries.size).to eq(3)
+          expect(top_queries.first).to eq(['"fire watch"', 1])
         end
       end
 
       it 'returns top queries with pagination' do
         VCR.use_cassette(:analytics_top_queries_paginated) do
           top_queries = client.analytics_top_queries(engine_slug, :start_date => '2013-08-01', :end_date => '2013-08-30', :per_page => 5, :page => 2)
-          top_queries.size.should == 5
-          top_queries.first.should == ['no simple victory', 1]
+          expect(top_queries.size).to eq(5)
+          expect(top_queries.first).to eq(['no simple victory', 1])
         end
       end
 
@@ -479,16 +569,16 @@ describe Swiftype::Client do
       it 'returns top queries with no results for the default time range' do
         VCR.use_cassette(:analytics_top_no_result_queries) do
           top_no_result_queries = client.analytics_top_no_result_queries(engine_slug)
-          top_no_result_queries.size.should == 2
-          top_no_result_queries.first.should == ['no results', 10]
+          expect(top_no_result_queries.size).to eq(2)
+          expect(top_no_result_queries.first).to eq(['no results', 10])
         end
       end
 
       it 'has top no result queries in date ranges' do
         VCR.use_cassette(:analytics_top_no_result_queries_paginated) do
           top_no_result_queries = client.analytics_top_no_result_queries(engine_slug, :start_date => '2013-08-01', :end_date => '2013-08-30', :per_page => 5, :page => 2)
-          top_no_result_queries.size.should == 1
-          top_no_result_queries.first.should == ['no result again', 2]
+          expect(top_no_result_queries.size).to eq(1)
+          expect(top_no_result_queries.first).to eq(['no result again', 2])
         end
       end
     end
@@ -501,8 +591,8 @@ describe Swiftype::Client do
     it 'gets all domains' do
       VCR.use_cassette(:list_domains) do
         domains = client.domains(engine_slug)
-        domains.size.should == 1
-        domains.first['id'].should == domain_id
+        expect(domains.size).to eq(1)
+        expect(domains.first['id']).to eq(domain_id)
       end
     end
 
@@ -510,7 +600,7 @@ describe Swiftype::Client do
       it 'shows a domain if it exists' do
         VCR.use_cassette(:find_domain) do
           domain = client.domain(engine_slug, domain_id)
-          domain['id'].should == domain_id
+          expect(domain['id']).to eq(domain_id)
         end
       end
 
@@ -528,7 +618,7 @@ describe Swiftype::Client do
         VCR.use_cassette(:create_domain) do
           url = 'http://www.zombo.com/'
           domain = client.create_domain(engine_slug, url)
-          domain['submitted_url'].should == url
+          expect(domain['submitted_url']).to eq(url)
         end
       end
     end
@@ -536,7 +626,7 @@ describe Swiftype::Client do
     it 'destroys a domain' do
       VCR.use_cassette(:destroy_domain) do
         response = client.destroy_domain(engine_slug, '52324b132ed960589800004a')
-        response.should be_nil
+        expect(response).to be_nil
       end
     end
 
@@ -544,7 +634,7 @@ describe Swiftype::Client do
       it 'enqueues a request to recrawl a domain' do
         VCR.use_cassette(:recrawl_domain_success) do
           domain = client.recrawl_domain(engine_slug, domain_id)
-          domain['id'].should == domain_id
+          expect(domain['id']).to eq(domain_id)
         end
       end
 
@@ -562,7 +652,7 @@ describe Swiftype::Client do
         VCR.use_cassette(:crawl_url) do
           url = 'http://crawler-demo-site.herokuapp.com/2012/01/01/first-post.html'
           crawled_url = client.crawl_url(engine_slug, domain_id, url)
-          crawled_url['url'].should == url
+          expect(crawled_url['url']).to eq(url)
         end
       end
     end
@@ -579,7 +669,7 @@ describe Swiftype::Client do
       it 'returns nil' do
         VCR.use_cassette(:log_clickthrough_success) do
           response = client.log_clickthrough(engine_slug, document_type_slug, query, external_id)
-          response.should == nil
+          expect(response).to eq(nil)
         end
       end