zena 1.0.0.beta3 → 1.0.0.rc1

data/test/unit/text_document_test.rb

@@ -26,7 +26,7 @@ class TextDocumentTest < Zena::Unit::TestCase
           body { font-size:10px; }
           #header { background:url('bird.jpg') }
           #pv     { background:url('bird_pv.jpg') }
-          #footer { background:url('/projects/wiki/flower.jpg') }
+          #footer { background:url('/projects list/a wiki with Zena/flower.jpg') }
           #no_stamp { background:url('/en/image30_pv.jpg?100001001345') }
           END_CSS
 
@@ -48,24 +48,24 @@ class TextDocumentTest < Zena::Unit::TestCase
         end
       end # in a folder with an image
     end # on a css text_document
-    
+
     context 'creating a text document' do
       context 'with a content_type' do
         subject do
           secure!(TextDocument) { TextDocument.create(
-            :node_name => "yoba",
+            :title => "yoba",
             :parent_id => nodes_id(:wiki),
             :text => "#header { color:red; }\n#footer { color:blue; }",
-            :content_type => 'text/css') 
+            :content_type => 'text/css')
           }
         end
-        
+
         should 'create a new TextDocument' do
           assert_difference('TextDocument.count', 1) do
             subject
           end
         end
-        
+
         should 'set extension from content_type' do
           assert_equal 'css', subject.ext
         end
@@ -75,11 +75,11 @@ class TextDocumentTest < Zena::Unit::TestCase
 
   def test_create_simplest
     login(:tiger)
-    doc = secure!(Document) { Document.create(:parent_id=>nodes_id(:cleanWater), :node_name => 'skiny')}
+    doc = secure!(Document) { Document.create(:parent_id=>nodes_id(:cleanWater), :title => 'skiny')}
     assert_equal TextDocument, doc.class
     assert !doc.new_record?, "Not a new record"
     assert_equal 0, doc.size
-    doc = secure!(Document) { Document.create(:parent_id=>nodes_id(:cleanWater), :node_name => 'medium', :text=>"12345678901234567890")}
+    doc = secure!(Document) { Document.create(:parent_id=>nodes_id(:cleanWater), :title => 'medium', :text=>"12345678901234567890")}
     assert_equal TextDocument, doc.class
     assert !doc.new_record?, "Not a new record"
     assert_equal 20, doc.size
@@ -91,6 +91,7 @@ class TextDocumentTest < Zena::Unit::TestCase
     file = uploaded_text('some.txt')
     doc = secure!(Document) { Document.create( :parent_id => nodes_id(:cleanWater),
                                                :file => file ) }
+
     assert_equal TextDocument, doc.class
     # reload
     doc = secure!(Document) { Document.find(doc[:id])}
@@ -127,8 +128,8 @@ class TextDocumentTest < Zena::Unit::TestCase
     body { font-size:10px; behavior:url("/stylesheets/csshover2.htc"); }
     #header { background:url('bird.jpg') }
     #pv     { background:url('bird_pv.jpg') }
-    #footer { background:url('/projects/wiki/flower.jpg') }
-    #back   { background:url('../../projects/wiki/flower.jpg') }
+    #footer { background:url('/projects list/a wiki with Zena/flower.jpg') }
+    #back   { background:url('../../projects list/a wiki with Zena/flower.jpg') }
     #no_stamp { background:url('/en/image30_pv.jpg') }
     END_CSS
     node.text = start.dup
@@ -154,8 +155,8 @@ class TextDocumentTest < Zena::Unit::TestCase
     body { font-size:10px; behavior:url("/stylesheets/csshover2.htc"); }
     #header { background:url('bird.jpg') }
     #pv     { background:url('bird_pv.jpg') }
-    #footer { background:url('/projects/wiki/flower.jpg') }
-    #back   { background:url('/projects/wiki/flower.jpg') }
+    #footer { background:url('/projects list/a wiki with Zena/flower.jpg') }
+    #back   { background:url('/projects list/a wiki with Zena/flower.jpg') }
     #no_stamp { background:url('bird_pv.jpg') }
     END_CSS
     assert_equal unparsed, text
@@ -169,13 +170,13 @@ class TextDocumentTest < Zena::Unit::TestCase
     bird = secure!(Node) { nodes(:bird_jpg)}
     b_at = bird.updated_at
     # We need to publish so that the title is used for fullpath
-    assert bird.update_attributes(:parent_id => node[:parent_id], :title => "greenBird", :v_status => Zena::Status[:pub])
+    assert bird.update_attributes(:parent_id => node[:parent_id], :title => "green_bird", :v_status => Zena::Status[:pub])
     Zena::Db.set_attribute(bird, :updated_at, b_at)
     start =<<-END_CSS
     body { font-size:10px; }
     #header { background:url('green_bird.jpg') }
     #tiny   { background:url('green_bird_tiny.jpg') }
-    #footer { background:url('/projects/wiki/flower.jpg') }
+    #footer { background:url('/projects list/a wiki with Zena/flower.jpg') }
     END_CSS
     node.text = start.dup
     # dummy controller

data/test/unit/user_test.rb

@@ -3,7 +3,10 @@ require 'test_helper'
 class UserTest < Zena::Unit::TestCase
 
   def test_find_allowed_user_by_login
-    assert_equal users_id(:su), User.find_allowed_user_by_login('su').id
+    login(:anon)
+    secure(User) do
+      assert_equal users_id(:lion), User.find_allowed_user_by_login('lion').id
+    end
   end
 
   def test_deleted_user_should_not_be_allowed
@@ -32,23 +35,27 @@ class UserTest < Zena::Unit::TestCase
     end
   end
 
-  def test_cannot_destroy_su
-    login(:su)
-    su = users(:su)
-    assert_raise(Zena::AccessViolation){ su.destroy }
-  end
+  context 'Destroying a user' do
+    context 'with admin rights' do
+      setup do
+        login(:lion)
+      end
 
-  def test_cannot_destroy_anon
-    login(:su)
-    anon = users(:anon)
-    assert_raise(Zena::AccessViolation){ anon.destroy }
-  end
+      should 'not allow anon destruction' do
+        assert_raise(Zena::AccessViolation){ users(:anon).destroy }
+      end
 
-  def test_can_destroy_ant
-    login(:lion)
-    ant = users(:ant)
-    assert_nothing_raised( Zena::AccessViolation ) { ant.destroy }
-  end
+      should 'not allow destruction of self' do
+        assert_raise(Zena::AccessViolation){ users(:lion).destroy }
+      end
+
+      should 'allow destruction of regular users' do
+        assert_difference('User.count', -1) do
+          assert_nothing_raised { users(:ant).destroy }
+        end
+      end
+    end # with admin rights
+  end # Destroying a user
 
   context 'Creating a new User' do
     setup do
@@ -56,37 +63,90 @@ class UserTest < Zena::Unit::TestCase
     end
 
     subject do
-      {
-        'name'       => 'Dupont',
+      attrs = {
         'lang'       => 'fr',
         'time_zone'  => 'Europe/Zurich',
         'status'     => '50',
         'password'   => 'secret',
         'login'      => 'bolomey',
-        'first_name' => 'Paul',
         'group_ids'  => [groups_id(:public), ''],
-        'email'      => 'paul.bolomey@brainfuck.com',
+        'node_attributes' => {
+          'name'       => 'Dupont',
+          'first_name' => 'Paul',
+          'email'      => 'paul.bolomey@brainfuck.com'
+        }
       }
+      secure(User) { User.create(attrs) }
     end
 
     should 'succeed' do
       assert_difference('User.count', 1) do
-        user = secure(User) { User.new(subject) }
-        user.save
+        subject
       end
     end
+
+    should 'use missing attributes from prototype' do
+      assert_equal 'Iping', subject.node.prop['address']
+    end
   end # Creating a new User
 
+  context 'Setting node attributes' do
+    setup do
+      login(:anon)
+      subject.node_attributes = {'title' => 'bar'}
+    end
+
+    subject do
+      User.new
+    end
+
+    should 'create a new record' do
+      assert subject.node.new_record?
+    end
+
+    should 'create a Node of the type defined in prototype attributes' do
+      assert_equal 'Contact', subject.node.klass
+    end
+
+    context 'more then once' do
+      setup do
+        @first  = subject.node
+        second = User.new
+        second.node_attributes = {}
+        @second = second.node
+      end
+
+      should 'return a new node on each call' do
+        assert_not_equal @first.object_id, @second.object_id
+      end
+    end # more then once
+
+  end # Setting node attributes
+
+  context 'On a user' do
+    subject do
+      users(:lion)
+    end
+
+    should 'evaluate rubyless code in prototype_attributes' do
+      assert_equal Hash[
+        :_parent_id => subject.site.root_id,
+        'klass'     => 'Contact',
+        'address'   => 'Iping',
+        'name'      => 'lion'], subject.prototype_attributes
+    end
+  end # On a user
+
   def test_create
     User.connection.execute "UPDATE users SET lang='ru' WHERE id IN (#{users_id(:incognito)},#{users_id(:whale)})"
     User.connection.execute "UPDATE sites SET languages='fr,ru' WHERE id=#{sites_id(:ocean)}"
     User.connection.execute "UPDATE users SET time_zone='US/Hawaii' WHERE id=#{users_id(:incognito)}"
     login(:whale)
 
-    user = secure!(User) { User.create("login"=>"john", "password"=>"isjjna78a9h") }
+    user = secure!(User) { User.create("login"=>"john", "password"=>"isjjna78a9h", 'node_attributes' => {'v_lang' => 'ru'}) }
 
     assert !user.new_record?, "Not a new record"
-    assert !user.contact.new_record?, "Users's contact node is not a new record"
+    assert !user.node.new_record?, "Users's contact node is not a new record"
 
     user = secure!(User) { User.find(user[:id]) } # reload
     assert_equal sites_id(:ocean), user.site_id
@@ -99,7 +159,7 @@ class UserTest < Zena::Unit::TestCase
     assert !user.user?, "Not a real user yet"
     assert visitor.user?, "Whale is a user"
 
-    contact = user.contact
+    contact = user.node
     assert_equal "john", contact.title
   end
 
@@ -111,25 +171,25 @@ class UserTest < Zena::Unit::TestCase
     assert user.errors[:base] #.any?
     login(:lion)
     user = secure!(User) { User.create("name"=>"Shakespeare", "status"=>"50", "group_ids"=>[""], "lang"=>"fr", "time_zone"=>"Bern", "first_name"=>"William", "login"=>"bob", "password"=>"jsahjks894", "email"=>"") }
-    assert !user.new_record?, "Saved"
-    assert !user.contact.new_record?, "BaseContact saved"
-    assert_equal sites_id(:zena), user.contact.site_id
+    assert !user.new_record?
+    assert !user.node.new_record?
+    assert_equal sites_id(:zena), user.node.site_id
   end
 
   def test_create_with_auto_publish
     Site.connection.execute "UPDATE sites SET auto_publish = #{Zena::Db::TRUE} WHERE id = #{sites_id(:zena)}"
     login(:lion)
-    user = secure!(User) { User.create("name"=>"Shakespeare", "status"=>"50", "group_ids"=>[""], "lang"=>"fr", "time_zone"=>"Europe/Zurich", "first_name"=>"William", "login"=>"bob", "password"=>"jsahjks894", "email"=>"") }
-    assert !user.new_record?, "Saved"
-    assert !user.contact.new_record?, "BaseContact saved"
-    assert_equal sites_id(:zena), user.contact.site_id
+    user = secure!(User) { User.create('status'=>'50', 'group_ids'=>[''], 'lang'=>'fr', 'time_zone'=>'Europe/Zurich', 'node_attributes' => {'first_name'=>'William', 'name'=>'Shakespeare'}, 'login'=>'bob', 'password'=>'jsahjks894') }
+    assert !user.new_record?
+    assert !user.node.new_record?
+    assert_equal sites_id(:zena), user.node.site_id
   end
 
   def test_create_admin_with_groups
     login(:lion)
-    user = secure!(User) { User.new("login"=>"john", "password"=>"isjjna78a9h", "group_ids" => [groups_id(:admin)]) }
+    user = secure(User) { User.new("login"=>"john", "password"=>"isjjna78a9h", "group_ids" => [groups_id(:admin)]) }
     assert user.save
-    user = secure!(User) { User.find(user[:id])}
+    user = secure(User) { User.find(user[:id])}
     assert_equal 3, user.groups.size
   end
 
@@ -146,13 +206,13 @@ class UserTest < Zena::Unit::TestCase
   def test_only_self_or_admin_can_update
     login(:tiger)
     user = secure!(User) { users(:ant) }
-    user.email = "eat@spam.com"
+    user.lang = 'de'
     assert !user.save
     assert user.errors[:base] #.any?
     user = secure!(User) { users(:tiger) }
-    user.email = "socr@isa.man"
+    user.lang = 'de'
     assert user.save
-    assert_equal "socr@isa.man", user.email
+    assert_equal 'de', user.lang
   end
 
   def test_only_admin_can_create
@@ -290,14 +350,14 @@ class UserTest < Zena::Unit::TestCase
 
   def test_redactions
     login(:tiger)
-    assert_equal ['opening'], visitor.redactions.map {|r| r.node.node_name}
+    assert_equal ['super ouverture'], visitor.redactions.map {|r| r.node.title}
     node = secure(Page) { Page.create(:title => 'hello', :parent_id => nodes_id(:projects)) }
     node.propose
-    assert_equal ['hello'], visitor.to_publish.map {|r| r.node.node_name}
-    assert_equal ['hello'], visitor.proposed.map {|r| r.node.node_name}
+    assert_equal ['hello'], visitor.to_publish.map {|r| r.node.title}
+    assert_equal ['hello'], visitor.proposed.map {|r| r.node.title}
 
     login(:lion)
-    assert_equal ['hello'], visitor.to_publish.map {|r| r.node.node_name}
+    assert_equal ['hello'], visitor.to_publish.map {|r| r.node.title}
   end
 
   context 'Creating a new user' do

data/test/unit/version_test.rb

@@ -11,8 +11,8 @@ class VersionTest < Zena::Unit::TestCase
       end
 
       context 'receiving author' do
-        should 'return a BaseContact' do
-          assert_kind_of BaseContact, subject.author
+        should 'return a Node' do
+          assert_kind_of Node, subject.author
         end
 
         should 'return the contact node of the author' do
@@ -58,7 +58,7 @@ class VersionTest < Zena::Unit::TestCase
     context 'on node creation' do
       context 'setting an invalid v_lang' do
         setup do
-          @node = secure!(Page) { Page.create(:v_lang => 'io', :parent_id => nodes_id(:status), :node_name => 'hello')}
+          @node = secure!(Page) { Page.create(:v_lang => 'io', :parent_id => nodes_id(:status), :title => 'hello')}
         end
 
         should 'not create record if lang is not allowed' do
@@ -72,7 +72,7 @@ class VersionTest < Zena::Unit::TestCase
 
       context 'setting a valid v_lang' do
         subject do
-          @node = secure!(Page) { Page.create(:v_lang => 'de', :parent_id => nodes_id(:status), :node_name => 'hello')}
+          @node = secure!(Page) { Page.create(:v_lang => 'de', :parent_id => nodes_id(:status), :title => 'hello')}
         end
 
         should 'create a single version' do

data/test/unit/virtual_class_test.rb

@@ -6,7 +6,7 @@ class VirtualClassTest < Zena::Unit::TestCase
   def test_virtual_subclasse
     # add a sub class
     login(:lion)
-    vclass = VirtualClass.create(:superclass => 'Post', :name => 'Super', :create_group_id =>  groups_id(:public))
+    vclass = VirtualClass.create(:superclass => 'Post', :name => 'Super', :create_group_id => groups_id(:public))
     assert !vclass.new_record?
     assert_equal "NNPS", vclass.kpath
   end
@@ -14,7 +14,7 @@ class VirtualClassTest < Zena::Unit::TestCase
   def test_node_classes_for_form
     login(:anon)
     # preload models
-    [Project, Skin, Note, Image, Template, BaseContact]
+    [Project, Skin, Note, Image, Template]
 
     classes_for_form = Node.classes_for_form
     assert classes_for_form.include?(["Node", "Node"])
@@ -27,13 +27,14 @@ class VirtualClassTest < Zena::Unit::TestCase
   def test_note_classes_for_form
     login(:anon)
     # preload models
-    [Project, Skin, Note, Image, Template, BaseContact]
+    [Project, Skin, Note, Image, Template]
 
     classes_for_form = Note.classes_for_form
     assert classes_for_form.include?(["Note", "Note"])
     assert classes_for_form.include?(["  Letter", "Letter"])
     assert classes_for_form.include?(["  Post", "Post"])
     classes_for_form.map!{|k,c| c}
+
     assert !classes_for_form.include?("Node")
     assert !classes_for_form.include?("Page")
     assert !classes_for_form.include?("Reference")
@@ -42,7 +43,7 @@ class VirtualClassTest < Zena::Unit::TestCase
   def test_post_classes_for_form
     # add a sub class
     login(:lion)
-    vclass = VirtualClass.create(:superclass => 'Post', :name => 'Super', :create_group_id =>  groups_id(:public))
+    vclass = VirtualClass.create(:superclass => 'Post', :name => 'Super', :create_group_id => groups_id(:public))
     assert !vclass.new_record?
 
     login(:anon)
@@ -61,7 +62,7 @@ class VirtualClassTest < Zena::Unit::TestCase
   def test_post_classes_for_form_opt
     # add a sub class
     login(:lion)
-    vclass = VirtualClass.create(:superclass => 'Post', :name => 'Super', :create_group_id =>  groups_id(:public))
+    vclass = VirtualClass.create(:superclass => 'Post', :name => 'Super', :create_group_id => groups_id(:public))
     assert !vclass.new_record?
 
     login(:anon)
@@ -80,12 +81,13 @@ class VirtualClassTest < Zena::Unit::TestCase
   def test_post_classes_for_form_opt
     # add a sub class
     login(:lion)
-    vclass = VirtualClass.create(:superclass => 'Post', :name => 'Super', :create_group_id =>  groups_id(:public))
+    vclass = VirtualClass.create(:superclass => 'Post', :name => 'Super', :create_group_id => groups_id(:public))
     assert !vclass.new_record?
 
     login(:anon)
 
     classes_for_form = Node.classes_for_form(:class => 'Post', :without=>'Super')
+
     assert classes_for_form.include?(["Post", "Post"])
     classes_for_form.map!{|k,c| c}
     assert !classes_for_form.include?("Node")
@@ -99,7 +101,7 @@ class VirtualClassTest < Zena::Unit::TestCase
   def test_node_classes_for_form_except
     login(:anon)
     # preload models
-    [Project, Skin, Note, Image, Template, BaseContact]
+    [Project, Skin, Note, Image, Template]
 
     classes_for_form = Node.classes_for_form(:without => 'Letter')
     assert classes_for_form.include?(["Node", "Node"])
@@ -149,19 +151,6 @@ class VirtualClassTest < Zena::Unit::TestCase
     assert_equal "NNL", node[:kpath]
   end
 
-  def test_new_instance
-    login(:ant)
-    klass = roles(:Letter)
-    assert node = secure!(Node) { klass.new_instance(:title => 'my letter', :parent_id => nodes_id(:cleanWater)) }
-    assert node.save
-    assert_kind_of Note, node
-    assert !node.new_record?
-    assert node.virtual_class
-    assert_equal roles_id(:Letter), node.vclass_id
-    assert_equal 'Letter', node.klass
-    assert node.vkind_of?('Letter')
-    assert_equal "NNL", node[:kpath]
-  end
 
   def test_relation
     login(:ant)
@@ -175,9 +164,9 @@ class VirtualClassTest < Zena::Unit::TestCase
   end
 
   def test_superclass
-    assert_equal Note, roles(:Post).superclass
-    assert_equal Note, roles(:Letter).superclass
-    assert_equal Page, roles(:Tracker).superclass
+    assert_equal VirtualClass['Note'], roles(:Post).superclass
+    assert_equal VirtualClass['Note'], roles(:Letter).superclass
+    assert_equal VirtualClass['Page'], roles(:Tracker).superclass
   end
 
   def test_new_conflict_virtual_kpath
@@ -198,17 +187,6 @@ class VirtualClassTest < Zena::Unit::TestCase
     assert_equal 'NPU', vclass.kpath
   end
 
-  def test_update
-    # add a sub class
-    login(:lion)
-    vclass = roles(:Post)
-    assert_equal "reading, book", vclass.dyn_keys
-    assert_equal "NNP", vclass.kpath
-    assert vclass.update_attributes(:dyn_keys => 'foo, bar')
-    assert_equal "foo, bar", vclass.dyn_keys
-    assert_equal "NNP", vclass.kpath
-  end
-
   def test_update_name
     # add a sub class
     login(:lion)
@@ -222,9 +200,9 @@ class VirtualClassTest < Zena::Unit::TestCase
     # add a sub class
     login(:lion)
     vclass = roles(:Post)
-    assert_equal Note, vclass.superclass
+    assert_equal VirtualClass['Note'], vclass.superclass
     assert vclass.update_attributes(:superclass => 'Project')
-    assert_equal Project, vclass.superclass
+    assert_equal VirtualClass['Project'], vclass.superclass
     assert_equal "NPPP", vclass.kpath
   end
 
@@ -233,6 +211,569 @@ class VirtualClassTest < Zena::Unit::TestCase
     assert roles(:Post).auto_create_discussion
   end
 
+  context 'Loading a virtual class' do
+    context 'with a kpath' do
+      subject do
+        VirtualClass['Post']
+      end
+
+      should 'return a virtual class' do
+        assert_kind_of VirtualClass, subject
+        assert_equal 'Post', subject.name
+      end
+
+      should 'cache found virtual class' do
+        assert_equal VirtualClass['Post'].object_id, subject.object_id
+      end
+
+      should 'return a loaded virtual class' do
+        assert_equal %w{assigned cached_role_ids date origin summary text title tz weight}, subject.column_names.sort
+      end
+
+      context 'related to a real class' do
+        subject do
+          VirtualClass.find_by_kpath('NN')
+        end
+
+        should 'return a virtual class' do
+          assert_kind_of VirtualClass, subject
+          assert_equal 'Note', subject.name
+        end
+
+        should 'return a loaded virtual class' do
+          assert_equal %w{assigned cached_role_ids origin summary text title tz weight}, subject.column_names.sort
+        end
+      end # related to a real class
+
+    end # with a kpath
+
+    context 'with an id' do
+      subject do
+        VirtualClass.find_by_id roles_id(:Post)
+      end
+
+      should 'return a virtual class' do
+        assert_kind_of VirtualClass, subject
+        assert_equal 'Post', subject.name
+      end
+
+      should 'cache found virtual class' do
+        assert_equal VirtualClass.find_by_id(roles_id(:Post)), subject
+        assert_equal VirtualClass['Post'].object_id, subject.object_id
+      end
+
+      should 'return a loaded virtual class' do
+        assert_equal %w{assigned cached_role_ids date origin summary text title tz weight}, subject.column_names.sort
+      end
+    end # with an id
+
+
+    context 'with a name' do
+      subject do
+        VirtualClass.find_by_name 'Post'
+      end
+
+      should 'return a virtual class' do
+        assert_kind_of VirtualClass, subject
+        assert_equal 'Post', subject.name
+      end
+
+      should 'cache found virtual class' do
+        assert_equal VirtualClass.find_by_id(roles_id(:Post)).object_id, subject.object_id
+        assert_equal VirtualClass['Post'].object_id, subject.object_id
+      end
+
+      should 'return a loaded virtual class' do
+        assert_equal %w{assigned cached_role_ids date origin summary text title tz weight}, subject.column_names.sort
+      end
+
+      context 'related to a real class' do
+        subject do
+          VirtualClass.find_by_name('Note')
+        end
+
+        should 'return a virtual class' do
+          assert_kind_of VirtualClass, subject
+          assert_equal 'Note', subject.name
+        end
+
+        should 'return a loaded virtual class' do
+          assert_equal %w{assigned cached_role_ids origin summary text title tz weight}, subject.column_names.sort
+        end
+      end # related to a real class
+    end # with a name
+
+    context 'from a node instance' do
+      subject do
+        nodes(:proposition)
+      end
+
+      should 'load from cache' do
+        assert_equal VirtualClass['Post'].object_id, subject.virtual_class.object_id
+      end
+
+      context 'that is not a virtual class instance' do
+        subject do
+          nodes(:projects)
+        end
+
+        should 'load from cache' do
+          assert_equal VirtualClass['Page'].object_id, subject.virtual_class.object_id
+        end
+      end # that is not a virtual class instance
+
+    end # from a node instance
+
+  end # Loading a virtual class
+
+  def self.should_clear_cache
+
+    should 'update roles_updated_at date' do
+      subject
+      date = current_site.roles_updated_at
+      assert_equal date.to_i, Site.find(current_site.id).roles_updated_at.to_i # to_i because of the precision in db
+      assert_kind_of Time, date
+      assert @before < current_site.roles_updated_at
+    end
+
+    should 'empty process cache' do
+      # in same process
+      subject
+      cache = VirtualClass.caches_by_site[current_site.id]
+      assert cache.instance_variable_get(:@cache_by_id).empty?
+      assert cache.instance_variable_get(:@cache_by_kpath).empty?
+      assert cache.instance_variable_get(:@cache_by_name).empty?
+    end
+
+    should 'mark cache' do
+      subject
+      # This is needed for other processes
+      assert @cache.stale?
+    end
+  end
+
+  def setup_cache_test
+    login(:lion)
+    Site.connection.execute 'UPDATE sites SET roles_updated_at = NULL'
+    # preload in cache
+    VirtualClass['Post'].column_names
+    @before = Time.now.utc
+    @cache  = VirtualClass.caches_by_site[current_site.id]
+  end
+
+  context 'Creating a Role' do
+    setup do
+      setup_cache_test
+    end
+
+    subject do
+      role = VirtualClass.create(:name => 'Flop', :superclass => 'Note', :create_group_id => groups_id(:public))
+      err role
+      assert !role.new_record?
+    end
+
+    should_clear_cache
+
+    should 'load new role from cache' do
+      subject
+      assert_kind_of VirtualClass, VirtualClass.find_by_name('Flop')
+    end
+
+  end # Creating a Role
+
+  context 'Creating a Column' do
+    setup do
+      setup_cache_test
+    end
+
+    subject do
+      column = Column.create(:role_id => roles_id(:Original), :ptype => 'string', :name => 'foo')
+      err column
+      assert !column.new_record?
+    end
+
+    should_clear_cache
+
+    should 'load new role from cache' do
+      subject
+      # no more linked to assigned
+      assert_equal %w{assigned cached_role_ids date foo origin summary text title tz weight}, VirtualClass['Post'].column_names.sort
+    end
+
+  end # Creating a Column
+
+  context 'Updating a Role' do
+    setup do
+      setup_cache_test
+    end
+
+    subject do
+      assert roles(:Original).update_attributes(:superclass => 'Page')
+    end
+
+    should_clear_cache
+
+    should 'load new role from cache' do
+      subject
+      # no more linked to Original
+      assert_equal %w{assigned cached_role_ids date summary text title}, VirtualClass['Post'].column_names.sort
+    end
+
+  end # Updating a Role
+
+  context 'Updating a Column' do
+    setup do
+      setup_cache_test
+    end
+
+    subject do
+      assert columns(:Original_tz).update_attributes(:name => 'toz')
+    end
+
+    should_clear_cache
+
+    should 'load new role from cache' do
+      subject
+      # change name
+      assert_equal %w{assigned cached_role_ids date origin summary text title toz weight}, VirtualClass['Post'].column_names.sort
+    end
+
+  end # Updating a Column
+
+  context 'Deleting a Role' do
+    setup do
+      setup_cache_test
+    end
+
+    subject do
+      assert roles(:Original).destroy
+    end
+
+    should_clear_cache
+
+    should 'load new role from cache' do
+      subject
+      # no more linked to Original
+      assert_equal %w{assigned cached_role_ids date summary text title}, VirtualClass['Post'].column_names.sort
+    end
+
+  end # Deleting a Role
+
+  context 'Deleting a Column' do
+    setup do
+      setup_cache_test
+    end
+
+    subject do
+      assert columns(:Original_tz).destroy
+    end
+
+    should_clear_cache
+
+    should 'load new role from cache' do
+      subject
+      # no more linked to assigned
+      assert_equal %w{assigned cached_role_ids date origin summary text title weight}, VirtualClass['Post'].column_names.sort
+    end
+
+  end # Deleting a Column
+
+  context 'Finding all classes' do
+    subject do
+      VirtualClass.all_classes
+    end
+
+    context 'without base or filter' do
+      should 'load all classes' do
+        assert_equal %w{N ND NDI NDT NDTT NN NNL NNP NP NPA NPP NPPB NPS NPSS NPT NR NRC}, subject.map(&:kpath).reject{|k| k =~ /\ANU|\ANDD/}.sort
+      end
+    end # without base or filter
+
+    context 'with a base' do
+      subject do
+        VirtualClass.all_classes('ND')
+      end
+
+      should 'load sub classes and self' do
+        VirtualClass.expire_cache!
+        assert_equal %w{ND NDI NDT NDTT}, subject.map(&:kpath).sort.reject{|k| k == 'NDD'} # test leakage
+      end
+    end # with a base
+
+    context 'with a filter' do
+      subject do
+        VirtualClass.all_classes('N', 'Document')
+      end
+
+      should 'description' do
+        assert_equal %w{N NN NNL NNP NP NPA NPP NPPB NPS NPSS NPT NR NRC}, subject.map(&:kpath).reject{|k| k =~ /\ANU/}.sort
+      end
+    end # with a filter
+
+  end # Finding all classes
+
+  context 'A Document vclass' do
+    context 'on new_instance' do
+      subject do
+        VirtualClass['Document'].new_instance(
+            :parent_id => nodes_id(:cleanWater),
+            :file      => uploaded_jpg('bird.jpg')
+        )
+      end
+
+      should 'select class from content type' do
+        assert_kind_of Image, subject
+      end
+    end # on new_instance
+  end # A Document vclass
+
+  context 'A vclass' do
+    context 'of a real class' do
+      subject do
+        VirtualClass['Page']
+      end
+
+      should 'return true on real_class?' do
+        assert subject.real_class?
+      end
+
+      should 'return super vclass' do
+        assert_equal VirtualClass['Node'], subject.superclass
+      end
+
+      should 'return safe column types' do
+        assert_equal %w{assigned origin summary text title tz weight}, subject.safe_column_types.keys.sort
+      end
+
+      should 'return nil on unsafe method type' do
+        assert_nil subject.safe_method_type(['cached_role_ids'])
+      end
+
+      should 'return type on safe method type' do
+        assert_equal Hash[:class => String, :nil => true, :method => "prop['title']"], subject.safe_method_type(['title'])
+      end
+
+      should 'return list of roles' do
+        assert_equal %w{Node Original Task}, subject.sorted_roles.map(&:name)
+      end
+
+      context 'that is a Node' do
+        subject do
+          VirtualClass['Node']
+        end
+
+        should 'return Node on super vclass' do
+          assert_equal Node, subject.superclass
+        end
+
+        should 'return safe columns' do
+          assert_equal %w{summary text title assigned origin tz weight}, subject.safe_columns.map(&:name)
+        end
+
+        should 'return defined safe columns' do
+          assert_equal %w{summary text title}, subject.defined_safe_columns.map(&:name)
+        end
+
+        should 'return safe column types' do
+          assert_equal %w{assigned origin summary text title tz weight}, subject.safe_column_types.keys.sort
+        end
+
+        should 'not include unsafe properties in safe column types' do
+          unsafe_prop = 'cached_role_ids'
+          assert subject.columns[unsafe_prop]
+          assert !subject.safe_column_types[unsafe_prop]
+        end
+
+        should 'return list of roles' do
+          assert_equal %w{Node Original Task}, subject.sorted_roles.map(&:name)
+        end
+      end
+    end # of a real class
+
+
+    context 'of a virtual class' do
+      subject do
+        VirtualClass['Post']
+      end
+
+      should 'return false on real_class?' do
+        assert !subject.real_class?
+      end
+
+      should 'return safe columns' do
+        assert_equal %w{summary text title assigned origin tz weight date}, subject.safe_columns.map(&:name)
+      end
+
+      should 'return defined safe columns' do
+        assert_equal %w{date}, subject.defined_safe_columns.map(&:name)
+      end
+
+      should 'return safe column types' do
+        assert_equal %w{assigned date origin summary text title tz weight}, subject.safe_column_types.keys.sort
+      end
+
+      should 'return type on safe method type' do
+        assert_equal Hash[:class => String, :nil => true, :method => "prop['title']"], subject.safe_method_type(['title'])
+        assert_equal Hash[:class => Time, :nil => true, :method => "prop['date']"], subject.safe_method_type(['date'])
+      end
+
+      should 'return type of ruby method on safe method type' do
+        assert_equal Hash[:class => Time, :nil => true, :method => "created_at"], subject.safe_method_type(['created_at'])
+      end
+
+      should 'return list of roles' do
+        assert_equal %w{Node Original Task Post}, subject.sorted_roles.map(&:name)
+      end
+    end # of a virtual class
+
+
+    context 'on all_relations' do
+      subject do
+        VirtualClass['Letter'].all_relations
+      end
+
+      should 'return a list of relation proxies' do
+        assert_kind_of RelationProxy, subject.first
+      end
+
+      should 'return a list of relation names when mapped with other_role' do
+        assert subject.map(&:other_role).include?('icon')
+      end
+    end # on relations
+
+
+    context 'on filtered_relations' do
+      subject do
+        VirtualClass['Letter'].filtered_relations('doc')
+      end
+
+      should 'filter relation proxies' do
+        assert_kind_of RelationProxy, subject.first
+      end
+
+      should 'return a list of relation names on other_role' do
+        assert_equal %w{reference reference_for set_tag}, subject.map(&:other_role).sort
+      end
+    end # on relations
+    
+    context 'on new_instance' do
+      subject do
+        VirtualClass['Letter'].new_instance(
+          :parent_id => nodes_id(:cleanWater),
+          :title     => 'lambda'
+        )
+      end
+
+      should 'use real_class' do
+        assert_kind_of Note, subject
+      end
+
+      should 'set virtual class' do
+        assert_equal VirtualClass['Letter'].object_id, subject.vclass.object_id
+      end
+    end # on new_instance
+  end # A note vclass
+
+  context 'A virtual class' do
+    subject do
+      VirtualClass['Post']
+    end
+
+    should 'respond to less or equal then' do
+      assert subject <= Note
+      assert subject <= Node
+      assert subject <= VirtualClass['Note']
+      assert !(subject <= Project)
+    end
+
+    should 'respond to less then' do
+      assert subject < Note
+      assert subject < Node
+      assert subject < VirtualClass['Note']
+      assert !(subject < Project)
+      assert !(subject < VirtualClass['Post'])
+    end
+
+    should 'consider role methods as safe' do
+      assert_equal Hash[:class=>String, :method=>"prop['assigned']", :nil=>true], subject.safe_method_type(['assigned'])
+    end
+  end # A virtual class
+
+  context 'A visitor with write access' do
+    setup do
+      login(:tiger)
+    end
+
+    context 'on a node' do
+      context 'from a class with roles' do
+        subject do
+          secure(Node) { nodes(:letter) }
+        end
+
+        should 'use method missing to assign properties' do
+          assert_nothing_raised do
+            subject.assigned = 'flat Eric'
+          end
+        end
+
+        should 'use property filter on set attributes' do
+          assert_nothing_raised do
+            subject.attributes = {'assigned' => 'flat Eric'}
+          end
+        end
+
+        should 'accept properties' do
+          subject.properties = {'assigned' => 'flat Eric'}
+          assert subject.save
+          assert_equal 'flat Eric', subject.assigned
+        end
+
+        should 'use property filter on update_attributes' do
+          assert_nothing_raised do
+            assert subject.update_attributes('assigned' => 'flat Eric', 'origin' => '2D')
+          end
+        end
+
+        should 'accept properties in update_attributes' do
+          assert_nothing_raised do
+            assert subject.update_attributes('properties' => {'assigned' => 'flat Eric'})
+            assert_equal 'flat Eric', subject.assigned
+          end
+        end
+
+        should 'consider role methods as safe' do
+          assert_equal Hash[:class=>String, :method=>"prop['paper']", :nil=>true], subject.safe_method_type(['paper'])
+        end
+
+        should 'not consider VirtualClass own methods as safe' do
+          assert_nil subject.safe_method_type(['name'])
+        end
+
+        should 'not allow arbitrary attributes' do
+          assert !subject.update_attributes('assigned' => 'flat Eric', 'bad' => 'property')
+        end
+
+        should 'not raise on bad attributes' do
+          assert_nothing_raised do
+            subject.attributes = {'elements' => 'Statistical Learning'}
+          end
+        end
+
+        should 'add an error on first bad attributes' do
+          subject.attributes = {'elements' => 'Statistical Learning'}
+          assert !subject.save
+          assert_equal 'property not declared', subject.errors[:elements]
+        end
+
+        should 'not allow property bypassing' do
+          assert !subject.update_attributes('properties' => {'bad' => 'property'})
+          assert_equal 'property not declared', subject.errors[:bad]
+        end
+
+      end # from a class with roles
+    end # on a node
+  end # A visitor with write access
+
   context 'importing virtual class definitions' do
     setup do
       login(:lion)