opensearch-ruby 2.0.3 → 3.4.0

data/test/dsl/unit/search_size_from_test.rb

@@ -0,0 +1,68 @@
+# SPDX-License-Identifier: Apache-2.0
+#
+# The OpenSearch Contributors require contributions made to
+# this file be licensed under the Apache-2.0 license or a
+# compatible open source license.
+#
+# Modifications Copyright OpenSearch Contributors. See
+# GitHub history for details.
+#
+# 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.
+
+require_relative '../test_helper'
+
+module OpenSearch
+  module Test
+    class SearchSizeTest < ::OpenSearch::Test::UnitTestCase
+      context 'Search pagination' do
+        should 'encode the size parameter' do
+          subject = OpenSearch::DSL::Search::Search.new do
+            size 5
+          end
+          assert_equal({ size: 5 }, subject.to_hash)
+        end
+
+        should 'encode the from parameter' do
+          subject = OpenSearch::DSL::Search::Search.new do
+            from 5
+          end
+          assert_equal({ from: 5 }, subject.to_hash)
+        end
+
+        should 'have getter methods' do
+          subject = OpenSearch::DSL::Search::Search.new
+          assert_nil subject.size
+          assert_nil subject.from
+          subject.size = 5
+          subject.from = 5
+          assert_equal 5, subject.size
+          assert_equal 5, subject.from
+        end
+
+        should 'have setter methods' do
+          subject = OpenSearch::DSL::Search::Search.new
+          subject.size = 5
+          subject.from = 5
+          assert_equal 5, subject.size
+          assert_equal 5, subject.from
+          assert_equal({ size: 5, from: 5 }, subject.to_hash)
+        end
+      end
+    end
+  end
+end

data/test/dsl/unit/search_sort_test.rb

@@ -0,0 +1,91 @@
+# SPDX-License-Identifier: Apache-2.0
+#
+# The OpenSearch Contributors require contributions made to
+# this file be licensed under the Apache-2.0 license or a
+# compatible open source license.
+#
+# Modifications Copyright OpenSearch Contributors. See
+# GitHub history for details.
+#
+# 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.
+
+require_relative '../test_helper'
+
+module OpenSearch
+  module Test
+    class SearchSortTest < ::OpenSearch::Test::UnitTestCase
+      subject { OpenSearch::DSL::Search::Sort.new }
+
+      context 'Search sort' do
+        should 'add a single field' do
+          subject = OpenSearch::DSL::Search::Sort.new :foo
+          assert_equal([:foo], subject.to_hash)
+        end
+
+        should 'add multiple fields' do
+          subject = OpenSearch::DSL::Search::Sort.new %i[foo bar]
+          assert_equal(%i[foo bar], subject.to_hash)
+        end
+
+        should 'add a field with options' do
+          subject = OpenSearch::DSL::Search::Sort.new foo: { order: 'desc', mode: 'avg' }
+          assert_equal([{ foo: { order: 'desc', mode: 'avg' } }], subject.to_hash)
+        end
+
+        should 'add fields with the DSL method' do
+          subject = OpenSearch::DSL::Search::Sort.new do
+            by :foo
+            by :bar, order: 'desc'
+          end
+
+          assert_equal(
+            [
+              :foo,
+              { bar: { order: 'desc' } }
+            ], subject.to_hash
+          )
+        end
+
+        should 'be empty' do
+          subject = OpenSearch::DSL::Search::Sort.new
+          assert_equal subject.empty?, true
+        end
+
+        should 'not be empty' do
+          subject = OpenSearch::DSL::Search::Sort.new foo: { order: 'desc' }
+          assert_equal subject.empty?, false
+        end
+
+        context '#to_hash' do
+          should 'not duplicate values when defined by arguments' do
+            subject = OpenSearch::DSL::Search::Sort.new foo: { order: 'desc' }
+            assert_equal(subject.to_hash, subject.to_hash)
+          end
+
+          should 'not duplicate values when defined by a block' do
+            subject = OpenSearch::DSL::Search::Sort.new do
+              by :foo
+            end
+
+            assert_equal(subject.to_hash, subject.to_hash)
+          end
+        end
+      end
+    end
+  end
+end

data/test/dsl/unit/search_suggest_test.rb

@@ -0,0 +1,46 @@
+# SPDX-License-Identifier: Apache-2.0
+#
+# The OpenSearch Contributors require contributions made to
+# this file be licensed under the Apache-2.0 license or a
+# compatible open source license.
+#
+# Modifications Copyright OpenSearch Contributors. See
+# GitHub history for details.
+#
+# 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.
+
+require_relative '../test_helper'
+
+module OpenSearch
+  module Test
+    class SearchSuggestTest < ::OpenSearch::Test::UnitTestCase
+      subject { OpenSearch::DSL::Search::Suggest.new :foo }
+
+      context 'Search suggest' do
+        should 'be an empty hash by default' do
+          assert_equal({ foo: {} }, subject.to_hash)
+        end
+
+        should 'contain options' do
+          subject = OpenSearch::DSL::Search::Suggest.new :foo, boo: 'bam'
+          assert_equal({ foo: { boo: 'bam' } }, subject.to_hash)
+        end
+      end
+    end
+  end
+end

data/test/dsl/unit/search_test.rb

@@ -0,0 +1,268 @@
+# SPDX-License-Identifier: Apache-2.0
+#
+# The OpenSearch Contributors require contributions made to
+# this file be licensed under the Apache-2.0 license or a
+# compatible open source license.
+#
+# Modifications Copyright OpenSearch Contributors. See
+# GitHub history for details.
+#
+# 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.
+
+require_relative '../test_helper'
+
+module OpenSearch
+  module Test
+    class SearchTest < ::OpenSearch::Test::UnitTestCase
+      subject { OpenSearch::DSL::Search::Search.new }
+
+      context 'The Search module' do
+        should 'have the search method on instance' do
+          class DummySearchReceiver
+            include OpenSearch::DSL::Search
+          end
+
+          assert_instance_of OpenSearch::DSL::Search::Search, DummySearchReceiver.new.search
+        end
+
+        should 'have the search method on module' do
+          class DummySearchReceiver
+            include OpenSearch::DSL::Search
+          end
+
+          assert_instance_of OpenSearch::DSL::Search::Search, OpenSearch::DSL::Search.search
+        end
+
+        should 'have access to the calling context' do
+          class DummySearchReceiver
+            include OpenSearch::DSL::Search
+
+            def initialize
+              @other_value = 'foo'
+            end
+
+            def value
+              42
+            end
+
+            def search_definition
+              search do |q|
+                q.from value
+                q.size @other_value
+                q.stored_fields ['term']
+
+                q.filter do |q|
+                  q._and do |q|
+                    q.term thang: @other_value
+                    q.term attributes: value
+                  end
+                end
+              end
+            end
+          end
+
+          assert_equal({ from: 42,
+                         size: 'foo',
+                         stored_fields: ['term'],
+                         filter: { and: [{ term: { thang: 'foo' } },
+                                         { term: { attributes: 42 } }] } },
+                       DummySearchReceiver.new.search_definition.to_hash)
+        end
+      end
+
+      context 'The Search class' do
+        context 'with query' do
+          should 'take the query as a literal value' do
+            subject.query foo: 'bar'
+            assert_equal({ query: { foo: 'bar' } }, subject.to_hash)
+          end
+
+          should 'take the query as a block' do
+            OpenSearch::DSL::Search::Query.expects(:new).returns({ foo: 'bar' })
+            subject.query { ; }
+            assert_equal({ query: { foo: 'bar' } }, subject.to_hash)
+          end
+
+          should 'allow chaining' do
+            assert_instance_of OpenSearch::DSL::Search::Search, subject.query(:foo)
+            assert_instance_of OpenSearch::DSL::Search::Search, subject.query(:foo).query(:bar)
+          end
+
+          should 'be converted to hash' do
+            assert_equal({}, subject.to_hash)
+
+            subject.query foo: 'bar'
+            assert_equal({ query: { foo: 'bar' } }, subject.to_hash)
+          end
+
+          should 'have a getter/setter method' do
+            assert_nil subject.query
+            subject.query = Object.new
+            assert_not_nil subject.query
+          end
+        end
+
+        context 'with filter' do
+          should 'take the filter as a literal value' do
+            subject.filter foo: 'bar'
+            assert_equal({ filter: { foo: 'bar' } }, subject.to_hash)
+          end
+
+          should 'take the filter as a block' do
+            OpenSearch::DSL::Search::Filter.expects(:new).returns({ foo: 'bar' })
+            subject.filter { ; }
+            assert_equal({ filter: { foo: 'bar' } }, subject.to_hash)
+          end
+
+          should 'allow chaining' do
+            assert_instance_of OpenSearch::DSL::Search::Search, subject.filter(:foo)
+            assert_instance_of OpenSearch::DSL::Search::Search, subject.filter(:foo).filter(:bar)
+          end
+
+          should 'be converted to hash' do
+            assert_equal({}, subject.to_hash)
+
+            subject.filter foo: 'bar'
+            assert_equal({ filter: { foo: 'bar' } }, subject.to_hash)
+          end
+
+          should 'have a getter/setter method' do
+            assert_nil subject.filter
+            subject.filter = Object.new
+            assert_not_nil subject.filter
+          end
+        end
+
+        context 'with post_filter' do
+          should 'take the filter as a literal value' do
+            subject.post_filter foo: 'bar'
+            assert_equal({ post_filter: { foo: 'bar' } }, subject.to_hash)
+          end
+
+          should 'take the filter as a block' do
+            OpenSearch::DSL::Search::Filter.expects(:new).returns({ foo: 'bar' })
+            subject.post_filter { ; }
+            assert_equal({ post_filter: { foo: 'bar' } }, subject.to_hash)
+          end
+
+          should 'allow chaining' do
+            assert_instance_of OpenSearch::DSL::Search::Search, subject.post_filter(:foo)
+            assert_instance_of OpenSearch::DSL::Search::Search, subject.post_filter(:foo).post_filter(:bar)
+          end
+
+          should 'be converted to hash' do
+            assert_equal({}, subject.to_hash)
+
+            subject.post_filter foo: 'bar'
+            assert_equal({ post_filter: { foo: 'bar' } }, subject.to_hash)
+          end
+
+          should 'have a getter/setter method' do
+            assert_nil subject.post_filter
+            subject.post_filter = Object.new
+            assert_not_nil subject.post_filter
+          end
+        end
+
+        context 'with aggregations' do
+          should 'take the aggregation as a literal value' do
+            subject.aggregation :foo, terms: 'bar'
+            assert_equal({ aggregations: { foo: { terms: 'bar' } } }, subject.to_hash)
+          end
+
+          should 'take the aggregation as a block' do
+            OpenSearch::DSL::Search::Aggregation.expects(:new).returns({ tam: 'tam' })
+            subject.aggregation :foo do; end
+            assert_equal({ aggregations: { foo: { tam: 'tam' } } }, subject.to_hash)
+          end
+
+          should 'allow chaining' do
+            assert_instance_of OpenSearch::DSL::Search::Search, subject.aggregation(:foo)
+            assert_instance_of OpenSearch::DSL::Search::Search, subject.aggregation(:foo).aggregation(:bar)
+          end
+
+          should 'be converted to hash' do
+            assert_equal({}, subject.to_hash)
+
+            subject.post_filter foo: 'bar'
+            assert_equal({ post_filter: { foo: 'bar' } }, subject.to_hash)
+          end
+
+          should 'have a getter/setter method' do
+            assert_nil subject.aggregations
+            subject.aggregations = { foo: Object.new }
+            assert_not_nil subject.aggregations
+          end
+        end
+
+        context 'with sorting' do
+          should 'be converted to hash' do
+            subject.sort :foo
+            assert_equal({ sort: [:foo] }, subject.to_hash)
+          end
+
+          should 'have a getter method' do
+            assert_nil subject.sort
+            subject.sort :foo
+            assert_instance_of OpenSearch::DSL::Search::Sort, subject.sort
+          end
+
+          should 'have a setter method' do
+            sort_object = OpenSearch::DSL::Search::Sort.new foo: { order: 'desc' }, bar: { order: 'asc' }
+            subject.sort = sort_object
+            assert_not_nil subject.sort
+            assert_equal({ sort: [{ foo: { order: 'desc' }, bar: { order: 'asc' } }] }, subject.to_hash)
+          end
+        end
+
+        context 'with suggest' do
+          should 'be converted to hash' do
+            subject.suggest :foo, { bar: 'bam' }
+            assert_equal({ suggest: { foo: { bar: 'bam' } } }, subject.to_hash)
+          end
+
+          should 'have a getter/setter method' do
+            assert_nil subject.suggest
+            subject.suggest = Object.new
+            assert_not_nil subject.suggest
+          end
+        end
+
+        context 'with highlighting' do
+          should 'be converted to a hash' do
+            subject.highlight foo: 'bar'
+            assert_not_nil subject.highlight
+            assert_equal({ highlight: { foo: 'bar' } }, subject.to_hash)
+          end
+        end
+
+        context 'with options' do
+          should 'encode options' do
+            subject.explain true
+            subject.fields %i[foo bar]
+            assert_equal({ explain: true, fields: %i[foo bar] }, subject.to_hash)
+          end
+
+          should 'raise an exception for unknown method' do
+            assert_raise(NoMethodError) { subject.foobar true }
+          end
+        end
+      end
+    end
+  end
+end

data/test/dsl/unit/utils_test.rb

@@ -0,0 +1,47 @@
+# SPDX-License-Identifier: Apache-2.0
+#
+# The OpenSearch Contributors require contributions made to
+# this file be licensed under the Apache-2.0 license or a
+# compatible open source license.
+#
+# Modifications Copyright OpenSearch Contributors. See
+# GitHub history for details.
+#
+# 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.
+
+require_relative '../test_helper'
+
+module OpenSearch
+  module Test
+    class UtilsTest < ::OpenSearch::Test::UnitTestCase
+      context 'Utils' do
+        should 'convert a string to camelcase' do
+          assert_equal 'Foo', OpenSearch::DSL::Utils.__camelize('foo')
+        end
+
+        should 'convert an underscored string to camelcase' do
+          assert_equal 'FooBar', OpenSearch::DSL::Utils.__camelize('foo_bar')
+        end
+
+        should 'convert a symbol' do
+          assert_equal 'FooBar', OpenSearch::DSL::Utils.__camelize(:foo_bar)
+        end
+      end
+    end
+  end
+end

data/test/transport/integration/transport_test.rb

@@ -0,0 +1,117 @@
+# SPDX-License-Identifier: Apache-2.0
+#
+# The OpenSearch Contributors require contributions made to
+# this file be licensed under the Apache-2.0 license or a
+# compatible open source license.
+#
+# Modifications Copyright OpenSearch Contributors. See
+# GitHub history for details.
+#
+# 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.
+
+require_relative '../test_helper'
+
+class OpenSearch::Transport::ClientIntegrationTest < Minitest::Test
+  context "Transport" do
+    setup do
+      @host, @port = OPENSEARCH_HOSTS.first.split(':')
+      begin; Object.send(:remove_const, :Patron);   rescue NameError; end
+    end
+
+    should "allow to customize the Faraday adapter to Typhoeus" do
+      # Require the library so autodetection finds it.
+      require 'typhoeus'
+      # Require the adapter so autodetection finds it.
+      require 'faraday/typhoeus' if Gem::Version.new(Faraday::VERSION) >= Gem::Version.new('2')
+
+      transport = OpenSearch::Transport::Transport::HTTP::Faraday.new \
+        :hosts => [ { host: @host, port: @port } ] do |f|
+          f.response :logger
+          f.adapter  :typhoeus
+        end
+
+      client = OpenSearch::Transport::Client.new transport: transport
+      response = client.perform_request 'GET', ''
+
+      assert_respond_to(response.body, :to_hash)
+      assert_not_nil response.body['name']
+      assert_equal 'application/json; charset=UTF-8', response.headers['content-type']
+    end unless jruby?
+
+    should "allow to customize the Faraday adapter to NetHttpPersistent" do
+      # Require the library so autodetection finds it.
+      require 'net/http/persistent'
+      # Require the adapter so autodetection finds it.
+      require 'faraday/net_http_persistent'
+
+      transport = OpenSearch::Transport::Transport::HTTP::Faraday.new \
+                                                                       :hosts => [ { host: @host, port: @port } ] do |f|
+        f.response :logger
+        f.adapter  :net_http_persistent
+      end
+
+      client = OpenSearch::Transport::Client.new transport: transport
+      client.perform_request 'GET', ''
+    end
+
+    should "allow to define connection parameters and pass them" do
+      transport = OpenSearch::Transport::Transport::HTTP::Faraday.new \
+                    :hosts => [ { host: @host, port: @port } ],
+                    :options => { :transport_options => {
+                                    :params => { :format => 'yaml' }
+                                  }
+                                }
+
+      client = OpenSearch::Transport::Client.new transport: transport
+      response = client.perform_request 'GET', ''
+
+      assert response.body.start_with?("---\n"), "Response body should be YAML: #{response.body.inspect}"
+    end
+
+    should "use the Curb client" do
+      require 'curb'
+      require 'opensearch/transport/transport/http/curb'
+
+      transport = OpenSearch::Transport::Transport::HTTP::Curb.new \
+        :hosts => [ { host: @host, port: @port } ] do |curl|
+          curl.verbose = true
+        end
+
+      client = OpenSearch::Transport::Client.new transport: transport
+      client.perform_request 'GET', ''
+    end unless JRUBY
+
+    should "deserialize JSON responses in the Curb client" do
+      require 'curb'
+      require 'opensearch/transport/transport/http/curb'
+
+      transport = OpenSearch::Transport::Transport::HTTP::Curb.new \
+        :hosts => [ { host: @host, port: @port } ] do |curl|
+          curl.verbose = true
+        end
+
+      client = OpenSearch::Transport::Client.new transport: transport
+      response = client.perform_request 'GET', ''
+
+      assert_respond_to(response.body, :to_hash)
+      assert_not_nil response.body['name']
+      assert_equal 'application/json', response.headers['content-type']
+    end unless JRUBY
+  end
+
+end