elasticsearch-persistence 5.0.2 → 6.1.1

data/test/integration/repository/virtus_model_test.rb

@@ -1,118 +0,0 @@
-require 'test_helper'
-
-require 'virtus'
-
-module Elasticsearch
-  module Persistence
-    class RepositoryWithVirtusIntegrationTest < Elasticsearch::Test::IntegrationTestCase
-
-      class ::Page
-        include Virtus.model
-
-        attribute :id,        String, writer: :private
-        attribute :title,     String
-        attribute :views,     Integer, default: 0
-        attribute :published, Boolean, default: false
-        attribute :slug,      String,  default: lambda { |page, attr| page.title.downcase.gsub(' ', '-') }
-
-        def set_id(id)
-          self.id = id
-        end
-      end
-
-      context "The repository with a Virtus model" do
-        setup do
-          @repository = Elasticsearch::Persistence::Repository.new do
-            index :pages
-            klass Page
-
-            def deserialize(document)
-              page = klass.new document['_source']
-              page.set_id document['_id']
-              page
-            end
-          end
-        end
-
-        should "save and find the object" do
-          page = Page.new title: 'Test Page'
-
-          response = @repository.save page
-          id = response['_id']
-
-          result = @repository.find(id)
-
-          assert_instance_of Page,  result
-          assert_equal 'Test Page', result.title
-          assert_equal 0,           result.views
-
-          assert_not_nil Elasticsearch::Persistence.client.get index: 'pages',
-                                                               type: 'page',
-                                                               id: id
-        end
-
-        should "update the object with a partial document" do
-          response = @repository.save Page.new(title: 'Test')
-          id = response['_id']
-
-          page = @repository.find(id)
-
-          assert_equal 'Test', page.title
-
-          @repository.update page.id, doc: { title: 'UPDATE' }
-
-          page = @repository.find(id)
-          assert_equal 'UPDATE', page.title
-        end
-
-        should "update the object with a Hash" do
-          response = @repository.save Page.new(title: 'Test')
-          id = response['_id']
-
-          page = @repository.find(id)
-
-          assert_equal 'Test', page.title
-
-          @repository.update id: page.id, title: 'UPDATE'
-
-          page = @repository.find(id)
-          assert_equal 'UPDATE', page.title
-        end
-
-        should "update the object with a script" do
-          response = @repository.save Page.new(title: 'Test Page')
-          id = response['_id']
-
-          page = @repository.find(id)
-
-          assert_not_nil page.id
-          assert_equal 0, page.views
-
-          @repository.update page.id, script: 'ctx._source.views += 1'
-
-          page = @repository.find(id)
-          assert_equal 1, page.views
-
-          @repository.update id: page.id, script: 'ctx._source.views += 1'
-
-          page = @repository.find(id)
-          assert_equal 2, page.views
-        end
-
-        should "update the object with a script and params" do
-          response = @repository.save Page.new(title: 'Test Page')
-
-          @repository.update id: response['_id'],
-                             script: {
-                              inline: 'ctx._source.views += params.count',
-                              params: { count: 3 }
-                             }
-
-          page = @repository.find(response['_id'])
-          assert_equal 3, page.views
-        end
-      end
-
-    end
-  end
-end

data/test/test_helper.rb

@@ -1,55 +0,0 @@
-RUBY_1_8 = defined?(RUBY_VERSION) && RUBY_VERSION < '1.9'
-
-exit(0) if RUBY_1_8
-
-$LOAD_PATH.unshift File.expand_path('../../../elasticsearch-model/lib', __FILE__) if File.exists? File.expand_path('../../../elasticsearch-model/lib', __FILE__)
-
-require 'simplecov' and SimpleCov.start { add_filter "/test|test_/" } if ENV["COVERAGE"]
-
-# Register `at_exit` handler for integration tests shutdown.
-# MUST be called before requiring `test/unit`.
-at_exit { Elasticsearch::Test::IntegrationTestCase.__run_at_exit_hooks } if ENV['SERVER']
-
-if defined?(RUBY_VERSION) && RUBY_VERSION > '2.2'
-  require 'test-unit'
-  require 'mocha/test_unit'
-else
-  require 'minitest/autorun'
-  require 'mocha/mini_test'
-end
-
-require 'shoulda-context'
-
-require 'turn' unless ENV["TM_FILEPATH"] || ENV["NOTURN"] || defined?(RUBY_VERSION) && RUBY_VERSION > '2.2'
-
-require 'ansi'
-require 'oj'
-
-require 'elasticsearch/extensions/test/cluster'
-require 'elasticsearch/extensions/test/startup_shutdown'
-
-require 'elasticsearch/persistence'
-
-module Elasticsearch
-  module Test
-    class IntegrationTestCase < ::Test::Unit::TestCase
-      extend Elasticsearch::Extensions::Test::StartupShutdown
-
-      startup  { Elasticsearch::Extensions::Test::Cluster.start(nodes: 1) if ENV['SERVER'] and not Elasticsearch::Extensions::Test::Cluster.running? }
-      shutdown { Elasticsearch::Extensions::Test::Cluster.stop if ENV['SERVER'] && started? }
-      context "IntegrationTest" do; should "noop on Ruby 1.8" do; end; end if RUBY_1_8
-
-      def setup
-        tracer = ::Logger.new(STDERR)
-        tracer.formatter = lambda { |s, d, p, m| "#{m.gsub(/^.*$/) { |n| '   ' + n }.ansi(:faint)}\n" }
-        Elasticsearch::Persistence.client = Elasticsearch::Client.new \
-                                              host: "localhost:#{(ENV['TEST_CLUSTER_PORT'] || 9250)}",
-                                              tracer: (ENV['QUIET'] ? nil : tracer)
-      end
-
-      def teardown
-        Elasticsearch::Persistence.client.indices.delete index: '_all'
-      end
-    end
-  end
-end

data/test/unit/model_base_test.rb

@@ -1,72 +0,0 @@
-require 'test_helper'
-
-require 'elasticsearch/persistence/model'
-require 'elasticsearch/persistence/model/rails'
-
-class Elasticsearch::Persistence::ModelBaseTest < Test::Unit::TestCase
-  context "The model" do
-    setup do
-      class DummyBaseModel
-        include Elasticsearch::Persistence::Model
-
-        attribute :name, String
-      end
-    end
-
-    should "respond to id, _id, _index, _type and _version" do
-      model = DummyBaseModel.new
-
-      [:id, :_id, :_index, :_type, :_version].each { |method| assert_respond_to model, method }
-    end
-
-    should "set the ID from attributes during initialization" do
-      model = DummyBaseModel.new id: 1
-      assert_equal 1, model.id
-
-      model = DummyBaseModel.new 'id' => 2
-      assert_equal 2, model.id
-    end
-
-    should "set the ID using setter method" do
-      model = DummyBaseModel.new id: 1
-      assert_equal 1, model.id
-
-      model.id = 2
-      assert_equal 2, model.id
-    end
-
-    should "have ID in attributes" do
-      model = DummyBaseModel.new id: 1, name: 'Test'
-      assert_equal 1, model.attributes[:id]
-    end
-
-    should "have the customized inspect method" do
-      model = DummyBaseModel.new name: 'Test'
-      assert_match /name\: "Test"/, model.inspect
-    end
-
-    context "with custom document_type" do
-      setup do
-        @model = DummyBaseModel
-        @gateway = mock()
-        @mapping = mock()
-        @model.stubs(:gateway).returns(@gateway)
-        @gateway.stubs(:mapping).returns(@mapping)
-        @document_type = 'dummybase'
-      end
-
-      should "forward the argument to mapping" do
-        @gateway.expects(:document_type).with(@document_type).once
-        @mapping.expects(:type=).with(@document_type).once
-        @model.document_type @document_type
-      end
-
-      should "return the value from the gateway" do
-        @gateway.expects(:document_type).once.returns(@document_type)
-        @mapping.expects(:type=).never
-        returned_type = @model.document_type
-        assert_equal @document_type, returned_type
-      end
-    end
-  end
-end

data/test/unit/model_find_test.rb

@@ -1,153 +0,0 @@
-require 'test_helper'
-
-require 'active_model'
-require 'virtus'
-
-require 'elasticsearch/persistence/model/errors'
-require 'elasticsearch/persistence/model/find'
-
-class Elasticsearch::Persistence::ModelFindTest < Test::Unit::TestCase
-  context "The model find module," do
-
-    class DummyFindModel
-      include ActiveModel::Naming
-      include ActiveModel::Conversion
-      include ActiveModel::Serialization
-      include ActiveModel::Serializers::JSON
-      include ActiveModel::Validations
-
-      include Virtus.model
-
-      extend  Elasticsearch::Persistence::Model::Find::ClassMethods
-
-      extend  ActiveModel::Callbacks
-      define_model_callbacks :create, :save, :update, :destroy
-      define_model_callbacks :find, :touch, only: :after
-
-      attribute :title, String
-      attribute :count, Integer, default: 0
-      attribute :created_at, DateTime, default: lambda { |o,a| Time.now.utc }
-      attribute :updated_at, DateTime, default: lambda { |o,a| Time.now.utc }
-    end
-
-    setup do
-      @gateway = stub(client: stub(), index_name: 'foo', document_type: 'bar')
-      DummyFindModel.stubs(:gateway).returns(@gateway)
-
-      DummyFindModel.stubs(:index_name).returns('foo')
-      DummyFindModel.stubs(:document_type).returns('bar')
-
-      @response = MultiJson.load <<-JSON
-        {
-          "took": 14,
-          "timed_out": false,
-          "_shards": {
-            "total": 5,
-            "successful": 5,
-            "failed": 0
-          },
-          "hits": {
-            "total": 1,
-            "max_score": 1.0,
-            "hits": [
-              {
-                "_index": "dummy",
-                "_type": "dummy",
-                "_id": "abc123",
-                "_score": 1.0,
-                "_source": {
-                  "name": "TEST"
-                }
-              }
-            ]
-          }
-        }
-      JSON
-    end
-
-    should "find all records" do
-      DummyFindModel
-        .stubs(:search)
-        .with({ query: { match_all: {} }, size: 10_000 }, {})
-        .returns(@response)
-
-      DummyFindModel.all
-    end
-
-    should "pass options when finding all records" do
-      DummyFindModel
-        .expects(:search)
-        .with({ query: { match: { title: 'test' } }, size: 10_000 }, { routing: 'abc123' })
-        .returns(@response)
-
-      DummyFindModel.all( { query: { match: { title: 'test' } } }, { routing: 'abc123' } )
-    end
-
-    context "finding via scroll" do
-      setup do
-        @gateway
-        .expects(:deserialize)
-        .returns('_source' => {'foo' => 'bar'})
-        .at_least_once
-
-        # 1. Initial batch of documents and the scroll_id
-        @gateway.client
-          .expects(:search)
-          .with do |arguments|
-            assert_equal 'foo',  arguments[:index]
-            assert_equal 'bar',  arguments[:type]
-            true
-          end
-          .returns(MultiJson.load('{"_scroll_id":"abc123==", "hits":{"hits":[{"_source":{"foo":"bar_1"}}]}}'))
-
-        # 2. Second batch of documents and the scroll_id
-        # 3. Last, empty batch of documents
-        @gateway.client
-          .expects(:scroll)
-          .twice
-          .returns(MultiJson.load('{"_scroll_id":"abc456==", "hits":{"hits":[{"_source":{"foo":"bar_2"}}]}}'))
-          .then
-          .returns(MultiJson.load('{"_scroll_id":"abc789==", "hits":{"hits":[]}}'))
-      end
-
-      should "find all records in batches" do
-        @doc = nil
-        result = DummyFindModel.find_in_batches { |batch| @doc = batch.first['_source']['foo'] }
-
-        assert_equal 'abc789==', result
-        assert_equal 'bar',      @doc
-      end
-
-      should "return an Enumerator for find in batches" do
-        @doc = nil
-        assert_nothing_raised do
-          e = DummyFindModel.find_in_batches
-          assert_instance_of Enumerator, e
-
-          e.each { |batch| @doc = batch.first['_source']['foo'] }
-          assert_equal 'bar',      @doc
-        end
-      end
-
-      should "find each" do
-        @doc = nil
-        result = DummyFindModel.find_each { |doc| @doc = doc['_source']['foo'] }
-
-        assert_equal 'abc789==', result
-        assert_equal 'bar',      @doc
-      end
-
-      should "return an Enumerator for find each" do
-        @doc = nil
-        assert_nothing_raised do
-          e = DummyFindModel.find_each
-          assert_instance_of Enumerator, e
-
-          e.each { |doc| @doc = doc['_source']['foo'] }
-          assert_equal 'bar',      @doc
-        end
-      end
-    end
-
-  end
-end

data/test/unit/model_gateway_test.rb

@@ -1,101 +0,0 @@
-require 'test_helper'
-
-require 'elasticsearch/persistence/model'
-require 'elasticsearch/persistence/model/rails'
-
-class Elasticsearch::Persistence::ModelGatewayTest < Test::Unit::TestCase
-  context "The model gateway" do
-    setup do
-      class DummyGatewayModel
-        include Elasticsearch::Persistence::Model
-      end
-    end
-
-    teardown do
-      Elasticsearch::Persistence::ModelGatewayTest.__send__ :remove_const, :DummyGatewayModel \
-      rescue NameError; nil
-    end
-
-    should "be accessible" do
-      assert_instance_of Elasticsearch::Persistence::Repository::Class, DummyGatewayModel.gateway
-
-      $a = 0
-      DummyGatewayModel.gateway { $a += 1 }
-      assert_equal 1, $a
-
-      @b = 0
-      def run!; DummyGatewayModel.gateway { |g| @b += 1 }; end
-      run!
-      assert_equal 1, @b
-
-      assert_equal DummyGatewayModel, DummyGatewayModel.gateway.klass
-    end
-
-    should "define common attributes" do
-      d = DummyGatewayModel.new
-
-      assert_respond_to d, :updated_at
-      assert_respond_to d, :created_at
-    end
-
-    should "allow to configure settings" do
-      DummyGatewayModel.settings(number_of_shards: 1)
-
-      assert_equal 1, DummyGatewayModel.settings.to_hash[:number_of_shards]
-    end
-
-    should "allow to configure mappings" do
-      DummyGatewayModel.mapping { indexes :name, analyzer: 'snowball' }
-
-      assert_equal 'snowball',
-                   DummyGatewayModel.mapping.to_hash[:dummy_gateway_model][:properties][:name][:analyzer]
-    end
-
-    should "configure the mapping via attribute" do
-      DummyGatewayModel.attribute :name, String, mapping: { analyzer: 'snowball' }
-
-      assert_respond_to DummyGatewayModel, :name
-      assert_equal 'snowball',
-                   DummyGatewayModel.mapping.to_hash[:dummy_gateway_model][:properties][:name][:analyzer]
-    end
-
-    should "configure the mapping via an attribute block" do
-      DummyGatewayModel.attribute :name, String do
-        indexes :name, analyzer: 'custom'
-      end
-
-      assert_respond_to DummyGatewayModel, :name
-      assert_equal 'custom',
-                   DummyGatewayModel.mapping.to_hash[:dummy_gateway_model][:properties][:name][:analyzer]
-    end
-
-    should "properly look up types for classes" do
-      assert_equal 'text',    Elasticsearch::Persistence::Model::Utils::lookup_type(String)
-      assert_equal 'integer', Elasticsearch::Persistence::Model::Utils::lookup_type(Integer)
-      assert_equal 'float',   Elasticsearch::Persistence::Model::Utils::lookup_type(Float)
-      assert_equal 'date',    Elasticsearch::Persistence::Model::Utils::lookup_type(Date)
-      assert_equal 'boolean', Elasticsearch::Persistence::Model::Utils::lookup_type(Virtus::Attribute::Boolean)
-    end
-
-    should "remove IDs from hash when serializing" do
-      assert_equal( {foo: 'bar'}, DummyGatewayModel.gateway.serialize(id: '123', foo: 'bar') )
-    end
-
-    should "set IDs from hash when deserializing" do
-      assert_equal 'abc123', DummyGatewayModel.gateway.deserialize('_id' => 'abc123', '_source' => {}).id
-    end
-
-    should "set @persisted variable from hash when deserializing" do
-      assert DummyGatewayModel.gateway.deserialize('_id' => 'abc123', '_source' => {}).instance_variable_get(:@persisted)
-    end
-
-    should "allow accessing the raw _source" do
-      assert_equal 'bar', DummyGatewayModel.gateway.deserialize('_source' => { 'foo' => 'bar' })._source['foo']
-    end
-
-    should "allow to access the raw hit from results as Hashie::Mash" do
-      assert_equal 0.42, DummyGatewayModel.gateway.deserialize('_score' => 0.42, '_source' => {}).hit._score
-    end
-
-  end
-end