elasticsearch-model 0.0.1 → 0.1.0.rc1

data/test/unit/proxy_test.rb

@@ -0,0 +1,88 @@
+require 'test_helper'
+
+class Elasticsearch::Model::SearchTest < Test::Unit::TestCase
+  context "Searching module" do
+    class ::DummyProxyModel
+      include Elasticsearch::Model::Proxy
+
+      def self.foo
+        'classy foo'
+      end
+
+      def bar
+        'insta barr'
+      end
+
+      def as_json(options)
+        {foo: 'bar'}
+      end
+    end
+
+    class ::DummyProxyModelWithCallbacks
+      def self.before_save(&block)
+        (@callbacks ||= {})[block.hash] = block
+      end
+
+      def changed_attributes; [:foo]; end
+
+      def changes
+        {:foo => ['One', 'Two']}
+      end
+    end
+
+    should "setup the class proxy method" do
+      assert_respond_to DummyProxyModel, :__elasticsearch__
+    end
+
+    should "setup the instance proxy method" do
+      assert_respond_to DummyProxyModel.new, :__elasticsearch__
+    end
+
+    should "register the hook for before_save callback" do
+      ::DummyProxyModelWithCallbacks.expects(:before_save).returns(true)
+      DummyProxyModelWithCallbacks.__send__ :include, Elasticsearch::Model::Proxy
+    end
+
+    should "set the @__changed_attributes variable before save" do
+      instance = ::DummyProxyModelWithCallbacks.new
+      instance.__elasticsearch__.expects(:instance_variable_set).with do |name, value|
+        assert_equal :@__changed_attributes, name
+        assert_equal({foo: 'Two'}, value)
+      end
+
+      ::DummyProxyModelWithCallbacks.__send__ :include, Elasticsearch::Model::Proxy
+
+      ::DummyProxyModelWithCallbacks.instance_variable_get(:@callbacks).each do |n,b|
+        instance.instance_eval(&b)
+      end
+    end
+
+    should "delegate methods to the target" do
+      assert_respond_to DummyProxyModel.__elasticsearch__,     :foo
+      assert_respond_to DummyProxyModel.new.__elasticsearch__, :bar
+
+      assert_raise(NoMethodError) { DummyProxyModel.__elasticsearch__.xoxo }
+      assert_raise(NoMethodError) { DummyProxyModel.new.__elasticsearch__.xoxo }
+
+      assert_equal 'classy foo', DummyProxyModel.__elasticsearch__.foo
+      assert_equal 'insta barr', DummyProxyModel.new.__elasticsearch__.bar
+    end
+
+    should "return the proxy class from instance proxy" do
+      assert_equal Elasticsearch::Model::Proxy::ClassMethodsProxy, DummyProxyModel.new.__elasticsearch__.class.class
+    end
+
+    should "return the origin class from instance proxy" do
+      assert_equal DummyProxyModel, DummyProxyModel.new.__elasticsearch__.klass
+    end
+
+    should "delegate as_json from the proxy to target" do
+      assert_equal({foo: 'bar'}, DummyProxyModel.new.__elasticsearch__.as_json)
+    end
+
+    should "have inspect method indicating the proxy" do
+      assert_match /PROXY/, DummyProxyModel.__elasticsearch__.inspect
+      assert_match /PROXY/, DummyProxyModel.new.__elasticsearch__.inspect
+    end
+  end
+end

data/test/unit/response_base_test.rb

@@ -0,0 +1,40 @@
+require 'test_helper'
+
+class Elasticsearch::Model::BaseTest < Test::Unit::TestCase
+  context "Response base module" do
+    class OriginClass
+      def self.index_name;    'foo'; end
+      def self.document_type; 'bar'; end
+    end
+
+    class DummyBaseClass
+      include Elasticsearch::Model::Response::Base
+    end
+
+    RESPONSE = { 'hits' => { 'total' => 123, 'max_score' => 456, 'hits' => [] } }
+
+    setup do
+      @search   = Elasticsearch::Model::Searching::SearchRequest.new OriginClass, '*'
+      @response = Elasticsearch::Model::Response::Response.new OriginClass, @search
+      @search.stubs(:execute!).returns(RESPONSE)
+    end
+
+    should "access klass, response, total and max_score" do
+      r = DummyBaseClass.new OriginClass, @response
+
+      assert_equal OriginClass, r.klass
+      assert_equal @response, r.response
+      assert_equal RESPONSE,  r.response.response
+      assert_equal 123, r.total
+      assert_equal 456, r.max_score
+    end
+
+    should "have abstract methods results and records" do
+      r = DummyBaseClass.new OriginClass, @response
+
+      assert_raise(Elasticsearch::Model::NotImplemented) { |e| r.results }
+      assert_raise(Elasticsearch::Model::NotImplemented) { |e| r.records }
+    end
+
+  end
+end

data/test/unit/response_pagination_test.rb

@@ -0,0 +1,159 @@
+require 'test_helper'
+
+class Elasticsearch::Model::ResponsePaginationTest < Test::Unit::TestCase
+  context "Response pagination" do
+    class ModelClass
+      include ::Kaminari::ConfigurationMethods
+
+      def self.index_name;    'foo'; end
+      def self.document_type; 'bar'; end
+    end
+
+    RESPONSE = { 'took' => '5', 'timed_out' => false, '_shards' => {'one' => 'OK'},
+                 'hits' => { 'total' => 100, 'hits' => (1..100).to_a.map { |i| { _id: i } } } }
+
+    setup do
+      @search    = Elasticsearch::Model::Searching::SearchRequest.new ModelClass, '*'
+      @response = Elasticsearch::Model::Response::Response.new ModelClass, @search, RESPONSE
+      @response.klass.stubs(:client).returns mock('client')
+    end
+
+    should "have pagination methods" do
+      assert_respond_to @response, :page
+      assert_respond_to @response, :limit_value
+      assert_respond_to @response, :offset_value
+      assert_respond_to @response, :limit
+      assert_respond_to @response, :offset
+      assert_respond_to @response, :total_count
+    end
+
+    context "#page method" do
+      should "advance the from/size" do
+        @response.klass.client
+          .expects(:search)
+            .with do |definition|
+              assert_equal 25, definition[:from]
+              assert_equal 25, definition[:size]
+            end
+          .returns(RESPONSE)
+
+        assert_nil @response.search.definition[:from]
+        assert_nil @response.search.definition[:size]
+
+        @response.page(2).to_a
+        assert_equal 25, @response.search.definition[:from]
+        assert_equal 25, @response.search.definition[:size]
+      end
+
+      should "advance the from/size further" do
+        @response.klass.client
+          .expects(:search)
+            .with do |definition|
+              assert_equal 75, definition[:from]
+              assert_equal 25, definition[:size]
+            end
+          .returns(RESPONSE)
+
+        @response.page(4).to_a
+        assert_equal 75, @response.search.definition[:from]
+        assert_equal 25, @response.search.definition[:size]
+      end
+    end
+
+    context "limit/offset readers" do
+      should "return the default" do
+        assert_equal 0, @response.limit_value
+        assert_equal 0, @response.offset_value
+      end
+
+      should "return the value from URL parameters" do
+        search    = Elasticsearch::Model::Searching::SearchRequest.new ModelClass, '*', size: 10, from: 50
+        @response = Elasticsearch::Model::Response::Response.new ModelClass, search, RESPONSE
+
+        assert_equal 10, @response.limit_value
+        assert_equal 50, @response.offset_value
+      end
+
+      should "return the value from body" do
+        search    = Elasticsearch::Model::Searching::SearchRequest.new ModelClass, { query: { match_all: {} }, from: 10, size: 50 }
+        @response = Elasticsearch::Model::Response::Response.new ModelClass, search, RESPONSE
+
+        assert_equal 50, @response.limit_value
+        assert_equal 10, @response.offset_value
+      end
+    end
+
+    context "limit setter" do
+      setup do
+        @response.records
+        @response.results
+      end
+
+      should "set the values" do
+        @response.limit(35)
+        assert_equal 35, @response.search.definition[:size]
+      end
+
+      should "reset the variables" do
+        @response.limit(35)
+
+        assert_nil @response.instance_variable_get(:@response)
+        assert_nil @response.instance_variable_get(:@records)
+        assert_nil @response.instance_variable_get(:@results)
+      end
+    end
+
+    context "offset setter" do
+      setup do
+        @response.records
+        @response.results
+      end
+
+      should "set the values" do
+        @response.offset(15)
+        assert_equal 15, @response.search.definition[:from]
+      end
+
+      should "reset the variables" do
+        @response.offset(35)
+
+        assert_nil @response.instance_variable_get(:@response)
+        assert_nil @response.instance_variable_get(:@records)
+        assert_nil @response.instance_variable_get(:@results)
+      end
+    end
+
+    context "total" do
+      should "return the number of hits" do
+        @response.expects(:results).returns(mock('results', total: 100))
+        assert_equal 100, @response.total_count
+      end
+    end
+
+    context "results" do
+      setup do
+        @search.stubs(:execute!).returns RESPONSE
+      end
+
+      should "return current page and total count" do
+        assert_equal 1, @response.page(1).results.current_page
+        assert_equal 100, @response.results.total_count
+
+        assert_equal 5, @response.page(5).results.current_page
+      end
+    end
+
+    context "records" do
+      setup do
+        @search.stubs(:execute!).returns RESPONSE
+      end
+
+      should "return current page and total count" do
+        assert_equal 1, @response.page(1).records.current_page
+        assert_equal 100, @response.records.total_count
+
+        assert_equal 5, @response.page(5).records.current_page
+      end
+    end
+  end
+end

data/test/unit/response_records_test.rb

@@ -0,0 +1,87 @@
+require 'test_helper'
+
+class Elasticsearch::Model::RecordsTest < Test::Unit::TestCase
+  context "Response records" do
+    class DummyCollection
+      include Enumerable
+
+      def each(&block); ['FOO'].each(&block); end
+      def size;         ['FOO'].size;         end
+      def empty?;       ['FOO'].empty?;       end
+      def foo;          'BAR';                end
+    end
+
+    class DummyModel
+      def self.index_name;    'foo'; end
+      def self.document_type; 'bar'; end
+
+      def self.find(*args)
+        DummyCollection.new
+      end
+    end
+
+    RESPONSE = { 'hits' => { 'total' => 123, 'max_score' => 456, 'hits' => [{'foo' => 'bar'}] } }
+    RESULTS  = Elasticsearch::Model::Response::Results.new DummyModel, RESPONSE
+
+    setup do
+      search   = Elasticsearch::Model::Searching::SearchRequest.new DummyModel, '*'
+      search.stubs(:execute!).returns RESPONSE
+
+      response = Elasticsearch::Model::Response::Response.new DummyModel, search
+      @records = Elasticsearch::Model::Response::Records.new DummyModel, response
+    end
+
+    should "access the records" do
+      assert_respond_to @records, :records
+      assert_equal 1, @records.records.size
+      assert_equal 'FOO', @records.records.first
+    end
+
+    should "delegate Enumerable methods to records" do
+      assert ! @records.empty?
+      assert_equal 'FOO', @records.first
+    end
+
+    should "delegate methods to records" do
+      assert_respond_to   @records, :foo
+      assert_equal 'BAR', @records.foo
+    end
+
+    should "have each_with_hit method" do
+      @records.each_with_hit do |record, hit|
+        assert_equal 'FOO', record
+        assert_equal 'bar', hit.foo
+      end
+    end
+
+    should "have map_with_hit method" do
+      assert_equal ['FOO---bar'], @records.map_with_hit { |record, hit| "#{record}---#{hit.foo}" }
+    end
+
+    context "with adapter" do
+      module DummyAdapter
+        module RecordsMixin
+          def records
+            ['FOOBAR']
+          end
+        end
+
+        def records_mixin
+          RecordsMixin
+        end; module_function :records_mixin
+      end
+
+      should "delegate the records method to the adapter" do
+        Elasticsearch::Model::Adapter.expects(:from_class)
+                                     .with(DummyModel)
+                                     .returns(DummyAdapter)
+
+        @records = Elasticsearch::Model::Response::Records.new DummyModel,
+                                                               RESPONSE
+
+        assert_equal ['FOOBAR'], @records.records
+      end
+    end
+
+  end
+end

data/test/unit/response_result_test.rb

@@ -0,0 +1,52 @@
+require 'test_helper'
+
+class Elasticsearch::Model::ResultTest < Test::Unit::TestCase
+  context "Response result" do
+
+    should "have method access to properties" do
+      result = Elasticsearch::Model::Response::Result.new foo: 'bar', bar: { bam: 'baz' }
+
+      assert_respond_to result, :foo
+      assert_respond_to result, :bar
+
+      assert_equal 'bar', result.foo
+      assert_equal 'baz', result.bar.bam
+
+      assert_raise(NoMethodError) { result.xoxo }
+    end
+
+    should "delegate method calls to `_source` when available" do
+      result = Elasticsearch::Model::Response::Result.new foo: 'bar', _source: { bar: 'baz' }
+
+      assert_respond_to result, :foo
+      assert_respond_to result, :_source
+      assert_respond_to result, :bar
+
+      assert_equal 'bar', result.foo
+      assert_equal 'baz', result._source.bar
+      assert_equal 'baz', result.bar
+    end
+
+    should "delegate methods to @result" do
+      result = Elasticsearch::Model::Response::Result.new foo: 'bar'
+
+      assert_equal 'bar', result.foo
+      assert_equal 'bar', result.fetch('foo')
+      assert_equal 'moo', result.fetch('NOT_EXIST', 'moo')
+
+      assert_respond_to result, :to_hash
+      assert_equal({'foo' => 'bar'}, result.to_hash)
+
+      assert_raise(NoMethodError) { result.does_not_exist }
+    end
+
+    should "delegate as_json to @result even when ActiveSupport changed half of Ruby" do
+      require 'active_support/json/encoding'
+      result = Elasticsearch::Model::Response::Result.new foo: 'bar'
+
+      result.instance_variable_get(:@result).expects(:as_json)
+      result.as_json(except: 'foo')
+    end
+
+  end
+end

data/test/unit/response_results_test.rb

@@ -0,0 +1,31 @@
+require 'test_helper'
+
+class Elasticsearch::Model::ResultsTest < Test::Unit::TestCase
+  context "Response results" do
+    class OriginClass
+      def self.index_name;    'foo'; end
+      def self.document_type; 'bar'; end
+    end
+
+    RESPONSE = { 'hits' => { 'total' => 123, 'max_score' => 456, 'hits' => [{'foo' => 'bar'}] } }
+
+    setup do
+      @search   = Elasticsearch::Model::Searching::SearchRequest.new OriginClass, '*'
+      @response = Elasticsearch::Model::Response::Response.new OriginClass, @search
+      @results  = Elasticsearch::Model::Response::Results.new  OriginClass, @response
+      @search.stubs(:execute!).returns(RESPONSE)
+    end
+
+    should "access the results" do
+      assert_respond_to @results, :results
+      assert_equal 1, @results.results.size
+      assert_equal 'bar', @results.results.first.foo
+    end
+
+    should "delegate Enumerable methods to results" do
+      assert ! @results.empty?
+      assert_equal 'bar', @results.first.foo
+    end
+
+  end
+end