elasticsearch-persistence 0.1.3 → 0.1.4

data/test/integration/repository/default_class_test.rb

@@ -96,6 +96,12 @@ module Elasticsearch
           assert_equal 2, results.size
         end
 
+        should "count notes" do
+          @repository.save Note.new(title: 'Test')
+          @repository.client.indices.refresh index: @repository.index_name
+          assert_equal 1, @repository.count
+        end
+
         should "save and find a plain hash" do
           @repository.save id: 1, title: 'Hash'
           result = @repository.find(1)

data/test/unit/model_base_test.rb

@@ -0,0 +1,40 @@
+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
+      m = DummyBaseModel.new id: 1
+      assert_equal 1, m.id
+
+      m = DummyBaseModel.new 'id' => 2
+      assert_equal 2, m.id
+    end
+
+    should "have ID in attributes" do
+      m = DummyBaseModel.new id: 1, name: 'Test'
+      assert_equal 1, m.attributes[:id]
+    end
+
+    should "have the customized inspect method" do
+      m = DummyBaseModel.new name: 'Test'
+      assert_match /name\: "Test"/, m.inspect
+    end
+  end
+end

data/test/unit/model_find_test.rb

@@ -0,0 +1,147 @@
+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)
+
+      @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
+      @gateway
+        .expects(:search)
+        .with({ query: { match_all: {} }, size: 10_000 })
+        .returns(@response)
+
+      DummyFindModel.all
+    end
+
+    should "pass options when finding all records" do
+      @gateway
+        .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 scan/scroll" do
+      setup do
+        @gateway
+        .expects(:deserialize)
+        .with('_source' => {'foo' => 'bar'})
+        .returns('_source' => {'foo' => 'bar'})
+
+        @gateway.client
+          .expects(:search)
+          .with do |arguments|
+            assert_equal 'scan', arguments[:search_type]
+            assert_equal 'foo',  arguments[:index]
+            assert_equal 'bar',  arguments[:type]
+          end
+          .returns(MultiJson.load('{"_scroll_id":"abc123==", "hits":{"hits":[]}}'))
+
+        @gateway.client
+          .expects(:scroll)
+          .twice
+          .returns(MultiJson.load('{"_scroll_id":"abc456==", "hits":{"hits":[{"_source":{"foo":"bar"}}]}}'))
+          .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

@@ -0,0 +1,99 @@
+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 'string',  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 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

data/test/unit/model_rails_test.rb

@@ -0,0 +1,88 @@
+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: 'string' }
+  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"
+                }
+
+      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"
+                }
+
+      m = MyRailsModel.new params
+      assert_equal "2014-01-01", m.published_on.iso8601
+    end
+
+  end
+end

data/test/unit/model_store_test.rb

@@ -0,0 +1,493 @@
+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]
+          end
+          .returns({'_id' => 'abc123'})
+
+        assert ! subject.persisted?
+
+        assert subject.save
+        assert subject.persisted?
+      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
+        Time.expects(:now).returns(Time.parse('2014-01-01T00:00:00Z')).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 "pass the options to gateway" do
+        @gateway
+          .expects(:save)
+          .with do |object, options|
+            assert_equal 'ABC', options[:routing]
+          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]
+          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]
+          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]
+          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]
+          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]
+          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]
+          end
+          .returns({'_id' => 'abc123', 'version' => 2})
+
+        assert subject.update( {}, { script: 'EXEC' } )
+      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]
+          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]
+          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]
+          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]
+          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]
+          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]
+          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]
+          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)
+        Time.expects(:now).returns(Time.parse('2014-01-01T00:00:00Z')).at_least_once
+
+        @gateway
+          .expects(:update)
+          .with do |id, options|
+            assert_equal '2014-01-01T00:00:00Z', options[:doc][:updated_at]
+          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)
+        Time.expects(:now).returns(Time.parse('2014-01-01T00:00:00Z')).at_least_once
+
+        @gateway
+          .expects(:update)
+          .with do |id, options|
+            assert_equal '2014-01-01T00:00:00Z', options[:doc][:created_at]
+          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]
+          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