elasticsearch-model-queryable 0.1.5

data/test/unit/response_records_test.rb

@@ -0,0 +1,91 @@
+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' => [{'_id' => '1', '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
+
+    should "return the IDs" do
+      assert_equal ['1'], @records.ids
+    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,90 @@
+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 "return _id as #id" do
+      result = Elasticsearch::Model::Response::Result.new foo: 'bar', _id: 42, _source: { id: 12 }
+
+      assert_equal 42, result.id
+      assert_equal 12, result._source.id
+    end
+
+    should "return _type as #type" do
+      result = Elasticsearch::Model::Response::Result.new foo: 'bar', _type: 'baz', _source: { type: 'BAM' }
+
+      assert_equal 'baz', result.type
+      assert_equal 'BAM', result._source.type
+    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 existence method calls to `_source`" do
+      result = Elasticsearch::Model::Response::Result.new foo: 'bar', _source: { bar: { bam: 'baz' } }
+
+      assert_respond_to result._source, :bar?
+      assert_respond_to result, :bar?
+
+      assert_equal true,  result._source.bar?
+      assert_equal true,  result.bar?
+      assert_equal false, result.boo?
+
+      assert_equal true,  result.bar.bam?
+      assert_equal false, result.bar.boo?
+    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_equal ['foo'], result.keys
+
+      assert_respond_to result, :to_hash
+      assert_equal({'foo' => 'bar'}, result.to_hash)
+
+      assert_raise(NoMethodError) { result.does_not_exist }
+    end
+
+    should "delegate existence method calls to @result" do
+      result = Elasticsearch::Model::Response::Result.new foo: 'bar', _source: { bar: 'bam' }
+      assert_respond_to result, :foo?
+
+      assert_equal true,  result.foo?
+      assert_equal false, result.boo?
+      assert_equal false, result._source.foo?
+      assert_equal false, result._source.boo?
+    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

data/test/unit/response_test.rb

@@ -0,0 +1,67 @@
+require 'test_helper'
+
+class Elasticsearch::Model::ResponseTest < Test::Unit::TestCase
+  context "Response" do
+    class OriginClass
+      def self.index_name;    'foo'; end
+      def self.document_type; 'bar'; end
+    end
+
+    RESPONSE = { 'took' => '5', 'timed_out' => false, '_shards' => {'one' => 'OK'}, 'hits' => { 'hits' => [] } }
+
+    setup do
+      @search  = Elasticsearch::Model::Searching::SearchRequest.new OriginClass, '*'
+      @search.stubs(:execute!).returns(RESPONSE)
+    end
+
+    should "access klass, response, took, timed_out, shards" do
+      response = Elasticsearch::Model::Response::Response.new OriginClass, @search
+
+      assert_equal OriginClass, response.klass
+      assert_equal @search,     response.search
+      assert_equal RESPONSE,    response.response
+      assert_equal '5',         response.took
+      assert_equal false,       response.timed_out
+      assert_equal 'OK',        response.shards.one
+    end
+
+    should "wrap the raw Hash response in Hashie::Mash" do
+      @search  = Elasticsearch::Model::Searching::SearchRequest.new OriginClass, '*'
+      @search.stubs(:execute!).returns({'hits' => { 'hits' => [] }, 'aggregations' => { 'dates' => 'FOO' }})
+
+      response = Elasticsearch::Model::Response::Response.new OriginClass, @search
+
+      assert_respond_to response.response, :aggregations
+      assert_equal 'FOO', response.response.aggregations.dates
+    end
+
+    should "load and access the results" do
+      @search.expects(:execute!).returns(RESPONSE)
+
+      response = Elasticsearch::Model::Response::Response.new OriginClass, @search
+      assert_instance_of Elasticsearch::Model::Response::Results, response.results
+      assert_equal 0, response.size
+    end
+
+    should "load and access the records" do
+      @search.expects(:execute!).returns(RESPONSE)
+
+      response = Elasticsearch::Model::Response::Response.new OriginClass, @search
+      assert_instance_of Elasticsearch::Model::Response::Records, response.records
+      assert_equal 0, response.size
+    end
+
+    should "delegate Enumerable methods to results" do
+      @search.expects(:execute!).returns(RESPONSE)
+
+      response = Elasticsearch::Model::Response::Response.new OriginClass, @search
+      assert response.empty?
+    end
+
+    should "be initialized lazily" do
+      @search.expects(:execute!).never
+
+      Elasticsearch::Model::Response::Response.new OriginClass, @search
+    end
+  end
+end

data/test/unit/searching_search_request_test.rb

@@ -0,0 +1,78 @@
+require 'test_helper'
+
+class Elasticsearch::Model::SearchRequestTest < Test::Unit::TestCase
+  context "SearchRequest class" do
+    class ::DummySearchingModel
+      extend Elasticsearch::Model::Searching::ClassMethods
+
+      def self.index_name;    'foo'; end
+      def self.document_type; 'bar'; end
+
+    end
+
+    setup do
+      @client = mock('client')
+      DummySearchingModel.stubs(:client).returns(@client)
+    end
+
+    should "pass the search definition as a simple query" do
+      @client.expects(:search).with do |params|
+        assert_equal 'foo', params[:q]
+        true
+      end
+      .returns({})
+
+      s = Elasticsearch::Model::Searching::SearchRequest.new ::DummySearchingModel, 'foo'
+      s.execute!
+    end
+
+    should "pass the search definition as a Hash" do
+      @client.expects(:search).with do |params|
+        assert_equal( {foo: 'bar'}, params[:body] )
+        true
+      end
+      .returns({})
+
+      s = Elasticsearch::Model::Searching::SearchRequest.new ::DummySearchingModel, foo: 'bar'
+      s.execute!
+    end
+
+    should "pass the search definition as a JSON string" do
+      @client.expects(:search).with do |params|
+        assert_equal( '{"foo":"bar"}', params[:body] )
+        true
+      end
+      .returns({})
+
+      s = Elasticsearch::Model::Searching::SearchRequest.new ::DummySearchingModel, '{"foo":"bar"}'
+      s.execute!
+    end
+
+    should "pass the search definition as an object which responds to to_hash" do
+      class MySpecialQueryBuilder
+        def to_hash; {foo: 'bar'}; end
+      end
+
+      @client.expects(:search).with do |params|
+        assert_equal( {foo: 'bar'}, params[:body] )
+        true
+      end
+      .returns({})
+
+      s = Elasticsearch::Model::Searching::SearchRequest.new ::DummySearchingModel, MySpecialQueryBuilder.new
+      s.execute!
+    end
+
+    should "pass the options to the client" do
+      @client.expects(:search).with do |params|
+        assert_equal 'foo', params[:q]
+        assert_equal 15,    params[:size]
+        true
+      end
+      .returns({})
+
+      s = Elasticsearch::Model::Searching::SearchRequest.new ::DummySearchingModel, 'foo', size: 15
+      s.execute!
+    end
+  end
+end

data/test/unit/searching_test.rb

@@ -0,0 +1,41 @@
+require 'test_helper'
+
+class Elasticsearch::Model::SearchingTest < Test::Unit::TestCase
+  context "Searching module" do
+    class ::DummySearchingModel
+      extend Elasticsearch::Model::Searching::ClassMethods
+
+      def self.index_name;    'foo'; end
+      def self.document_type; 'bar'; end
+    end
+
+    setup do
+      @client = mock('client')
+      DummySearchingModel.stubs(:client).returns(@client)
+    end
+
+    should "have the search method" do
+      assert_respond_to DummySearchingModel, :search
+    end
+
+    should "initialize the search object" do
+      Elasticsearch::Model::Searching::SearchRequest
+        .expects(:new).with do |klass, query, options|
+          assert_equal DummySearchingModel, klass
+          assert_equal 'foo', query
+          assert_equal({default_operator: 'AND'}, options)
+          true
+        end
+        .returns( stub('search') )
+
+      DummySearchingModel.search 'foo', default_operator: 'AND'
+    end
+
+    should "not execute the search" do
+      Elasticsearch::Model::Searching::SearchRequest
+        .expects(:new).returns( mock('search').expects(:execute!).never )
+
+      DummySearchingModel.search 'foo'
+    end
+  end
+end

data/test/unit/serializing_test.rb

@@ -0,0 +1,17 @@
+require 'test_helper'
+
+class Elasticsearch::Model::SerializingTest < Test::Unit::TestCase
+  context "Serializing module" do
+    class DummyClass
+      include Elasticsearch::Model::Serializing::InstanceMethods
+
+      def as_json(options={})
+        'HASH'
+      end
+    end
+
+    should "delegate to as_json by default" do
+      assert_equal 'HASH', DummyClass.new.as_indexed_json
+    end
+  end
+end