elastic-enterprise-search 7.14.0 → 7.16.0

data/spec/integration/app-search/documents_spec.rb

@@ -0,0 +1,123 @@
+# Licensed to Elasticsearch B.V. under one or more contributor
+# license agreements. See the NOTICE file distributed with
+# this work for additional information regarding copyright
+# ownership. Elasticsearch B.V. licenses this file to you under
+# the Apache License, Version 2.0 (the "License"); you may
+# not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+# frozen_string_literal: true
+
+require_relative "#{__dir__}/app_search_helper.rb"
+
+describe Elastic::EnterpriseSearch::AppSearch::Client do
+  context 'documents' do
+    let(:engine_name) { 'documents' }
+    let(:documents) do
+      [
+        { name: 'Super Lorenzo Bros', year: '1985' },
+        { name: 'Pack-Man', year: '1980' },
+        { name: 'Galaxxian', year: '1979' },
+        { name: 'Audiovisual, the hedgehog', year: '1991' }
+      ]
+    end
+
+    before do
+      create_engine(engine_name)
+    end
+
+    after do
+      delete_engines
+    end
+
+    def extract_from_key(key)
+      ->(h) { h[key] }
+    end
+
+    it 'indexes and lists documents' do
+      response = client.index_documents(engine_name, documents: documents)
+      expect(response.status).to eq 200
+      expect(response.body.count).to eq 4
+      expect(response.body.map(&:keys)).to eq [['id', 'errors'], ['id', 'errors'], ['id', 'errors'], ['id', 'errors']]
+
+      response = client.list_documents(engine_name)
+      attempts = 0
+      while response.body['results'].count < 1 && attempts < 20
+        sleep 1
+        attempts += 1
+        response = client.list_documents(engine_name)
+      end
+
+      expect(response.status).to eq 200
+      expect(response.body['results'].count).to eq 4
+    end
+
+    it 'retrieves documents by ID' do
+      response = client.index_documents(engine_name, documents: documents)
+      ids = response.body.map(&->(h) { h['id'] })
+
+      attempts = 0
+      while client.list_documents(engine_name).body['results'].count < 4 && attempts < 20
+        sleep 1
+        attempts += 1
+      end
+
+      response = client.documents(engine_name, document_ids: ids)
+
+      expect(response.status).to eq 200
+      expect(response.body.count).to eq 4
+      expect(
+        response.body.map(&extract_from_key('name')) - documents.map(&extract_from_key(:name))
+      ).to be_empty
+    end
+
+    it 'searches for a document' do
+      client.index_documents(engine_name, documents: documents)
+
+      response = client.search(engine_name, body: { query: 'Pack-Man' })
+      attempts = 0
+      while response.body['results'].count < 1 && attempts < 20
+        sleep 1
+        attempts += 1
+        response = client.search(engine_name, body: { query: 'Pack-Man' })
+      end
+      expect(response.status).to eq 200
+      expect(response.body['meta']['engine']).to eq({ 'name' => engine_name, 'type' => 'default' })
+      expect(response.body['results'].first['name']).to eq({ 'raw' => 'Pack-Man' })
+      expect(response.body['results'].first['year']).to eq({ 'raw' => '1980' })
+    end
+
+    it 'deletes a document' do
+      document = { name: 'Celda', year: 1986 }
+      response = client.index_documents(engine_name, documents: document)
+      expect(response.status).to eq 200
+
+      id = response.body.first['id']
+
+      response = client.delete_documents(engine_name, document_ids: [id])
+      expect(response.status).to eq 200
+      expect(response.body.first['deleted'])
+    end
+
+    it 'updates a document' do
+      document = { name: 'Al*bert', year: 1983 }
+      response = client.index_documents(engine_name, documents: document)
+      expect(response.status).to eq 200
+
+      id = response.body.first['id']
+
+      response = client.put_documents(engine_name, documents: [{ id: id, year: 1982 }])
+      expect(response.status).to eq 200
+      expect(response.body).to eq [{ 'id' => id, 'errors' => [] }]
+    end
+  end
+end

data/spec/integration/app-search/engines_spec.rb

@@ -0,0 +1,78 @@
+# Licensed to Elasticsearch B.V. under one or more contributor
+# license agreements. See the NOTICE file distributed with
+# this work for additional information regarding copyright
+# ownership. Elasticsearch B.V. licenses this file to you under
+# the Apache License, Version 2.0 (the "License"); you may
+# not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+# frozen_string_literal: true
+
+require_relative "#{__dir__}/app_search_helper.rb"
+
+describe Elastic::EnterpriseSearch::AppSearch::Client do
+  context 'Engines' do
+    let(:engine_name) { 'test-create-engines' }
+
+    after do
+      delete_engines
+    end
+
+    it 'creates a new engine' do
+      response = client.create_engine(name: engine_name)
+
+      expect(response.status).to eq 200
+      expect(response.body).to eq(
+        {
+          'name' => engine_name,
+          'type' => 'default',
+          'language' => nil,
+          'document_count' => 0
+        }
+      )
+    end
+
+    it 'lists engines' do
+      client.create_engine(name: 'engine1')
+      client.create_engine(name: 'engine2')
+
+      response = client.list_engines
+      expect(response.status).to eq 200
+
+      expect(response.body.dig('meta', 'page', 'total_results')).to eq 2
+      expect(response.body['results']).to include(
+        { 'name' => 'engine1', 'type' => 'default', 'language' => nil, 'document_count' => 0 }
+      )
+      expect(response.body['results']).to include(
+        { 'name' => 'engine2', 'type' => 'default', 'language' => nil, 'document_count' => 0 }
+      )
+    end
+
+    it 'retrieves an engine by name' do
+      engine_name = 'retrieve-engine'
+      client.create_engine(name: engine_name)
+      response = client.engine(engine_name)
+      expect(response.status).to eq 200
+      expect(response.body).to eq(
+        { 'name' => engine_name, 'type' => 'default', 'language' => nil, 'document_count' => 0 }
+      )
+    end
+
+    it 'deletes an engine' do
+      engine_name = 'delete-engine'
+      client.create_engine(name: engine_name)
+      response = client.delete_engine(engine_name)
+      expect(response.status).to eq 200
+      expect(response.body).to eq({ 'deleted' => true })
+    end
+  end
+end

data/spec/{app-search/api_log_clickthrough_spec.rb → integration/app-search/log_clickthrough_spec.rb}

@@ -17,18 +17,25 @@
 
 # frozen_string_literal: true
 
-require_relative './api_spec_helper'
+require_relative "#{__dir__}/app_search_helper.rb"
 
 describe Elastic::EnterpriseSearch::AppSearch::Client do
-  context 'api_log_clickthrough' do
-    let(:engine_name) { 'films' }
+  context 'Log Click through' do
+    let(:engine_name) { 'videogames' }
+
+    before do
+      create_engine(engine_name)
+    end
+
+    after do
+      client.delete_engine(engine_name)
+    end
 
     it 'logs clicked results' do
-      VCR.use_cassette('app_search/api_log_clickthrough') do
-        response = @client.log_clickthrough(engine_name, query_text: 'moon', document_id: 'doc-id')
+      body = { query: 'moon', document_id: 'doc_id' }
+      response = client.log_clickthrough(engine_name, body: body)
 
-        expect(response.status).to eq 200
-      end
+      expect(response.status).to eq 200
     end
   end
 end

data/spec/integration/app-search/meta_engines_spec.rb

@@ -0,0 +1,75 @@
+# Licensed to Elasticsearch B.V. under one or more contributor
+# license agreements. See the NOTICE file distributed with
+# this work for additional information regarding copyright
+# ownership. Elasticsearch B.V. licenses this file to you under
+# the Apache License, Version 2.0 (the "License"); you may
+# not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+# frozen_string_literal: true
+
+require_relative "#{__dir__}/app_search_helper.rb"
+
+describe Elastic::EnterpriseSearch::AppSearch::Client do
+  context 'Meta Engines' do
+    let(:engine_name) { 'new-meta-engine' }
+    let(:create_meta_engine) do
+      body = {
+        name: engine_name,
+        type: 'meta',
+        source_engines: ['books', 'videogames']
+      }
+      client.create_engine(name: engine_name, body: body)
+    end
+
+    before do
+      client.create_engine(name: 'books')
+      client.create_engine(name: 'videogames')
+    end
+
+    after do
+      delete_engines
+    end
+
+    it 'creates a meta engine' do
+      response = create_meta_engine
+      expect(response.status).to eq 200
+      expect(response.body['name']).to eq(engine_name)
+      expect(response.body['type']).to eq('meta')
+      expect(response.body['source_engines'].sort).to eq(['books', 'videogames'])
+    end
+
+    it 'adds a new source engine to a meta engine' do
+      create_meta_engine
+      # Create new source engine to add:
+      client.create_engine(name: 'add-source')
+      response = client.add_meta_engine_source(engine_name, source_engines: ['add-source'])
+
+      expect(response.status).to eq 200
+      expect(response.body['name']).to eq(engine_name)
+      expect(response.body['type']).to eq('meta')
+      expect(response.body['source_engines'].sort).to eq(['add-source', 'books', 'videogames'])
+    end
+
+    it 'removes a source engine from a meta engine' do
+      create_meta_engine
+      client.create_engine(name: 'remove-source')
+      client.add_meta_engine_source(engine_name, source_engines: ['remove-source'])
+      response = client.delete_meta_engine_source(engine_name, source_engines: ['remove-source'])
+
+      expect(response.status).to eq 200
+      expect(response.body['name']).to eq(engine_name)
+      expect(response.body['type']).to eq('meta')
+      expect(response.body['source_engines'].sort).to eq(['books', 'videogames'])
+    end
+  end
+end

data/spec/integration/app-search/query_suggestion_spec.rb

@@ -0,0 +1,50 @@
+# Licensed to Elasticsearch B.V. under one or more contributor
+# license agreements. See the NOTICE file distributed with
+# this work for additional information regarding copyright
+# ownership. Elasticsearch B.V. licenses this file to you under
+# the Apache License, Version 2.0 (the "License"); you may
+# not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+# frozen_string_literal: true
+
+require_relative "#{__dir__}/app_search_helper.rb"
+
+describe Elastic::EnterpriseSearch::AppSearch::Client do
+  context 'Query Suggestion' do
+    let(:engine_name) { 'query-suggestions' }
+
+    before do
+      create_engine(engine_name)
+    end
+
+    after do
+      delete_engines
+    end
+
+    it 'provides query suggestions' do
+      client.index_documents(engine_name, documents: [{ title: 'A trip to the moon' }])
+      attempts = 0
+      response = client.query_suggestion(engine_name, query: 'moo')
+
+      while response.body['results']['documents'].count < 1 && attempts < 20
+        sleep 1
+        attempts += 1
+        response = client.query_suggestion(engine_name, query: 'moo')
+      end
+      expect(response.status).to eq 200
+      expect(response.body['results']['documents']).to include(
+        { 'suggestion' => 'moon' }
+      )
+    end
+  end
+end

data/spec/{app-search/api_schema_spec.rb → integration/app-search/schema_spec.rb}

@@ -17,32 +17,37 @@
 
 # frozen_string_literal: true
 
-require 'spec_helper'
-require_relative './api_spec_helper'
+require_relative "#{__dir__}/app_search_helper.rb"
 
 describe Elastic::EnterpriseSearch::AppSearch::Client do
-  context 'schema' do
-    let(:engine_name) { 'films' }
+  let(:engine_name) { 'schema' }
+
+  before do
+    create_engine(engine_name)
+    client.index_documents(engine_name, documents: [{ title: 'test', director: 'someone' }])
+  end
 
+  after do
+    client.delete_engine(engine_name)
+    sleep 1
+  end
+
+  context 'schema' do
     it 'returns an engine schema' do
-      VCR.use_cassette('app_search/api_schema') do
-        response = @client.schema(engine_name)
+      response = client.schema(engine_name)
 
-        expect(response.status).to eq 200
-        expect(response.body).to eq({ 'title' => 'text', 'year' => 'number', 'director' => 'text' })
-      end
+      expect(response.status).to eq 200
+      expect(response.body).to eq({ 'title' => 'text', 'director' => 'text' })
     end
 
     it 'updates a schema for an engine' do
-      VCR.use_cassette('app_search/api_put_schema') do
-        response = @client.put_schema(engine_name, schema: { year: 'text' })
+      response = client.put_schema(engine_name, schema: { year: 'number' })
 
-        expect(response.status).to eq 200
-        expect(response.body).to eq({ 'title' => 'text', 'year' => 'text', 'director' => 'text' })
+      expect(response.status).to eq 200
+      expect(response.body).to eq({ 'title' => 'text', 'year' => 'number', 'director' => 'text' })
 
-        response = @client.schema(engine_name)
-        expect(response.body).to eq({ 'title' => 'text', 'year' => 'text', 'director' => 'text' })
-      end
+      response = client.schema(engine_name)
+      expect(response.body).to eq({ 'title' => 'text', 'year' => 'number', 'director' => 'text' })
     end
   end
 end

data/spec/integration/app-search/search_and_multiple_search_spec.rb

@@ -0,0 +1,67 @@
+# Licensed to Elasticsearch B.V. under one or more contributor
+# license agreements. See the NOTICE file distributed with
+# this work for additional information regarding copyright
+# ownership. Elasticsearch B.V. licenses this file to you under
+# the Apache License, Version 2.0 (the "License"); you may
+# not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+# frozen_string_literal: true
+
+require_relative "#{__dir__}/app_search_helper.rb"
+
+describe Elastic::EnterpriseSearch::AppSearch::Client do
+  let(:engine_name) { 'search' }
+  let(:documents) do
+    [
+      { title: 'Animal Farm', author: 'George Orwell' },
+      { title: '1984', author: 'George Orwell' },
+      { title: 'Jungle Tales', author: 'Horacio Quiroga' },
+      { title: 'Lenguas de diamante', author: 'Juana de Ibarbourou' },
+      { title: 'Metamorphosis', author: 'Franz Kafka' },
+      { title: 'The Handmaid\'s Tale', author: 'Margaret Atwood' }
+    ]
+  end
+
+  before do
+    create_engine(engine_name)
+    client.index_documents(engine_name, documents: documents)
+    sleep 1
+  end
+
+  after do
+    delete_engines
+  end
+
+  context 'search' do
+    it 'performs a single query search' do
+      response = client.search(engine_name, query: 'Ibarbourou')
+      expect(response.status).to eq 200
+      expect(response.body).not_to be nil
+      expect(response.body['results'].count).to be 1
+
+      expect(response.body['results'].first['author']['raw']).to eq documents[3][:author]
+      expect(response.body['results'].first['title']['raw']).to eq documents[3][:title]
+    end
+  end
+
+  context 'multi query search' do
+    it 'performs a multi query search' do
+      response = client.multi_search(engine_name, body: { queries: [{ query: 'George' }, { query: 'Margaret' }] })
+      expect(response.status).to eq 200
+      expect(response.body.class).to be Array
+      expect(response.body.count).to be 2
+      expect(response.body[0]['results']).to_not be nil
+      expect(response.body[1]['results']).to_not be nil
+    end
+  end
+end

data/spec/integration/app-search/search_settings_spec.rb

@@ -0,0 +1,87 @@
+# Licensed to Elasticsearch B.V. under one or more contributor
+# license agreements. See the NOTICE file distributed with
+# this work for additional information regarding copyright
+# ownership. Elasticsearch B.V. licenses this file to you under
+# the Apache License, Version 2.0 (the "License"); you may
+# not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+# frozen_string_literal: true
+
+require_relative "#{__dir__}/app_search_helper.rb"
+
+describe Elastic::EnterpriseSearch::AppSearch::Client do
+  let(:engine_name) { 'search-settings' }
+
+  before do
+    create_engine(engine_name)
+  end
+
+  after do
+    delete_engines
+  end
+
+  context 'search settings' do
+    it 'returns engine search settings' do
+      response = client.search_settings(engine_name)
+
+      expect(response.status).to eq 200
+      expect(response.body['search_fields'])
+      expect(response.body['result_fields'])
+      expect(response.body['boosts'])
+    end
+
+    it 'updates search settings' do
+      client.put_schema(engine_name, schema: { year: 'number' })
+      documents = [
+        { title: 'Attack of the Giant Leeches', year: 1959, director: 'Bernard L. Kowalski' },
+        { title: '20,000 Leagues Under the Sea', year: 1916, director: 'Stuart Paton' },
+        { title: 'Indestructible Man', year: 1956, director: 'Jack Pollexfen' },
+        { title: 'Metropolis', year: 1927, director: 'Fritz Lang' }
+      ]
+      client.index_documents(engine_name, documents: documents)
+
+      body = {
+        boosts: {
+          year: [
+            {
+              type: 'proximity',
+              function: 'linear',
+              center: 1950,
+              factor: 9
+            }
+          ]
+        }
+      }
+      response = client.put_search_settings(engine_name, body: body)
+
+      expect(response.status).to eq 200
+      expect(response.body['boosts']).to eq(
+        {
+          'year' => [
+            { 'type' => 'proximity',
+              'function' => 'linear',
+              'center' => 1950,
+              'factor' => 9 }
+          ]
+        }
+      )
+    end
+
+    it 'resets search settings' do
+      response = client.reset_search_settings(engine_name)
+
+      expect(response.body['boosts']).to eq({})
+      expect(response.status).to eq 200
+    end
+  end
+end

data/spec/integration/app-search/synonyms_spec.rb

@@ -0,0 +1,79 @@
+# Licensed to Elasticsearch B.V. under one or more contributor
+# license agreements. See the NOTICE file distributed with
+# this work for additional information regarding copyright
+# ownership. Elasticsearch B.V. licenses this file to you under
+# the Apache License, Version 2.0 (the "License"); you may
+# not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+# frozen_string_literal: true
+
+require_relative "#{__dir__}/app_search_helper.rb"
+
+describe Elastic::EnterpriseSearch::AppSearch::Client do
+  let(:engine_name) { 'synonyms' }
+
+  before do
+    create_engine(engine_name)
+  end
+
+  after do
+    delete_engines
+  end
+
+  context 'Synonyms' do
+    it 'creates a synonym set' do
+      response = client.create_synonym_set(engine_name, body: { synonyms: ['joypad', 'gamepad'] })
+
+      expect(response.status).to eq 200
+      expect(response.body['synonyms'].sort).to eq ['gamepad', 'joypad']
+      expect(response.body['id'])
+    end
+
+    it 'lists synonym sets' do
+      client.create_synonym_set(engine_name, body: { synonyms: ['joypad', 'gamepad'] })
+      response = client.list_synonym_sets(engine_name)
+
+      expect(response.status).to eq 200
+      expect(response.body['results'].count).to be > 0
+      expect(response.body['results'].first['synonyms'].sort).to eq ['gamepad', 'joypad']
+    end
+
+    it 'retrieves a synonym set by ID' do
+      id = client.create_synonym_set(engine_name, body: { synonyms: ['joypad', 'gamepad'] }).body['id']
+      response = client.synonym_set(engine_name, synonym_set_id: id)
+
+      expect(response.status).to eq 200
+      expect(response.body).to eq({ 'id' => id, 'synonyms' => ['joypad', 'gamepad'] })
+    end
+
+    it 'updates a synonym set' do
+      id = client.create_synonym_set(engine_name, body: { synonyms: ['joypad', 'gamepad'] }).body['id']
+      response = client.put_synonym_set(
+        engine_name,
+        synonym_set_id: id,
+        body: { synonyms: ['gamepad', 'controller'] }
+      )
+
+      expect(response.status).to eq 200
+      expect(response.body).to eq({ 'id' => id, 'synonyms' => ['gamepad', 'controller'] })
+    end
+
+    it 'deletes a synonym set' do
+      id = client.create_synonym_set(engine_name, body: { synonyms: ['joypad', 'gamepad'] }).body['id']
+      response = @client.delete_synonym_set(engine_name, synonym_set_id: id)
+
+      expect(response.status).to eq 200
+      expect(response.body).to eq({ 'deleted' => true })
+    end
+  end
+end