zena 0.16.9 → 1.0.0.beta1

data/test/unit/node_name_test.rb

@@ -0,0 +1,137 @@
+require 'test_helper'
+
+class NodeNameTest < Zena::Unit::TestCase
+
+  context 'A visitor with write access' do
+    setup do
+      login(:tiger)
+    end
+
+    context 'on a node' do
+      subject do
+        secure!(Node) { nodes(:people) }
+      end
+
+      should 'sync node_name with title on publish' do
+        assert subject.update_attributes(:title => 'nice people')
+        assert subject.publish
+        assert_equal 'nicePeople', subject.node_name
+      end
+
+      should 'sync node_name with title if name changed' do
+        assert subject.update_attributes(:title => 'nice people', :node_name => 'foobar')
+        assert_equal 'foobar', subject.node_name
+        assert subject.publish
+        assert_equal 'nicePeople', subject.node_name
+      end
+
+      should 'not sync node_name with title on redaction' do
+        assert subject.update_attributes(:title => 'nice people')
+        assert_equal 'people', subject.node_name
+      end
+
+      context 'with another node with same node_name' do
+        setup do
+          page = secure!(Page) { Page.create(
+            :parent_id => subject.parent_id,
+            :title     => 'nice people') # ==> nicePeople
+          }
+        end
+
+        should 'not sync node_name with title on redaction' do
+          assert subject.update_attributes(:title => 'nice people')
+          assert_equal 'people', subject.node_name
+        end
+
+        should 'set an error on node_name with title on publish' do
+          assert subject.update_attributes(:title => 'nice people')
+          assert !subject.publish
+          assert_equal subject.errors[:node_name], 'has already been taken'
+        end
+      end # with another node with same node_name
+    end # on a node
+  end # A visitor with write access
+
+  # TODO: move these tests above
+
+  def test_get_fullpath_rebuild
+    login(:lion)
+    node = secure!(Node) { nodes(:lake)  }
+    assert_equal 'projects/cleanWater/lakeAddress', node.fullpath
+    assert node.update_attributes(:parent_id => nodes_id(:collections))
+    assert_equal 'collections/lakeAddress', node.fullpath
+  end
+
+  def test_fullpath_updated_on_parent_rename
+    login(:tiger)
+    node = secure!(Node) { nodes(:tiger) }
+    assert_equal 'people/tiger', node.fullpath
+    node = secure!(Node) { nodes(:tiger) }
+    assert_equal 'people/tiger', node[:fullpath] # make sure fullpath is cached
+
+    node = secure!(Node) { nodes(:people) }
+    assert node.update_attributes(:title => 'nice people')
+    assert node.publish
+    assert_equal 'nicePeople', node.node_name # sync node_name
+    node = secure!(Node) { nodes(:tiger) }
+    assert_equal 'nicePeople/tiger', node[:fullpath]
+  end
+
+  def test_rootpath
+    login(:ant)
+    node = secure!(Node) { nodes(:status) }
+    assert_equal 'zena/projects/cleanWater/status', node.rootpath
+    node = secure!(Node) { nodes(:zena) }
+    assert_equal 'zena', node.rootpath
+  end
+
+  def test_basepath
+    login(:tiger)
+    node = secure!(Node) { nodes(:status) }
+    assert_equal 'projects/cleanWater', node.basepath
+    node = secure!(Node) { nodes(:projects) }
+    assert_equal '', node.basepath
+    node = secure!(Node) { nodes(:proposition) }
+    assert_equal '', node.basepath
+  end
+
+  def test_sync_node_name_before_publish_if_single_version
+    login(:ant)
+    node = secure!(Node) { Node.create(:title => 'Eve', :parent_id => nodes_id(:people)) }
+    assert_equal Zena::Status[:red], node.v_status
+    assert_equal 'Eve', node.node_name
+    node.update_attributes(:title => 'Lilith')
+    assert_equal Zena::Status[:red], node.v_status
+    assert_equal 'Lilith', node.node_name
+  end
+
+  def test_sync_node_name_on_title_change_auto_pub_no_sync
+    Site.connection.execute "UPDATE sites set auto_publish = #{Zena::Db::TRUE}, redit_time = 3600 WHERE id = #{sites_id(:zena)}"
+    Version.connection.execute "UPDATE versions set updated_at = '#{Time.now.strftime('%Y-%m-%d %H:%M:%S')}' WHERE node_id IN (#{nodes_id(:status)},#{nodes_id(:people)})"
+    login(:tiger)
+
+    node = secure!(Node) { nodes(:status) }
+    assert node.update_attributes(:title => 'simply different')
+    assert_equal 'simplyDifferent', node.node_name
+    visitor.lang = 'fr'
+    # not ref lang
+    node = secure!(Node) { nodes(:people) }
+    assert node.update_attributes(:title => 'des gens sympathiques')
+    assert_equal 'fr', node.v_lang
+    assert_equal 'desGensSympathiques', node.node_name
+  end
+
+  def test_sync_node_name_on_title_change_auto_pub
+    test_site('zena')
+    Site.connection.execute "UPDATE sites set auto_publish = #{Zena::Db::TRUE}, redit_time = 3600 WHERE id = #{sites_id(:zena)}"
+    Version.connection.execute "UPDATE versions set updated_at = '#{Time.now.strftime('%Y-%m-%d %H:%M:%S')}' WHERE node_id IN (#{nodes_id(:people)})"
+    login(:tiger)
+    node = secure!(Node) { nodes(:people) }
+    # was in sync, correct lang
+    assert_equal node.node_name, node.title
+    assert node.update_attributes(:title => 'nice people')
+    node = secure!(Node) { nodes(:people) }
+    assert_equal 'nice people', node.title
+    assert_equal 'nicePeople', node.node_name
+  end
+end

data/test/unit/node_test.rb

@@ -1,15 +1,117 @@
+# encoding: utf-8
 require 'test_helper'
 
 class NodeTest < Zena::Unit::TestCase
 
   NEW_DEFAULT = {
-    :name       => 'hello',
-    :rgroup_id  => Zena::FoxyParser::id('zena', 'public'),
-    :wgroup_id  => Zena::FoxyParser::id('zena', 'workers'),
-    :dgroup_id  => Zena::FoxyParser::id('zena', 'managers'),
-    :parent_id  => Zena::FoxyParser::id('zena', 'cleanWater'),
+    :node_name => 'hello',
+    :rgroup_id => Zena::FoxyParser::id('zena', 'public'),
+    :wgroup_id => Zena::FoxyParser::id('zena', 'workers'),
+    :dgroup_id => Zena::FoxyParser::id('zena', 'managers'),
+    :parent_id => Zena::FoxyParser::id('zena', 'cleanWater'),
   }.freeze
 
+  context 'On a node' do
+    subject do
+      secure!(Node) { nodes(:cleanWater) }
+    end
+
+    context 'with a sub-node' do
+      should 'return true on ancestor?' do
+        assert subject.ancestor?(secure!(Node) { nodes(:status) })
+      end
+    end # with a sub-node
+
+    context 'with a node that is not a sub-node' do
+      should 'return false on ancestor?' do
+        assert !subject.ancestor?(secure!(Node) { nodes(:people) })
+      end
+    end # with a node that is not a sub-node
+
+    should 'return true on ancestor? on self' do
+      assert subject.ancestor?(subject)
+    end
+  end # On a node
+
+  context 'A logged in user' do
+    setup do
+      login(:lion)
+    end
+
+    context 'on a node with write access' do
+      subject do
+        secure!(Node) { nodes(:lion) }
+      end
+
+      context 'adding a comment with m_title' do
+        subject do
+          node = secure!(Node) { nodes(:lion) }
+          node.update_attributes(:m_title => 'Amartya Sen', :m_text => 'Equality of What')
+          node
+        end
+
+        should 'create a Comment' do
+          assert_difference('Comment.count', 1) do
+            subject
+          end
+        end
+
+        should 'set comment title from m_title' do
+          assert_equal 'Amartya Sen', subject.comments.first.title
+        end
+
+        should 'set author from visitor' do
+          assert_equal users_id(:lion), subject.comments.first.user_id
+        end
+      end # adding a comment with m_title
+
+      context 'setting an indexed field' do
+        subject do
+          node = secure!(Node) { nodes(:art) }
+          node.update_attributes(:origin => 'Dada')
+          node
+        end
+
+        should 'create index entries' do
+          assert_difference('IdxNodesString.count', 1) do
+            subject
+          end
+        end
+
+        should 'write field value in index' do
+          subject
+          index = IdxNodesString.find(:first, :conditions => {:key => 'origin', :node_id => subject.id})
+          assert_equal 'origin', index.key
+          assert_equal 'Dada', index.value
+        end
+
+        should 'keep index entries up to date' do
+          subject
+
+          assert_difference('IdxNodesString.count', 0) do
+            subject.update_attributes(:origin => 'Surrealism')
+          end
+
+          index = IdxNodesString.find(:first, :conditions => {:key => 'origin', :node_id => subject.id})
+          assert_equal 'origin', index.key
+          assert_equal 'Surrealism', index.value
+        end
+
+        should 'find indexed nodes with exact search' do
+          subject # create index entry
+          assert node = Node.search_records(:origin => 'Dada').first
+          assert_equal nodes_id(:art), node.id
+        end
+
+        should 'find indexed nodes with hash search' do
+          subject # create index entry
+          assert node = Node.search_records(:origin => 'Dada').first
+          assert_equal nodes_id(:art), node.id
+        end
+      end # setting an indexed field
+    end # on a node with write access
+  end # A logged in user
+
   def test_rebuild_fullpath
     Node.connection.execute "UPDATE nodes SET fullpath = NULL, basepath = NULL WHERE id = #{nodes_id(:wiki)}"
     login(:ant)
@@ -36,109 +138,23 @@ class NodeTest < Zena::Unit::TestCase
 
   def test_match_query
     query = Node.match_query('smala')
-    assert_equal "nodes.name LIKE 'smala%'", query[:conditions]
+    assert_equal "nodes.node_name LIKE 'smala%'", query[:conditions]
     query = Node.match_query('.', :node => nodes(:wiki))
     assert_equal ["parent_id = ?", nodes_id(:wiki)], query[:conditions]
   end
 
-  def transform_attributes_zazen_shortcut_v_text
-    login(:lion)
-    [
-      ["Hi, this is just a simple \"test\"::w or \"\"::w+_life.rss. OK ?\n\n!:lake+_pv!",
-       "Hi, this is just a simple \"test\":25 or \"\":29_life.rss. OK ?\n\n!24_pv!"],
-
-      ["Hi ![30,:lake+]! ![]!",
-       "Hi ![30,24]! ![]!"],
-
-      ["Hi !{:bird,:lake+}! !{}!",
-       "Hi !{30,24}! !{}!"],
-
-      ["Hi !30!::clean !:bird!::clean !:bird/nice bird!:21 !30_pv/hello ladies!:21",
-       "Hi !30!:21 !30!:21 !30/nice bird!:21 !30_pv/hello ladies!:21"],
-
-      ["Hi, this is normal "":1/ just a\n\n* asf\n* asdf ![23,33]!",
-       "Hi, this is normal "":1/ just a\n\n* asf\n* asdf ![23,33]!"],
-    ].each do |src,res|
-      assert_equal res, secure(Node) { Node.transform_attributes( 'v_text' => src )['v_text'] }
-    end
-  end
-
-  def test_transform_attributes
-    login(:tiger)
-    visitor[:time_zone] = "Europe/Zurich"
-    [
-      [{'parent_id' => 'lake+'},
-       {'parent_id' => nodes_id(:lake_jpg)}],
-
-      [{'d_super_id' => 'lake',           'd_other_id' => '11'},
-       {'d_super_id' => nodes_zip(:lake), 'd_other_id' => 11}],
-
-      [{'tag_ids' => "33,news"},
-       {'tag_ids' => [nodes_id(:art), nodes_id(:news)]}],
-
-      [{'parent_id' => '999', 'tag_ids' => "999,34,art"},
-       {'parent_id' => '999', 'tag_ids' => [nodes_id(:news),nodes_id(:art)]}],
-
-      [{'link' => {'hot' => {'other_id' => '22', 'date' => '2009-7-15 16:58' }}},
-       {'link' => {'hot' => {'other_id' => nodes_id(:status), 'date' => Time.gm(2009,7,15,16,58)}}}], # this should be 14:58 when #255 is fixed (tz support).
-    ].each do |src,res|
-      assert_equal res, secure(Node) { Node.transform_attributes( src ) }
-    end
-  end
-
-  def test_get_fullpath_rebuild
-    login(:lion)
-    node = secure!(Node) { nodes(:lake)  }
-    assert_equal 'projects/cleanWater/lakeAddress', node.fullpath
-    assert node.update_attributes(:parent_id => nodes_id(:collections))
-    assert_equal 'collections/lakeAddress', node.fullpath
-  end
-
-  def test_fullpath_updated_on_parent_rename
-    login(:tiger)
-    node = secure!(Node) { nodes(:tiger) }
-    assert_equal 'people/tiger', node.fullpath
-    node = secure!(Node) { nodes(:tiger) }
-    assert_equal 'people/tiger', node[:fullpath] # make sure fullpath is cached
-
-    node = secure!(Node) { nodes(:people) }
-    assert node.update_attributes(:v_title => 'nice people')
-    assert node.publish
-    assert_equal 'nicePeople', node.name # sync name
-    node = secure!(Node) { nodes(:tiger) }
-    assert_equal 'nicePeople/tiger', node[:fullpath]
-  end
-
-  def test_rootpath
-    login(:ant)
-    node = secure!(Node) { nodes(:status) }
-    assert_equal 'zena/projects/cleanWater/status', node.rootpath
-    node = secure!(Node) { nodes(:zena) }
-    assert_equal 'zena', node.rootpath
-  end
-
-  def test_basepath
-    login(:tiger)
-    node = secure!(Node) { nodes(:status) }
-    assert_equal 'projects/cleanWater', node.basepath
-    node = secure!(Node) { nodes(:projects) }
-    assert_equal '', node.basepath
-    node = secure!(Node) { nodes(:proposition) }
-    assert_equal '', node.basepath
-  end
-
   def test_ancestors
     Node.connection.execute "UPDATE nodes SET parent_id = #{nodes_id(:proposition)} WHERE id = #{nodes_id(:bird_jpg)}"
     login(:tiger)
     node = secure!(Node) { nodes(:status) }
-    assert_equal ['zena', 'projects', 'cleanWater'], node.ancestors.map { |a| a[:name] }
+    assert_equal ['zena', 'projects', 'cleanWater'], node.ancestors.map { |a| a[:node_name] }
     node = secure!(Node) { nodes(:zena) }
     assert_equal [], node.ancestors
     node = secure!(Node) { nodes(:bird_jpg) }
     prop = secure!(Node) { nodes(:proposition)}
     assert_kind_of Node, prop
     assert prop.can_read?
-    assert_equal ['zena', 'projects', 'secret', 'proposition'], node.ancestors.map { |a| a[:name] }
+    assert_equal ['zena', 'projects', 'secret', 'proposition'], node.ancestors.map { |a| a[:node_name] }
   end
 
   def test_ancestors_infinit_loop
@@ -152,12 +168,12 @@ class NodeTest < Zena::Unit::TestCase
     login(:tiger)
     node = secure!(Node) { nodes(:proposition) }
     assert_kind_of Node, node
-    assert_equal ['zena', 'projects', 'secret'], node.ancestors.map { |a| a[:name] } # ant can view 'proposition' but not the project proposition is in
+    assert_equal ['zena', 'projects', 'secret'], node.ancestors.map { |a| a[:node_name] } # ant can view 'proposition' but not the project proposition is in
   end
 
   def test_create_simplest
     login(:ant)
-    test_page = secure!(Node) { Node.create(:name=>"yoba", :parent_id => nodes_id(:cleanWater), :inherit=>1 ) }
+    test_page = secure!(Node) { Node.create(:node_name => 'yoba', :parent_id => nodes_id(:cleanWater), :inherit=>1 ) }
     assert ! test_page.new_record? , "Not a new record"
     assert_equal nodes_id(:cleanWater), test_page.parent[:id]
     assert_equal 'projects/cleanWater/yoba', test_page.fullpath
@@ -166,15 +182,6 @@ class NodeTest < Zena::Unit::TestCase
     assert_equal 'projects/cleanWater', parent.fullpath
   end
 
-  def test_cannot_update_v_status
-    login(:ant)
-    test_page = secure!(Node) { nodes(:status) }
-    assert_equal 2, test_page.version.number
-    assert test_page.update_attributes( :v_status => Zena::Status[:pub], :v_title => "New funky title")
-    assert_equal 3, test_page.version.number
-    assert_equal Zena::Status[:red], test_page.version.status
-  end
-
   def test_new_bad_parent
     login(:tiger)
     attrs = NEW_DEFAULT.dup
@@ -208,16 +215,16 @@ class NodeTest < Zena::Unit::TestCase
     assert node.save , "Save succeeds"
   end
 
-  def test_page_new_without_name
+  def test_page_new_without_node_name
     login(:tiger)
-    node = secure!(Node) { Node.new(:parent_id=>nodes_id(:cleanWater)) }
+    node = secure!(Node) { Node.new(:parent_id => nodes_id(:cleanWater)) }
     assert ! node.save, 'Save fails'
-    assert_equal 'can\'t be blank', node.errors[:name]
+    assert_equal 'can\'t be blank', node.errors[:node_name]
   end
 
   def test_new_set_section_id
     login(:tiger)
-    node = secure!(Page) { Page.create(:parent_id=>nodes_id(:people), :name=>'SuperPage')}
+    node = secure!(Page) { Page.create(:parent_id => nodes_id(:people), :node_name => 'SuperPage')}
     assert ! node.new_record?, 'Not a new record'
     assert_equal nodes_id(:people), node[:section_id]
   end
@@ -256,17 +263,17 @@ class NodeTest < Zena::Unit::TestCase
     assert node.save , "Save succeeds"
   end
 
-  def test_page_update_without_name
+  def test_page_update_without_node_name
     login(:tiger)
     node = secure!(Node) { nodes(:status)  }
-    node[:name] = nil
+    node[:node_name] = nil
     assert node.save, 'Save succeeds'
-    assert_equal 'statusTitle', node[:name]
+    assert_equal 'statusTitle', node[:node_name]
     node = secure!(Node) { nodes(:status)  }
-    node[:name] = nil
-    node.version.title = ""
+    node[:node_name] = nil
+    node.title = ""
     assert !node.save, 'Save fails'
-    assert_equal 'can\'t be blank', node.errors[:name]
+    assert_equal 'can\'t be blank', node.errors[:node_name]
   end
 
   def test_update_set_section_id
@@ -280,23 +287,6 @@ class NodeTest < Zena::Unit::TestCase
     assert_equal nodes_id(:zena), node[:section_id]
   end
 
-  def test_before_destroy
-    login(:tiger)
-    node = secure!(Node) { nodes(:projects)  }
-    assert !node.destroy, "Cannot destroy"
-    assert_equal 'cannot be removed (contains subpages or data)', node.errors[:base]
-    node = secure!(Node) { nodes(:bananas)  }
-    assert node.destroy, "Can destroy"
-  end
-
-  def test_cannot_destroy_has_private
-    login(:tiger)
-    node = secure!(Node) { nodes(:lion)  }
-    assert_nil node.find(:all, 'pages'), "No subpages"
-    assert !node.destroy, "Cannot destroy"
-    assert_equal 'cannot be removed (contains subpages or data)', node.errors[:base]
-  end
-
   def test_parent
     login(:anon)
     assert_equal nodes_id(:projects), secure!(Node) { nodes(:wiki) }.parent[:id]
@@ -339,13 +329,13 @@ class NodeTest < Zena::Unit::TestCase
   def test_new_child
     login(:ant)
     node = secure!(Node) { nodes(:cleanWater)  }
-    child = node.new_child( :name => 'status', :class => Page )
+    child = node.new_child(:node_name => 'status', :class => Page )
     assert !child.save, "Save fails"
-    assert child.errors[:name].any?
+    assert child.errors[:node_name].any?
 
-    child = node.new_child( :name => 'new_name', :class => Page )
+    child = node.new_child(:node_name => 'new_name', :class => Page )
     assert child.save , "Save succeeds"
-    assert_equal Zena::Status[:red],  child.version.status
+    assert_equal Zena::Status[:red],  child.v_status
     assert_equal child[:user_id], users_id(:ant)
     assert_equal node[:dgroup_id], child[:dgroup_id]
     assert_equal node[:rgroup_id], child[:rgroup_id]
@@ -374,36 +364,22 @@ class NodeTest < Zena::Unit::TestCase
     assert_equal 'Solenopsis Invicta', node.author.fullname
   end
 
-  def test_ext
-    node = nodes(:status)
-    node[:name] = 'bob. and bob.jpg'
-    assert_equal 'jpg', node.ext
-    node[:name] = 'no ext'
-    assert_equal '', node.ext
-    node[:name] = ''
-    assert_equal '', node.ext
-    node[:name] = nil
-    assert_equal '', node.ext
-  end
-
-  def test_set_name_with_title
+  def test_set_node_name_with_title
     login(:tiger)
-    node = secure!(Node) { Node.create(NEW_DEFAULT.stringify_keys.merge('name' => '', 'v_title' => 'small bed')) }
+    node = secure!(Node) { Node.create(NEW_DEFAULT.stringify_keys.merge('node_name' => '', 'title' => 'small bed')) }
     assert_kind_of Node, node
     assert !node.new_record?
-    assert_equal 'smallBed', node.name
+    assert_equal 'smallBed', node.node_name
   end
 
-  def test_set_name
+  def test_set_node_name
     node = nodes(:wiki)
-    node.name = " J'aime l'aïl en août ! "
-    assert_equal 'JAimeLAilEnAout', node.name
-    assert_equal 'JAimeLAilEnAout', node[:name]
-    node.name = "LIEUX"
-    assert_equal 'LIEUX', node.name
+    node.node_name = " J'aime l'aïl en août ! "
+    assert_equal 'JAimeLAilEnAout', node.node_name
+    node.node_name = "LIEUX"
+    assert_equal 'LIEUX', node.node_name
   end
 
-
   def test_change_project_to_page
     login(:tiger)
     node = secure!(Node) { nodes(:cleanWater)  }
@@ -439,7 +415,7 @@ class NodeTest < Zena::Unit::TestCase
     end
 
     should 'be allowed to change attributes' do
-      assert @node.update_attributes(:name => 'vodou', :event_at => Time.now)
+      assert @node.update_attributes(:node_name => 'vodou', :event_at => Time.now)
     end
 
     should 'not be allowed to set parent' do
@@ -452,79 +428,82 @@ class NodeTest < Zena::Unit::TestCase
   context 'A visitor with drive access' do
     setup do
       login(:tiger)
-      @node = secure!(Node) { nodes(:wiki) }
     end
 
     context 'on a published node with documents' do
 
+      subject do
+        secure!(Node) { nodes(:wiki) }
+      end
+
       should 'see a published node with published documents' do
-        assert_equal Zena::Status[:pub], @node.version.status
+        assert_equal Zena::Status[:pub], subject.v_status
         assert_equal Zena::Status[:pub], versions(:bird_jpg_en).status
         assert_equal Zena::Status[:pub], versions(:flower_jpg_en).status
       end
 
       should 'unpublish documents when unpublishing node' do
-        assert @node.unpublish
+        assert subject.unpublish
         assert_equal Zena::Status[:rem], versions(:bird_jpg_en).status
         assert_equal Zena::Status[:rem], versions(:flower_jpg_en).status
       end
     end
 
     context 'on a removed node with removed documents' do
-      setup do
-        @node.unpublish
-        @node = secure!(Node) { nodes(:wiki) }
-      end
-
-      should 'see a removed node with removed documents' do
-        assert_equal Zena::Status[:rem], @node.version.status
-        assert_equal Zena::Status[:rem], versions(:bird_jpg_en).status
-        assert_equal Zena::Status[:rem], versions(:flower_jpg_en).status
+      subject do
+        node = secure!(Node) { nodes(:wiki) }
+        node.unpublish
+        node.reload
+        node
       end
 
       should 'publish documents when publishing node' do
-        assert @node.publish
+        assert subject.publish
         assert_equal Zena::Status[:pub], versions(:bird_jpg_en).status
         assert_equal Zena::Status[:pub], versions(:flower_jpg_en).status
       end
     end
 
     context 'on a redaction node with documents in redaction status' do
-      setup do
-        @node.unpublish
-        @node.redit
-        @node = secure!(Node) { nodes(:wiki) }
+      subject do
+        node = secure!(Node) { nodes(:wiki) }
+        node.unpublish
+        node.redit
+        node.reload
+        node
       end
 
       should 'see redactions' do
-        assert_equal Zena::Status[:red], @node.version.status
+        assert_equal Zena::Status[:red], subject.v_status
         assert_equal Zena::Status[:red], versions(:bird_jpg_en).status
         assert_equal Zena::Status[:red], versions(:flower_jpg_en).status
       end
 
       should 'propose documents when proposing node' do
-        assert @node.propose
+        assert subject.propose
         assert_equal Zena::Status[:prop_with], versions(:bird_jpg_en).status
         assert_equal Zena::Status[:prop_with], versions(:flower_jpg_en).status
       end
     end
 
     context 'on a proposition with proposed documents' do
-      setup do
-        @node.unpublish
-        @node.redit
-        @node.propose
-        @node = secure!(Node) { nodes(:wiki) }
+      subject do
+        node = secure!(Node) { nodes(:wiki) }
+        node.unpublish
+        node.redit
+        node.propose
+        node.reload
+        node
       end
 
       should 'see propositions' do
-        assert_equal Zena::Status[:prop], @node.version.status
+        assert_equal Zena::Status[:prop], subject.v_status
         assert_equal Zena::Status[:prop_with], versions(:bird_jpg_en).status
         assert_equal Zena::Status[:prop_with], versions(:flower_jpg_en).status
       end
 
       should 'refuse documents when refusing node' do
-        assert @node.refuse
+        assert subject.refuse
         assert_equal Zena::Status[:red], versions(:bird_jpg_en).status
         assert_equal Zena::Status[:red], versions(:flower_jpg_en).status
       end
@@ -614,13 +593,13 @@ class NodeTest < Zena::Unit::TestCase
     assert @node.save
     tags = @node.find(:all, 'set_tags')
     assert_equal 2, tags.size
-    assert_equal 'art', tags[0].name
-    assert_equal 'news', tags[1].name
+    assert_equal 'art', tags[0].node_name
+    assert_equal 'news', tags[1].node_name
     @node.rel['set_tag'].other_ids = [nodes_id(:art)]
     @node.save
     tags = @node.find(:all, 'set_tags')
     assert_equal 1, tags.size
-    assert_equal 'art', tags[0].name
+    assert_equal 'art', tags[0].node_name
   end
 
   def test_tag_update
@@ -647,7 +626,7 @@ class NodeTest < Zena::Unit::TestCase
       # do something on a project
       node = secure!(Node) { nodes(:wiki) }
       assert_equal 'NPP', node.class.kpath
-      assert node.update_attributes(:v_title=>'new title'), "Can change attributes"
+      assert node.update_attributes(:title=>'new title'), "Can change attributes"
       # sweep only kpath NPP
       i = 3
       assert_equal "content 3", Cache.with(visitor.id, visitor.group_ids, 'NP', 'pages')  { "content #{i}" }
@@ -656,7 +635,7 @@ class NodeTest < Zena::Unit::TestCase
       # do something on a note
       node = secure!(Node) { nodes(:proposition) }
       assert_equal 'NNP', node.vclass.kpath
-      assert node.update_attributes(:name => 'popo' ), "Can change attributes"
+      assert node.update_attributes(:node_name => 'popo' ), "Can change attributes"
       # sweep only kpath NN
       i = 4
       assert_equal "content 3", Cache.with(visitor.id, visitor.group_ids, 'NP', 'pages')  { "content #{i}" }
@@ -674,7 +653,7 @@ class NodeTest < Zena::Unit::TestCase
   def test_discussion_lang
     login(:tiger)
     node = secure!(Node) { nodes(:status) }
-    assert_equal Zena::Status[:pub], node.version.status
+    assert_equal Zena::Status[:pub], node.v_status
     discussion = node.discussion
     assert_kind_of Discussion, discussion
     assert_equal discussions_id(:outside_discussion_on_status_en), discussion[:id]
@@ -697,7 +676,7 @@ class NodeTest < Zena::Unit::TestCase
     login(:ant)
     node = secure!(Node) { nodes(:status) }
     assert_nil node.discussion
-    node.update_attributes( :v_title=>'test' )
+    node.update_attributes( :title=>'test' )
     discussion = node.discussion
     assert_kind_of Discussion, discussion
     assert discussion.inside?
@@ -706,20 +685,20 @@ class NodeTest < Zena::Unit::TestCase
   def test_inside_discussion
     login(:tiger)
     node = secure!(Node) { nodes(:status) }
-    node.update_attributes( :v_title=>'new status' )
-    assert_equal Zena::Status[:red], node.version.status
+    node.update_attributes( :title=>'new status' )
+    assert_equal Zena::Status[:red], node.v_status
     discussion = node.discussion
     assert_equal discussions_id(:inside_discussion_on_status), discussion[:id]
   end
 
   def test_auto_create_discussion
     login(:tiger)
-    post   = secure!(Node) { Node.create_node(:v_status => Zena::Status[:pub], :v_title => 'a new post', :class => 'Post', :parent_id => nodes_zip(:cleanWater)) }
-    letter = secure!(Node) { Node.create_node(:v_status => Zena::Status[:pub], :v_title => 'a letter', :class => 'Letter', :parent_id => nodes_zip(:cleanWater)) }
+    post   = secure!(Node) { Node.create_node(:v_status => Zena::Status[:pub], :title => 'a new post', :class => 'Post', :parent_id => nodes_zip(:cleanWater)) }
+    letter = secure!(Node) { Node.create_node(:v_status => Zena::Status[:pub], :title => 'a letter', :class => 'Letter', :parent_id => nodes_zip(:cleanWater)) }
     assert !post.new_record?, "Not a new record"
     assert !letter.new_record?, "Not a new record"
-    assert_equal Zena::Status[:pub], post.version.status, "Published"
-    assert_equal Zena::Status[:pub], letter.version.status, "Published"
+    assert_equal Zena::Status[:pub], post.v_status, "Published"
+    assert_equal Zena::Status[:pub], letter.v_status, "Published"
     assert !letter.discussion
     assert post.discussion
     assert !post.discussion.new_record?
@@ -732,9 +711,9 @@ class NodeTest < Zena::Unit::TestCase
 
   def test_auto_create_discussion
     login(:tiger)
-    letter = secure!(Node) { Node.create_node(:v_status => Zena::Status[:pub], :v_title => 'a letter', :class => 'Letter', :parent_id => nodes_zip(:cleanWater)) }
+    letter = secure!(Node) { Node.create_node(:v_status => Zena::Status[:pub], :title => 'a letter', :class => 'Letter', :parent_id => nodes_zip(:cleanWater)) }
     assert !letter.new_record?, "Not a new record"
-    assert_equal Zena::Status[:pub], letter.version.status, "Published"
+    assert_equal Zena::Status[:pub], letter.v_status, "Published"
     login(:lion)
     letter = secure!(Node) { Node.find(letter.id) }
     assert letter.can_auto_create_discussion?
@@ -768,14 +747,14 @@ class NodeTest < Zena::Unit::TestCase
 
   def test_other_site_id
     login(:whale)
-    node = secure!(Node) { Node.create(:parent_id=>nodes_id(:ocean), :rgroup_id=>groups_id(:aqua), :wgroup_id=>groups_id(:masters), :dgroup_id=>groups_id(:masters), :name=>"fish") }
+    node = secure!(Node) { Node.create(:parent_id => nodes_id(:ocean), :rgroup_id => groups_id(:aqua), :wgroup_id => groups_id(:masters), :dgroup_id => groups_id(:masters), :node_name => "fish") }
     assert !node.new_record?, "Not a new record"
     assert_equal sites_id(:ocean), node[:site_id]
   end
 
   def test_other_site_id_fool_id
     login(:whale)
-    node = secure!(Node) { Node.create(:parent_id=>nodes_id(:ocean), :rgroup_id=>groups_id(:aqua), :wgroup_id=>groups_id(:masters), :dgroup_id=>groups_id(:masters), :name=>"fish", :site_id=>sites_id(:zena)) }
+    node = secure!(Node) { Node.create(:parent_id => nodes_id(:ocean), :rgroup_id => groups_id(:aqua), :wgroup_id => groups_id(:masters), :dgroup_id => groups_id(:masters), :node_name => "fish", :site_id => sites_id(:zena)) }
     assert !node.new_record?, "Not a new record"
     assert_equal sites_id(:ocean), node[:site_id]
   end
@@ -788,10 +767,16 @@ class NodeTest < Zena::Unit::TestCase
     assert_equal original_site_id, node.site_id
   end
 
+  def test_cannot_set_site_id_with_new_record
+    login(:tiger)
+    node = Node.new(:site_id => 1234)
+    assert_nil node.site_id
+  end
+
   def test_zip
-    next_zip = Zena::Db.fetch_row("SELECT zip FROM zips WHERE site_id = #{sites_id(:zena)}").to_i
+    next_zip = Zena::Db.fetch_attribute("SELECT zip FROM zips WHERE site_id = #{sites_id(:zena)}").to_i
     login(:tiger)
-    node = secure!(Node) { Node.create(:parent_id=>nodes_id(:zena), :name=>"fly")}
+    node = secure!(Node) { Node.create(:parent_id=>nodes_id(:zena), :node_name => "fly")}
     assert !node.new_record?, "Not a new record"
     assert_equal (next_zip + 1), node.zip
   end
@@ -812,7 +797,7 @@ class NodeTest < Zena::Unit::TestCase
 
   def test_create_node
     login(:ant)
-    node = secure!(Node) { Node.create_node(:parent_id => nodes_zip(:secret), :name => 'funny') }
+    node = secure!(Node) { Node.create_node(:parent_id => nodes_zip(:secret), :node_name => 'funny') }
     assert_equal nodes_id(:secret), node[:parent_id]
     assert node.new_record?, "Not saved"
     assert_equal 'invalid reference', node.errors[:parent_id]
@@ -820,7 +805,7 @@ class NodeTest < Zena::Unit::TestCase
 
   def test_create_node_with__parent_id
     login(:ant)
-    node = secure!(Node) { Node.create_node(:_parent_id => nodes_id(:secret), :name => 'funny') }
+    node = secure!(Node) { Node.create_node(:_parent_id => nodes_id(:secret), :node_name => 'funny') }
     assert_equal nodes_id(:secret), node[:parent_id]
     assert node.new_record?, "Not saved"
     assert_equal 'invalid reference', node.errors[:parent_id]
@@ -828,36 +813,36 @@ class NodeTest < Zena::Unit::TestCase
 
   def test_create_node_ok
     login(:tiger)
-    node = secure!(Node) { Node.create_node('parent_id' => nodes_zip(:cleanWater), 'name' => 'funny') }
+    node = secure!(Node) { Node.create_node('parent_id' => nodes_zip(:cleanWater), 'node_name' => 'funny') }
     assert_equal nodes_id(:cleanWater), node[:parent_id]
-    assert_equal 'funny', node[:name]
+    assert_equal 'funny', node[:node_name]
     assert !node.new_record?
   end
 
   def test_create_or_update_node_create
     login(:tiger)
-    node = secure!(Node) { Node.create_or_update_node('parent_id' => nodes_zip(:cleanWater), 'name' => 'funny') }
+    node = secure!(Node) { Node.create_or_update_node('parent_id' => nodes_zip(:cleanWater), 'node_name' => 'funny') }
     assert_equal nodes_id(:cleanWater), node[:parent_id]
-    assert_equal 'funny', node[:name]
+    assert_equal 'funny', node[:node_name]
     assert !node.new_record?, "Saved"
   end
 
   def test_create_or_update_node_update
     login(:tiger)
-    node = secure!(Node) { Node.create_or_update_node('parent_id' => nodes_zip(:cleanWater), 'name' => 'status', 'v_title'=>"It's all broken") }
+    node = secure!(Node) { Node.create_or_update_node('parent_id' => nodes_zip(:cleanWater), 'node_name' => 'status', 'title'=>"It's all broken") }
     assert_equal nodes_id(:cleanWater), node[:parent_id]
     assert_equal nodes_id(:status), node[:id]
     node = secure!(Node) { nodes(:status) }
-    assert_equal 'status', node[:name]
-    assert_equal "It's all broken", node.version.title
+    assert_equal 'status', node[:node_name]
+    assert_equal "It's all broken", node.title
   end
 
   def test_create_with_klass
     login(:tiger)
-    node = secure!(Node) { Node.create_node('parent_id' => nodes_zip(:projects), 'name' => 'funny', 'klass' => 'TextDocument', 'c_content_type' => 'application/x-javascript') }
+    node = secure!(Node) { Node.create_node('parent_id' => nodes_zip(:projects), 'node_name' => 'funny', 'klass' => 'TextDocument', 'content_type' => 'application/x-javascript') }
     assert_kind_of TextDocument, node
     assert_equal nodes_id(:projects), node[:parent_id]
-    assert_equal 'funny', node[:name]
+    assert_equal 'funny', node[:node_name]
     assert !node.new_record?, "Saved"
   end
 
@@ -865,7 +850,7 @@ class NodeTest < Zena::Unit::TestCase
     assert_equal Node, Node.get_class('node')
     assert_equal Node, Node.get_class('nodes')
     assert_equal Node, Node.get_class('Node')
-    assert_equal virtual_classes(:Letter), Node.get_class('Letter')
+    assert_equal roles(:Letter), Node.get_class('Letter')
     assert_equal TextDocument, Node.get_class('TextDocument')
   end
 
@@ -893,67 +878,67 @@ done: \"I am done\""
 
   def test_create_nodes_from_gzip_file
     login(:tiger)
-    parent = secure!(Project) { Project.create(:name => 'import', :parent_id => nodes_id(:zena)) }
+    parent = secure!(Project) { Project.create(:node_name => 'import', :parent_id => nodes_id(:zena)) }
     assert !parent.new_record?, "Not a new record"
     nodes = secure!(Node) { Node.create_nodes_from_folder(:archive => uploaded_archive('simple.zml.gz'), :parent_id => parent[:id] )}.values
     assert_equal 1, nodes.size
     simple = nodes[0]
     assert_kind_of Note, simple
-    assert_equal virtual_classes(:Post), simple.vclass
+    assert_equal roles(:Post), simple.vclass
     assert !simple.new_record?
   end
 
   def test_create_nodes_from_folder_with_defaults
     login(:tiger)
-    parent = secure!(Project) { Project.create(:name => 'import', :parent_id => nodes_id(:zena), :rgroup_id => groups_id(:managers), :wgroup_id => groups_id(:managers)) }
+    parent = secure!(Project) { Project.create(:node_name => 'import', :parent_id => nodes_id(:zena), :rgroup_id => groups_id(:managers), :wgroup_id => groups_id(:managers)) }
     assert !parent.new_record?, "Not a new record"
     result = secure!(Node) { Node.create_nodes_from_folder(:folder => File.join(Zena::ROOT, 'test', 'fixtures', 'import'), :parent_id => parent[:id] )}.values
     assert_equal 4, result.size
 
-    children = parent.find(:all, 'children order by name ASC')
+    children = parent.find(:all, 'children order by node_name asc')
     assert_equal 2, children.size
-    assert_equal 'photos', children[0].name
+    assert_equal 'Photos', children[0].node_name
     assert_equal groups_id(:managers), children[0].rgroup_id
-    assert_equal 'simple', children[1].name
+    assert_equal 'simple', children[1].node_name
     assert_equal groups_id(:managers), children[1].rgroup_id
 
     # we use children[1] as parent just to use any empty node
     result = secure!(Node) { Node.create_nodes_from_folder(:folder => File.join(Zena::ROOT, 'test', 'fixtures', 'import'), :parent_id => children[1][:id], :defaults => { :rgroup_id => groups_id(:public) } )}.values
     assert_equal 4, result.size
 
-    children = children[1].find(:all, 'children order by name ASC')
+    children = children[1].find(:all, 'children order by node_name ASC')
     assert_equal 2, children.size
-    assert_equal 'photos', children[0].name
+    assert_equal 'Photos', children[0].node_name
     assert_equal groups_id(:public), children[0].rgroup_id
   end
 
   def test_create_nodes_from_folder_with_publish
     login(:tiger)
     nodes = secure!(Node) { Node.create_nodes_from_folder(:folder => File.join(Zena::ROOT, 'test', 'fixtures', 'import'), :parent_id => nodes_id(:zena) )}.values
-    assert_equal Zena::Status[:red], nodes[0].version.status
+    assert_equal Zena::Status[:red], nodes[0].v_status
 
     nodes = secure!(Node) { Node.create_nodes_from_folder(:folder => File.join(Zena::ROOT, 'test', 'fixtures', 'import'), :parent_id => nodes_id(:cleanWater), :defaults => { :v_status => Zena::Status[:pub] }) }.values
-    assert_equal Zena::Status[:pub], nodes[0].version.status
+    assert_equal Zena::Status[:pub], nodes[0].v_status
   end
 
   def test_create_nodes_from_archive
     login(:tiger)
     res = secure!(Node) { Node.create_nodes_from_folder(:archive => uploaded_archive('import.tgz'), :parent_id => nodes_id(:zena)) }.values
-    photos = secure!(Section) { Section.find_by_name('photos') }
+    photos = secure!(Section) { Section.find_by_node_name('Photos') }
     assert_kind_of Section, photos
-    bird = secure!(Node) { Node.find_by_parent_id_and_name(photos[:id], 'bird') }
+    bird = secure!(Node) { Node.find_by_parent_id_and_node_name(photos[:id], 'bird') }
     assert_kind_of Image, bird
-    assert_equal 56183, bird.version.content.size
-    assert_equal 'Lucy in the sky', bird.version.title
+    assert_equal 56183, bird.size
+    assert_equal 'Lucy in the sky', bird.text
     visitor.lang = 'fr'
-    bird = secure!(Node) { Node.find_by_parent_id_and_name(photos[:id], 'bird') }
-    assert_equal 'Le septième ciel', bird.version.title
+    bird = secure!(Node) { Node.find_by_parent_id_and_node_name(photos[:id], 'bird') }
+    assert_equal 'Le septième ciel', bird.text
     assert_equal 1, bird[:inherit]
     assert_equal groups_id(:public), bird[:rgroup_id]
     assert_equal groups_id(:workers), bird[:wgroup_id]
     assert_equal groups_id(:managers), bird[:dgroup_id]
 
-    simple = secure!(Node) { Node.find_by_parent_id_and_name(nodes_id(:zena), 'simple') }
+    simple = secure!(Node) { Node.find_by_parent_id_and_node_name(nodes_id(:zena), 'simple') }
     assert_equal 0, simple[:inherit]
     assert_equal groups_id(:managers), simple[:rgroup_id]
     assert_equal groups_id(:managers), simple[:wgroup_id]
@@ -963,7 +948,7 @@ done: \"I am done\""
   def test_create_nodes_from_zip_archive
     login(:tiger)
     res = secure!(Node) { Node.create_nodes_from_folder(:archive => uploaded_zip('letter.zip'), :parent_id => nodes_id(:zena), :class => 'Letter') }.values
-    res.sort!{|a,b| a.name <=> b.name}
+    res.sort!{|a,b| a.node_name <=> b.node_name}
     letter, bird = res[1], res[0]
     assert_kind_of Note, letter
     assert_equal 'Letter', letter.klass
@@ -973,17 +958,16 @@ done: \"I am done\""
     preserving_files('test.host/data') do
       bird = node = nil
       login(:tiger)
-      node = secure!(Page) { Page.create(:parent_id => nodes_id(:status), :name=>'photos', :v_title => 'my photos', :v_text => '![]!') }
+      node = secure!(Page) { Page.create(:parent_id => nodes_id(:status), :title => 'Photos', :text => '![]!') }
       assert !node.new_record?
-      assert_nothing_raised { node = secure!(Node) { Node.find_by_path( 'projects/cleanWater/status/photos') } }
-      assert_raise(ActiveRecord::RecordNotFound) { node = secure!(Node) { Node.find_by_path( 'projects/cleanWater/status/photos/bird') } }
-      assert_equal 'photos', node.name
-      assert_no_match %r{I took during my last vacations}, node.version.text
+      assert_nothing_raised { node = secure!(Node) { Node.find_by_path('projects/cleanWater/status/Photos') } }
+      assert_raise(ActiveRecord::RecordNotFound) { node = secure!(Node) { Node.find_by_path( 'projects/cleanWater/status/Photos/bird') } }
+      assert_no_match %r{I took during my last vacations}, node.text
       v1_id = node.version.id
-      secure!(Node) { Node.create_nodes_from_folder(:archive => uploaded_archive('import.tgz'), :parent_id => nodes_id(:status)) }.values
-      assert_nothing_raised { node = secure!(Node) { Node.find_by_path( 'projects/cleanWater/status/photos') } }
-      assert_nothing_raised { bird = secure!(Node) { Node.find_by_path( 'projects/cleanWater/status/photos/bird') } }
-      assert_match %r{I took during my last vacations}, node.version.text
+      secure!(Node) { Node.create_nodes_from_folder(:archive => uploaded_archive('import.tgz'), :parent_id => nodes_id(:status)) }
+      assert_nothing_raised { node = secure!(Node) { Node.find_by_path('projects/cleanWater/status/Photos') } }
+      assert_nothing_raised { bird = secure!(Node) { Node.find_by_path('projects/cleanWater/status/Photos/bird') } }
+      assert_match %r{I took during my last vacations}, node.text
       assert_equal v1_id, node.version.id
       assert_kind_of Image, bird
     end
@@ -995,10 +979,10 @@ done: \"I am done\""
     visitor.time_zone = 'Asia/Jakarta'
     assert_equal 'Asia/Jakarta', visitor.time_zone
     status = secure!(Node) { nodes(:status) }
-    assert status.update_attributes_with_transformation(:v_status => Zena::Status[:pub], :v_text => "This is a \"link\":#{nodes_zip(:projects)}.", :d_foo => "A picture: !#{nodes_zip(:bird_jpg)}!")
+    assert status.update_attributes_with_transformation(:v_status => Zena::Status[:pub], :text => "This is a \"link\":#{nodes_zip(:projects)}.", :origin => "A picture: !#{nodes_zip(:bird_jpg)}!")
     yaml = status.to_yaml
-    assert_match %r{v_text:\s+\"?This is a "link":\(\.\./\.\.\)\.}, yaml
-    assert_match %r{d_foo:\s+\"?A picture: !\(\.\./\.\./wiki/bird\)!}, yaml
+    assert_match %r{text:\s+\"?This is a "link":\(\.\./\.\.\)\.}, yaml
+    assert_match %r{origin:\s+\"?A picture: !\(\.\./\.\./wiki/bird\)!}, yaml
     assert_no_match %r{log_at}, yaml
   end
 
@@ -1006,11 +990,11 @@ done: \"I am done\""
     login(:tiger)
     visitor.time_zone = 'Asia/Jakarta'
     prop = secure!(Node) { nodes(:proposition) }
-    assert prop.update_attributes_with_transformation(:v_status => Zena::Status[:pub], :v_text => "This is a \"link\":#{nodes_zip(:projects)}.", :d_foo => "A picture: !#{nodes_zip(:bird_jpg)}!", :log_at => "2008-10-20 14:53")
+    assert prop.update_attributes_with_transformation(:v_status => Zena::Status[:pub], :text => "This is a \"link\":#{nodes_zip(:projects)}.", :origin => "A picture: !#{nodes_zip(:bird_jpg)}!", :log_at => "2008-10-20 14:53")
     assert_equal Time.gm(2008,10,20,7,53), prop.log_at
     yaml = prop.to_yaml
-    assert_match %r{v_text:\s+\"?This is a "link":\(\.\./\.\.\)\.}, yaml
-    assert_match %r{d_foo:\s+\"?A picture: !\(\.\./\.\./wiki/bird\)!}, yaml
+    assert_match %r{text:\s+\"?This is a "link":\(\.\./\.\.\)\.}, yaml
+    assert_match %r{origin:\s+\"?A picture: !\(\.\./\.\./wiki/bird\)!}, yaml
     assert_match %r{log_at:\s+\"?2008-10-20 14:53:00\"?$}, yaml
   end
 
@@ -1019,15 +1003,15 @@ done: \"I am done\""
     parent = secure!(Node) { nodes(:cleanWater) }
     children = parent.find(:all, 'children')
     assert_equal 8, children.size
-    assert_equal 'bananas', children[0].name
-    assert_equal 'crocodiles', children[1].name
+    assert_equal 'bananas', children[0].node_name
+    assert_equal 'crocodiles', children[1].node_name
 
     Node.connection.execute "UPDATE nodes SET position = -1.0 WHERE id = #{nodes_id(:water_pdf)}"
     Node.connection.execute "UPDATE nodes SET position = -0.5 WHERE id = #{nodes_id(:lake)}"
     children = parent.find(:all, 'children')
     assert_equal 8, children.size
-    assert_equal 'water', children[0].name
-    assert_equal 'lakeAddress', children[1].name
+    assert_equal 'water', children[0].node_name
+    assert_equal 'lakeAddress', children[1].node_name
   end
 
   def test_plural_relation
@@ -1042,17 +1026,6 @@ done: \"I am done\""
     assert Node.plural_relation?('tagged')
   end
 
-  def test_safe_read
-    login(:ant)
-    node   = secure!(Node) {Node.find(:first, :conditions => ['id = ?', nodes_id(:lake)], :select => "*, 'foozibar' AS foobar") }
-    status = secure!(Node) { nodes(:status) }
-    assert_equal 'lakeAddress', node.safe_read('name')
-    assert_equal 'The lake we love', node.safe_read('v_title')
-    assert_equal 'gaspard', status.safe_read('d_assigned')
-    assert_equal 'Between Tanzania, Congo and Zambia', node.safe_read('c_address')
-    assert_equal 'foozibar', node.safe_read('foobar')
-  end
-
   def test_classes_for_form
     assert_equal [["Page", "Page"],
      ["  Project", "Project"],
@@ -1069,18 +1042,18 @@ done: \"I am done\""
 
   def test_allowed_change_to_classes
     node_changes = Node.allowed_change_to_classes.reject{|k| k[/Dummy/]} # In case we are testing after Secure
-    assert_equal ["Node","Note","Letter","Post","Page","Project","Section","Skin","Reference"], node_changes
+    assert_equal %w{Node Note Letter Post Page Project Section Skin Reference}, node_changes
 
     assert_equal node_changes, Page.allowed_change_to_classes.reject{|k| k[/Dummy/]}
     assert_equal node_changes, Project.allowed_change_to_classes.reject{|k| k[/Dummy/]}
     assert_equal node_changes, Note.allowed_change_to_classes.reject{|k| k[/Dummy/]}
     assert_equal node_changes, Reference.allowed_change_to_classes.reject{|k| k[/Dummy/]}
 
-    assert_equal ["Document","TextDocument","Template"], Document.allowed_change_to_classes.reject{|k| k[/Dummy/]}
+    assert_equal %w{Document TextDocument Template}, Document.allowed_change_to_classes.reject{|k| k[/Dummy/]}
 
     assert_equal ["Image"], Image.allowed_change_to_classes.reject{|k| k[/Dummy/]}
 
-    assert_equal ["Contact"], Contact.allowed_change_to_classes.reject{|k| k[/Dummy/]}
+    assert_equal ["BaseContact"], BaseContact.allowed_change_to_classes.reject{|k| k[/Dummy/]}
   end
 
   def test_match_one_node_only
@@ -1109,33 +1082,10 @@ done: \"I am done\""
     assert_equal BigDecimal.new("56"), entries[0].value
   end
 
-  def test_icon_by_relation
-    login(:ant)
-    node = secure!(Node) { nodes(:cleanWater) } # has an 'icon' relation
-    icon = node.icon
-    assert_kind_of Image, icon
-    assert_equal nodes_id(:lake_jpg), icon[:id]
-  end
-
-  def test_icon_by_first_child
-    login(:tiger)
-    node = secure!(Node) { nodes(:wiki) } # has no 'icon' relation
-    icon = node.icon
-    assert_kind_of Image, icon
-    assert_equal nodes_id(:bird_jpg), icon[:id] # first child
-    # define flower as icon
-    assert node.update_attributes(:icon_id => nodes_id(:flower_jpg))
-    node = secure!(Node) { nodes(:wiki) } # reload
-    icon = node.icon
-    assert_kind_of Image, icon
-    assert_equal nodes_id(:flower_jpg), icon[:id] # icon
-  end
-
-
   context 'A class\' native classes hash' do
     should 'be indexed by kpath' do
-      assert_equal ['N', 'ND', 'NDI', 'NDT', 'NDTT', 'NN', 'NP', 'NPP', 'NPS', 'NPSS', 'NR', 'NRC', 'NU', 'NUS'], Node.native_classes.keys.sort
-      assert_equal ['ND', 'NDI', 'NDT', 'NDTT'], Document.native_classes.keys.sort
+      assert_equal [], %w{N ND NDI NDT NDTT NN NP NPP NPS NPSS NR NRC NU NUS} - Node.native_classes.keys
+      assert_equal [], %w{ND NDI NDT NDTT} - Document.native_classes.keys
     end
 
     should 'should point to real (ruby) sub-classes and self' do
@@ -1168,8 +1118,8 @@ done: \"I am done\""
       assert_equal Node, Node.get_class_from_kpath('N')
       assert_equal Page, Node.get_class_from_kpath('NP')
       assert_equal Image, Node.get_class_from_kpath('NDI')
-      assert_equal virtual_classes(:Post), Node.get_class_from_kpath('NNP')
-      assert_equal virtual_classes(:Letter), Node.get_class_from_kpath('NNL')
+      assert_equal roles(:Post), Node.get_class_from_kpath('NNP')
+      assert_equal roles(:Letter), Node.get_class_from_kpath('NNL')
       assert_equal TextDocument, Node.get_class_from_kpath('NDT')
     end
   end
@@ -1177,20 +1127,20 @@ done: \"I am done\""
 
   def test_position_on_create
     login(:lion)
-    node = secure!(Page) { Page.create(:name=>"yoba", :parent_id => nodes_id(:cleanWater), :inherit=>1 ) }
+    node = secure!(Page) { Page.create(:node_name => "yoba", :parent_id => nodes_id(:cleanWater), :inherit=>1 ) }
     assert !node.new_record?
     assert_equal 0.0, node.position
     assert node.update_attributes(:position => 5.0)
     assert_equal 5.0, node.position
     node = secure!(Page) { Page.find_by_id(node.id) } # reload
     assert_equal 5.0, node.position
-    node = secure!(Page) { Page.create(:name=>"babo", :parent_id => nodes_id(:cleanWater), :inherit=>1 ) }
+    node = secure!(Page) { Page.create(:node_name => "babo", :parent_id => nodes_id(:cleanWater), :inherit=>1 ) }
     assert !node.new_record?
     assert_equal 6.0, node.position
 
     # position has different scopes depending on first two letters of kpath: 'ND', 'NN', 'NP', 'NR'
     doc = secure!(Document) { Document.create( :parent_id=>nodes_id(:cleanWater),
-                                              :c_file  => uploaded_fixture('water.pdf', 'application/pdf', 'wat'), :v_title => "lazy waters.pdf") }
+                                              :file  => uploaded_fixture('water.pdf', 'application/pdf', 'wat'), :title => "lazy waters.pdf") }
     assert !doc.new_record?
     assert_equal 0.0, doc.position
 
@@ -1211,24 +1161,6 @@ done: \"I am done\""
     assert_equal 0.0, node.position
   end
 
-  def test_add_comment
-    login(:lion)
-    node = secure!(Node) { nodes(:lion) }
-    assert node.can_comment?
-    assert_nil node.comments
-
-    node = secure!(Node) { nodes(:lion) } # reload
-    assert node.update_attributes(:m_title => 'changed icon', :m_text => 'new icon is "flower"', :icon_id => nodes_id(:flower_jpg))
-
-    node = secure!(Node) { nodes(:lion) } # reload
-    comments = node.comments
-    assert_equal 1, comments.size
-    comment = comments[0]
-    assert_equal 'changed icon', comment[:title]
-    assert_equal 'new icon is "flower"', comment[:text]
-    assert_equal 'Panthera Leo Verneyi', comment.author_name
-  end
-
   def test_custom_a
     login(:lion)
     node = secure!(Node) { nodes(:status) }
@@ -1247,16 +1179,26 @@ done: \"I am done\""
   def test_replace_attributes_in_values
     login(:lion)
     node = secure!(Node) { nodes(:status) }
-    new_attributes = node.replace_attributes_in_values(:foo => "id: [id], v_title: [v_title]")
-    assert_equal "id: 22, v_title: status title", new_attributes[:foo]
+    new_attributes = node.replace_attributes_in_values(:foo => 'id: #{id}, title: #{title}')
+    assert_equal "id: 22, title: status title", new_attributes[:foo]
   end
 
   def test_copy
     login(:lion)
     node = secure!(Node) { nodes(:status) }
-    new_attributes = secure(Node) { Node.transform_attributes(:copy_id => nodes_zip(:bird_jpg), :icon_id => '[id]')}
-    assert_equal Hash['icon_id', nodes_id(:bird_jpg)], new_attributes
-    assert node.update_attributes_with_transformation(:copy_id => nodes_zip(:bird_jpg), :icon_id => '[id]')
+    attributes = {
+      :copy_id => nodes_zip(:bird_jpg),
+      :icon_id => '#{id}',
+      :m_title => 'Changed icon to "#{title}"',
+      :m_text  => 'By #{visitor.login}'
+    }
+
+    new_attributes = secure(Node) { Node.transform_attributes(attributes) }
+    assert_equal Hash['icon_id' => nodes_id(:bird_jpg),
+                      'm_title' => 'Changed icon to "bird"',
+                      'm_text'  => 'By lion'], new_attributes
+
+    assert node.update_attributes_with_transformation(attributes)
     assert_equal nodes_id(:bird_jpg), node.find(:first, 'icon')[:id]
   end
 
@@ -1266,8 +1208,8 @@ done: \"I am done\""
       export_folder = File.join(SITES_ROOT, 'test.host', 'tmp')
       FileUtils::mkpath(export_folder)
       # Add a page and a text document into 'wiki'
-      assert secure!(Node) { Node.create(:v_title=>"Hello World!", :v_text => "Bonjour", :parent_id => nodes_id(:wiki), :inherit=>1 ) }
-      assert secure!(TextDocument) { TextDocument.create(:name=>"yoba", :parent_id => nodes_id(:wiki), :v_text => "#header { color:red; }\n#footer { color:blue; }", :c_content_type => 'text/css') }
+      assert secure!(Node) { Node.create(:title=>"Hello World!", :text => "Bonjour", :parent_id => nodes_id(:wiki), :inherit=>1 ) }
+      assert secure!(TextDocument) { TextDocument.create(:node_name => "yoba", :parent_id => nodes_id(:wiki), :text => "#header { color:red; }\n#footer { color:blue; }", :content_type => 'text/css') }
       wiki = secure!(Node) { nodes(:wiki) }
       assert_equal 4, wiki.find(:all, "children").size
       wiki.export_to_folder(export_folder)
@@ -1289,8 +1231,8 @@ done: \"I am done\""
       export_folder = File.join(SITES_ROOT, 'test.host', 'tmp')
       FileUtils::mkpath(export_folder)
       # Add a page and a text document into 'wiki'
-      assert secure!(Node) { Node.create(:v_title=>"Hello World!", :v_text => "Bonjour", :parent_id => nodes_id(:wiki), :inherit=>1 ) }
-      assert secure!(TextDocument) { TextDocument.create(:name=>"yoba", :parent_id => nodes_id(:wiki), :v_text => "#header { color:red; }\n#footer { color:blue; }", :c_content_type => 'text/css') }
+      assert secure!(Node) { Node.create(:title=>"Hello World!", :text => "Bonjour", :parent_id => nodes_id(:wiki), :inherit=>1 ) }
+      assert secure!(TextDocument) { TextDocument.create(:node_name => "yoba", :parent_id => nodes_id(:wiki), :text => "#header { color:red; }\n#footer { color:blue; }", :content_type => 'text/css') }
       wiki = secure!(Node) { nodes(:wiki) }
       assert_equal 4, wiki.find(:all, "children").size
       archive = wiki.archive
@@ -1322,7 +1264,7 @@ done: \"I am done\""
     lion       = secure!(Node) { nodes(:lion) }
     people     = secure!(Node) { nodes(:people) }
     cleanWater = secure!(Node) { nodes(:cleanWater) }
-    assert lion.update_attributes(:name => 'status')
+    assert lion.update_attributes(:title => 'status', :v_status => Zena::Status[:pub])
     assert_equal 'people/status', lion.fullpath
        # path                           base_node
     { ['(/projects/cleanWater/status)', nil]  => nodes_id(:status),
@@ -1337,201 +1279,172 @@ done: \"I am done\""
   def test_unparse_assets
     login(:lion)
     @node = secure!(Node) { nodes(:status) }
-    assert @node.update_attributes(:v_text => "Hello this is \"art\":#{nodes_zip(:art)}. !#{nodes_zip(:bird_jpg)}!")
-    assert_equal "Hello this is \"art\":(../../../collections/art). !(../../wiki/bird)!", @node.unparse_assets(@node.version.text, self, 'v_text')
+    assert @node.update_attributes(:text => "Hello this is \"art\":#{nodes_zip(:art)}. !#{nodes_zip(:bird_jpg)}!")
+    assert_equal "Hello this is \"art\":(../../../collections/art). !(../../wiki/bird)!", @node.unparse_assets(@node.text, self, 'text')
   end
 
   def test_parse_assets
     login(:lion)
     @node = secure!(Node) { nodes(:status) }
-    assert @node.update_attributes(:v_text => "Hello this is \"art\":(../../../collections/art).")
-    assert_equal "Hello this is \"art\":#{nodes_zip(:art)}.", @node.parse_assets(@node.version.text, self, 'v_text')
+    assert @node.update_attributes(:text => "Hello this is \"art\":(../../../collections/art).")
+    assert_equal "Hello this is \"art\":#{nodes_zip(:art)}.", @node.parse_assets(@node.text, self, 'text')
   end
 
   context 'Finding safe method type' do
     context 'for safe methods in class' do
       should 'return method name' do
-        ['m_text', 'inherit', 'l_status', 'l_comment', 'm_text', 'inherit'].each do |k|
-          assert_equal k, Contact.safe_method_type([k])[:method]
+        ['m_text', 'inherit', 'l_status', 'l_comment', 'm_text', 'inherit', 'v_status'].each do |k|
+          assert_equal k, BaseContact.safe_method_type([k])[:method]
         end
       end
     end
 
     context 'for methods not declared as safe in the class' do
       should 'return nil' do
-        ['puts', 'raise', 'blah', 'system', 'id'].each do |k|
-          assert_nil Contact.safe_method_type([k])
+        ['puts', 'raise', 'blah', 'system'].each do |k|
+          assert_nil BaseContact.safe_method_type([k])
         end
       end
     end
 
+    context 'for id' do
+      should 'return zip' do
+        assert_equal Hash[:class=>Number, :method=>'zip'], BaseContact.safe_method_type(['id'])
+      end
+    end
+
     context 'for relation pseudo-methods' do
       should 'use rel and try' do
         ['hot_status', 'blah_comment', 'blah_zips', 'blah_id', 'blah_ids'].each do |k|
-          assert_match %r{rel\[.#{k.gsub(/_.+/,'')}.\]\.try}, Contact.safe_method_type([k])[:method]
+          assert_match %r{rel\[.#{k.gsub(/_.+/,'')}.\]\.try}, BaseContact.safe_method_type([k])[:method]
         end
       end
     end
 
-    context 'for safe methods in version using nested alias' do
+    context 'for safe properties' do
       should 'return version and method name when safe' do
-        ['v_status', 'v_title'].each do |k|
-          assert_equal "version.#{k[2..-1]}", Contact.safe_method_type([k])[:method]
+        ['text', 'title', 'first_name', 'name'].each do |k|
+          assert_equal "prop['#{k}']", BaseContact.safe_method_type([k])[:method]
         end
       end
 
-      should 'return version and safe_read when unsafe' do
-        ['v_foo'].each do |k|
-          assert_equal "version.safe_read(\"#{k[2..-1]}\")", Contact.safe_method_type([k])[:method]
+      should 'return nil when unsafe' do
+        ['first_name', 'name'].each do |k|
+          assert_nil Node.safe_method_type([k])
         end
       end
     end
+  end
 
-    context 'for dynattributes using nested alias' do
-      should 'return dyn access' do
-        ['d_something', 'd_foo'].each do |k|
-          assert_equal "version.dyn[\"#{k[2..-1]}\"]", Contact.safe_method_type([k])[:method]
-        end
-      end
+  # FIXME: write test
+  def test_assets
+    print 'P'
+    # sweep_cache (save) => remove asset folder
+    # render math ?
+  end
+
+  def find_node_by_pseudo(string, base_node = nil)
+    secure(Node) { Node.find_node_by_pseudo(string, base_node || @node) }
+  end
+
+  def assert_transforms(result, src)
+    if src.kind_of?(Hash)
+      assert_equal result, secure(Node) { Node.transform_attributes( src ) }
+    else
+      assert_equal result, secure(Node) { Node.transform_attributes( 'text' => src )['text'] }
     end
+  end
 
-    context 'for methods in content using nested alias' do
-      should 'use safe_content_read when method not declared' do
-        ['c_first_name', 'c_name', 'c_system'].each do |k|
-          assert_equal "version.safe_content_read(\"#{k[2..-1]}\")", Node.safe_method_type([k])[:method]
-        end
+  context 'Transforming attributes' do
+    context 'with non-ISO date format' do
+      setup do
+        I18n.locale = 'fr'
+        visitor.time_zone = 'Asia/Jakarta'
       end
 
-      should 'use method name when safe' do
-        ['c_first_name', 'c_name'].each do |k|
-          assert_equal "version.content.#{k[2..-1]}", Contact.safe_method_type([k])[:method]
-        end
+      subject do
+        '9-9-2009 15:17'
+      end
+
+      should 'parse event_at date' do
+        assert_transforms Hash['event_at' => Time.utc(2009,9,9,8,17)], Hash['event_at' => '9-9-2009 15:17']
       end
-    end
-  end
 
-  def test_safe_
-    ['c_file', 'c_blah', 'c_system'].each do |k|
-      assert_match %r{safe_content_read\(.#{k.gsub(/^.+_/,'')}.\)}, Contact.safe_method_type([k])[:method], "#{k} should use safe_read"
+      should 'parse log_at date' do
+        assert_transforms Hash['log_at' => Time.utc(2009,9,9,8,17)], Hash['log_at' => '9-9-2009 15:17']
+      end
     end
 
+    context 'with zazen content' do
+      setup do
+        login(:lion)
+      end
 
-    ['c_file'].each do |k|
-      assert Image.safe_method_type([k]), "#{k} should be safe"
-    end
-  end
+      should 'parse pseudo ids' do
+        assert_transforms "Hi, this is just a simple \"test\":25 or \"\":29_life.rss. OK ?\n\n!24_pv!",
+                          "Hi, this is just a simple \"test\"::w or \"\"::w+_life.rss. OK ?\n\n!:lake+_pv!"
+      end
 
-  def test_sync_name_on_v_title_change_no_sync
-    login(:tiger)
-    # We do not care anymore if the node was not in sync
-    node = secure!(Node) { nodes(:status) }
-    assert node.update_attributes(:v_title => 'simply different')
-    assert node.publish
-    assert_equal 'simplyDifferent', node.name
-    visitor.lang = 'fr'
-    # not ref lang
-    node = secure!(Node) { nodes(:people) }
-    assert node.update_attributes(:v_title => 'nice people')
-    assert node.publish
-    assert_equal 'fr', node.version.lang
-    assert_equal 'people', node.name
-  end
+      should 'parse pseudo ids with offset in gallery' do
+        assert_transforms "Hi ![30,24]! ![]!",
+                          "Hi ![30,:lake+]! ![]!"
+      end
 
-  def test_sync_name_on_v_title_change
-    login(:tiger)
-    # was in sync, correct lang
-    node = secure!(Node) { nodes(:people) }
-    assert node.update_attributes(:v_title => 'nice people')
-    assert_equal 'people', node.name
-    assert_equal Zena::Status[:red], node.version.status
-    assert node.publish
-    assert_equal 'nicePeople', node.name
-  end
+      should 'parse pseudo ids in doc_list' do
+        assert_transforms "Hi !{30,24}! !{}!",
+                          "Hi !{:bird,:lake+}! !{}!"
 
-  def test_sync_name_should_result_on_duplicates
-    login(:tiger)
-    # was in sync, correct lang
-    people = secure!(Node) { nodes(:people) }
-    node = secure!(Page) { Page.create(:v_title => 'nice people', :parent_id => people.parent_id)}
-    assert !node.new_record?
-    assert_equal 'nicePeople', node.name
-    # would sync to 'nicePeople'
-    assert people.update_attributes(:v_title => 'nice people')
-    assert_equal 'people', people.name
-    assert people.publish
-    assert_equal 'nicePeople-1', people.name
-  end
+      end
 
-  def test_sync_name_before_publish_if_single_version
-    login(:ant)
-    node = secure!(Node) { Node.create(:v_title => 'Eve', :parent_id => nodes_id(:people)) }
-    assert_equal Zena::Status[:red], node.version.status
-    assert_equal 'Eve', node.name
-    node.update_attributes(:v_title => 'Lilith')
-    assert_equal Zena::Status[:red], node.version.status
-    assert_equal 'Lilith', node.name
-  end
+      should 'parse pseudo ids in links' do
+        assert_transforms "Hi !30!:21 !30!:21 !30/nice bird!:21 !30_pv/hello ladies!:21",
+                          "Hi !30!::clean !:bird!::clean !:bird/nice bird!:21 !30_pv/hello ladies!:21"
+      end
 
-  def test_sync_name_on_v_title_change_auto_pub_no_sync
-    Site.connection.execute "UPDATE sites set auto_publish = 1, redit_time = 3600 WHERE id = #{sites_id(:zena)}"
-    Version.connection.execute "UPDATE versions set updated_at = '#{Time.now.strftime('%Y-%m-%d %H:%M:%S')}' WHERE node_id IN (#{nodes_id(:status)},#{nodes_id(:people)})"
-    login(:tiger)
+      should 'not alter existing code without pseudo ids' do
+        assert_transforms "Hi, this is normal "":1/ just a\n\n* asf\n* asdf ![23,33]!",
+                          "Hi, this is normal "":1/ just a\n\n* asf\n* asdf ![23,33]!"
+      end
+    end # with zazen content
 
-    node = secure!(Node) { nodes(:status) }
-    assert node.update_attributes(:v_title => 'simply different')
-    assert_equal 'simplyDifferent', node.name
-    visitor.lang = 'fr'
-    # not ref lang
-    node = secure!(Node) { nodes(:people) }
-    assert node.update_attributes(:v_title => 'nice people')
-    assert_equal 'fr', node.version.lang
-    assert_equal 'people', node.name
-  end
+    context 'with ids' do
+      setup do
+        login(:tiger)
+      end
 
-  def test_sync_name_on_v_title_change_auto_pub
-    test_site('zena')
-    Site.connection.execute "UPDATE sites set auto_publish = 1, redit_time = 3600 WHERE id = #{sites_id(:zena)}"
-    Version.connection.execute "UPDATE versions set updated_at = '#{Time.now.strftime('%Y-%m-%d %H:%M:%S')}' WHERE node_id IN (#{nodes_id(:people)})"
-    login(:tiger)
-    node = secure!(Node) { nodes(:people) }
-    # was in sync, correct lang
-    assert_equal node.name, node.version.title
-    assert node.update_attributes(:v_title => 'nice people')
-    node = secure!(Node) { nodes(:people) }
-    assert_equal 'nice people', node.version.title
-    assert_equal 'nicePeople', node.name
-  end
+      should 'parse pseudo_ids in parent_id' do
+        assert_transforms Hash['parent_id' => nodes_id(:lake_jpg)],
+                          Hash['parent_id' => 'lake+']
+      end
 
-  # FIXME: write test
-  def test_assets
-    print 'P'
-    # sweep_cache (save) => remove asset folder
-    # render math ?
-  end
+      should 'parse pseudo_ids in links' do
+        assert_transforms Hash['tag_ids' => [nodes_id(:art), nodes_id(:news)]],
+                          Hash['tag_ids' => '33,news']
+      end
 
-  def find_node_by_pseudo(string, base_node = nil)
-    secure(Node) { Node.find_node_by_pseudo(string, base_node || @node) }
-  end
+      should 'leave single bad ids' do
+        assert_transforms Hash['parent_id' => '999', 'hot_id' => '999'],
+                          Hash['parent_id' => '999', 'hot_id' => '999']
+      end
 
-  def test_should_parse_event_at_date
-    I18n.locale = 'fr'
-    visitor.time_zone = 'Asia/Jakarta'
-    v = secure(Node) {Node.new('event_at' => '9-9-2009 15:17')}
-    assert_equal Time.utc(2009,9,9,8,17), v.event_at
-  end
+      should 'remove bad values from id lists' do
+        assert_transforms Hash['tag_ids' => [nodes_id(:news),nodes_id(:art)]],
+                          Hash['tag_ids' => '999,34,art']
+      end
 
-  def test_should_parse_log_at_date
-    I18n.locale = 'fr'
-    visitor.time_zone = 'Asia/Jakarta'
-    v = secure(Node) {Node.new('log_at' => '9-9-2009 15:17')}
-    assert_equal Time.utc(2009,9,9,8,17), v.log_at
-  end
+      should 'parse dates and ids in rel' do
+        # this should be 14:58 when #255 is fixed (tz support).
+        assert_transforms Hash['link' => {'hot' => {'other_id' => nodes_id(:status), 'date' => Time.gm(2009,7,15,16,58)}}],
+                          Hash['link' => {'hot' => {'other_id' => '22', 'date' => '2009-7-15 16:58' }}]
+      end
+    end # with ids
+  end # Transforming attributes
 
   def test_parse_keys
     node = secure(Node) { nodes(:status) }
-    assert_equal ['d_assigned', 'v_text', 'v_title', 'v_summary', 'd_problems', 'd_archive'], node.parse_keys
+    assert_equal %w{archive problems summary text title}, node.parse_keys.sort
 
     note = secure(Node) { nodes(:opening) }
-    assert_equal ['v_text', 'v_title', 'v_summary'], note.parse_keys
+    assert_equal %w{text title}, note.parse_keys.sort
   end
 end