elasticsearch-persistence 5.0.2 → 6.1.1

data/test/unit/model_rails_test.rb

@@ -1,112 +0,0 @@
-require 'test_helper'
-
-require 'elasticsearch/persistence/model'
-require 'elasticsearch/persistence/model/rails'
-
-require 'rails'
-require 'action_controller/railtie'
-require 'action_view/railtie'
-
-class ::MyRailsModel
-  include Elasticsearch::Persistence::Model
-  include Elasticsearch::Persistence::Model::Rails
-
-  attribute :name, String, mapping: { analyzer: 'english' }
-  attribute :published_at, DateTime
-  attribute :published_on, Date
-end
-
-class Application < Rails::Application
-  config.eager_load = false
-  config.root       = File.dirname(File.expand_path('../../../tmp', __FILE__))
-  config.logger     = Logger.new($stderr)
-
-  routes.append do
-    resources :my_rails_models
-  end
-end
-
-class ApplicationController < ActionController::Base
-  include Application.routes.url_helpers
-  include ActionController::UrlFor
-end
-ApplicationController.default_url_options = { host: 'localhost' }
-ApplicationController._routes.append { resources :my_rails_models }
-
-class MyRailsModelController < ApplicationController; end
-
-Application.initialize!
-
-class Elasticsearch::Persistence::ModelRailsTest < Test::Unit::TestCase
-  context "The model in a Rails application" do
-
-    should "generate proper URLs and paths" do
-      model = MyRailsModel.new name: 'Test'
-      model.stubs(:id).returns(1)
-      model.stubs(:persisted?).returns(true)
-
-      controller = MyRailsModelController.new
-      controller.request = ActionDispatch::Request.new({})
-
-      assert_equal 'http://localhost/my_rails_models/1', controller.url_for(model)
-      assert_equal '/my_rails_models/1/edit',            controller.edit_my_rails_model_path(model)
-    end
-
-    should "generate a link" do
-      class MyView; include ActionView::Helpers::UrlHelper; end
-
-      model = MyRailsModel.new name: 'Test'
-      view  = MyView.new
-      view.expects(:url_for).with(model).returns('foo/bar')
-
-      assert_equal '<a href="foo/bar">Show</a>', view.link_to('Show', model)
-    end
-
-    should "parse DateTime from Rails forms" do
-      params = { "published_at(1i)"=>"2014",
-                 "published_at(2i)"=>"1",
-                 "published_at(3i)"=>"1",
-                 "published_at(4i)"=>"12",
-                 "published_at(5i)"=>"00"
-                }
-
-      assert_equal '2014-1-1- 12:00:',
-                   Elasticsearch::Persistence::Model::Rails.__convert_rails_dates(params)['published_at']
-
-      m = MyRailsModel.new params
-      assert_equal "2014-01-01T12:00:00+00:00", m.published_at.iso8601
-    end
-
-    should "parse Date from Rails forms" do
-      params = { "published_on(1i)"=>"2014",
-                 "published_on(2i)"=>"1",
-                 "published_on(3i)"=>"1"
-                }
-
-      assert_equal '2014-1-1-',
-             Elasticsearch::Persistence::Model::Rails.__convert_rails_dates(params)['published_on']
-
-
-      m = MyRailsModel.new params
-      assert_equal "2014-01-01", m.published_on.iso8601
-    end
-
-    context "when updating," do
-      should "pass the options to gateway" do
-        model = MyRailsModel.new name: 'Test'
-        model.stubs(:persisted?).returns(true)
-
-        model.class.gateway
-          .expects(:update)
-          .with do |object, options|
-            assert_equal 'ABC', options[:routing]
-            true
-          end
-          .returns({'_id' => 'abc123'})
-
-        assert model.update( { title: 'UPDATED' }, { routing: 'ABC' } )
-      end
-    end
-
-  end
-end

data/test/unit/model_store_test.rb

@@ -1,576 +0,0 @@
-require 'test_helper'
-
-require 'active_model'
-require 'virtus'
-
-require 'elasticsearch/persistence/model/base'
-require 'elasticsearch/persistence/model/errors'
-require 'elasticsearch/persistence/model/store'
-
-class Elasticsearch::Persistence::ModelStoreTest < Test::Unit::TestCase
-  context "The model store module," do
-
-    class DummyStoreModel
-      include ActiveModel::Naming
-      include ActiveModel::Conversion
-      include ActiveModel::Serialization
-      include ActiveModel::Serializers::JSON
-      include ActiveModel::Validations
-
-      include Virtus.model
-
-      include Elasticsearch::Persistence::Model::Base::InstanceMethods
-      extend  Elasticsearch::Persistence::Model::Store::ClassMethods
-      include Elasticsearch::Persistence::Model::Store::InstanceMethods
-
-      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
-      @shoulda_subject = DummyStoreModel.new title: 'Test'
-      @gateway         = stub
-      DummyStoreModel.stubs(:gateway).returns(@gateway)
-    end
-
-    teardown do
-      Elasticsearch::Persistence::ModelStoreTest.__send__ :remove_const, :DummyStoreModelWithCallback \
-      rescue NameError; nil
-    end
-
-    should "be new_record" do
-      assert subject.new_record?
-    end
-
-    context "when creating," do
-      should "save the object and return it" do
-        DummyStoreModel.any_instance.expects(:save).returns({'_id' => 'X'})
-
-        assert_instance_of DummyStoreModel, DummyStoreModel.create(title: 'Test')
-      end
-
-      should "execute the callbacks" do
-        DummyStoreModelWithCallback = Class.new(DummyStoreModel)
-        @gateway.expects(:save).returns({'_id' => 'X'})
-
-        DummyStoreModelWithCallback.after_create { $stderr.puts "CREATED" }
-        DummyStoreModelWithCallback.after_save   { $stderr.puts "SAVED"   }
-
-        $stderr.expects(:puts).with('CREATED')
-        $stderr.expects(:puts).with('SAVED')
-
-        DummyStoreModelWithCallback.create name: 'test'
-      end
-    end
-
-    context "when saving," do
-      should "save the model" do
-        @gateway
-          .expects(:save)
-          .with do |object, options|
-            assert_equal subject, object
-            assert_equal nil, options[:id]
-            true
-          end
-          .returns({'_id' => 'abc123'})
-
-        assert subject.save
-      end
-
-      should "save the model and set the ID" do
-        @gateway
-          .expects(:save)
-          .returns({'_id' => 'abc123'})
-
-        assert_nil subject.id
-
-        subject.save
-        assert_equal 'abc123', subject.id
-      end
-
-      should "save the model and update the timestamp" do
-        now = Time.parse('2014-01-01T00:00:00Z')
-        Time.expects(:now).returns(now).at_least_once
-        @gateway
-          .expects(:save)
-          .returns({'_id' => 'abc123'})
-
-        subject.save
-        assert_equal Time.parse('2014-01-01T00:00:00Z'), subject.updated_at
-      end
-
-      should "not save an invalid model" do
-        @gateway
-          .expects(:save)
-          .never
-
-        subject.instance_eval do
-          def valid?; false; end;
-        end
-
-        assert ! subject.save
-        assert ! subject.persisted?
-      end
-
-      should "skip the validation with the :validate option" do
-        @gateway
-          .expects(:save)
-          .with do |object, options|
-            assert_equal subject, object
-            assert_equal nil, options[:id]
-            true
-          end
-          .returns({'_id' => 'abc123'})
-
-        subject.instance_eval do
-          def valid?; false; end;
-        end
-
-        assert subject.save validate: false
-        assert subject.persisted?
-      end
-
-      should "pass the options to gateway" do
-        @gateway
-          .expects(:save)
-          .with do |object, options|
-            assert_equal 'ABC', options[:routing]
-            true
-          end
-          .returns({'_id' => 'abc123'})
-
-        assert subject.save routing: 'ABC'
-      end
-
-      should "return the response" do
-         @gateway
-          .expects(:save)
-          .returns('FOOBAR')
-
-        assert_equal 'FOOBAR', subject.save
-      end
-
-      should "execute the callbacks" do
-        @gateway.expects(:save).returns({'_id' => 'abc'})
-        DummyStoreModelWithCallback = Class.new(DummyStoreModel)
-
-        DummyStoreModelWithCallback.after_save { $stderr.puts "SAVED" }
-
-        $stderr.expects(:puts).with('SAVED')
-        d = DummyStoreModelWithCallback.new name: 'Test'
-        d.save
-      end
-
-      should "save the model to its own index" do
-        @gateway.expects(:save)
-          .with do |model, options|
-            assert_equal 'my_custom_index', options[:index]
-            assert_equal 'my_custom_type',  options[:type]
-            true
-          end
-          .returns({'_id' => 'abc'})
-
-        d = DummyStoreModel.new name: 'Test'
-        d.instance_variable_set(:@_index, 'my_custom_index')
-        d.instance_variable_set(:@_type,  'my_custom_type')
-        d.save
-      end
-
-      should "set the meta attributes from response" do
-        @gateway.expects(:save)
-          .with do |model, options|
-            assert_equal 'my_custom_index', options[:index]
-            assert_equal 'my_custom_type',  options[:type]
-            true
-          end
-          .returns({'_id' => 'abc', '_index' => 'foo', '_type' => 'bar', '_version' => '100'})
-
-        d = DummyStoreModel.new name: 'Test'
-        d.instance_variable_set(:@_index, 'my_custom_index')
-        d.instance_variable_set(:@_type,  'my_custom_type')
-        d.save
-
-        assert_equal 'foo', d._index
-        assert_equal 'bar', d._type
-        assert_equal '100', d._version
-      end
-    end
-
-    context "when destroying," do
-      should "remove the model from Elasticsearch" do
-        subject.expects(:persisted?).returns(true)
-        subject.expects(:id).returns('abc123')
-        subject.expects(:freeze).returns(subject)
-
-        @gateway
-          .expects(:delete)
-          .with('abc123', {})
-          .returns({'_id' => 'abc123', 'version' => 2})
-
-        assert subject.destroy
-        assert subject.destroyed?
-      end
-
-      should "pass the options to gateway" do
-        subject.expects(:persisted?).returns(true)
-        subject.expects(:freeze).returns(subject)
-
-        @gateway
-          .expects(:delete)
-          .with do |object, options|
-            assert_equal 'ABC', options[:routing]
-            true
-          end
-          .returns({'_id' => 'abc123'})
-
-        assert subject.destroy routing: 'ABC'
-      end
-
-      should "return the response" do
-        subject.expects(:persisted?).returns(true)
-        subject.expects(:freeze).returns(subject)
-
-        @gateway
-          .expects(:delete)
-          .returns('FOOBAR')
-
-        assert_equal 'FOOBAR', subject.destroy
-      end
-
-      should "execute the callbacks" do
-        @gateway.expects(:delete).returns({'_id' => 'abc'})
-        DummyStoreModelWithCallback = Class.new(DummyStoreModel)
-
-        DummyStoreModelWithCallback.after_destroy { $stderr.puts "DELETED" }
-
-        $stderr.expects(:puts).with('DELETED')
-        d = DummyStoreModelWithCallback.new name: 'Test'
-        d.expects(:persisted?).returns(true)
-        d.expects(:freeze).returns(d)
-
-        d.destroy
-      end
-
-      should "remove the model from its own index" do
-        @gateway.expects(:delete)
-          .with do |model, options|
-            assert_equal 'my_custom_index', options[:index]
-            assert_equal 'my_custom_type',  options[:type]
-            true
-          end
-          .returns({'_id' => 'abc'})
-
-        d = DummyStoreModel.new name: 'Test'
-        d.instance_variable_set(:@_index, 'my_custom_index')
-        d.instance_variable_set(:@_type,  'my_custom_type')
-        d.expects(:persisted?).returns(true)
-        d.expects(:freeze).returns(d)
-
-        d.destroy
-      end
-    end
-
-    context "when updating," do
-      should "update the document with partial attributes" do
-        subject.expects(:persisted?).returns(true)
-        subject.expects(:id).returns('abc123').at_least_once
-
-        @gateway
-          .expects(:update)
-          .with do |id, options|
-            assert_equal 'abc123', id
-            assert_equal 'UPDATED', options[:doc][:title]
-            true
-          end
-          .returns({'_id' => 'abc123', 'version' => 2})
-
-        assert subject.update title: 'UPDATED'
-
-        assert_equal 'UPDATED', subject.title
-      end
-
-      should "allow to update the document with a custom script" do
-        subject.expects(:persisted?).returns(true)
-        subject.expects(:id).returns('abc123').at_least_once
-
-        @gateway
-          .expects(:update)
-          .with do |id, options|
-            assert_equal 'abc123', id
-            assert_equal 'EXEC', options[:script]
-            true
-          end
-          .returns({'_id' => 'abc123', 'version' => 2})
-
-        assert subject.update( {}, { script: 'EXEC' } )
-      end
-
-      should "not update an invalid model" do
-        @gateway
-          .expects(:update)
-          .never
-
-        subject.instance_eval do
-          def valid?; false; end;
-        end
-
-        assert ! subject.update(title: 'INVALID')
-      end
-
-      should "skip the validation with the :validate option" do
-        subject.expects(:persisted?).returns(true).at_least_once
-        subject.expects(:id).returns('abc123').at_least_once
-
-        @gateway
-          .expects(:update)
-          .with do |object, options|
-            assert_equal 'abc123', object
-            assert_equal nil, options[:id]
-            assert_equal 'INVALID', options[:doc][:title]
-            true
-          end
-          .returns({'_id' => 'abc123'})
-
-        subject.instance_eval do
-          def valid?; false; end;
-        end
-
-        assert subject.update( { title: 'INVALID' }, { validate: false } )
-        assert subject.persisted?
-      end
-
-      should "pass the options to gateway" do
-        subject.expects(:persisted?).returns(true)
-
-        @gateway
-          .expects(:update)
-          .with do |object, options|
-            assert_equal 'ABC', options[:routing]
-            true
-          end
-          .returns({'_id' => 'abc123'})
-
-        assert subject.update( { title: 'UPDATED' }, { routing: 'ABC' } )
-      end
-
-      should "return the response" do
-        subject.expects(:persisted?).returns(true)
-
-        @gateway
-          .expects(:update)
-          .returns('FOOBAR')
-
-        assert_equal 'FOOBAR', subject.update
-      end
-
-      should "execute the callbacks" do
-        @gateway.expects(:update).returns({'_id' => 'abc'})
-        DummyStoreModelWithCallback = Class.new(DummyStoreModel)
-
-        DummyStoreModelWithCallback.after_update { $stderr.puts "UPDATED" }
-
-        $stderr.expects(:puts).with('UPDATED')
-        d = DummyStoreModelWithCallback.new name: 'Test'
-        d.expects(:persisted?).returns(true)
-        d.update name: 'Update'
-      end
-
-      should "update the model in its own index" do
-        @gateway.expects(:update)
-          .with do |model, options|
-            assert_equal 'my_custom_index', options[:index]
-            assert_equal 'my_custom_type',  options[:type]
-            true
-          end
-          .returns({'_id' => 'abc'})
-
-        d = DummyStoreModel.new name: 'Test'
-        d.instance_variable_set(:@_index, 'my_custom_index')
-        d.instance_variable_set(:@_type,  'my_custom_type')
-        d.expects(:persisted?).returns(true)
-
-        d.update name: 'Update'
-      end
-
-      should "set the meta attributes from response" do
-        @gateway.expects(:update)
-          .with do |model, options|
-            assert_equal 'my_custom_index', options[:index]
-            assert_equal 'my_custom_type',  options[:type]
-            true
-          end
-          .returns({'_id' => 'abc', '_index' => 'foo', '_type' => 'bar', '_version' => '100'})
-
-        d = DummyStoreModel.new name: 'Test'
-        d.instance_variable_set(:@_index, 'my_custom_index')
-        d.instance_variable_set(:@_type,  'my_custom_type')
-        d.expects(:persisted?).returns(true)
-
-        d.update name: 'Update'
-
-        assert_equal 'foo', d._index
-        assert_equal 'bar', d._type
-        assert_equal '100', d._version
-      end
-    end
-
-    context "when incrementing," do
-      should "increment the attribute" do
-        subject.expects(:persisted?).returns(true)
-
-        @gateway
-          .expects(:update)
-          .with do |id, options|
-            assert_equal 'ctx._source.count += 1', options[:script]
-            true
-          end
-          .returns({'_id' => 'abc123', 'version' => 2})
-
-        assert subject.increment :count
-
-        assert_equal 1, subject.count
-      end
-
-      should "set the meta attributes from response" do
-        subject.expects(:persisted?).returns(true)
-
-        @gateway.expects(:update)
-          .with do |model, options|
-            assert_equal 'my_custom_index', options[:index]
-            assert_equal 'my_custom_type',  options[:type]
-            true
-          end
-          .returns({'_id' => 'abc', '_index' => 'foo', '_type' => 'bar', '_version' => '100'})
-
-        subject.instance_variable_set(:@_index, 'my_custom_index')
-        subject.instance_variable_set(:@_type,  'my_custom_type')
-
-        subject.increment :count
-
-        assert_equal 'foo', subject._index
-        assert_equal 'bar', subject._type
-        assert_equal '100', subject._version
-      end
-    end
-
-    context "when decrement," do
-      should "decrement the attribute" do
-        subject.expects(:persisted?).returns(true)
-
-        @gateway
-          .expects(:update)
-          .with do |id, options|
-            assert_equal 'ctx._source.count = ctx._source.count - 1', options[:script]
-            true
-          end
-          .returns({'_id' => 'abc123', 'version' => 2})
-
-        assert subject.decrement :count
-
-        assert_equal -1, subject.count
-      end
-
-      should "set the meta attributes from response" do
-        subject.expects(:persisted?).returns(true)
-
-        @gateway.expects(:update)
-          .with do |model, options|
-            assert_equal 'my_custom_index', options[:index]
-            assert_equal 'my_custom_type',  options[:type]
-            true
-          end
-          .returns({'_id' => 'abc', '_index' => 'foo', '_type' => 'bar', '_version' => '100'})
-
-        subject.instance_variable_set(:@_index, 'my_custom_index')
-        subject.instance_variable_set(:@_type,  'my_custom_type')
-
-        subject.decrement :count
-
-        assert_equal 'foo', subject._index
-        assert_equal 'bar', subject._type
-        assert_equal '100', subject._version
-      end
-    end
-
-    context "when touching," do
-      should "raise exception when touching not existing attribute" do
-        subject.expects(:persisted?).returns(true)
-        assert_raise(ArgumentError) { subject.touch :foobar }
-      end
-
-      should "update updated_at by default" do
-        subject.expects(:persisted?).returns(true)
-        now = Time.parse('2014-01-01T00:00:00Z')
-        Time.expects(:now).returns(now).at_least_once
-
-        @gateway
-          .expects(:update)
-          .with do |id, options|
-            assert_equal '2014-01-01T00:00:00Z', options[:doc][:updated_at]
-            true
-          end
-          .returns({'_id' => 'abc123', 'version' => 2})
-
-        subject.touch
-        assert_equal Time.parse('2014-01-01T00:00:00Z'), subject.updated_at
-      end
-
-      should "update a custom attribute by default" do
-        subject.expects(:persisted?).returns(true)
-        now = Time.parse('2014-01-01T00:00:00Z')
-        Time.expects(:now).returns(now).at_least_once
-
-        @gateway
-          .expects(:update)
-          .with do |id, options|
-            assert_equal '2014-01-01T00:00:00Z', options[:doc][:created_at]
-            true
-          end
-          .returns({'_id' => 'abc123', 'version' => 2})
-
-        subject.touch :created_at
-        assert_equal Time.parse('2014-01-01T00:00:00Z'), subject.created_at
-      end
-
-      should "execute the callbacks" do
-        @gateway.expects(:update).returns({'_id' => 'abc'})
-        DummyStoreModelWithCallback = Class.new(DummyStoreModel)
-
-        DummyStoreModelWithCallback.after_touch { $stderr.puts "TOUCHED" }
-
-        $stderr.expects(:puts).with('TOUCHED')
-        d = DummyStoreModelWithCallback.new name: 'Test'
-        d.expects(:persisted?).returns(true)
-        d.touch
-      end
-
-      should "set the meta attributes from response" do
-        subject.expects(:persisted?).returns(true)
-
-        @gateway.expects(:update)
-          .with do |model, options|
-            assert_equal 'my_custom_index', options[:index]
-            assert_equal 'my_custom_type',  options[:type]
-            true
-          end
-          .returns({'_id' => 'abc', '_index' => 'foo', '_type' => 'bar', '_version' => '100'})
-
-        subject.instance_variable_set(:@_index, 'my_custom_index')
-        subject.instance_variable_set(:@_type,  'my_custom_type')
-
-        subject.touch
-
-        assert_equal 'foo', subject._index
-        assert_equal 'bar', subject._type
-        assert_equal '100', subject._version
-      end
-    end
-
-  end
-end