elasticsearch-persistence-queryable 0.1.8

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,117 @@
+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.expects(:search)
+        .returns(Elasticsearch::Persistence::Repository::Response::Results.new( subject, {'hits' => { 'total' => 1 }}))
+      assert_equal 1, subject.count
+    end
+
+    should "pass arguments from count to search" do
+      subject.expects(:search)
+        .with do |query_or_definition, options|
+          assert_equal 'bar', query_or_definition[:query][:match][:foo]
+          assert_equal true, options[:ignore_unavailable]
+          true
+        end
+        .returns(Elasticsearch::Persistence::Repository::Response::Results.new( subject, {'hits' => { 'total' => 1 }}))
+
+      subject.count( { query: { match: { foo: 'bar' } } }, { ignore_unavailable: true } )
+    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