elasticsearch-persistence 0.0.0 → 0.0.1

data/test/unit/repository_naming_test.rb

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

@@ -0,0 +1,98 @@
+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 Hashie::Mash" 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

@@ -0,0 +1,97 @@
+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])
+      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])
+      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])
+      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]
+      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]
+      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
+  end
+
+end

data/test/unit/repository_serialize_test.rb

@@ -0,0 +1,57 @@
+require 'test_helper'
+
+class Elasticsearch::Persistence::RepositorySerializeTest < Test::Unit::TestCase
+  context "The repository serialization" do
+    class DummyDocument
+      def to_hash
+        { foo: 'bar' }
+      end
+    end
+
+    class MyDocument; end
+
+    setup do
+      @shoulda_subject = Class.new() { include Elasticsearch::Persistence::Repository::Serialize }.new
+    end
+
+    context "serialize" do
+      should "call #to_hash on passed object" do
+        document = DummyDocument.new
+        assert_equal( { foo: 'bar' }, subject.serialize(document))
+      end
+    end
+
+    context "deserialize" do
+      should "get the class name from #klass" do
+        subject.expects(:klass)
+               .returns(MyDocument)
+
+        MyDocument.expects(:new)
+
+        subject.deserialize( {} )
+      end
+
+      should "get the class name from Elasticsearch _type" do
+        subject.expects(:klass)
+               .returns(nil)
+
+        subject.expects(:__get_klass_from_type)
+               .returns(MyDocument)
+
+        MyDocument.expects(:new)
+
+        subject.deserialize( {} )
+      end
+
+      should "create the class instance with _source attributes" do
+        subject.expects(:klass).returns(nil)
+
+        subject.expects(:__get_klass_from_type).returns(MyDocument)
+
+        MyDocument.expects(:new).with({ 'foo' => 'bar' })
+
+        subject.deserialize( {'_source' => { 'foo' => 'bar' } } )
+      end
+    end
+  end
+end

data/test/unit/repository_store_test.rb

@@ -0,0 +1,287 @@
+require 'test_helper'
+
+class Elasticsearch::Persistence::RepositoryStoreTest < Test::Unit::TestCase
+  context "The repository store" do
+    class MyDocument; end
+
+    setup do
+      @shoulda_subject = Class.new() do
+        include Elasticsearch::Persistence::Repository::Store
+        include Elasticsearch::Persistence::Repository::Naming
+      end.new
+      @shoulda_subject.stubs(:index_name).returns('test')
+    end
+
+    context "save" do
+      should "serialize the document, get type from klass and index it" do
+        subject.expects(:serialize).returns({foo: 'bar'})
+        subject.expects(:document_type).returns(nil)
+        subject.expects(:klass).at_least_once.returns(MyDocument)
+        subject.expects(:__get_type_from_class).with(MyDocument).at_least_once.returns('my_document')
+        subject.expects(:__get_id_from_document).returns('1')
+
+        client = mock
+        client.expects(:index).with do |arguments|
+          assert_equal 'my_document', arguments[:type]
+          assert_equal '1', arguments[:id]
+          assert_equal({foo: 'bar'}, arguments[:body])
+        end
+        subject.expects(:client).returns(client)
+
+        subject.save({foo: 'bar'})
+      end
+
+      should "serialize the document, get type from document class and index it" do
+        subject.expects(:serialize).returns({foo: 'bar'})
+        subject.expects(:document_type).returns(nil)
+        subject.expects(:klass).at_least_once.returns(nil)
+        subject.expects(:__get_type_from_class).with(MyDocument).returns('my_document')
+        subject.expects(:__get_id_from_document).returns('1')
+
+        client = mock
+        client.expects(:index).with do |arguments|
+          assert_equal 'my_document', arguments[:type]
+          assert_equal '1', arguments[:id]
+          assert_equal({foo: 'bar'}, arguments[:body])
+        end
+        subject.expects(:client).returns(client)
+
+        subject.save(MyDocument.new)
+      end
+
+      should "serialize the document, get type from document_type and index it" do
+        subject.expects(:serialize).returns({foo: 'bar'})
+
+        subject.expects(:document_type).returns('my_document')
+
+        subject.expects(:klass).never
+        subject.expects(:__get_type_from_class).never
+
+        subject.expects(:__get_id_from_document).returns('1')
+
+        client = mock
+        client.expects(:index).with do |arguments|
+          assert_equal 'my_document', arguments[:type]
+          assert_equal '1', arguments[:id]
+          assert_equal({foo: 'bar'}, arguments[:body])
+        end
+        subject.expects(:client).returns(client)
+
+        subject.save(MyDocument.new)
+      end
+
+      should "pass the options to the client" do
+        subject.expects(:serialize).returns({foo: 'bar'})
+        subject.expects(:document_type).returns(nil)
+        subject.expects(:klass).at_least_once.returns(MyDocument)
+        subject.expects(:__get_type_from_class).with(MyDocument).returns('my_document')
+        subject.expects(:__get_id_from_document).returns('1')
+
+        client = mock
+        client.expects(:index).with do |arguments|
+          assert_equal 'foobarbam', arguments[:index]
+          assert_equal 'bambam', arguments[:routing]
+        end
+        subject.expects(:client).returns(client)
+
+        subject.save({foo: 'bar'}, { index: 'foobarbam', routing: 'bambam' })
+      end
+    end
+
+    context "update" do
+      should "get the ID from first argument and :doc from options" do
+        subject.expects(:serialize).never
+        subject.expects(:document_type).returns('mydoc')
+        subject.expects(:__extract_id_from_document).never
+
+        client = mock
+        client.expects(:update).with do |arguments|
+          assert_equal '1',     arguments[:id]
+          assert_equal 'mydoc', arguments[:type]
+          assert_equal({doc: { foo: 'bar' }}, arguments[:body])
+        end
+        subject.expects(:client).returns(client)
+
+        subject.update('1', doc: { foo: 'bar' })
+      end
+
+      should "get the ID from first argument and :script from options" do
+        subject.expects(:document_type).returns('mydoc')
+        subject.expects(:__extract_id_from_document).never
+
+        client = mock
+        client.expects(:update).with do |arguments|
+          assert_equal '1',     arguments[:id]
+          assert_equal 'mydoc', arguments[:type]
+          assert_equal({script: 'ctx._source.foo += 1'}, arguments[:body])
+        end
+        subject.expects(:client).returns(client)
+
+        subject.update('1', script: 'ctx._source.foo += 1')
+      end
+
+      should "get the ID from first argument and :script with :upsert from options" do
+        subject.expects(:document_type).returns('mydoc')
+        subject.expects(:__extract_id_from_document).never
+
+        client = mock
+        client.expects(:update).with do |arguments|
+          assert_equal '1',     arguments[:id]
+          assert_equal 'mydoc', arguments[:type]
+          assert_equal({script: 'ctx._source.foo += 1', upsert: { foo: 1 }}, arguments[:body])
+        end
+        subject.expects(:client).returns(client)
+
+        subject.update('1', script: 'ctx._source.foo += 1', upsert: { foo: 1 })
+      end
+
+      should "get the ID and :doc from document" do
+        subject.expects(:document_type).returns('mydoc')
+
+        client = mock
+        client.expects(:update).with do |arguments|
+          assert_equal '1',     arguments[:id]
+          assert_equal 'mydoc', arguments[:type]
+          assert_equal({doc: { foo: 'bar' }}, arguments[:body])
+        end
+        subject.expects(:client).returns(client)
+
+        subject.update(id: '1', foo: 'bar')
+      end
+
+      should "get the ID and :script from document" do
+        subject.expects(:document_type).returns('mydoc')
+
+        client = mock
+        client.expects(:update).with do |arguments|
+          assert_equal '1',     arguments[:id]
+          assert_equal 'mydoc', arguments[:type]
+          assert_equal({script: 'ctx._source.foo += 1'}, arguments[:body])
+        end
+        subject.expects(:client).returns(client)
+
+        subject.update(id: '1', script: 'ctx._source.foo += 1')
+      end
+
+      should "get the ID and :script with :upsert from document" do
+        subject.expects(:document_type).returns('mydoc')
+
+        client = mock
+        client.expects(:update).with do |arguments|
+          assert_equal '1',     arguments[:id]
+          assert_equal 'mydoc', arguments[:type]
+          assert_equal({script: 'ctx._source.foo += 1', upsert: { foo: 1 } }, arguments[:body])
+        end
+        subject.expects(:client).returns(client)
+
+        subject.update(id: '1', script: 'ctx._source.foo += 1', upsert: { foo: 1 })
+      end
+
+      should "override the type from params" do
+        subject.expects(:document_type).never
+
+        client = mock
+        client.expects(:update).with do |arguments|
+          assert_equal '1',   arguments[:id]
+          assert_equal 'foo', arguments[:type]
+          assert_equal({script: 'ctx._source.foo += 1'}, arguments[:body])
+        end
+        subject.expects(:client).returns(client)
+
+        subject.update(id: '1', script: 'ctx._source.foo += 1', type: 'foo')
+      end
+
+      should "raise an exception when passed incorrect argument" do
+        assert_raise(ArgumentError) { subject.update(MyDocument.new, foo: 'bar') }
+      end
+    end
+
+    context "delete" do
+      should "get type from klass when passed only ID" do
+        subject.expects(:serialize).never
+        subject.expects(:document_type).returns(nil)
+        subject.expects(:klass).at_least_once.returns(MyDocument)
+        subject.expects(:__get_type_from_class).with(MyDocument).returns('my_document')
+        subject.expects(:__get_id_from_document).never
+
+        client = mock
+        client.expects(:delete).with do |arguments|
+          assert_equal 'my_document', arguments[:type]
+          assert_equal '1', arguments[:id]
+        end
+        subject.expects(:client).returns(client)
+
+        subject.delete('1')
+      end
+
+      should "get ID from document and type from klass when passed a document" do
+        subject.expects(:serialize).returns({id: '1', foo: 'bar'})
+        subject.expects(:document_type).returns(nil)
+        subject.expects(:klass).at_least_once.returns(MyDocument)
+        subject.expects(:__get_type_from_class).with(MyDocument).returns('my_document')
+        subject.expects(:__get_id_from_document).with({id: '1', foo: 'bar'}).returns('1')
+
+        client = mock
+        client.expects(:delete).with do |arguments|
+          assert_equal 'my_document', arguments[:type]
+          assert_equal '1', arguments[:id]
+        end
+        subject.expects(:client).returns(client)
+
+        subject.delete({id: '1', foo: 'bar'})
+      end
+
+      should "get ID from document and type from document_type when passed a document" do
+        subject.expects(:serialize).returns({id: '1', foo: 'bar'})
+
+        subject.expects(:document_type).returns('my_document')
+
+        subject.expects(:klass).never
+        subject.expects(:__get_type_from_class).never
+
+        subject.expects(:__get_id_from_document).with({id: '1', foo: 'bar'}).returns('1')
+
+        client = mock
+        client.expects(:delete).with do |arguments|
+          assert_equal 'my_document', arguments[:type]
+          assert_equal '1', arguments[:id]
+        end
+        subject.expects(:client).returns(client)
+
+        subject.delete({id: '1', foo: 'bar'})
+      end
+
+      should "get ID and type from document when passed a document" do
+        subject.expects(:serialize).returns({id: '1', foo: 'bar'})
+        subject.expects(:document_type).returns(nil)
+        subject.expects(:klass).at_least_once.returns(nil)
+        subject.expects(:__get_type_from_class).with(MyDocument).returns('my_document')
+        subject.expects(:__get_id_from_document).with({id: '1', foo: 'bar'}).returns('1')
+
+        client = mock
+        client.expects(:delete).with do |arguments|
+          assert_equal 'my_document', arguments[:type]
+          assert_equal '1', arguments[:id]
+        end
+        subject.expects(:client).returns(client)
+
+        subject.delete(MyDocument.new)
+      end
+
+      should "pass the options to the client" do
+        subject.expects(:document_type).returns(nil)
+        subject.expects(:klass).at_least_once.returns(MyDocument)
+        subject.expects(:__get_type_from_class).returns('my_document')
+
+        client = mock
+        client.expects(:delete).with do |arguments|
+          assert_equal 'foobarbam', arguments[:index]
+          assert_equal 'bambam', arguments[:routing]
+        end
+        subject.expects(:client).returns(client)
+
+        subject.delete('1', index: 'foobarbam', routing: 'bambam')
+      end
+    end
+  end
+end