elasticsearch-persistence-queryable 0.1.8

data/test/unit/repository_find_test.rb

@@ -0,0 +1,388 @@
+require 'test_helper'
+
+class Elasticsearch::Persistence::RepositoryFindTest < Test::Unit::TestCase
+  class MyDocument; end
+
+  context "The repository" do
+    setup do
+      @shoulda_subject = Class.new() { include Elasticsearch::Persistence::Repository::Find }.new
+
+      @client = mock
+      @shoulda_subject.stubs(:document_type).returns(nil)
+      @shoulda_subject.stubs(:klass).returns(nil)
+      @shoulda_subject.stubs(:index_name).returns('my_index')
+      @shoulda_subject.stubs(:client).returns(@client)
+    end
+
+    context "find method" do
+      should "find one document when passed a single, literal ID" do
+        subject.expects(:__find_one).with(1, {})
+        subject.find(1)
+      end
+
+      should "find multiple documents when passed multiple IDs" do
+        subject.expects(:__find_many).with([1, 2], {})
+        subject.find(1, 2)
+      end
+
+      should "find multiple documents when passed an array of IDs" do
+        subject.expects(:__find_many).with([1, 2], {})
+        subject.find([1, 2])
+      end
+
+      should "pass the options" do
+        subject.expects(:__find_one).with(1, { foo: 'bar' })
+        subject.find(1, foo: 'bar')
+
+        subject.expects(:__find_many).with([1, 2], { foo: 'bar' })
+        subject.find([1, 2], foo: 'bar')
+
+        subject.expects(:__find_many).with([1, 2], { foo: 'bar' })
+        subject.find(1, 2, foo: 'bar')
+      end
+    end
+
+    context "'exists?' method" do
+      should "return false when the document does not exist" do
+        @client.expects(:exists).returns(false)
+        assert_equal false, subject.exists?('1')
+      end
+
+      should "return whether document for klass exists" do
+        subject.expects(:document_type).returns(nil)
+        subject.expects(:klass).returns(MyDocument).at_least_once
+        subject.expects(:__get_type_from_class).with(MyDocument).returns('my_document')
+
+        @client
+          .expects(:exists)
+          .with do |arguments|
+            assert_equal 'my_document', arguments[:type]
+            assert_equal '1', arguments[:id]
+            true
+          end
+          .returns(true)
+
+        assert_equal true, subject.exists?('1')
+      end
+
+      should "return whether document for document_type exists" do
+        subject.expects(:document_type).returns('my_document')
+        subject.expects(:klass).returns(MyDocument).at_most_once
+        subject.expects(:__get_type_from_class).never
+
+        @client
+          .expects(:exists)
+          .with do |arguments|
+            assert_equal 'my_document', arguments[:type]
+            assert_equal '1', arguments[:id]
+            true
+          end
+          .returns(true)
+
+        assert_equal true, subject.exists?('1')
+      end
+
+      should "return whether document exists" do
+        subject.expects(:klass).returns(nil)
+        subject.expects(:__get_type_from_class).never
+
+        @client
+          .expects(:exists)
+          .with do |arguments|
+            assert_equal '_all', arguments[:type]
+            assert_equal '1', arguments[:id]
+            true
+          end
+          .returns(true)
+
+        assert_equal true, subject.exists?('1')
+      end
+
+      should "pass options to the client" do
+        @client.expects(:exists).with do |arguments|
+          assert_equal 'foobarbam', arguments[:index]
+          assert_equal 'bambam',    arguments[:routing]
+          true
+        end
+
+        subject.exists? '1', index: 'foobarbam', routing: 'bambam'
+      end
+    end
+
+    context "'__find_one' method" do
+      should "find document based on klass and return a deserialized object" do
+        subject.expects(:document_type).returns(nil)
+        subject.expects(:klass).returns(MyDocument).at_least_once
+        subject.expects(:__get_type_from_class).with(MyDocument).returns('my_document')
+
+        subject.expects(:deserialize).with({'_source' => {'foo' => 'bar'}}).returns(MyDocument.new)
+
+        @client
+          .expects(:get)
+          .with do |arguments|
+            assert_equal 'my_document', arguments[:type]
+            assert_equal '1', arguments[:id]
+            true
+          end
+          .returns({'_source' => { 'foo' => 'bar' }})
+
+        assert_instance_of MyDocument, subject.__find_one('1')
+      end
+
+      should "find document based on document_type and return a deserialized object" do
+        subject.expects(:document_type).returns('my_document')
+        subject.expects(:klass).returns(MyDocument).at_most_once
+        subject.expects(:__get_type_from_class).never
+
+        subject.expects(:deserialize).with({'_source' => {'foo' => 'bar'}}).returns(MyDocument.new)
+
+        @client
+          .expects(:get)
+          .with do |arguments|
+            assert_equal 'my_document', arguments[:type]
+            assert_equal '1', arguments[:id]
+            true
+          end
+          .returns({'_source' => { 'foo' => 'bar' }})
+
+        assert_instance_of MyDocument, subject.__find_one('1')
+      end
+
+      should "find document and return a deserialized object" do
+        subject.expects(:document_type).returns(nil)
+        subject.expects(:klass).returns(nil).at_least_once
+        subject.expects(:__get_type_from_class).never
+
+        subject.expects(:deserialize).with({'_source' => {'foo' => 'bar'}}).returns(MyDocument.new)
+
+        @client
+          .expects(:get)
+          .with do |arguments|
+            assert_equal '_all', arguments[:type]
+            assert_equal '1', arguments[:id]
+            true
+          end
+          .returns({'_source' => { 'foo' => 'bar' }})
+
+        assert_instance_of MyDocument, subject.__find_one('1')
+      end
+
+      should "raise DocumentNotFound exception when the document cannot be found" do
+        subject.expects(:document_type).returns(nil)
+        subject.expects(:klass).returns(nil).at_least_once
+
+        subject.expects(:deserialize).never
+
+        @client
+          .expects(:get)
+          .raises(Elasticsearch::Transport::Transport::Errors::NotFound)
+
+        assert_raise Elasticsearch::Persistence::Repository::DocumentNotFound do
+          subject.__find_one('foobar')
+        end
+      end
+
+      should "pass other exceptions" do
+        subject.expects(:klass).returns(nil).at_least_once
+
+        subject.expects(:deserialize).never
+
+        @client
+          .expects(:get)
+          .raises(RuntimeError)
+
+        assert_raise RuntimeError do
+          subject.__find_one('foobar')
+        end
+      end
+
+      should "pass options to the client" do
+        subject.expects(:klass).returns(nil).at_least_once
+        subject.expects(:deserialize)
+
+        @client
+          .expects(:get)
+          .with do |arguments|
+            assert_equal 'foobarbam', arguments[:index]
+            assert_equal 'bambam',    arguments[:routing]
+            true
+          end
+          .returns({'_source' => { 'foo' => 'bar' }})
+
+        subject.__find_one '1', index: 'foobarbam', routing: 'bambam'
+      end
+    end
+
+    context "'__find_many' method" do
+      setup do
+        @response = {"docs"=>
+        [ {"_index"=>"my_index",
+           "_type"=>"note",
+           "_id"=>"1",
+           "_version"=>1,
+           "found"=>true,
+           "_source"=>{"id"=>"1", "title"=>"Test 1"}},
+
+          {"_index"=>"my_index",
+           "_type"=>"note",
+           "_id"=>"2",
+           "_version"=>1,
+           "found"=>true,
+           "_source"=>{"id"=>"2", "title"=>"Test 2"}}
+        ]}
+      end
+
+      should "find documents based on klass and return an Array of deserialized objects" do
+        subject.expects(:document_type).returns(nil)
+        subject.expects(:klass).returns(MyDocument).at_least_once
+        subject.expects(:__get_type_from_class).with(MyDocument).returns('my_document')
+
+        subject
+          .expects(:deserialize)
+          .with(@response['docs'][0])
+          .returns(MyDocument.new)
+
+        subject
+          .expects(:deserialize)
+          .with(@response['docs'][1])
+          .returns(MyDocument.new)
+
+        @client
+          .expects(:mget)
+          .with do |arguments|
+            assert_equal 'my_document', arguments[:type]
+            assert_equal ['1', '2'], arguments[:body][:ids]
+            true
+          end
+          .returns(@response)
+
+        results = subject.__find_many(['1', '2'])
+        assert_instance_of MyDocument, results[0]
+        assert_instance_of MyDocument, results[1]
+      end
+
+      should "find documents based on document_type and return an Array of deserialized objects" do
+        subject.expects(:document_type).returns('my_document')
+        subject.expects(:klass).returns(MyDocument).at_most_once
+        subject.expects(:__get_type_from_class).never
+
+        subject.expects(:deserialize).twice
+
+        @client
+          .expects(:mget)
+          .with do |arguments|
+            assert_equal 'my_document', arguments[:type]
+            assert_equal ['1', '2'], arguments[:body][:ids]
+            true
+          end
+          .returns(@response)
+
+        subject.__find_many(['1', '2'])
+      end
+
+      should "find documents and return an Array of deserialized objects" do
+        subject.expects(:document_type).returns(nil)
+        subject.expects(:klass).returns(nil).at_least_once
+        subject.expects(:__get_type_from_class).never
+
+        subject
+          .expects(:deserialize)
+          .with(@response['docs'][0])
+          .returns(MyDocument.new)
+
+        subject
+          .expects(:deserialize)
+          .with(@response['docs'][1])
+          .returns(MyDocument.new)
+
+        @client
+          .expects(:mget)
+          .with do |arguments|
+            assert_equal '_all', arguments[:type]
+            assert_equal ['1', '2'], arguments[:body][:ids]
+            true
+          end
+          .returns(@response)
+
+        results = subject.__find_many(['1', '2'])
+
+        assert_equal 2, results.size
+
+        assert_instance_of MyDocument, results[0]
+        assert_instance_of MyDocument, results[1]
+      end
+
+      should "find keep missing documents in the result as nil" do
+        @response = {"docs"=>
+        [ {"_index"=>"my_index",
+           "_type"=>"note",
+           "_id"=>"1",
+           "_version"=>1,
+           "found"=>true,
+           "_source"=>{"id"=>"1", "title"=>"Test 1"}},
+
+          {"_index"=>"my_index",
+           "_type"=>"note",
+           "_id"=>"3",
+           "_version"=>1,
+           "found"=>false},
+
+          {"_index"=>"my_index",
+           "_type"=>"note",
+           "_id"=>"2",
+           "_version"=>1,
+           "found"=>true,
+           "_source"=>{"id"=>"2", "title"=>"Test 2"}}
+        ]}
+
+        subject.expects(:document_type).returns(nil)
+        subject.expects(:klass).returns(MyDocument).at_least_once
+        subject.expects(:__get_type_from_class).with(MyDocument).returns('my_document')
+
+        subject
+          .expects(:deserialize)
+          .with(@response['docs'][0])
+          .returns(MyDocument.new)
+
+        subject
+          .expects(:deserialize)
+          .with(@response['docs'][2])
+          .returns(MyDocument.new)
+
+        @client
+          .expects(:mget)
+          .with do |arguments|
+            assert_equal 'my_document', arguments[:type]
+            assert_equal ['1', '3', '2'], arguments[:body][:ids]
+            true
+          end
+          .returns(@response)
+
+        results = subject.__find_many(['1', '3', '2'])
+
+        assert_equal 3, results.size
+
+        assert_instance_of MyDocument, results[0]
+        assert_instance_of NilClass,   results[1]
+        assert_instance_of MyDocument, results[2]
+      end
+
+      should "pass options to the client" do
+        subject.expects(:klass).returns(nil).at_least_once
+        subject.expects(:deserialize).twice
+
+        @client
+          .expects(:mget)
+          .with do |arguments|
+            assert_equal 'foobarbam', arguments[:index]
+            assert_equal 'bambam',    arguments[:routing]
+            true
+          end
+          .returns(@response)
+
+        subject.__find_many ['1', '2'], index: 'foobarbam', routing: 'bambam'
+      end
+    end
+
+  end
+end

data/test/unit/repository_indexing_test.rb

@@ -0,0 +1,37 @@
+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=>"string"}}}}, 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

@@ -0,0 +1,146 @@
+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