opensearch-ruby 2.0.3 → 3.4.0

data/test/dsl/unit/search_base_aggregation_component_test.rb

@@ -0,0 +1,66 @@
+# 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 BaseAggregationComponentTest < ::OpenSearch::Test::UnitTestCase
+      context 'BaseAggregationComponent' do
+        class DummyAggregationComponent
+          include ::OpenSearch::DSL::Search::BaseAggregationComponent
+        end
+
+        class ::OpenSearch::DSL::Search::Aggregations::Dummy
+          include ::OpenSearch::DSL::Search::BaseAggregationComponent
+        end
+
+        subject { DummyAggregationComponent.new }
+
+        should 'return an instance of the aggregation by name' do
+          assert_instance_of ::OpenSearch::DSL::Search::Aggregations::Dummy, subject.dummy
+        end
+
+        should 'raise an exception when unknown aggregation is called' do
+          assert_raise(NoMethodError) { subject.foobar }
+        end
+
+        should 'add a nested aggregation' do
+          subject.aggregation :inner do
+            dummy field: 'foo'
+          end
+
+          assert !subject.aggregations.empty?, "#{subject.aggregations.inspect} is empty"
+
+          assert_instance_of OpenSearch::DSL::Search::Aggregation, subject.aggregations[:inner]
+          assert_equal({ dummy: { field: 'foo' } }, subject.aggregations[:inner].to_hash)
+
+          assert_equal 'foo', subject.to_hash[:aggregations][:inner][:dummy][:field]
+        end
+      end
+    end
+  end
+end

data/test/dsl/unit/search_base_component_test.rb

@@ -0,0 +1,210 @@
+# 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 BaseComponentTest < ::OpenSearch::Test::UnitTestCase
+      context 'BaseComponent' do
+        class DummyComponent
+          include OpenSearch::DSL::Search::BaseComponent
+        end
+
+        class DummyComponentWithAName
+          include OpenSearch::DSL::Search::BaseComponent
+          name :foo
+        end
+
+        class DummyComponentWithNewName
+          include OpenSearch::DSL::Search::BaseComponent
+        end
+
+        class DummyCompoundFilter
+          include OpenSearch::DSL::Search::BaseCompoundFilterComponent
+        end
+
+        subject { DummyComponent.new :foo }
+
+        should 'have a name' do
+          assert_equal :dummy_component, DummyComponent.new.name
+        end
+
+        should 'have a custom name' do
+          assert_equal :foo, DummyComponentWithAName.new.name
+        end
+
+        should 'allow to set a name' do
+          DummyComponentWithNewName.name :foo
+          assert_equal :foo, DummyComponentWithNewName.new.name
+          assert_equal :foo, DummyComponentWithNewName.name
+
+          DummyComponentWithNewName.name = :bar
+          assert_equal :bar, DummyComponentWithNewName.name
+          assert_equal :bar, DummyComponentWithNewName.new.name
+        end
+
+        should 'initialize the hash' do
+          assert_instance_of Hash, subject.to_hash
+        end
+
+        should 'have an empty Hash as args by default' do
+          subject = DummyComponentWithNewName.new
+          assert_equal({}, subject.instance_variable_get(:@args))
+        end
+
+        should 'have an option method with args' do
+          class DummyComponentWithOptionMethod
+            include OpenSearch::DSL::Search::BaseComponent
+            option_method :bar
+          end
+
+          subject = DummyComponentWithOptionMethod.new :foo
+          assert_respond_to subject, :bar
+
+          subject.bar 'BAM'
+          assert_equal({ dummy_component_with_option_method: { foo: { bar: 'BAM' } } }, subject.to_hash)
+        end
+
+        should 'keep track of option methods' do
+          class DummyComponentWithCustomOptionMethod
+            include OpenSearch::DSL::Search::BaseComponent
+            option_method :foo
+          end
+
+          subject = DummyComponentWithCustomOptionMethod
+          assert_includes subject.option_methods, :foo
+        end
+
+        should 'have an option method without args' do
+          class DummyComponentWithOptionMethod
+            include OpenSearch::DSL::Search::BaseComponent
+            option_method :bar
+          end
+
+          subject = DummyComponentWithOptionMethod.new
+          assert_respond_to subject, :bar
+
+          subject.bar 'BAM'
+          assert_equal({ dummy_component_with_option_method: { bar: 'BAM' } }, subject.to_hash)
+        end
+
+        should 'define a custom option method' do
+          class DummyComponentWithCustomOptionMethod
+            include OpenSearch::DSL::Search::BaseComponent
+            option_method :bar, ->(*_args) { @hash = { foo: 'bar' } }
+          end
+
+          subject = DummyComponentWithCustomOptionMethod.new
+          subject.bar
+
+          assert_equal 'bar', subject.instance_variable_get(:@hash)[:foo]
+        end
+
+        should 'execute the passed block' do
+          subject = DummyComponent.new(:foo) { @foo = 'BAR' }
+
+          assert_respond_to  subject, :call
+          assert_instance_of DummyComponent, subject.call
+          assert_equal       'BAR', subject.instance_variable_get(:@foo)
+        end
+
+        should 'respond to empty?' do
+          assert DummyComponent.new.empty?
+          assert DummyComponent.new(:foo).empty?
+
+          subject = DummyComponent.new(:foo) { @hash = { foo: 'bar' } }
+          assert !subject.empty?
+        end
+
+        context 'to_hash conversion' do
+          should 'build the hash with the block with args' do
+            subject = DummyComponent.new :foo do
+              @hash[:dummy_component][:foo].update moo: 'xoo'
+            end
+
+            assert_equal({ dummy_component: { foo: { moo: 'xoo' } } }, subject.to_hash)
+          end
+
+          should 'build the hash with the block without args' do
+            subject = DummyComponent.new do
+              @hash[:dummy_component].update moo: 'xoo'
+            end
+
+            assert_equal({ dummy_component: { moo: 'xoo' } }, subject.to_hash)
+          end
+
+          should 'build the hash with the option method' do
+            class DummyComponentWithOptionMethod
+              include OpenSearch::DSL::Search::BaseComponent
+              option_method :foo
+            end
+
+            subject = DummyComponentWithOptionMethod.new do
+              foo 'bar'
+            end
+
+            assert_equal({ dummy_component_with_option_method: { foo: 'bar' } }, subject.to_hash)
+          end
+
+          should 'build the hash with the passed args' do
+            subject = DummyComponent.new foo: 'bar'
+
+            assert_equal({ dummy_component: { foo: 'bar' } }, subject.to_hash)
+          end
+
+          should 'merge the top-level options to the hash' do
+            class DummyComponentWithOptionMethod
+              include OpenSearch::DSL::Search::BaseComponent
+              option_method :bar
+            end
+
+            subject = DummyComponentWithOptionMethod.new :foo, xoo: 'X' do
+              bar 'B'
+            end
+
+            assert_equal({ dummy_component_with_option_method: { xoo: 'X', foo: { bar: 'B' } } }, subject.to_hash)
+          end
+
+          should 'return the already built hash' do
+            subject = DummyComponent.new
+            subject.instance_variable_set(:@hash, { foo: 'bar' })
+
+            assert_equal({ foo: 'bar' }, subject.to_hash)
+          end
+        end
+
+        context 'compound filter' do
+          subject { DummyCompoundFilter.new }
+
+          should 'raise an exception for unknown DSL method' do
+            assert_raise(NoMethodError) { subject.foofoo }
+          end
+        end
+      end
+    end
+  end
+end

data/test/dsl/unit/search_filter_test.rb

@@ -0,0 +1,84 @@
+# 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 SearchFilterTest < ::OpenSearch::Test::UnitTestCase
+      subject { OpenSearch::DSL::Search::Filter.new }
+
+      context 'Search Filter' do
+        should 'be serializable to a Hash' do
+          assert_equal({}, subject.to_hash)
+
+          subject = OpenSearch::DSL::Search::Filter.new
+          subject.instance_variable_set(:@value, { foo: 'bar' })
+          assert_equal({ foo: 'bar' }, subject.to_hash)
+        end
+
+        should 'evaluate the block and return itself' do
+          block   = proc { 1 + 1 }
+          subject = OpenSearch::DSL::Search::Filter.new(&block)
+
+          subject.expects(:instance_eval)
+          assert_instance_of OpenSearch::DSL::Search::Filter, subject.call
+        end
+
+        should 'call the block and return itself' do
+          block   = proc { |_s| 1 + 1 }
+          subject = OpenSearch::DSL::Search::Filter.new(&block)
+
+          block.expects(:call)
+          assert_instance_of OpenSearch::DSL::Search::Filter, subject.call
+        end
+
+        should 'define the value with filter methods' do
+          assert_nothing_raised do
+            subject.term foo: 'bar'
+            assert_instance_of Hash, subject.to_hash
+            assert_equal({ term: { foo: 'bar' } }, subject.to_hash)
+          end
+        end
+
+        should 'redefine the value with filter methods' do
+          assert_nothing_raised do
+            subject.term foo: 'bar'
+            subject.term foo: 'bam'
+            subject.to_hash
+            subject.to_hash
+            assert_instance_of Hash, subject.to_hash
+            assert_equal({ term: { foo: 'bam' } }, subject.to_hash)
+          end
+        end
+
+        should 'raise an exception for unknown filter' do
+          assert_raise(NoMethodError) { subject.foofoo }
+        end
+      end
+    end
+  end
+end

data/test/dsl/unit/search_highlight_test.rb

@@ -0,0 +1,103 @@
+# 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 HighlightTest < ::OpenSearch::Test::UnitTestCase
+      context 'Search highlight' do
+        subject { OpenSearch::DSL::Search::Highlight.new }
+
+        should 'take a Hash' do
+          subject = OpenSearch::DSL::Search::Highlight.new fields: { 'foo' => {} }, pre_tags: ['*'], post_tags: ['*']
+
+          assert_equal({ fields: { 'foo' => {} }, pre_tags: ['*'], post_tags: ['*'] }, subject.to_hash)
+        end
+
+        should 'encode fields as an array' do
+          subject.fields %w[foo bar]
+          assert_equal({ fields: { foo: {}, bar: {} } }, subject.to_hash)
+        end
+
+        should 'encode fields as a Hash' do
+          subject.fields foo: { bar: 1 }, xoo: { bar: 2 }
+          assert_equal({ fields: { foo: { bar: 1 }, xoo: { bar: 2 } } }, subject.to_hash)
+        end
+
+        should 'encode a field' do
+          subject.field 'foo'
+          assert_equal({ fields: { foo: {} } }, subject.to_hash)
+        end
+
+        should 'be additive on multiple calls' do
+          subject.fields %w[foo bar]
+          subject.field  'bam'
+          subject.field  'baz', { xoo: 10 }
+          assert_equal({ fields: { foo: {}, bar: {}, bam: {}, baz: { xoo: 10 } } }, subject.to_hash)
+        end
+
+        should 'encode pre_tags' do
+          subject.pre_tags '*'
+          assert_equal({ pre_tags: ['*'] }, subject.to_hash)
+        end
+
+        should 'encode post_tags' do
+          subject.post_tags '*'
+          assert_equal({ post_tags: ['*'] }, subject.to_hash)
+        end
+
+        should 'encode pre_tags as an array' do
+          subject.pre_tags ['*', '**']
+          assert_equal({ pre_tags: ['*', '**'] }, subject.to_hash)
+        end
+
+        should 'encode post_tags as an array' do
+          subject.post_tags ['*', '**']
+          assert_equal({ post_tags: ['*', '**'] }, subject.to_hash)
+        end
+
+        should 'encode the encoder option' do
+          subject.encoder 'foo'
+          assert_equal({ encoder: 'foo' }, subject.to_hash)
+        end
+
+        should 'encode the tags_schema option' do
+          subject.tags_schema 'foo'
+          assert_equal({ tags_schema: 'foo' }, subject.to_hash)
+        end
+
+        should 'combine the options' do
+          subject.fields %w[foo bar]
+          subject.field  'bam'
+          subject.pre_tags '*'
+          subject.post_tags '*'
+          assert_equal({ fields: { foo: {}, bar: {}, bam: {} }, pre_tags: ['*'], post_tags: ['*'] }, subject.to_hash)
+        end
+      end
+    end
+  end
+end

data/test/dsl/unit/search_options_test.rb

@@ -0,0 +1,114 @@
+# 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 SearchOptionsTest < ::OpenSearch::Test::UnitTestCase
+      subject { OpenSearch::DSL::Search::Options.new }
+
+      context 'Search options' do
+        should 'combine different options' do
+          subject.version true
+          subject.min_score 0.5
+
+          assert_equal({ version: true, min_score: 0.5 }, subject.to_hash)
+        end
+
+        should 'encode _source' do
+          subject._source false
+          assert_equal({ _source: false }, subject.to_hash)
+
+          subject._source 'foo.*'
+          assert_equal({ _source: 'foo.*' }, subject.to_hash)
+
+          subject._source %w[foo bar]
+          assert_equal({ _source: %w[foo bar] }, subject.to_hash)
+
+          subject._source include: ['foo.*'], exclude: ['bar.*']
+          assert_equal({ _source: { include: ['foo.*'], exclude: ['bar.*'] } }, subject.to_hash)
+
+          subject.source false
+          assert_equal({ _source: false }, subject.to_hash)
+        end
+
+        should 'encode fields' do
+          subject.fields ['foo']
+          assert_equal({ fields: ['foo'] }, subject.to_hash)
+        end
+
+        should 'encode script_fields' do
+          subject.script_fields ['foo']
+          assert_equal({ script_fields: ['foo'] }, subject.to_hash)
+        end
+
+        should 'encode fielddata_fields' do
+          subject.fielddata_fields ['foo']
+          assert_equal({ fielddata_fields: ['foo'] }, subject.to_hash)
+        end
+
+        should 'encode rescore' do
+          subject.rescore foo: 'bar'
+          assert_equal({ rescore: { foo: 'bar' } }, subject.to_hash)
+        end
+
+        should 'encode explain' do
+          subject.explain true
+          assert_equal({ explain: true }, subject.to_hash)
+        end
+
+        should 'encode version' do
+          subject.version true
+          assert_equal({ version: true }, subject.to_hash)
+        end
+
+        should 'encode track_total_hits' do
+          subject.track_total_hits 123
+          assert_equal({ track_total_hits: 123 }, subject.to_hash)
+
+          subject.track_total_hits true
+          assert_equal({ track_total_hits: true }, subject.to_hash)
+        end
+
+        should 'encode indices_boost' do
+          subject.indices_boost foo: 'bar'
+          assert_equal({ indices_boost: { foo: 'bar' } }, subject.to_hash)
+        end
+
+        should 'encode track_scores' do
+          subject.track_scores true
+          assert_equal({ track_scores: true }, subject.to_hash)
+        end
+
+        should 'encode min_score' do
+          subject.min_score 0.5
+          assert_equal({ min_score: 0.5 }, subject.to_hash)
+        end
+      end
+    end
+  end
+end

data/test/dsl/unit/search_query_test.rb

@@ -0,0 +1,88 @@
+# 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 SearchQueryTest < ::OpenSearch::Test::UnitTestCase
+      subject { OpenSearch::DSL::Search::Query.new }
+
+      context 'Search Query' do
+        should 'be serializable to a Hash' do
+          assert_equal({}, subject.to_hash)
+
+          subject = OpenSearch::DSL::Search::Query.new
+          subject.instance_variable_set(:@value, {})
+          assert_equal({}, subject.to_hash)
+        end
+
+        should 'evaluate the block and return itself' do
+          block   = proc { 1 + 1 }
+          subject = OpenSearch::DSL::Search::Query.new(&block)
+
+          subject.expects(:instance_eval)
+          assert_instance_of OpenSearch::DSL::Search::Query, subject.call
+        end
+
+        should 'call the block and return itself' do
+          block   = proc { |_s| 1 + 1 }
+          subject = OpenSearch::DSL::Search::Query.new(&block)
+
+          block.expects(:call)
+          assert_instance_of OpenSearch::DSL::Search::Query, subject.call
+        end
+
+        should 'define the value with query methods' do
+          assert_nothing_raised do
+            subject.match foo: 'bar'
+            assert_instance_of Hash, subject.to_hash
+            assert_equal({ match: { foo: 'bar' } }, subject.to_hash)
+          end
+        end
+
+        should 'redefine the value with query methods' do
+          assert_nothing_raised do
+            subject.match foo: 'bar'
+            subject.match foo: 'bam'
+            subject.to_hash
+            subject.to_hash
+            assert_instance_of Hash, subject.to_hash
+            assert_equal({ match: { foo: 'bam' } }, subject.to_hash)
+          end
+        end
+
+        should 'have the query methods' do
+          assert_nothing_raised { subject.match foo: 'bar' }
+        end
+
+        should 'raise an exception for unknown query' do
+          assert_raise(NoMethodError) { subject.foofoo }
+        end
+      end
+    end
+  end
+end