elasticsearch-persistence 5.1.0 → 6.0.0.pre

data/test/unit/repository_indexing_test.rb

@@ -1,37 +0,0 @@
-require 'test_helper'
-
-class Elasticsearch::Persistence::RepositoryIndexingTest < Test::Unit::TestCase
-  context "The repository index methods" do
-    class MyDocument; end
-
-    setup do
-      @shoulda_subject = Class.new() { include Elasticsearch::Model::Indexing::ClassMethods }.new
-      @shoulda_subject.stubs(:index_name).returns('my_index')
-      @shoulda_subject.stubs(:document_type).returns('my_document')
-    end
-
-    should "have the convenience index management methods" do
-      %w( create_index!  delete_index! refresh_index! ).each do |method|
-        assert_respond_to subject, method
-      end
-    end
-
-    context "mappings" do
-      should "configure the mappings for the type" do
-        subject.mappings do
-          indexes :title
-        end
-
-        assert_equal( {:"my_document"=>{:properties=>{:title=>{:type=>"text"}}}}, subject.mappings.to_hash )
-      end
-    end
-
-    context "settings" do
-      should "configure the settings for the index" do
-        subject.settings foo: 'bar'
-        assert_equal( {foo: 'bar'},  subject.settings.to_hash)
-      end
-    end
-
-  end
-end

data/test/unit/repository_module_test.rb

@@ -1,146 +0,0 @@
-require 'test_helper'
-
-class Elasticsearch::Persistence::RepositoryModuleTest < Test::Unit::TestCase
-  context "The repository module" do
-
-    class DummyModel
-      def initialize(attributes={})
-        @attributes = attributes
-      end
-
-      def to_hash
-        @attributes
-      end
-
-      def inspect
-        "<Note #{@attributes.inspect}>"
-      end
-    end
-
-    setup do
-      class DummyRepository
-        include Elasticsearch::Persistence::Repository
-      end
-    end
-
-    teardown do
-      Elasticsearch::Persistence::RepositoryModuleTest.__send__ :remove_const, :DummyRepository
-    end
-
-    context "when included" do
-      should "set up the gateway for the class and instance" do
-        assert_respond_to DummyRepository,     :gateway
-        assert_respond_to DummyRepository.new, :gateway
-
-        assert_instance_of Elasticsearch::Persistence::Repository::Class, DummyRepository.gateway
-        assert_instance_of Elasticsearch::Persistence::Repository::Class, DummyRepository.new.gateway
-      end
-
-      should "proxy repository methods from the class to the gateway" do
-        class DummyRepository
-          include Elasticsearch::Persistence::Repository
-
-          index :foobar
-          klass DummyModel
-          type  :my_dummy_model
-          mapping { indexes :title, analyzer: 'snowball' }
-        end
-
-        repository = DummyRepository.new
-
-        assert_equal :foobar,         DummyRepository.index
-        assert_equal DummyModel,      DummyRepository.klass
-        assert_equal :my_dummy_model, DummyRepository.type
-        assert_equal 'snowball', DummyRepository.mappings.to_hash[:my_dummy_model][:properties][:title][:analyzer]
-
-        assert_equal :foobar,         repository.index
-        assert_equal DummyModel,      repository.klass
-        assert_equal :my_dummy_model, repository.type
-        assert_equal 'snowball', repository.mappings.to_hash[:my_dummy_model][:properties][:title][:analyzer]
-      end
-
-      should "correctly delegate to the gateway" do
-        repository = DummyRepository.new
-        assert_instance_of Method, repository.method(:index)
-      end
-
-      should "proxy repository methods from the instance to the gateway" do
-        class DummyRepository
-          include Elasticsearch::Persistence::Repository
-        end
-
-        repository = DummyRepository.new
-        repository.index :foobar
-        repository.klass DummyModel
-        repository.type  :my_dummy_model
-        repository.mapping { indexes :title, analyzer: 'snowball' }
-
-        assert_equal :foobar,         DummyRepository.index
-        assert_equal DummyModel,      DummyRepository.klass
-        assert_equal :my_dummy_model, DummyRepository.type
-        assert_equal 'snowball', DummyRepository.mappings.to_hash[:my_dummy_model][:properties][:title][:analyzer]
-
-        assert_equal :foobar,         repository.index
-        assert_equal DummyModel,      repository.klass
-        assert_equal :my_dummy_model, repository.type
-        assert_equal 'snowball', repository.mappings.to_hash[:my_dummy_model][:properties][:title][:analyzer]
-      end
-
-      should "allow to define gateway methods in the class definition via block passed to the gateway method" do
-        class DummyRepositoryWithGatewaySerialize
-          include Elasticsearch::Persistence::Repository
-
-          gateway do
-            def serialize(document)
-              'FAKE!'
-            end
-          end
-        end
-
-        repository = DummyRepositoryWithGatewaySerialize.new
-        repository.client.transport.logger = Logger.new(STDERR)
-
-        client = mock
-        client.expects(:index).with do |arguments|
-          assert_equal('xxx',   arguments[:id])
-          assert_equal('FAKE!', arguments[:body])
-          true
-        end
-        repository.gateway.expects(:client).returns(client)
-
-        repository.gateway.expects(:__get_id_from_document).returns('xxx')
-
-        repository.save( id: '123', foo: 'bar' )
-      end
-    end
-
-    should "allow to define gateway methods in the class definition via regular method definition" do
-      class DummyRepositoryWithDirectSerialize
-        include Elasticsearch::Persistence::Repository
-
-        def serialize(document)
-          'FAKE IN CLASS!'
-        end
-      end
-
-      repository = DummyRepositoryWithDirectSerialize.new
-      repository.client.transport.logger = Logger.new(STDERR)
-
-      client = mock
-      client.expects(:index).with do |arguments|
-        assert_equal('xxx',   arguments[:id])
-        assert_equal('FAKE IN CLASS!', arguments[:body])
-        true
-      end
-      repository.gateway.expects(:client).returns(client)
-
-      repository.gateway.expects(:__get_id_from_document).returns('xxx')
-
-      repository.save( id: '123', foo: 'bar' )
-    end
-
-    should "configure the index name in the shortcut initializer" do
-      assert_equal 'repository', Elasticsearch::Persistence::Repository.new.index_name
-    end
-  end
-end

data/test/unit/repository_naming_test.rb

@@ -1,146 +0,0 @@
-require 'test_helper'
-
-class Elasticsearch::Persistence::RepositoryNamingTest < Test::Unit::TestCase
-  context "The repository naming" do
-    # Fake class for the naming tests
-    class ::Foobar; end
-    class ::FooBar; end
-    module ::Foo; class Bar; end; end
-
-    setup do
-      @shoulda_subject = Class.new() { include Elasticsearch::Persistence::Repository::Naming }.new
-    end
-
-    context "get Ruby class from the Elasticsearch type" do
-      should "get a simple class" do
-        assert_equal Foobar, subject.__get_klass_from_type('foobar')
-      end
-      should "get a camelcased class" do
-        assert_equal FooBar, subject.__get_klass_from_type('foo_bar')
-      end
-      should "get a namespaced class" do
-        assert_equal Foo::Bar, subject.__get_klass_from_type('foo/bar')
-      end
-      should "re-raise a NameError exception" do
-        assert_raise NameError do
-          subject.__get_klass_from_type('foobarbazbam')
-        end
-      end
-    end
-
-    context "get Elasticsearch type from the Ruby class" do
-      should "encode a simple class" do
-        assert_equal 'foobar', subject.__get_type_from_class(Foobar)
-      end
-      should "encode a camelcased class" do
-        assert_equal 'foo_bar', subject.__get_type_from_class(FooBar)
-      end
-      should "encode a namespaced class" do
-        assert_equal 'foo/bar', subject.__get_type_from_class(Foo::Bar)
-      end
-    end
-
-    context "get an ID from the document" do
-      should "get an ID from Hash" do
-        assert_equal 1, subject.__get_id_from_document(id: 1)
-        assert_equal 1, subject.__get_id_from_document(_id: 1)
-        assert_equal 1, subject.__get_id_from_document('id'  => 1)
-        assert_equal 1, subject.__get_id_from_document('_id' => 1)
-      end
-    end
-
-    context "extract an ID from the document" do
-      should "delete the key from theHash" do
-        d1 = { :id   => 1 }
-        d2 = { :_id  => 1 }
-        d3 = { 'id'  => 1 }
-        d4 = { '_id' => 1 }
-
-        assert_equal 1, subject.__extract_id_from_document(d1)
-        assert_nil   d1[:id]
-
-        assert_equal 1, subject.__extract_id_from_document(d2)
-        assert_nil   d1[:_id]
-
-        assert_equal 1, subject.__extract_id_from_document(d3)
-        assert_nil   d1['id']
-
-        assert_equal 1, subject.__extract_id_from_document(d4)
-        assert_nil   d1['_id']
-      end
-    end
-
-    context "document class name" do
-      should "be nil by default" do
-        assert_nil subject.klass
-      end
-
-      should "be settable" do
-        subject.klass = Foobar
-        assert_equal Foobar, subject.klass
-      end
-
-      should "be settable by DSL" do
-        subject.klass Foobar
-        assert_equal Foobar, subject.klass
-      end
-    end
-
-    context "index_name" do
-      should "default to the class name" do
-        subject.instance_eval do
-          def self.class
-            'FakeRepository'
-          end
-        end
-
-        assert_equal 'fake_repository', subject.index_name
-      end
-
-      should "be settable" do
-        subject.index_name = 'foobar1'
-        assert_equal 'foobar1', subject.index_name
-
-        subject.index_name 'foobar2'
-        assert_equal 'foobar2', subject.index_name
-      end
-
-      should "be aliased as `index`" do
-        subject.index_name = 'foobar1'
-        assert_equal 'foobar1', subject.index
-      end
-
-      should "be inferred from the host class" do
-        class ::MySpecialRepository; end
-        subject.define_singleton_method(:host) { MySpecialRepository }
-        assert_equal 'my_special_repository', subject.index_name
-      end
-    end
-
-    context "document_type" do
-      should "be nil when no klass is set" do
-        assert_equal nil, subject.document_type
-      end
-
-      should "default to klass" do
-        subject.klass Foobar
-        assert_equal 'foobar', subject.document_type
-      end
-
-      should "be aliased as `type`" do
-        subject.klass Foobar
-        assert_equal 'foobar', subject.type
-      end
-
-      should "be settable" do
-        subject.document_type = 'foobar'
-        assert_equal 'foobar', subject.document_type
-      end
-
-      should "be settable by DSL" do
-        subject.document_type 'foobar'
-        assert_equal 'foobar', subject.document_type
-      end
-    end
-  end
-end

data/test/unit/repository_response_results_test.rb

@@ -1,98 +0,0 @@
-require 'test_helper'
-
-class Elasticsearch::Persistence::RepositoryResponseResultsTest < Test::Unit::TestCase
-  include Elasticsearch::Persistence
-  class MyDocument; end
-
-  context "Response results" do
-    setup do
-      @repository = Repository.new
-
-      @response = { "took" => 2,
-                   "timed_out" => false,
-                   "_shards" => {"total" => 5, "successful" => 5, "failed" => 0},
-                   "hits" =>
-                    { "total" => 2,
-                      "max_score" => 0.19,
-                      "hits" =>
-                       [{"_index" => "my_index",
-                         "_type" => "note",
-                         "_id" => "1",
-                         "_score" => 0.19,
-                         "_source" => {"id" => 1, "title" => "Test 1"}},
-
-                         {"_index" => "my_index",
-                         "_type" => "note",
-                         "_id" => "2",
-                         "_score" => 0.19,
-                         "_source" => {"id" => 2, "title" => "Test 2"}}
-                       ]
-                    }
-                  }
-
-      @shoulda_subject = Repository::Response::Results.new @repository, @response
-    end
-
-    should "provide the access to the repository" do
-      assert_instance_of Repository::Class, subject.repository
-    end
-
-    should "provide the access to the response" do
-      assert_equal 5, subject.response['_shards']['total']
-    end
-
-    should "wrap the response in HashWrapper" do
-      assert_equal 5, subject.response._shards.total
-    end
-
-    should "return the total" do
-      assert_equal 2, subject.total
-    end
-
-    should "return the max_score" do
-      assert_equal 0.19, subject.max_score
-    end
-
-    should "delegate methods to results" do
-      subject.repository
-        .expects(:deserialize)
-        .twice
-        .returns(MyDocument.new)
-
-      assert_equal 2, subject.size
-      assert_respond_to subject, :each
-    end
-
-    should "respond to missing" do
-      assert_instance_of Method, subject.method(:to_a)
-    end
-
-    should "yield each object with hit" do
-      @shoulda_subject = Repository::Response::Results.new \
-        @repository,
-        { 'hits' => { 'hits' => [{'_id' => '1', 'foo' => 'bar'}] } }
-
-      subject.repository
-        .expects(:deserialize)
-        .returns('FOO')
-
-      subject.each_with_hit do |object, hit|
-        assert_equal 'FOO', object
-        assert_equal 'bar', hit.foo
-      end
-    end
-
-    should "map objects and hits" do
-      @shoulda_subject = Repository::Response::Results.new \
-        @repository,
-        { 'hits' => { 'hits' => [{'_id' => '1', 'foo' => 'bar'}] } }
-
-      subject.repository
-        .expects(:deserialize)
-        .returns('FOO')
-
-      assert_equal ['FOO---bar'], subject.map_with_hit { |object, hit| "#{object}---#{hit.foo}" }
-    end
-  end
-
-end

data/test/unit/repository_search_test.rb

@@ -1,117 +0,0 @@
-require 'test_helper'
-
-class Elasticsearch::Persistence::RepositorySearchTest < Test::Unit::TestCase
-  class MyDocument; end
-
-  context "The repository search" do
-    setup do
-      @shoulda_subject = Class.new() { include Elasticsearch::Persistence::Repository::Search }.new
-
-      @client = mock
-      @shoulda_subject.stubs(:document_type).returns(nil)
-      @shoulda_subject.stubs(:klass).returns(nil)
-      @shoulda_subject.stubs(:index_name).returns('test')
-      @shoulda_subject.stubs(:client).returns(@client)
-    end
-
-    should "search in type based on klass" do
-      subject.expects(:klass).returns(MyDocument).at_least_once
-      subject.expects(:__get_type_from_class).with(MyDocument).returns('my_document')
-
-      @client.expects(:search).with do |arguments|
-        assert_equal 'test',        arguments[:index]
-        assert_equal 'my_document', arguments[:type]
-        assert_equal({foo: 'bar'},  arguments[:body])
-        true
-      end
-
-      subject.search foo: 'bar'
-    end
-
-    should "search in type based on document_type" do
-      subject.expects(:document_type).returns('my_special_document').at_least_once
-      subject.expects(:__get_type_from_class).never
-
-      @client.expects(:search).with do |arguments|
-        assert_equal 'test',                arguments[:index]
-        assert_equal 'my_special_document', arguments[:type]
-        assert_equal({foo: 'bar'},          arguments[:body])
-        true
-      end
-
-      subject.search foo: 'bar'
-    end
-
-    should "search across all types" do
-      subject.expects(:document_type).returns(nil).at_least_once
-      subject.expects(:klass).returns(nil).at_least_once
-      subject.expects(:__get_type_from_class).never
-
-      @client.expects(:search).with do |arguments|
-        assert_equal 'test', arguments[:index]
-        assert_equal nil,    arguments[:type]
-        assert_equal({foo: 'bar'}, arguments[:body])
-        true
-      end
-
-      assert_instance_of Elasticsearch::Persistence::Repository::Response::Results,
-                         subject.search(foo: 'bar')
-    end
-
-    should "pass options to the client" do
-      subject.expects(:klass).returns(nil).at_least_once
-      subject.expects(:__get_type_from_class).never
-
-      @client.expects(:search).twice.with do |arguments|
-        assert_equal 'bambam', arguments[:routing]
-        true
-      end
-
-      assert_instance_of Elasticsearch::Persistence::Repository::Response::Results,
-                         subject.search( {foo: 'bar'}, { routing: 'bambam' } )
-      assert_instance_of Elasticsearch::Persistence::Repository::Response::Results,
-                         subject.search( 'foobar', { routing: 'bambam' } )
-    end
-
-    should "search with simple search" do
-      subject.expects(:klass).returns(nil).at_least_once
-      subject.expects(:__get_type_from_class).never
-
-      @client.expects(:search).with do |arguments|
-        assert_equal 'foobar', arguments[:q]
-        true
-      end
-
-      assert_instance_of Elasticsearch::Persistence::Repository::Response::Results,
-                         subject.search('foobar')
-    end
-
-    should "raise error for incorrect search definitions" do
-      subject.expects(:klass).returns(nil).at_least_once
-      subject.expects(:__get_type_from_class).never
-
-      assert_raise ArgumentError do
-        subject.search 123
-      end
-    end
-
-    should "return the number of domain objects" do
-      subject.client.expects(:count).returns({'count' => 1})
-      assert_equal 1, subject.count
-    end
-
-    should "pass arguments to count" do
-      subject.client.expects(:count)
-        .with do |arguments|
-          assert_equal 'test', arguments[:index]
-          assert_equal 'bar',  arguments[:body][:query][:match][:foo]
-          assert_equal true,   arguments[:ignore_unavailable]
-          true
-        end
-        .returns({'count' => 1})
-
-      assert_equal 1, subject.count( { query: { match: { foo: 'bar' } } }, { ignore_unavailable: true } )
-    end
-  end
-
-end