elastic-enterprise-search 7.14.0 → 7.16.0

data/{spec/app-search/api_logs_spec.rb → lib/elastic/workplace-search/api/triggers_blocklist.rb}

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # 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
@@ -15,21 +17,28 @@
 # specific language governing permissions and limitations
 # under the License.
 
-# frozen_string_literal: true
-
-require_relative './api_spec_helper'
+module Elastic
+  module EnterpriseSearch
+    module WorkplaceSearch
+      module Actions
+        # Get current triggers blocklist
+        #
+        # @param arguments [Hash] endpoint arguments
+        # @option arguments [Hash] :headers optional HTTP headers to send with the request
+        #
+        # @see https://www.elastic.co/guide/en/workplace-search/current/automatic-query-refinement-blocklist.html
+        #
+        def triggers_blocklist(arguments = {})
+          headers = arguments.delete(:headers) || {}
 
-describe Elastic::EnterpriseSearch::AppSearch::Client do
-  context 'api_logs' do
-    it 'returns api logs' do
-      VCR.use_cassette('app_search/api_logs') do
-        response = @client.api_logs(
-          'videogames',
-          from_date: Date.new(2020, 10, 0o1),
-          to_date: Date.new(2020, 11, 0o5)
-        )
-        expect(response.status).to eq 200
-        expect(response.body['results'].count).to be > 1
+          request(
+            :get,
+            'api/ws/v1/automatic_query_refinement/',
+            arguments,
+            {},
+            headers
+          )
+        end
       end
     end
   end

data/lib/elastic/workplace-search/workplace_search.rb

@@ -21,25 +21,10 @@ module Elastic
   module EnterpriseSearch
     # Workplace Search client for Enterprise Search.
     module WorkplaceSearch
-      # The Request module is included in the WorkplaceSearch Client to override
-      # EnterpriseSearch client's authentication method with Workplace's
-      # authentication.
-      module Request
-        def setup_authentication_header
-          case http_auth
-          when Hash
-            basic_auth_header
-          when String
-            "Bearer #{http_auth}"
-          end
-        end
-      end
-
       # The Workplace Search Client
       # Extends EnterpriseSearch client but overrides authentication to use access token.
       class Client < Elastic::EnterpriseSearch::Client
         include Elastic::EnterpriseSearch::WorkplaceSearch::Actions
-        include Elastic::EnterpriseSearch::WorkplaceSearch::Request
         include Elastic::EnterpriseSearch::Utils
 
         # Create a new Elastic::EnterpriseSearch::WorkplaceSearch::Client client

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

@@ -0,0 +1,80 @@
+# 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 'Adaptive Relevance' do
+    let(:engine_name) { 'adaptive-relevance' }
+
+    before do
+      create_engine(engine_name)
+    end
+
+    after do
+      delete_engines
+    end
+
+    it 'retrieves adaptive relevance settings' do
+      response = client.adaptive_relevance_settings(engine_name)
+      expect(response.body['curation'])
+      expect(response.status).to eq 200
+    end
+
+    it 'updates settings and lists adaptive relevance for an engine' do
+      body = { curation: { enabled: true } }
+      # Enables curations
+      response = client.put_adaptive_relevance_settings(engine_name, body: body)
+      expect(response.status).to eq 200
+      expect(response.body.dig('curation', 'enabled'))
+
+      # Lists suggestions
+      response = client.list_adaptive_relevance_suggestions(engine_name)
+      expect(response.status).to eq 200
+      expect(response.body['meta'])
+      expect(response.body['results'])
+    end
+
+    xit 'updates adaptive relevance' do
+      body = { curation: { enabled: true } }
+      client.put_adaptive_relevance_settings(engine_name, body: body)
+
+      # Index document and create curation:
+      id = client.index_documents(engine_name, documents: [{ title: 'experiment' }]).body.first['id']
+      body = { queries: ['test'], promoted: [id] }
+      client.create_curation(engine_name, body: body)
+      body = [{ query: 'test', type: 'curation', status: 'applied' }]
+      response = client.put_adaptive_relevance_suggestions(engine_name, body: body)
+
+      expect(response.status).to eq 200
+    end
+
+    xit 'retrieves an adaptive relevance' do
+      # Enables curations
+      client.put_adaptive_relevance_settings(engine_name, body: { curation: { enabled: true } })
+      id = client.index_documents(engine_name, documents: [{ title: 'experiment' }]).body.first['id']
+      body = { queries: ['test'], promoted: [id] }
+      client.create_curation(engine_name, body: body)
+
+      response = client.adaptive_relevance_suggestions(engine_name, search_suggestion_query: 'test')
+      expect(response.status).to eq 200
+      expect(response.body)
+    end
+  end
+end

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

@@ -0,0 +1,110 @@
+# 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 'API Key' do
+    it 'creates and deletes an API key' do
+      name = 'created-key'
+      body = { name: name, type: 'private', read: true, write: true, access_all_engines: true }
+      response = client.create_api_key(body: body)
+
+      expect(response.status).to eq 200
+      expect(response.body.keys).to include('id')
+      expect(response.body.keys).to include('key')
+      expect(response.body).to include('name' => name)
+      expect(response.body).to include('type' => 'private')
+      expect(response.body).to include('read' => true)
+      expect(response.body).to include('write' => true)
+      expect(response.body).to include('access_all_engines' => true)
+
+      response = client.delete_api_key(api_key_name: name)
+
+      expect(response.status).to eq 200
+      expect(response.body).to eq({ 'deleted' => true })
+    end
+
+    it 'gets the details of an API key' do
+      name = 'details-key'
+      body = { name: name, type: 'private', read: true, write: true, access_all_engines: true }
+      client.create_api_key(body: body)
+
+      response = client.api_key(api_key_name: name)
+
+      expect(response.status).to eq 200
+      expect(response.body.keys).to include('id')
+      expect(response.body.keys).to include('key')
+      expect(response.body).to include('name' => name)
+      expect(response.body).to include('type' => 'private')
+      expect(response.body).to include('read' => true)
+      expect(response.body).to include('write' => true)
+      expect(response.body).to include('access_all_engines' => true)
+      expect(response.body)
+
+      client.delete_api_key(api_key_name: name)
+    end
+
+    it 'updates an API key' do
+      key_name = 'updates-key'
+      engine_name = 'update-engine'
+      body = { name: key_name, type: 'private', read: true, write: true, access_all_engines: true }
+      client.create_api_key(body: body)
+      create_engine(engine_name)
+
+      body = { name: key_name, type: 'private', read: true, write: true, engines: [engine_name] }
+      attempts = 0
+      begin
+        response = put_api_key(key_name, body)
+      # Since we're creating the API key and trying to update it right away, we sometimes get a 404
+      # if the transaction hasn't been confirmed. We give it a second and try again for a few times:
+      rescue Elasticsearch::Transport::Transport::Errors::NotFound
+        attempts += 1
+        if attempts > 5
+          Logger.new($stdout).log('Attempted 6 times')
+          raise e
+        end
+
+        sleep 1
+        response = put_api_key(key_name, body)
+      end
+      expect(response.status).to eq 200
+      expect(response.body['engines']).to eq [engine_name]
+      client.delete_engine(engine_name)
+    end
+
+    def put_api_key(key_name, body)
+      client.put_api_key(api_key_name: key_name, body: body)
+    end
+
+    it 'lists API keys' do
+      body = { name: 'api-key-1', type: 'private', read: true, write: true, access_all_engines: true }
+      client.create_api_key(body: body)
+      body = { name: 'api-key-2', type: 'private', read: true, write: true, access_all_engines: true }
+      client.create_api_key(body: body)
+
+      response = client.list_api_keys
+      expect(response.status).to eq 200
+      expect(response.body['results'].select { |r| ['api-key-1', 'api-key-2'].include? r['name'] }.count).to be 2
+      expect(response.body['results'].count).to be >= 2
+      client.delete_api_key(api_key_name: 'api-key-1')
+      client.delete_api_key(api_key_name: 'api-key-2')
+    end
+  end
+end

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

@@ -0,0 +1,59 @@
+# 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 'API logs' do
+    let(:engine_name) { 'videogames' }
+    let(:api_key_name) { 'logs-api-key' }
+
+    before do
+      create_engine(engine_name)
+      # Create API Key Client to log events:
+      body = { name: api_key_name, type: 'private', read: true, write: true, access_all_engines: true }
+      api_key = client.create_api_key(body: body).body['key']
+      private_key_client = Elastic::EnterpriseSearch::AppSearch::Client.new(
+        host: ENV['ELASTIC_ENTERPRISE_HOST'] || 'http://localhost:3002',
+        http_auth: api_key
+      )
+      id = private_key_client.index_documents(engine_name, documents: [{ title: 'Test Document' }]).body.first['id']
+      private_key_client.documents(engine_name, document_ids: [id])
+      private_key_client.delete_documents(engine_name, document_ids: [id])
+    end
+
+    after do
+      delete_engines
+      client.delete_api_key(api_key_name: api_key_name)
+    end
+
+    it 'returns api logs' do
+      response = client.api_logs(engine_name, from_date: Date.today - 1, to_date: Date.today + 1)
+      expect(response.status).to eq 200
+
+      attempts = 0
+      while response.body['results'].count < 1 && attempts < 20
+        sleep 1
+        attempts += 1
+        response = client.api_logs(engine_name, from_date: Date.today - 1, to_date: Date.today + 1)
+      end
+      expect(response.body['results'].count).to be >= 1
+    end
+  end
+end

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

@@ -0,0 +1,51 @@
+# 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 'spec_helper'
+require 'logger'
+
+# App Search Integration tests Client Configuration
+def client
+  @client ||= Elastic::EnterpriseSearch::AppSearch::Client.new(
+    host: ENV['ELASTIC_ENTERPRISE_HOST'] || 'http://localhost:3002',
+    http_auth: {
+      user: ENV['ELASTIC_ENTERPRISE_USER'] || 'enterprise_search',
+      password: ENV['ELASTIC_ENTERPRISE_PASSWORD'] || 'changeme'
+    }
+  )
+end
+
+def delete_engines
+  engines = client.list_engines.body['results']
+  engines.each do |engine|
+    client.delete_engine(engine['name'])
+    # Gives time to the server to sync:
+    sleep 2
+  end
+end
+
+def create_engine(name)
+  client.create_engine(name: name)
+rescue Elasticsearch::Transport::Transport::Errors::BadRequest => e
+  raise e unless e.message.match(/Name is already taken/)
+
+  Logger.new($stdout).info("Engine '#{name}' had already been created, giving time for the server to sync.")
+  sleep 5
+  client.create_engine(name: name)
+end

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

@@ -0,0 +1,47 @@
+# 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 'Count Analytics' do
+    let(:engine_name) { 'count-analytics' }
+
+    before do
+      create_engine(engine_name)
+      sleep 1
+    end
+
+    after do
+      delete_engines
+    end
+
+    it 'returns count analytics' do
+      response = client.count_analytics(engine_name)
+
+      expect(response.status).to eq 200
+      expect(response.body['results'].count).to be > 1
+    end
+
+    it 'returns count analytics with filters' do
+      response = client.count_analytics(engine_name, body: { filters: { tag: 'web' } })
+      expect(response.status).to eq 200
+      expect(response.body['results'].count).to be > 1
+    end
+  end
+end

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

@@ -0,0 +1,86 @@
+# 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 'Crawler crawl requests' do
+    let(:engine_name) { 'crawler-requests' }
+    let(:name) { 'https://www.elastic.co' }
+
+    before do
+      create_engine(engine_name)
+      body = { name: name }
+      response = client.create_crawler_domain(engine_name, body: body)
+      @domain = response.body
+    end
+
+    after do
+      client.delete_crawler_active_crawl_request(engine_name)
+      delete_engines
+    end
+
+    it 'creates, gets, lists and deletes a crawl request' do
+      response = client.create_crawler_crawl_request(engine_name)
+
+      expect(response.status).to eq 200
+      expect(response.body.keys).to include('status')
+      expect(response.body.keys).to include('id')
+      request_id = response.body['id']
+
+      # get crawl request
+      response = client.crawler_crawl_request(engine_name, crawl_request_id: request_id)
+      expect(response.status).to eq 200
+      expect(response.body.keys).to include('status')
+      expect(response.body.keys).to include('id')
+
+      # get active crawl request details
+      response = client.crawler_active_crawl_request(engine_name)
+      expect(response.status).to eq 200
+      expect(response.body.keys).to include('status')
+      expect(response.body.keys).to include('id')
+
+      attempts = 0
+      while response.body['status'] != 'running' && attempts < 20
+        sleep 1
+        attempts += 1
+        response = client.crawler_active_crawl_request(engine_name)
+      end
+      expect(response.body['status']).to eq 'running'
+
+      # list crawl requests
+      response = client.list_crawler_crawl_requests(engine_name)
+      expect(response.status).to eq 200
+
+      # delete active crawl request
+      response = client.delete_active_crawl_request(engine_name)
+      expect(response.status).to eq 200
+    end
+
+    it 'creates, starts and stops a crawl request' do
+      response = client.create_crawler_crawl_request(engine_name)
+      request_id = response.body['id']
+
+      response = client.delete_crawler_active_crawl_request(engine_name)
+      expect(response.status).to eq 200
+      expect(response.body['id']).to eq request_id
+      expect(response.body['status']).to eq('canceling')
+    end
+  end
+end

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

@@ -0,0 +1,73 @@
+# 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 'Crawler crawl rules' do
+    let(:engine_name) { 'crawler-crawl-rule' }
+    let(:name) { 'https://www.elastic.co' }
+
+    before do
+      create_engine(engine_name)
+      body = { name: name }
+      response = client.create_crawler_domain(engine_name, body: body)
+      @domain = response.body
+    end
+
+    after do
+      client.delete_engine(engine_name)
+    end
+
+    it 'creates, updates and deletes a rule' do
+      # Create a crawler crawl rule
+      body = { order: 1, policy: 'allow', rule: 'contains', pattern: '/stack' }
+      response = client.create_crawler_crawl_rule(engine_name, domain_id: @domain['id'], body: body)
+      expect(response.status).to eq 200
+      rule_id = response.body['id']
+      expect(response.body['order']).to eq 1
+      expect(response.body['policy']).to eq 'allow'
+      expect(response.body['rule']).to eq 'contains'
+      expect(response.body['pattern']).to eq '/stack'
+
+      # Update a crawler crawl rule
+      body = { order: 2, policy: 'allow', rule: 'begins', pattern: '/stack' }
+      response = client.put_crawler_crawl_rule(
+        engine_name,
+        domain_id: @domain['id'],
+        crawl_rule_id: rule_id,
+        body: body
+      )
+      expect(response.status).to eq 200
+      expect(response.body['order']).to eq 2
+      expect(response.body['policy']).to eq 'allow'
+      expect(response.body['rule']).to eq 'begins'
+      expect(response.body['pattern']).to eq '/stack'
+
+      # Delete a crawler crawl rule
+      response = client.delete_crawler_crawl_rule(
+        engine_name,
+        domain_id: @domain['id'],
+        crawl_rule_id: rule_id
+      )
+      expect(response.status).to eq 200
+      expect(response.body).to eq({ 'deleted' => true })
+    end
+  end
+end

data/spec/integration/app-search/crawler_domain_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
+  context 'Crawler Domain' do
+    let(:engine_name) { 'crawler' }
+    let(:name) { 'https://www.elastic.co' }
+
+    before do
+      create_engine(engine_name)
+    end
+
+    after do
+      client.delete_crawler_domain(engine_name, domain_id: @domain['id'])
+      client.delete_engine(engine_name)
+      sleep 1
+    end
+
+    it 'creates, gets and lists a crawler domain' do
+      body = { name: name }
+      response = client.create_crawler_domain(engine_name, body: body)
+      @domain = response.body
+
+      expect(response.status).to eq 200
+      expect(response.body['id']).to eq @domain['id']
+      expect(response.body).to include('name' => name)
+
+      # client.crawler_domain
+      response = client.crawler_domain(engine_name, domain_id: @domain['id'])
+      expect(response.status).to eq 200
+      expect(response.body['id']).to eq @domain['id']
+      expect(response.body).to include('name' => name)
+
+      # client.list_crawler_domains
+      response = client.list_crawler_domains(engine_name)
+      expect(response.status).to eq 200
+      expect(response.body['results'].first['id']).to eq(@domain['id'])
+    end
+
+    it 'creates and updates a crawler domain' do
+      body = { name: name }
+      response = client.create_crawler_domain(engine_name, body: body)
+      @domain = response.body
+
+      expect(response.status).to eq 200
+      expect(response.body['id']).to eq @domain['id']
+      expect(response.body).to include('name' => name)
+
+      new_name = 'https://www.wikipedia.org'
+      body = { name: new_name }
+      response = client.put_crawler_domain(engine_name, domain_id: @domain['id'], domain: body)
+
+      expect(response.status).to eq 200
+      expect(response.body['id']).to eq @domain['id']
+      expect(response.body).to include('name' => new_name)
+    end
+
+    it 'validates a domain' do
+      body = { name: name }
+      @domain = client.create_crawler_domain(engine_name, body: body).body
+      body = { url: name }
+      response = client.crawler_domain_validation_result(body: body)
+
+      expect(response.status).to eq 200
+      expect(response.body['url']).to eq name
+      expect(response.body['valid']).to eq true
+    end
+  end
+end