elasticsearch-model-queryable 0.1.5

data/test/unit/module_test.rb

@@ -0,0 +1,57 @@
+require 'test_helper'
+
+class Elasticsearch::Model::ModuleTest < Test::Unit::TestCase
+  context "The main module" do
+
+    context "client" do
+      should "have a default" do
+        client = Elasticsearch::Model.client
+        assert_not_nil     client
+        assert_instance_of Elasticsearch::Transport::Client, client
+      end
+
+      should "be settable" do
+        begin
+          Elasticsearch::Model.client = "Foobar"
+          assert_equal "Foobar", Elasticsearch::Model.client
+        ensure
+          Elasticsearch::Model.client = nil
+        end
+      end
+    end
+
+    context "when included in module/class, " do
+      class ::DummyIncludingModel; end
+      class ::DummyIncludingModelWithSearchMethodDefined
+        def self.search(query, options={})
+          "SEARCH"
+        end
+      end
+
+      should "include and set up the proxy" do
+        DummyIncludingModel.__send__ :include, Elasticsearch::Model
+
+        assert_respond_to DummyIncludingModel,     :__elasticsearch__
+        assert_respond_to DummyIncludingModel.new, :__elasticsearch__
+      end
+
+      should "delegate important methods to the proxy" do
+        DummyIncludingModel.__send__ :include, Elasticsearch::Model
+
+        assert_respond_to DummyIncludingModel, :search
+        assert_respond_to DummyIncludingModel, :mappings
+        assert_respond_to DummyIncludingModel, :settings
+        assert_respond_to DummyIncludingModel, :index_name
+        assert_respond_to DummyIncludingModel, :document_type
+        assert_respond_to DummyIncludingModel, :import
+      end
+
+      should "not override existing method" do
+        DummyIncludingModelWithSearchMethodDefined.__send__ :include, Elasticsearch::Model
+
+        assert_equal 'SEARCH', DummyIncludingModelWithSearchMethodDefined.search('foo')
+      end
+    end
+
+  end
+end

data/test/unit/naming_test.rb

@@ -0,0 +1,76 @@
+require 'test_helper'
+
+class Elasticsearch::Model::NamingTest < Test::Unit::TestCase
+  context "Naming module" do
+    class ::DummyNamingModel
+      extend ActiveModel::Naming
+
+      extend  Elasticsearch::Model::Naming::ClassMethods
+      include Elasticsearch::Model::Naming::InstanceMethods
+    end
+
+    module ::MyNamespace
+      class DummyNamingModelInNamespace
+        extend ActiveModel::Naming
+
+        extend  Elasticsearch::Model::Naming::ClassMethods
+        include Elasticsearch::Model::Naming::InstanceMethods
+      end
+    end
+
+    should "return the default index_name" do
+      assert_equal 'dummy_naming_models', DummyNamingModel.index_name
+      assert_equal 'dummy_naming_models', DummyNamingModel.new.index_name
+    end
+
+    should "return the sanitized default index_name for namespaced model" do
+      assert_equal 'my_namespace-dummy_naming_model_in_namespaces', ::MyNamespace::DummyNamingModelInNamespace.index_name
+      assert_equal 'my_namespace-dummy_naming_model_in_namespaces', ::MyNamespace::DummyNamingModelInNamespace.new.index_name
+    end
+
+    should "return the default document_type" do
+      assert_equal 'dummy_naming_model', DummyNamingModel.document_type
+      assert_equal 'dummy_naming_model', DummyNamingModel.new.document_type
+    end
+
+    should "set and return the index_name" do
+      DummyNamingModel.index_name 'foobar'
+      assert_equal 'foobar', DummyNamingModel.index_name
+
+      d = DummyNamingModel.new
+      d.index_name 'foobar_d'
+      assert_equal 'foobar_d', d.index_name
+    end
+
+    should "set the index_name with setter" do
+      DummyNamingModel.index_name = 'foobar_index_S'
+      assert_equal 'foobar_index_S', DummyNamingModel.index_name
+
+      d = DummyNamingModel.new
+      d.index_name = 'foobar_index_s'
+      assert_equal 'foobar_index_s', d.index_name
+
+      assert_equal 'foobar_index_S', DummyNamingModel.index_name
+    end
+
+    should "set and return the document_type" do
+      DummyNamingModel.document_type 'foobar'
+      assert_equal 'foobar', DummyNamingModel.document_type
+
+      d = DummyNamingModel.new
+      d.document_type 'foobar_d'
+      assert_equal 'foobar_d', d.document_type
+    end
+
+    should "set the document_type with setter" do
+      DummyNamingModel.document_type = 'foobar_type_S'
+      assert_equal 'foobar_type_S', DummyNamingModel.document_type
+
+      d = DummyNamingModel.new
+      d.document_type = 'foobar_type_s'
+      assert_equal 'foobar_type_s', d.document_type
+
+      assert_equal 'foobar_type_S', DummyNamingModel.document_type
+    end
+  end
+end

data/test/unit/proxy_test.rb

@@ -0,0 +1,89 @@
+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)
+        true
+      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_kaminari_test.rb

@@ -0,0 +1,189 @@
+require 'test_helper'
+
+class Elasticsearch::Model::ResponsePaginationKaminariTest < 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]
+              true
+            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]
+              true
+            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 Kaminari.config.default_per_page, @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 "ignore the value from request body" do
+        search    = Elasticsearch::Model::Searching::SearchRequest.new ModelClass,
+                    { query: { match_all: {} }, from: 333, size: 999 }
+        @response = Elasticsearch::Model::Response::Response.new ModelClass, search, RESPONSE
+
+        assert_equal Kaminari.config.default_per_page, @response.limit_value
+        assert_equal 0, @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 "with the page() and limit() methods" do
+      setup do
+        @response.records
+        @response.results
+      end
+
+      should "set the values" do
+        @response.page(3).limit(35)
+        assert_equal 35, @response.search.definition[:size]
+        assert_equal 70, @response.search.definition[:from]
+      end
+
+      should "set the values when limit is called first" do
+        @response.limit(35).page(3)
+        assert_equal 35, @response.search.definition[:size]
+        assert_equal 70, @response.search.definition[:from]
+      end
+
+      should "reset the instance variables" do
+        @response.page(3).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_pagination_will_paginate_test.rb

@@ -0,0 +1,208 @@
+require 'test_helper'
+require 'will_paginate'
+require 'will_paginate/collection'
+
+class Elasticsearch::Model::ResponsePaginationWillPaginateTest < Test::Unit::TestCase
+  context "Response pagination" do
+    class ModelClass
+      def self.index_name;    'foo'; end
+      def self.document_type; 'bar'; end
+
+      # WillPaginate adds this method to models (see WillPaginate::PerPage module)
+      def self.per_page
+        33
+      end
+    end
+
+    # Subsclass Response so we can include WillPaginate module without conflicts with Kaminari.
+    class WillPaginateResponse < Elasticsearch::Model::Response::Response
+      include Elasticsearch::Model::Response::Pagination::WillPaginate
+    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 = WillPaginateResponse.new ModelClass, @search, RESPONSE
+      @response.klass.stubs(:client).returns mock('client')
+
+      @expected_methods = [
+        # methods needed by WillPaginate::CollectionMethods
+        :current_page,
+        :offset,
+        :per_page,
+        :total_entries,
+        :length,
+
+        # methods defined by WillPaginate::CollectionMethods
+        :total_pages,
+        :previous_page,
+        :next_page,
+        :out_of_bounds?,
+      ]
+    end
+
+    should "have pagination methods" do
+      assert_respond_to @response, :paginate
+
+      @expected_methods.each do |method|
+        assert_respond_to @response, method
+      end
+    end
+
+    context "response.results" do
+      should "have pagination methods" do
+        @expected_methods.each do |method|
+          assert_respond_to @response.results, method
+        end
+      end
+    end
+
+    context "response.records" do
+      should "have pagination methods" do
+        @expected_methods.each do |method|
+          @response.klass.stubs(:find).returns([])
+          assert_respond_to @response.records, method
+        end
+      end
+    end
+
+    context "#offset method" do
+      should "calculate offset using current_page and per_page" do
+        @response.per_page(3).page(3)
+        assert_equal 6, @response.offset
+      end
+    end
+    context "#length method" do
+      should "return count of paginated results" do
+        @response.per_page(3).page(3)
+        assert_equal 3, @response.length
+      end
+    end
+
+    context "#paginate method" do
+      should "set from/size using defaults" do
+        @response.klass.client
+          .expects(:search)
+            .with do |definition|
+              assert_equal 0, definition[:from]
+              assert_equal 33, definition[:size]
+              true
+            end
+          .returns(RESPONSE)
+
+        assert_nil @response.search.definition[:from]
+        assert_nil @response.search.definition[:size]
+
+        @response.paginate(page: nil).to_a
+        assert_equal 0, @response.search.definition[:from]
+        assert_equal 33, @response.search.definition[:size]
+      end
+
+      should "set from/size using default per_page" do
+        @response.klass.client
+          .expects(:search)
+            .with do |definition|
+              assert_equal 33, definition[:from]
+              assert_equal 33, definition[:size]
+              true
+            end
+          .returns(RESPONSE)
+
+        assert_nil @response.search.definition[:from]
+        assert_nil @response.search.definition[:size]
+
+        @response.paginate(page: 2).to_a
+        assert_equal 33, @response.search.definition[:from]
+        assert_equal 33, @response.search.definition[:size]
+      end
+
+      should "set from/size using custom page and per_page" do
+        @response.klass.client
+          .expects(:search)
+            .with do |definition|
+              assert_equal 18, definition[:from]
+              assert_equal 9, definition[:size]
+              true
+            end
+          .returns(RESPONSE)
+
+        assert_nil @response.search.definition[:from]
+        assert_nil @response.search.definition[:size]
+
+        @response.paginate(page: 3, per_page: 9).to_a
+        assert_equal 18, @response.search.definition[:from]
+        assert_equal 9, @response.search.definition[:size]
+      end
+
+      should "search for first page if specified page is < 1" do
+        @response.klass.client
+          .expects(:search)
+            .with do |definition|
+              assert_equal 0, definition[:from]
+              assert_equal 33, definition[:size]
+              true
+            end
+          .returns(RESPONSE)
+
+        assert_nil @response.search.definition[:from]
+        assert_nil @response.search.definition[:size]
+
+        @response.paginate(page: "-1").to_a
+        assert_equal 0, @response.search.definition[:from]
+        assert_equal 33, @response.search.definition[:size]
+      end
+    end
+
+    context "#page and #per_page shorthand methods" do
+      should "set from/size using default per_page" do
+        @response.page(5)
+        assert_equal 132, @response.search.definition[:from]
+        assert_equal 33, @response.search.definition[:size]
+      end
+
+      should "set from/size when calling #page then #per_page" do
+        @response.page(5).per_page(3)
+        assert_equal 12, @response.search.definition[:from]
+        assert_equal 3, @response.search.definition[:size]
+      end
+
+      should "set from/size when calling #per_page then #page" do
+        @response.per_page(3).page(5)
+        assert_equal 12, @response.search.definition[:from]
+        assert_equal 3, @response.search.definition[:size]
+      end
+    end
+
+    context "#current_page method" do
+      should "return 1 by default" do
+        @response.paginate({})
+        assert_equal 1, @response.current_page
+      end
+
+      should "return current page number" do
+        @response.paginate(page: 3, per_page: 9)
+        assert_equal 3, @response.current_page
+      end
+
+      should "return nil if not pagination set" do
+        assert_equal nil, @response.current_page
+      end
+    end
+
+    context "#per_page method" do
+      should "return value set in paginate call" do
+        @response.paginate(per_page: 8)
+        assert_equal 8, @response.per_page
+      end
+    end
+
+    context "#total_entries method" do
+      should "return total from response" do
+        @response.expects(:results).returns(mock('results', total: 100))
+        assert_equal 100, @response.total_entries
+      end
+    end
+  end
+end