property 1.0.0 → 1.1.0

data/test/shoulda_macros/index.rb

@@ -1,18 +1,7 @@
 module IndexMacros
-  class IndexedStringEmp < ActiveRecord::Base
-    set_table_name :i_string_employees
-  end
-
-  class MLIndexedStringEmp < ActiveRecord::Base
-    set_table_name :i_ml_string_employees
-  end
-
-  class IndexedIntegerEmp < ActiveRecord::Base
-    set_table_name :i_integer_employees
-  end
-
   # Simple class
-  class Employee < ActiveRecord::Base
+  class Client < ActiveRecord::Base
+    set_table_name :employees
     include Property
 
     def index_reader(group_name)
@@ -31,7 +20,7 @@ class Test::Unit::TestCase
 
     context "assigned to an instance of Dummy" do
       subject do
-        dummy = IndexMacros::Employee.new
+        dummy = IndexMacros::Client.new
         dummy.has_role @poet
         dummy
       end
@@ -41,22 +30,22 @@ class Test::Unit::TestCase
       end
 
       should 'create multilingual string indices on save' do
-        assert_difference('IndexMacros::MLIndexedStringEmp.count', 2) do
+        assert_difference('IdxEmployeesMlString.count', 2) do
           subject.poem = 'Hyperions Schicksalslied'
           subject.save
         end
       end
 
       should 'create integer indices on save' do
-        assert_difference('IndexMacros::IndexedIntegerEmp.count', 1) do
+        assert_difference('IdxEmployeesInteger.count', 1) do
           subject.year = 1770
           subject.save
         end
       end
 
       should 'not create blank indices on save' do
-        assert_difference('IndexMacros::IndexedStringEmp.count', 0) do
-          assert_difference('IndexMacros::IndexedIntegerEmp.count', 0) do
+        assert_difference('IdxEmployeesString.count', 0) do
+          assert_difference('IdxEmployeesInteger.count', 0) do
             subject.save
           end
         end
@@ -68,14 +57,14 @@ class Test::Unit::TestCase
 
     context "assigned to an instance of Dummy" do
       subject do
-        dummy = IndexMacros::Employee.new
+        dummy = IndexMacros::Client.new
         dummy.has_role @poet
         dummy
       end
 
       should 'not create indices on save' do
-        assert_difference('IndexMacros::IndexedStringEmp.count', 0) do
-          assert_difference('IndexMacros::IndexedIntegerEmp.count', 0) do
+        assert_difference('IdxEmployeesString.count', 0) do
+          assert_difference('IdxEmployeesInteger.count', 0) do
             subject.year = 1770
             subject.poem = 'Hyperions Schicksalslied'
             subject.save
@@ -84,8 +73,8 @@ class Test::Unit::TestCase
       end
 
       should 'not create blank indices on save' do
-        assert_difference('IndexMacros::IndexedStringEmp.count', 0) do
-          assert_difference('IndexMacros::IndexedIntegerEmp.count', 0) do
+        assert_difference('IdxEmployeesString.count', 0) do
+          assert_difference('IdxEmployeesInteger.count', 0) do
             subject.save
           end
         end

data/test/shoulda_macros/role.rb

@@ -139,6 +139,10 @@ class Test::Unit::TestCase
           assert @klass.has_role?(@poet)
         end
 
+        should 'return role from column' do
+          @klass.has_role @poet
+          assert_equal (@poet.kind_of?(Class) ? @poet.schema.role : @poet), @klass.schema.columns['poem'].role
+        end
       end
 
       context 'to an instance' do

data/test/shoulda_macros/serialization.rb

@@ -20,7 +20,7 @@ class Test::Unit::TestCase
         setup do
           @properties = Property::Properties[
             'string'     => "one\ntwo",
-            'serialized' => Dog.new('Pavlov', 'Freud'),
+            'serialized' => Cat.new('Pavlov', 'Freud'),
             'datetime'   => Time.utc(2010, 02, 12, 21, 31, 25),
             'float'      => 4.3432,
             'integer'    => 4
@@ -38,6 +38,22 @@ class Test::Unit::TestCase
           assert_equal @properties, properties
         end
 
+        context 'with ascii 18' do
+          subject do
+            Property::Properties[
+              'string' => (1..255).to_a.map{|n| n.chr}.join('') # "AB"
+            ]
+          end
+
+          should 'encode and decode ascii 18' do
+            string = @obj.encode_properties(subject)
+            properties = @obj.decode_properties(string)
+            assert_equal Property::Properties, properties.class
+            assert_equal subject, properties
+          end
+        end # with ascii 18
+
+
         should 'not include instance variables' do
           @properties.instance_eval do
             @baz   = 'some data'

data/test/test_helper.rb

@@ -1,12 +1,16 @@
 require 'pathname'
 $LOAD_PATH.unshift((Pathname(__FILE__).dirname +  '..' + 'lib').expand_path)
+
 require 'rubygems'
 require 'test/unit'
 require 'shoulda'
 require 'active_record'
+
+require 'database'
 require 'property'
 require 'shoulda_macros/serialization'
 require 'shoulda_macros/role'
 require 'shoulda_macros/index'
+
 require 'fixtures'
 require 'active_support/test_case'

data/test/unit/property/attribute_test.rb

@@ -217,26 +217,26 @@ class AttributeTest < Test::Unit::TestCase
 
     context 'a saved serialized class' do
       setup do
-        @dog = Dog.new('Pavlov', 'Freud')
+        @cat = Cat.new('Joann', 'Sfar')
       end
 
       subject do
         klass = Class.new(ActiveRecord::Base) do
           include Property
           set_table_name :dummies
-          property.serialize 'myserialized', Dog
+          property.serialize 'myserialized', Cat
         end
 
-        obj = klass.create('myserialized' => @dog)
+        obj = klass.create('myserialized' => @cat)
         klass.find(obj)
       end
 
       should 'find class back' do
-        assert_kind_of Dog, subject.prop['myserialized']
+        assert_kind_of Cat, subject.prop['myserialized']
       end
 
       should 'find same value' do
-        assert_equal @dog, subject.prop['myserialized']
+        assert_equal @cat, subject.prop['myserialized']
       end
     end
   end

data/test/unit/property/column_test.rb

@@ -0,0 +1,66 @@
+require 'test_helper'
+class AttributeTest < Test::Unit::TestCase
+
+  context 'Creating Column instances' do
+    context 'without index' do
+      subject do
+        Property::Column.new('name', nil, 'string', {})
+      end
+
+      should 'set index to nil' do
+        assert_nil subject.index
+      end
+    end # without index
+
+    context 'with index true' do
+      subject do
+        Property::Column.new('foo', nil, 'string', {:index => true})
+      end
+
+      should 'set index to type' do
+        assert_equal 'string', subject.index
+      end
+      
+      context 'and an index_group' do
+        subject do
+          Property::Column.new('foo', nil, 'string', {:index => true, :index_group => :integer})
+        end
+
+        should 'set index to index_group' do
+          assert_equal 'integer', subject.index
+        end
+      end # and an index_group
+    end # with index true
+
+    
+    context 'with an index name' do
+      subject do
+        Property::Column.new('foo', nil, 'string', {:index => :special})
+      end
+
+      should 'set index to index name' do
+        assert_equal 'special', subject.index
+      end
+    end # with an index name
+    
+    context 'with an index proc' do
+      subject do
+        Property::Column.new('foo', nil, 'string', {:index => Proc.new{}})
+      end
+
+      should 'set index to type' do
+        assert_equal 'string', subject.index
+      end
+      
+      context 'and an index_group' do
+        subject do
+          Property::Column.new('foo', nil, 'string', {:index => Proc.new{}, :index_group => :ml_string})
+        end
+
+        should 'set index to index_group' do
+          assert_equal 'ml_string', subject.index
+        end
+      end # and an index_group
+    end # with an index proc
+  end # Creating Column instances
+end

data/test/unit/property/declaration_test.rb

@@ -167,9 +167,9 @@ class DeclarationTest < Test::Unit::TestCase
     end
 
     should 'allow serialized columns' do
-      Dog = Struct.new(:name, :toy) do
+      Cat = Struct.new(:name, :toy) do
         def self.json_create(data)
-          Dog.new(data['name'], data['toy'])
+          Cat.new(data['name'], data['toy'])
         end
         def to_json(*args)
           { 'json_class' => self.class.to_s,
@@ -178,10 +178,10 @@ class DeclarationTest < Test::Unit::TestCase
         end
       end
 
-      subject.property.serialize('pet', Dog)
+      subject.property.serialize('pet', Cat)
       column = subject.schema.columns['pet']
       assert_equal 'pet', column.name
-      assert_equal Dog, column.klass
+      assert_equal Cat, column.klass
       assert_equal nil, column.type
     end
 

data/test/unit/property/index_complex_test.rb

@@ -2,18 +2,6 @@ require 'test_helper'
 require 'fixtures'
 
 class IndexComplexTest < ActiveSupport::TestCase
-  class IndexedStringEmp < ActiveRecord::Base
-    set_table_name :i_string_employees
-  end
-
-  class IndexedIntegerEmp < ActiveRecord::Base
-    set_table_name :i_integer_employees
-  end
-
-  class IndexedTextEmp < ActiveRecord::Base
-    set_table_name :i_text_employees
-  end
-
   # Complex index definition class
   class Person < ActiveRecord::Base
     include Property
@@ -31,14 +19,14 @@ class IndexComplexTest < ActiveSupport::TestCase
     property do |p|
       p.string  'name'
       # only runs if 'age' is not blank
-      p.integer 'age', :index => Proc.new {|r| {'age' => r.age == 0 ? nil : r.age + 10}}
-      p.string  'gender'
+      p.integer 'age',    :index => Proc.new {|r| {'age' => r.age == 0 ? nil : r.age + 10}}
+      p.string  'gender', :index => Proc.new {|r| {'gender' => r.gender[0]}}, :index_group => :integer
       p.string  'lang'
 
       p.index(:text) do |r| # r = record
         {
           "high"           => "gender:#{r.gender} age:#{r.age} name:#{r.name}",
-          "name_#{r.lang}" => r.name, # multi-lingual index
+          "name_#{r.lang}" => r.name, # multi-lingual index only matching existing object in required lang
         }
       end
     end
@@ -65,35 +53,41 @@ class IndexComplexTest < ActiveSupport::TestCase
 
     context 'on record creation' do
       should 'create index entries' do
-        assert_difference('IndexedTextEmp.count', 2) do
+        assert_difference('IdxEmployeesText.count', 2) do
           Person.create('name' => 'Juan', 'lang' => 'es', 'gender' => 'M', 'age' => 34)
         end
       end
 
       should 'not create index entries for blank values' do
-        assert_difference('IndexedIntegerEmp.count', 0) do
+        assert_difference('IdxEmployeesInteger.count', 0) do
           Person.create('name' => 'Pavlov')
         end
       end
 
       should 'store key and value pairs linked to the model' do
         person = Person.create('name' => 'Juan', 'lang' => 'es', 'gender' => 'M', 'age' => 34)
-        high_index, name_index = IndexedTextEmp.all(:conditions => {:employee_id => person.id}, :order => 'key asc')
+        high_index, name_index = IdxEmployeesText.all(:conditions => {:employee_id => person.id}, :order => 'key asc')
         assert_equal 'high', high_index.key
         assert_equal 'gender:M age:34 name:Juan', high_index.value
         assert_equal 'name_es', name_index.key
         assert_equal 'Juan', name_index.value
       end
 
-      should 'execute index Proc to build value' do
+      should 'execute index Proc to build values' do
         person = Person.create('name' => 'Juan', 'lang' => 'es', 'gender' => 'M', 'age' => 34)
-        int_index = IndexedIntegerEmp.first(:conditions => {:employee_id => person.id})
+        int_index = IdxEmployeesInteger.first(:conditions => {:employee_id => person.id, :key => 'age'})
         assert_equal 44, int_index.value
       end
+      
+      should 'use index_group setting to build values' do
+        person = Person.create('name' => 'Juan', 'lang' => 'es', 'gender' => 'M', 'age' => 34)
+        int_index = IdxEmployeesInteger.first(:conditions => {:employee_id => person.id, :key => 'gender'})
+        assert_equal "M"[0], int_index.value
+      end
 
       should 'remove blank values built from proc execution' do
         person = Person.create('name' => 'Juan', 'lang' => 'es', 'gender' => 'M', 'age' => 34)
-        assert_difference('IndexedIntegerEmp.count', -1) do
+        assert_difference('IdxEmployeesInteger.count', -1) do
           person.update_attributes('age' => 0)
         end
       end
@@ -105,13 +99,13 @@ class IndexComplexTest < ActiveSupport::TestCase
       end
 
       should 'update index entries' do
-        high_index, name_index = IndexedTextEmp.all(:conditions => {:employee_id => @person.id}, :order => 'key asc')
-        assert_difference('IndexedTextEmp.count', 0) do
+        high_index, name_index = IdxEmployeesText.all(:conditions => {:employee_id => @person.id}, :order => 'key asc')
+        assert_difference('IdxEmployeesText.count', 0) do
           @person.update_attributes('name' => 'Xavier')
         end
 
-        high_index = IndexedTextEmp.find(high_index.id) # reload (make sure the record has been updated, not recreated)
-        name_index = IndexedTextEmp.find(name_index.id) # reload (make sure the record has been updated, not recreated)
+        high_index = IdxEmployeesText.find(high_index.id) # reload (make sure the record has been updated, not recreated)
+        name_index = IdxEmployeesText.find(name_index.id) # reload (make sure the record has been updated, not recreated)
 
         assert_equal 'high', high_index.key
         assert_equal 'gender:M age:34 name:Xavier', high_index.value
@@ -121,15 +115,15 @@ class IndexComplexTest < ActiveSupport::TestCase
 
       context 'with key alterations' do
         should 'remove and create new keys' do
-          high_index, name_index = IndexedTextEmp.all(:conditions => {:employee_id => @person.id}, :order => 'key asc')
-          assert_difference('IndexedTextEmp.count', 0) do
+          high_index, name_index = IdxEmployeesText.all(:conditions => {:employee_id => @person.id}, :order => 'key asc')
+          assert_difference('IdxEmployeesText.count', 0) do
             @person.update_attributes('lang' => 'en', 'name' => 'John')
           end
 
-          assert IndexedTextEmp.find(high_index.id)
-          assert_nil IndexedTextEmp.find_by_id(name_index.id)
+          assert IdxEmployeesText.find(high_index.id)
+          assert_nil IdxEmployeesText.find_by_id(name_index.id)
 
-          high_index, name_index = IndexedTextEmp.all(:conditions => {:employee_id => @person.id}, :order => 'key asc')
+          high_index, name_index = IdxEmployeesText.all(:conditions => {:employee_id => @person.id}, :order => 'key asc')
 
           assert_equal 'high', high_index.key
           assert_equal 'gender:M age:34 name:John', high_index.value
@@ -142,8 +136,8 @@ class IndexComplexTest < ActiveSupport::TestCase
     context 'on record destruction' do
       should 'remove index entries' do
         person = Person.create('name' => 'Juan', 'lang' => 'es', 'gender' => 'M', 'age' => 34)
-        assert_difference('IndexedTextEmp.count', -2) do
-          assert_difference('IndexedIntegerEmp.count', -1) do
+        assert_difference('IdxEmployeesText.count', -2) do
+          assert_difference('IdxEmployeesInteger.count', -2) do
             person.destroy
           end
         end

data/test/unit/property/index_foreign_test.rb

@@ -2,18 +2,6 @@ require 'test_helper'
 require 'fixtures'
 
 class IndexForeignTest < ActiveSupport::TestCase
-  class IndexedStringEmp < ActiveRecord::Base
-    set_table_name :i_string_employees
-  end
-
-  class IndexedIntegerEmp < ActiveRecord::Base
-    set_table_name :i_integer_employees
-  end
-
-  class IndexedTextEmp < ActiveRecord::Base
-    set_table_name :i_text_employees
-  end
-
   class Version < ActiveRecord::Base
     belongs_to :contact, :class_name => 'IndexForeignTest::Contact',
                :foreign_key => 'employee_id'
@@ -74,14 +62,14 @@ class IndexForeignTest < ActiveSupport::TestCase
 
     context 'on record creation' do
       should 'create index entries' do
-        assert_difference('IndexedStringEmp.count', 2) do
+        assert_difference('IdxEmployeesString.count', 2) do
           Contact.create('name' => 'Juan', 'lang' => 'es', 'gender' => 'M', 'age' => 34)
         end
       end
 
       should 'store key and value pairs linked to the model' do
         person = Contact.create('name' => 'Juan', 'lang' => 'es', 'gender' => 'M', 'age' => 34)
-        high_index, name_index = IndexedStringEmp.all(:conditions => {:version_id => person.version.id}, :order => 'key asc')
+        high_index, name_index = IdxEmployeesString.all(:conditions => {:version_id => person.version.id}, :order => 'key asc')
         assert_equal 'high', high_index.key
         assert_equal 'gender:M age:34 name:Juan', high_index.value
         assert_equal 'name_es', name_index.key
@@ -90,7 +78,7 @@ class IndexForeignTest < ActiveSupport::TestCase
 
       should 'store key and value pairs linked to the foreign model' do
         person = Contact.create('name' => 'Juan', 'lang' => 'es', 'gender' => 'M', 'age' => 34)
-        high_index, name_index = IndexedStringEmp.all(:conditions => {:employee_id => person.id}, :order => 'key asc')
+        high_index, name_index = IdxEmployeesString.all(:conditions => {:employee_id => person.id}, :order => 'key asc')
         assert_equal 'high', high_index.key
         assert_equal 'gender:M age:34 name:Juan', high_index.value
         assert_equal 'name_es', name_index.key
@@ -104,13 +92,13 @@ class IndexForeignTest < ActiveSupport::TestCase
       end
 
       should 'update index entries' do
-        high_index, name_index = IndexedStringEmp.all(:conditions => {:employee_id => @person.id}, :order => 'key asc')
-        assert_difference('IndexedStringEmp.count', 0) do
+        high_index, name_index = IdxEmployeesString.all(:conditions => {:employee_id => @person.id}, :order => 'key asc')
+        assert_difference('IdxEmployeesString.count', 0) do
           @person.update_attributes('name' => 'Xavier')
         end
 
-        high_index = IndexedStringEmp.find(high_index.id) # reload (make sure the record has been updated, not recreated)
-        name_index = IndexedStringEmp.find(name_index.id) # reload (make sure the record has been updated, not recreated)
+        high_index = IdxEmployeesString.find(high_index.id) # reload (make sure the record has been updated, not recreated)
+        name_index = IdxEmployeesString.find(name_index.id) # reload (make sure the record has been updated, not recreated)
 
         assert_equal 'high', high_index.key
         assert_equal 'gender:M age:34 name:Xavier', high_index.value
@@ -120,15 +108,15 @@ class IndexForeignTest < ActiveSupport::TestCase
 
       context 'with key alterations' do
         should 'remove and create new keys' do
-          high_index, name_index = IndexedStringEmp.all(:conditions => {:employee_id => @person.id}, :order => 'key asc')
-          assert_difference('IndexedStringEmp.count', 0) do
+          high_index, name_index = IdxEmployeesString.all(:conditions => {:employee_id => @person.id}, :order => 'key asc')
+          assert_difference('IdxEmployeesString.count', 0) do
             @person.update_attributes('lang' => 'en', 'name' => 'John')
           end
 
-          assert IndexedStringEmp.find(high_index.id)
-          assert_nil IndexedStringEmp.find_by_id(name_index.id)
+          assert IdxEmployeesString.find(high_index.id)
+          assert_nil IdxEmployeesString.find_by_id(name_index.id)
 
-          high_index, name_index = IndexedStringEmp.all(:conditions => {:employee_id => @person.id}, :order => 'key asc')
+          high_index, name_index = IdxEmployeesString.all(:conditions => {:employee_id => @person.id}, :order => 'key asc')
 
           assert_equal 'high', high_index.key
           assert_equal 'gender:M age:34 name:John', high_index.value
@@ -141,13 +129,13 @@ class IndexForeignTest < ActiveSupport::TestCase
     context 'on record update with a new version' do
       should 'create new index entries' do
         @person = Contact.create('name' => 'Juan', 'lang' => 'es', 'gender' => 'M', 'age' => 34)
-        high_index1, name_index1 = IndexedStringEmp.all(:conditions => {:version_id => @person.version.id}, :order => 'key asc')
+        high_index1, name_index1 = IdxEmployeesString.all(:conditions => {:version_id => @person.version.id}, :order => 'key asc')
         @person.new_version!
-        assert_difference('IndexedStringEmp.count', 2) do
+        assert_difference('IdxEmployeesString.count', 2) do
           @person.update_attributes('name' => 'John', 'lang' => 'en')
         end
 
-        high_index, name_index = IndexedStringEmp.all(:conditions => {:version_id => @person.version.id}, :order => 'key asc')
+        high_index, name_index = IdxEmployeesString.all(:conditions => {:version_id => @person.version.id}, :order => 'key asc')
         assert_not_equal high_index1.id, high_index.id
         assert_not_equal name_index1.id, name_index.id
 
@@ -174,10 +162,10 @@ class IndexForeignTest < ActiveSupport::TestCase
         end
 
         should 'create index entries to sort multilingual values' do
-          people_fr = Contact.find(:all, :joins  => "INNER JOIN i_string_employees AS ise ON ise.employee_id = employees.id AND ise.key = 'name_fr'",
+          people_fr = Contact.find(:all, :joins  => "INNER JOIN idx_employees_strings AS ise ON ise.employee_id = employees.id AND ise.key = 'name_fr'",
                                           :order => "ise.value asc")
 
-          people_en = Contact.find(:all, :joins  => "INNER JOIN i_string_employees AS ise ON ise.employee_id = employees.id AND ise.key = 'name_en'",
+          people_en = Contact.find(:all, :joins  => "INNER JOIN idx_employees_strings AS ise ON ise.employee_id = employees.id AND ise.key = 'name_en'",
                                           :order => "ise.value asc")
 
           assert_equal [@jean.id, @jim.id], people_fr.map {|r| r.id}
@@ -201,10 +189,10 @@ class IndexForeignTest < ActiveSupport::TestCase
         end
 
         should 'create index entries to sort multilingual values' do
-          people_fr = Contact.find(:all, :joins  => "INNER JOIN i_string_employees AS ise ON ise.employee_id = employees.id AND ise.key = 'name_fr'",
+          people_fr = Contact.find(:all, :joins  => "INNER JOIN idx_employees_strings AS ise ON ise.employee_id = employees.id AND ise.key = 'name_fr'",
                                           :order => "ise.value asc")
 
-          people_en = Contact.find(:all, :joins  => "INNER JOIN i_string_employees AS ise ON ise.employee_id = employees.id AND ise.key = 'name_en'",
+          people_en = Contact.find(:all, :joins  => "INNER JOIN idx_employees_strings AS ise ON ise.employee_id = employees.id AND ise.key = 'name_en'",
                                           :order => "ise.value asc")
 
           # This is what we would like to have (once we have found an SQL trick to get the record in 'en')
@@ -221,8 +209,8 @@ class IndexForeignTest < ActiveSupport::TestCase
     context 'on record destruction' do
       should 'remove index entries' do
         person = Contact.create('name' => 'Juan', 'lang' => 'es', 'gender' => 'M', 'age' => 34)
-        assert_difference('IndexedStringEmp.count', -2) do
-          assert_difference('IndexedIntegerEmp.count', -1) do
+        assert_difference('IdxEmployeesString.count', -2) do
+          assert_difference('IdxEmployeesInteger.count', -1) do
             person.destroy
           end
         end

data/test/unit/property/index_simple_test.rb

@@ -2,13 +2,6 @@ require 'test_helper'
 require 'fixtures'
 
 class IndexSimpleTest < ActiveSupport::TestCase
-  class IndexedStringEmp < ActiveRecord::Base
-    set_table_name :i_special_employees
-  end
-
-  class IndexedIntegerEmp < ActiveRecord::Base
-    set_table_name :i_integer_employees
-  end
 
   # Simple index definition class
   class Dog < ActiveRecord::Base
@@ -59,7 +52,7 @@ class IndexSimpleTest < ActiveSupport::TestCase
 
     context 'on record creation' do
       should 'create index entries' do
-        assert_difference('IndexedStringEmp.count', 1) do
+        assert_difference('IdxEmployeesSpecial.count', 1) do
           Dog.create('name' => 'Pavlov')
         end
       end
@@ -70,17 +63,24 @@ class IndexSimpleTest < ActiveSupport::TestCase
        end
 
       should 'not create index entries for blank values' do
-        assert_difference('IndexedIntegerEmp.count', 0) do
+        assert_difference('IdxEmployeesInteger.count', 0) do
           Dog.create('name' => 'Pavlov')
         end
       end
 
-      should 'store a key and value pair linked to the model' do
+      should 'special indices linked to the model' do
         dog = Dog.create('name' => 'Pavlov')
-        index_string = IndexedStringEmp.first(:conditions => {:employee_id => dog.id})
+        index_string = IdxEmployeesSpecial.first(:conditions => {:employee_id => dog.id})
         assert_equal 'Pavlov', index_string.value
         assert_equal 'name', index_string.key
       end
+
+      should 'store a key and value pair linked to the model' do
+        dog = Dog.create('age' => 15)
+        index_integer = IdxEmployeesInteger.first(:conditions => {:employee_id => dog.id})
+        assert_equal 15, index_integer.value
+        assert_equal 'age', index_integer.key
+      end
     end
 
     context 'on record update' do
@@ -89,37 +89,37 @@ class IndexSimpleTest < ActiveSupport::TestCase
       end
 
       should 'update index entries' do
-        index_string = IndexedStringEmp.first(:conditions => {:employee_id => @dog.id})
-        assert_difference('IndexedStringEmp.count', 0) do
+        index_string = IdxEmployeesSpecial.first(:conditions => {:employee_id => @dog.id})
+        assert_difference('IdxEmployeesSpecial.count', 0) do
           @dog.update_attributes('name' => 'Médor')
         end
 
-        index_string = IndexedStringEmp.find(index_string.id)
+        index_string = IdxEmployeesSpecial.find(index_string.id)
         assert_equal 'Médor', index_string.value
         assert_equal 'name', index_string.key
       end
 
       should 'not create index entries for blank values' do
-        assert_difference('IndexedIntegerEmp.count', 0) do
+        assert_difference('IdxEmployeesInteger.count', 0) do
           @dog.update_attributes('name' => 'Médor')
         end
       end
 
       should 'remove blank values' do
-        assert_difference('IndexedStringEmp.count', -1) do
+        assert_difference('IdxEmployeesSpecial.count', -1) do
           @dog.update_attributes('name' => '')
         end
       end
 
       should 'create new entries for new keys' do
-        assert_difference('IndexedIntegerEmp.count', 1) do
+        assert_difference('IdxEmployeesInteger.count', 1) do
           @dog.update_attributes('age' => 7)
         end
       end
 
       should 'store a key and value pair linked to the model' do
         @dog.update_attributes('age' => 7)
-        index_int = IndexedIntegerEmp.first(:conditions => {:employee_id => @dog.id})
+        index_int = IdxEmployeesInteger.first(:conditions => {:employee_id => @dog.id})
         assert_equal 7, index_int.value
         assert_equal 'age', index_int.key
       end
@@ -130,13 +130,13 @@ class IndexSimpleTest < ActiveSupport::TestCase
         end
 
         should 'not alter indices' do
-          assert_difference('IndexedIntegerEmp.count', 0) do
+          assert_difference('IdxEmployeesInteger.count', 0) do
             assert_raises(Exception) do
               @dog.update_attributes('name' => 'raise')
             end
           end
 
-          index_string = IndexedStringEmp.first(:conditions => {:employee_id => @dog.id})
+          index_string = IdxEmployeesSpecial.first(:conditions => {:employee_id => @dog.id})
           assert_equal 'Pavlov', index_string.value
           assert_equal 'name', index_string.key
         end
@@ -147,8 +147,8 @@ class IndexSimpleTest < ActiveSupport::TestCase
     context 'on record destruction' do
       should 'remove index entries' do
         dog = Dog.create('name' => 'Pavlov', 'age' => 7)
-        assert_difference('IndexedStringEmp.count', -1) do
-          assert_difference('IndexedIntegerEmp.count', -1) do
+        assert_difference('IdxEmployeesSpecial.count', -1) do
+          assert_difference('IdxEmployeesInteger.count', -1) do
             dog.destroy
           end
         end