elastic-app-search 7.4.0 → 7.8.0

data/spec/config_helper.rb

@@ -3,6 +3,10 @@ module ConfigHelper
     ENV.fetch('AS_API_KEY', 'API_KEY')
   end
 
+  def ConfigHelper.get_as_admin_key
+    ENV.fetch('AS_ADMIN_KEY', 'ADMIN_KEY')
+  end
+
   def ConfigHelper.get_as_host_identifier
     ENV['AS_ACCOUNT_HOST_KEY'] || ENV['AS_HOST_IDENTIFIER'] || 'ACCOUNT_HOST_KEY'
   end

data/spec/credentials_spec.rb

@@ -0,0 +1,75 @@
+require 'securerandom'
+
+describe Elastic::AppSearch::Client::Credentials do
+  include_context 'App Search Admin Credentials'
+  include_context 'Test Engine'
+
+  let(:client) { Elastic::AppSearch::Client.new(client_options) }
+  let(:key_name) { "spec-key-#{SecureRandom.hex}" }
+  let(:api_key) do
+    {
+      :name => key_name,
+      :type => 'private',
+      :read => true,
+      :write => false,
+      :access_all_engines => false,
+      :engines => [
+        engine_name
+      ]
+    }
+  end
+
+  context '#create_credential' do
+    after { client.destroy_credential(key_name) }
+    subject { client.create_credential(api_key) }
+
+    it 'will create an API Key' do
+      expect(subject['name']).to(eq(key_name))
+    end
+  end
+
+  context '#get_credential' do
+    after { client.destroy_credential(key_name) }
+    before { client.create_credential(api_key) }
+    subject { client.get_credential(key_name) }
+
+    it 'will retrieve an API Key' do
+      expect(subject['name']).to(eq(key_name))
+    end
+  end
+
+  context '#update_credential' do
+    let(:updated_api_key) do
+      api_key['write'] = true
+      api_key
+    end
+
+    before { client.create_credential(api_key) }
+    after { client.destroy_credential(key_name) }
+    subject { client.update_credential(key_name, updated_api_key) }
+
+    it 'will update an API Key' do
+      expect(subject['name']).to(eq(key_name))
+      expect(subject['write']).to(eq(true))
+    end
+  end
+
+  context '#list_credentials' do
+    before { client.create_credential(api_key) }
+    after { client.destroy_credential(key_name) }
+    subject { client.list_credentials }
+
+    it 'will list all API Keys' do
+      expect(subject['results'].map { |r| r['name'] }.include?(key_name)).to(eq(true))
+    end
+  end
+
+  context '#destroy_credential' do
+    before { client.create_credential(api_key) }
+    subject { client.destroy_credential(key_name) }
+
+    it 'will delete an API Key' do
+      expect(subject['deleted']).to(eq(true))
+    end
+  end
+end

data/spec/curations_spec.rb

@@ -0,0 +1,82 @@
+describe Elastic::AppSearch::Client::Curations do
+  include_context 'App Search Credentials'
+  include_context 'Static Test Engine'
+
+  let(:client) { Elastic::AppSearch::Client.new(client_options) }
+
+  let(:curation) do
+    {
+      'queries' => [
+        'zion'
+      ],
+      'promoted' => [
+        document1['id']
+      ],
+      'hidden' => [
+        document2['id']
+      ]
+    }
+  end
+  let(:curation_id) { client.create_curation(engine_name, curation)['id'] }
+
+  after(:each) do
+    begin
+      client.destroy_curation(engine_name, curation_id)
+    rescue
+      # Ignore it
+    end
+  end
+
+  context '#create_curation' do
+    it 'will create a curation' do
+      expect(curation_id).not_to(be_empty)
+    end
+  end
+
+  context '#get_curation' do
+    subject { client.get_curation(engine_name, curation_id) }
+
+    it 'will retrieve a curation' do
+      expect(subject['queries']).to(eq(['zion']))
+    end
+  end
+
+  context '#update_curation' do
+    let(:updated_curation) do
+      {
+        'queries' => [
+          'zion', 'lion'
+        ],
+        'promoted' => [
+          document1['id']
+        ]
+      }
+    end
+    subject { client.update_curation(engine_name, curation_id, updated_curation) }
+
+    it 'will update a curation' do
+      expect(subject['id']).to(eq(curation_id))
+    end
+  end
+
+  context '#list_curations' do
+    subject { client.list_curations(engine_name, :current => 1, :size => 5) }
+
+    it 'will list curations' do
+      expect(subject['results']).to(eq([]))
+    end
+
+    it 'supports paging params' do
+      expect(subject['meta']['page']['current']).to(eq(1))
+      expect(subject['meta']['page']['size']).to(eq(5))
+    end
+  end
+
+  context '#destroy_curation' do
+    subject { client.destroy_curation(engine_name, curation_id) }
+
+    it 'will destroy a curation' do
+      expect(subject['deleted']).to(eq(true))
+    end
+  end
+end

data/spec/documents_spec.rb

@@ -0,0 +1,130 @@
+describe Elastic::AppSearch::Client::Documents do
+  include_context 'App Search Credentials'
+  include_context 'Test Engine'
+
+  let(:client) { Elastic::AppSearch::Client.new(client_options) }
+
+  context 'Documents' do
+    let(:document) { { 'url' => 'http://www.youtube.com/watch?v=v1uyQZNg2vE' } }
+
+    describe '#index_document' do
+      subject { client.index_document(engine_name, document) }
+
+      it 'should return a processed document status hash' do
+        expect(subject).to(match('id' => anything))
+      end
+
+      context 'when the document has an id' do
+        let(:id) { 'some_id' }
+        let(:document) { { 'id' => id, 'url' => 'http://www.youtube.com/watch?v=v1uyQZNg2vE' } }
+
+        it 'should return a processed document status hash with the same id' do
+          expect(subject).to(eq('id' => id))
+        end
+      end
+
+      context 'when a document has processing errors' do
+        let(:document) { { 'id' => 'too long' * 100 } }
+
+        it 'should raise an error when the API returns errors in the response' do
+          expect do
+            subject
+          end.to(raise_error(Elastic::AppSearch::InvalidDocument, /Invalid field/))
+        end
+      end
+
+      context 'when a document has a Ruby Time object' do
+        let(:time_rfc3339) { '2018-01-01T01:01:01+00:00' }
+        let(:time_object) { Time.parse(time_rfc3339) }
+        let(:document) { { 'created_at' => time_object } }
+
+        it 'should serialize the time object in RFC 3339' do
+          response = subject
+          expect(response).to(have_key('id'))
+          document_id = response.fetch('id')
+          expect do
+            documents = client.get_documents(engine_name, [document_id])
+            expect(documents.size).to(eq(1))
+            expect(documents.first['created_at']).to(eq(time_rfc3339))
+          end.to_not(raise_error)
+        end
+      end
+    end
+
+    describe '#index_documents' do
+      let(:documents) { [document, second_document] }
+      let(:second_document_id) { 'another_id' }
+      let(:second_document) { { 'id' => second_document_id, 'url' => 'https://www.youtube.com/watch?v=9T1vfsHYiKY' } }
+      subject { client.index_documents(engine_name, documents) }
+
+      it 'should return an array of document status hashes' do
+        expected = [
+          { 'id' => anything, 'errors' => [] },
+          { 'id' => second_document_id, 'errors' => [] }
+        ]
+        expect(subject).to(match(expected))
+      end
+
+      context 'when one of the documents has processing errors' do
+        let(:second_document) { { 'id' => 'too long' * 100 } }
+
+        it 'should return respective errors in an array of document processing hashes' do
+          expected = [
+            { 'id' => anything, 'errors' => [] },
+            { 'id' => anything, 'errors' => ['Invalid field type: id must be less than 800 characters'] },
+          ]
+          expect(subject).to(match(expected))
+        end
+      end
+    end
+
+    describe '#update_documents' do
+      let(:documents) { [document, second_document] }
+      let(:second_document_id) { 'another_id' }
+      let(:second_document) { { 'id' => second_document_id, 'url' => 'https://www.youtube.com/watch?v=9T1vfsHYiKY' } }
+      let(:updates) do
+        [
+          {
+            'id' => second_document_id,
+            'url' => 'https://www.example.com'
+          }
+        ]
+      end
+
+      subject { client.update_documents(engine_name, updates) }
+
+      before do
+        client.index_documents(engine_name, documents)
+      end
+
+      # Note that since indexing a document takes up to a minute,
+      # we don't expect this to succeed, so we simply verify that
+      # the request responded with the correct 'id', even though
+      # the 'errors' object likely contains errors.
+      it 'should update existing documents' do
+        expect(subject).to(match(['id' => second_document_id, 'errors' => anything]))
+      end
+    end
+
+    describe '#get_documents' do
+      let(:documents) { [first_document, second_document] }
+      let(:first_document_id) { 'id' }
+      let(:first_document) { { 'id' => first_document_id, 'url' => 'https://www.youtube.com/watch?v=v1uyQZNg2vE' } }
+      let(:second_document_id) { 'another_id' }
+      let(:second_document) { { 'id' => second_document_id, 'url' => 'https://www.youtube.com/watch?v=9T1vfsHYiKY' } }
+
+      subject { client.get_documents(engine_name, [first_document_id, second_document_id]) }
+
+      before do
+        client.index_documents(engine_name, documents)
+      end
+
+      it 'will return documents by id' do
+        response = subject
+        expect(response.size).to(eq(2))
+        expect(response[0]['id']).to(eq(first_document_id))
+        expect(response[1]['id']).to(eq(second_document_id))
+      end
+    end
+  end
+end

data/spec/engines_spec.rb

@@ -0,0 +1,74 @@
+describe Elastic::AppSearch::Client::Engines do
+  include_context 'App Search Credentials'
+  include_context 'Engine Name'
+
+  let(:client) { Elastic::AppSearch::Client.new(client_options) }
+
+  context 'Engines' do
+    after do
+      client.destroy_engine(engine_name) rescue Elastic::AppSearch::NonExistentRecord
+    end
+
+    context '#create_engine' do
+      it 'should create an engine when given a right set of parameters' do
+        expect { client.get_engine(engine_name) }.to(raise_error(Elastic::AppSearch::NonExistentRecord))
+        client.create_engine(engine_name)
+        expect { client.get_engine(engine_name) }.to_not(raise_error)
+      end
+
+      it 'should accept an optional language parameter' do
+        expect { client.get_engine(engine_name) }.to(raise_error(Elastic::AppSearch::NonExistentRecord))
+        client.create_engine(engine_name, 'da')
+        expect(client.get_engine(engine_name)).to(match('name' => anything, 'type' => anything, 'language' => 'da'))
+      end
+
+      it 'should return an engine object' do
+        engine = client.create_engine(engine_name)
+        expect(engine).to(be_kind_of(Hash))
+        expect(engine['name']).to(eq(engine_name))
+      end
+
+      it 'should return an error when the engine name has already been taken' do
+        client.create_engine(engine_name)
+        expect { client.create_engine(engine_name) }.to(raise_error) do |e|
+          expect(e).to(be_a(Elastic::AppSearch::BadRequest))
+          expect(e.errors).to(eq(['Name is already taken']))
+        end
+      end
+    end
+
+    context '#list_engines' do
+      it 'should return an array with a list of engines' do
+        expect(client.list_engines['results']).to(be_an(Array))
+      end
+
+      it 'should include the engine name in listed objects' do
+        client.create_engine(engine_name)
+
+        engines = client.list_engines['results']
+        expect(engines.find { |e| e['name'] == engine_name }).to_not(be_nil)
+      end
+
+      it 'should include the engine name in listed objects with pagination' do
+        client.create_engine(engine_name)
+
+        engines = client.list_engines(:current => 1, :size => 20)['results']
+        expect(engines.find { |e| e['name'] == engine_name }).to_not(be_nil)
+      end
+    end
+
+    context '#destroy_engine' do
+      it 'should destroy the engine if it exists' do
+        client.create_engine(engine_name)
+        expect { client.get_engine(engine_name) }.to_not(raise_error)
+
+        client.destroy_engine(engine_name)
+        expect { client.get_engine(engine_name) }.to(raise_error(Elastic::AppSearch::NonExistentRecord))
+      end
+
+      it 'should raise an error if the engine does not exist' do
+        expect { client.destroy_engine(engine_name) }.to(raise_error(Elastic::AppSearch::NonExistentRecord))
+      end
+    end
+  end
+end

data/spec/list_documents_spec.rb

@@ -0,0 +1,25 @@
+describe Elastic::AppSearch::Client::Documents do
+  include_context 'App Search Credentials'
+  include_context 'Static Test Engine'
+
+  let(:client) { Elastic::AppSearch::Client.new(client_options) }
+
+  context 'Documents' do
+    describe '#list_documents' do
+      context 'when no options are specified' do
+        it 'will return all documents' do
+          response = client.list_documents(engine_name)
+          expect(response['results'].size).to(eq(2))
+          expect(response['results'].map { |d| d['id'] }).to(include(document1['id'], document2['id']))
+        end
+      end
+
+      context 'when options are specified' do
+        it 'will return all documents' do
+          response = client.list_documents(engine_name, :page => { :size => 1, :current => 2 })
+          expect(response['results'].size).to(eq(1))
+        end
+      end
+    end
+  end
+end

data/spec/logs_spec.rb

@@ -0,0 +1,33 @@
+describe Elastic::AppSearch::Client::Logs do
+  include_context 'App Search Credentials'
+  include_context 'Test Engine'
+
+  let(:client) { Elastic::AppSearch::Client.new(client_options) }
+
+  context '#get_api_logs' do
+    let(:from) { Time.now.iso8601 }
+    let(:to) { Time.now.iso8601 }
+
+    subject do
+      options = {
+        :filters => {
+          :date => {
+            :from => from,
+            :to => to
+          }
+        },
+        :page => {
+          :total_results => 100,
+          :size => 20
+        },
+        :query => 'search',
+        :sort_direction => 'desc'
+      }
+      client.get_api_logs(engine_name, options)
+    end
+
+    it 'will retrieve api logs' do
+      expect(subject['results']).to(eq([]))
+    end
+  end
+end

data/spec/meta_engines_spec.rb

@@ -0,0 +1,73 @@
+describe Elastic::AppSearch::Client::MetaEngines do
+  include_context 'App Search Credentials'
+  include_context 'Engine Name'
+  include_context 'Meta Engine Name'
+  include_context 'Test Engine'
+
+  let(:client) { Elastic::AppSearch::Client.new(client_options) }
+  let(:source_engines) { [engine_name] }
+
+  # CI currently runs against SaaS. This feature is a Self-Managed only feature.
+  context 'Meta Engines', :skip => "Unable to test Self-Managed features in CI." do
+
+    after do
+      client.destroy_engine(meta_engine_name) rescue Elastic::AppSearch::NonExistentRecord
+    end
+
+    context '#create_meta_engine' do
+      it 'should create a meta engine when given a right set of parameters' do
+        expect { client.get_engine(meta_engine_name) }.to raise_error(Elastic::AppSearch::NonExistentRecord)
+        client.create_meta_engine(meta_engine_name, source_engines)
+        expect { client.get_engine(meta_engine_name) }.to_not raise_error
+      end
+
+      it 'should return a meta engine object' do
+        engine = client.create_meta_engine(meta_engine_name, source_engines)
+        expect(engine).to be_kind_of(Hash)
+        expect(engine['name']).to eq(meta_engine_name)
+        expect(engine['type']).to eq('meta')
+        expect(engine['source_engines']).to eq(source_engines)
+      end
+
+      it 'should return an error when the engine source engine is empty' do
+        expect { client.create_meta_engine(engine_name, []) }.to(raise_error) do |e|
+          expect(e).to be_a(Elastic::AppSearch::BadRequest)
+          expect(e.errors).to eq(['Source engines are required for meta engines'])
+        end
+      end
+    end
+
+    context '#add_meta_engine_sources' do
+      before do
+        client.create_meta_engine(meta_engine_name, source_engines)
+        client.delete_meta_engine_sources(meta_engine_name, source_engines)
+      end
+
+      it 'should add the source engine' do
+        expect { client.add_meta_engine_sources(meta_engine_name, source_engines) }.to_not raise_error do |engine|
+          expect(engine).to be_kind_of(Hash)
+          expect(engine['name']).to eq(meta_engine_name)
+          expect(engine['type']).to eq('meta')
+          expect(engine['source_engines']).to be_kind_of(Array)
+          expect(engine['source_engines']).to eq(source_engines)
+        end
+      end
+    end
+
+    context '#delete_meta_engine_sources' do
+      before do
+        client.create_meta_engine(meta_engine_name, source_engines)
+      end
+
+      it 'should remove the source engine' do
+        expect { client.delete_meta_engine_sources(meta_engine_name, source_engines) }.to_not raise_error do |engine|
+          expect(engine).to be_kind_of(Hash)
+          expect(engine['name']).to eq(meta_engine_name)
+          expect(engine['type']).to eq('meta')
+          expect(engine['source_engines']).to be_kind_of(Array)
+          expect(engine['source_engines']).to be_empty
+        end
+      end
+    end
+  end
+end