property 0.9.1 → 1.0.0

data/test/shoulda_macros/serialization.rb

@@ -19,7 +19,7 @@ class Test::Unit::TestCase
       context 'with Properties' do
         setup do
           @properties = Property::Properties[
-            'string'     => 'bar',
+            'string'     => "one\ntwo",
             'serialized' => Dog.new('Pavlov', 'Freud'),
             'datetime'   => Time.utc(2010, 02, 12, 21, 31, 25),
             'float'      => 4.3432,

data/test/test_helper.rb

@@ -6,5 +6,7 @@ require 'shoulda'
 require 'active_record'
 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/base_test.rb

@@ -0,0 +1,80 @@
+require 'test_helper'
+require 'fixtures'
+
+# including Property::Base is like including Property but without hooks
+class BaseTest < Test::Unit::TestCase
+
+  context 'An external storage including property base' do
+    class Version < ActiveRecord::Base
+      include Property::Base
+      belongs_to :contact, :class_name => 'BaseTest::Contact',
+                 :foreign_key => 'employee_id'
+      property do |p|
+        p.string 'first_name'
+      end
+    end
+
+    class Contact < ActiveRecord::Base
+      set_table_name :employees
+      has_many :versions, :class_name => 'BaseTest::Version'
+
+      include Property
+      store_properties_in :version
+
+      property do |p|
+        p.string 'first_name'
+        p.string 'name'
+      end
+
+      def version
+        @version ||= begin
+          if new_record?
+            versions.build
+          else
+            Version.first(:conditions => ['employee_id = ?', self.id]) || versions.build
+          end
+        end
+      end
+    end
+
+    context 'with properties' do
+      setup do
+        contact = Contact.create('first_name' => 'Angela', 'name' => 'Davis')
+        @version = Version.find(contact.version.id)
+      end
+
+      should 'unpack and read properties' do
+        assert_equal 'Angela', @version.first_name
+      end
+
+      should 'not execute save hooks' do
+        @version.prop['first_name'] = 'Angel'
+        assert @version.save
+        @version = Version.find(@version)
+        assert_equal 'Angela', @version.first_name
+      end
+
+      should 'not only have accessors for properties defined in self' do
+        assert_raise(ActiveRecord::UnknownAttributeError) do
+          @version.update_attributes('name' => 'Crenshaw')
+        end
+      end
+    end
+  end
+end
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

data/test/unit/property/declaration_test.rb

@@ -6,52 +6,72 @@ class DeclarationTest < Test::Unit::TestCase
   context 'A sub-class' do
     context 'from a class with property columns' do
       setup do
-        @klass = Developer
+        @ParentClass = Class.new(ActiveRecord::Base) do
+          include Property
+          property.string 'name'
+          def method_in_parent
+          end
+        end
+      end
+
+      subject do
+        Class.new(@ParentClass) do
+          property.integer 'age'
+          def method_in_self
+          end
+        end
       end
 
       should 'inherit property columns from parent class' do
-        assert_equal %w{age first_name language last_name}, @klass.schema.column_names.sort
+        assert_equal %w{age name}, subject.schema.column_names.sort
       end
 
       should 'see its property columns in schema' do
-        assert @klass.schema.has_column?('language')
+        assert subject.schema.has_column?('age')
       end
 
       should 'not back-propagate definitions to parent' do
-        assert !@klass.superclass.schema.has_column?('language')
+        assert !subject.superclass.schema.has_column?('age')
       end
 
       should 'inherit new definitions in parent' do
-        class ParentClass < ActiveRecord::Base
-          include Property
-          property.string 'name'
-        end
-
-        @klass = Class.new(ParentClass) do
-          property.integer 'age'
-        end
-
-        assert_equal %w{age name}, @klass.schema.column_names.sort
-
-        ParentClass.class_eval do
+        @ParentClass.class_eval do
           property.string 'first_name'
         end
 
-        assert_equal %w{age first_name name}, @klass.schema.column_names.sort
+        assert_equal %w{age first_name name}, subject.schema.column_names.sort
       end
 
       should 'not be allowed to overwrite a property from the parent class' do
-        assert_raise(TypeError) do
-          @klass.class_eval do
-            property.string 'age'
+        assert_raise(Property::RedefinedPropertyError) do
+          subject.class_eval do
+            property.string 'name'
           end
         end
       end
 
       should 'not be allowed to overwrite a property from the current class' do
-        assert_raise(TypeError) do
-          @klass.class_eval do
-            property.string 'language'
+        assert_raise(Property::RedefinedPropertyError) do
+          subject.class_eval do
+            property.string 'age'
+          end
+        end
+      end
+
+      # This is because we include a module and the module would hide the method
+      should 'not be allowed to define a property with the name of a method in the parent class' do
+        assert_raise(Property::RedefinedMethodError) do
+          subject.class_eval do
+            property.string 'method_in_parent'
+          end
+        end
+      end
+
+      # This is ok because it can be useful and the module inclusion would not hide it
+      should 'be allowed to define a property with the same name as a method in the current class' do
+        assert_nothing_raised do
+          subject.class_eval do
+            property.string 'method_in_self'
           end
         end
       end
@@ -135,6 +155,16 @@ class DeclarationTest < Test::Unit::TestCase
       assert_equal Time, column.klass
       assert_equal :datetime, column.type
     end
+    
+    should 'allow multiple declarations in one go' do
+      subject.property.string 'foo', 'bar', 'baz'
+      assert_equal %w{bar baz foo}, subject.schema.column_names.sort
+    end
+    
+    should 'allow multiple declarations in an Array' do
+      subject.property.string ['foo', 'bar', 'baz']
+      assert_equal %w{bar baz foo}, subject.schema.column_names.sort
+    end
 
     should 'allow serialized columns' do
       Dog = Struct.new(:name, :toy) do
@@ -167,15 +197,15 @@ class DeclarationTest < Test::Unit::TestCase
       assert column.indexed?
     end
 
-    context 'through a Behavior on an instance' do
+    context 'through a Role on an instance' do
       setup do
         @instance = subject.new
-        @poet = Property::Behavior.new('Poet')
+        @poet = Property::Role.new('Poet')
         @poet.property do |p|
           p.string 'poem'
         end
 
-        @instance.behave_like @poet
+        @instance.has_role @poet
       end
 
       should 'behave like any other property column' do
@@ -211,15 +241,44 @@ class DeclarationTest < Test::Unit::TestCase
     end
   end
 
-  context 'On a class with a schema' do
-    subject { Developer }
+  context 'A class with a schema' do
+    subject { Class.new(Developer) }
 
     should 'raise an exception if we ask to behave like a class without schema' do
-      assert_raise(TypeError) { subject.behave_like String }
+      assert_raise(TypeError) { subject.has_role String }
     end
 
     should 'raise an exception if we ask to behave like an object' do
-      assert_raise(TypeError) { subject.behave_like 'me' }
+      assert_raise(TypeError) { subject.has_role 'me' }
+    end
+    
+    should 'raise an exception if the role redefines properties' do
+      @emp = Property::Role.new('empi')
+      @emp.property.string 'first_name'
+      assert_raise(Property::RedefinedPropertyError) do
+        subject.has_role @emp
+      end
+    end
+    
+    should 'raise an exception if the role contains superclass methods' do
+      @emp = Property::Role.new('empi')
+      @emp.property.string 'method_in_parent'
+      assert_raise(Property::RedefinedMethodError) do
+        subject.has_role @emp
+      end
+    end
+    
+    should 'inherit properties when asking to behave like a class' do
+      @class = Class.new(ActiveRecord::Base) do
+        include Property
+        property do |p|
+          p.string 'hop'
+        end
+      end
+      
+      subject.has_role @class
+      assert_equal %w{language last_name hop age first_name}, subject.schema.column_names
+      assert subject.has_role?(@class)
     end
   end
 

data/test/unit/property/index_foreign_test.rb

@@ -57,12 +57,12 @@ class IndexForeignTest < ActiveSupport::TestCase
       end
     end
 
-    def index_reader
+    def index_reader(group_name)
       {'version_id' => version.id}
     end
 
     # Foreign index: we store the 'employee_id' in the index to get back directly to non-versioned class Contact (through employee_id key).
-    def index_writer
+    def index_writer(group_name)
       {'version_id' => version.id, 'employee_id' => self.id}
     end
   end

data/test/unit/property/index_simple_test.rb

@@ -3,7 +3,7 @@ require 'fixtures'
 
 class IndexSimpleTest < ActiveSupport::TestCase
   class IndexedStringEmp < ActiveRecord::Base
-    set_table_name :i_string_employees
+    set_table_name :i_special_employees
   end
 
   class IndexedIntegerEmp < ActiveRecord::Base
@@ -25,7 +25,7 @@ class IndexSimpleTest < ActiveSupport::TestCase
     alias_method_chain :save, :raise
 
     property do |p|
-      p.string  'name', :index   => true
+      p.string  'name', :index   => :special
       p.integer 'age',  :indexed => true # synonym
     end
   end
@@ -40,7 +40,7 @@ class IndexSimpleTest < ActiveSupport::TestCase
     end
 
     should 'group indices by type' do
-      assert_equal %w{integer string}, subject.index_groups.keys.map(&:to_s).sort
+      assert_equal %w{integer special}, subject.index_groups.keys.map(&:to_s).sort
     end
   end
 
@@ -49,6 +49,14 @@ class IndexSimpleTest < ActiveSupport::TestCase
       Dog
     end
 
+    class Mongrel < Dog
+      attr_accessor :last_index_group_name
+      def create_indices(group_name, new_keys, cur_indices)
+        @last_index_group_name = group_name
+        super
+      end
+    end
+
     context 'on record creation' do
       should 'create index entries' do
         assert_difference('IndexedStringEmp.count', 1) do
@@ -56,6 +64,11 @@ class IndexSimpleTest < ActiveSupport::TestCase
         end
       end
 
+      should 'call create_indices to create index entries' do
+         m = Mongrel.create('name' => 'Zed')
+         assert_equal 'special', m.last_index_group_name
+       end
+
       should 'not create index entries for blank values' do
         assert_difference('IndexedIntegerEmp.count', 0) do
           Dog.create('name' => 'Pavlov')
@@ -91,7 +104,7 @@ class IndexSimpleTest < ActiveSupport::TestCase
           @dog.update_attributes('name' => 'Médor')
         end
       end
-      
+
       should 'remove blank values' do
         assert_difference('IndexedStringEmp.count', -1) do
           @dog.update_attributes('name' => '')

data/test/unit/property/role_test.rb

@@ -0,0 +1,78 @@
+require 'test_helper'
+require 'fixtures'
+
+class RoleTest < ActiveSupport::TestCase
+  should_store_property_definitions(Property::Role)
+
+
+  context 'A Poet role' do
+    setup do
+      @poet = Property::Role.new('Poet') do |p|
+        p.string 'poem', :default => :muse
+        p.integer 'year'
+
+        p.actions do
+          def muse
+            'I am your muse'
+          end
+        end
+      end
+    end
+
+    should_insert_properties_on_has_role_poet
+    should_add_role_methods
+    should_take_part_in_used_list
+    should_not_maintain_indices # no indexed column defined
+
+    should 'return name on name' do
+      assert_equal 'Poet', @poet.name
+    end
+  end # A Poet role
+
+  context 'A Poet role with indices' do
+    setup do
+      @poet = Property::Role.new('Poet') do |p|
+        p.string  'poem', :index => :ml_string
+        p.integer 'year', :index => true
+      end
+    end
+
+    should_maintain_indices
+  end # A Poet role with indices
+
+
+  context 'A class used as role' do
+    class Foo < ActiveRecord::Base
+      include Property
+
+      property do |p|
+        p.string 'poem', :default => :muse
+        p.integer 'year'
+
+        p.actions do
+          def muse
+            'I am your muse'
+          end
+        end
+      end
+    end
+
+    setup do
+      @poet = Foo
+    end
+
+    should_insert_properties_on_has_role_poet
+    should_add_role_methods
+    should_take_part_in_used_list
+
+    context 'set on a sub-class instance' do
+      subject do
+        Employee.new
+      end
+
+      should 'not raise an exception' do
+        assert_nothing_raised { subject.has_role Developer }
+      end
+    end # set on a sub-class instance
+  end # A class used as role
+end

data/test/unit/property/stored_role_test.rb

@@ -0,0 +1,84 @@
+require 'test_helper'
+require 'fixtures'
+
+class StoredRoleTest < ActiveSupport::TestCase
+  class Column < ActiveRecord::Base
+    include Property::StoredColumn
+  end
+
+  class Role < ActiveRecord::Base
+    include Property::StoredRole
+    stored_columns_class 'StoredRoleTest::Column'
+  end
+
+  should_store_property_definitions(Role)
+
+  context 'A stored Role' do
+
+    context 'with column definitions' do
+      setup do
+        role = Role.create(:name => 'Poet')
+        role.stored_columns << Column.new(:ptype => 'string',  :name => 'poem')
+        role.stored_columns << Column.new(:ptype => 'integer', :name => 'year')
+        role.save!
+        @poet = Role.find(role.id)
+      end
+
+      should_insert_properties_on_has_role_poet
+      should_take_part_in_used_list(false)
+      should_not_maintain_indices # no indexed column defined
+
+      should 'create new role columns on save' do
+        @poet.property do |p|
+          p.string 'original_language'
+        end
+
+        assert_difference('Role.count', 0) do
+          assert_difference('Column.count', 1) do
+            @poet.save
+          end
+        end
+      end
+
+      should 'return name on name' do
+        assert_equal 'Poet', @poet.name
+      end
+    end # with column definitions
+  end # A stored Role
+
+  context 'A stored Role' do
+
+    context 'with indexed column definitions' do
+      setup do
+        role = Role.create(:name => 'Poet')
+        role.stored_columns << Column.new(:ptype => 'string',  :name => 'poem', :index => :ml_string)
+        role.stored_columns << Column.new(:ptype => 'integer', :name => 'year', :index => true)
+        role.save!
+        @poet = Role.find(role.id)
+      end
+
+      should_maintain_indices
+    end # with column definitions
+  end # A stored Role
+
+  context 'A new Role' do
+    subject do
+      Role.new('Poet') do |p|
+        p.string 'name'
+      end
+    end
+
+    should 'define properties with a block' do
+      assert_equal %w{name}, subject.column_names
+    end
+
+    should 'create role columns on save' do
+      role = subject
+      assert_difference('Role.count', 1) do
+        assert_difference('Column.count', 1) do
+          assert role.save
+        end
+      end
+    end
+  end # A new Role
+end