zena 1.0.0.beta3 → 1.0.0.rc1

data/test/unit/remote_test.rb

@@ -29,7 +29,7 @@ class RemoteTest < Zena::Integration::TestCase
             assert_equal 'Banana', remote.title
           end
         end
-        
+
         should 'respond to new' do
           node = subject.new(:title => 'Banana', :parent_id => nodes_zip(:cleanWater))
           assert_difference('Node.count', 1) do
@@ -47,7 +47,7 @@ class RemoteTest < Zena::Integration::TestCase
         end
 
         should 'find with all' do
-          assert_equal ["Art", "Top menu", "News list"], subject.all.map(&:title)
+          assert_equal ["Art", "News list", "Top menu"], subject.all.map(&:title)
         end
 
         should 'find with filters' do
@@ -82,6 +82,12 @@ class RemoteTest < Zena::Integration::TestCase
             subject
           end
         end
+        
+        should 'return node zip as id' do
+          subject
+          last = Node.find(:first, :order => 'id desc')
+          assert_equal last.zip, subject.id
+        end
 
         should 'use attributes to create node' do
           node = remote_node(subject.id)
@@ -223,7 +229,7 @@ class RemoteTest < Zena::Integration::TestCase
 
     context 'paginating results' do
       subject do
-        @app.all('pages order by node_name asc', :page => 2, :per_page => 3)
+        @app.all('pages order by title asc', :page => 2, :per_page => 3)
       end
 
       should 'paginate' do
@@ -250,18 +256,18 @@ class RemoteTest < Zena::Integration::TestCase
 
       should 'map missing attributes as first queries' do
         assert_equal 'Clean Water project', subject.icon_for.title
-        assert_equal ["Nice Bananas", "crocodiles", "status title", "Keeping things clean !"], subject.project.pages.map(&:title)
+        assert_equal ["crocodiles", "Keeping things clean !", "Nice Bananas", "status title"], subject.project.pages.map(&:title)
       end
 
       should 'map missing attributes as queries' do
-        assert_equal "Nice Bananas", subject.project.page.title
-        assert_equal ["Nice Bananas",
-         "crocodiles",
+        assert_equal "crocodiles", subject.project.page.title
+        assert_equal ["crocodiles",
          "it's a lake",
+         "Keeping things clean !",
          "The lake we love",
+         "Nice Bananas",
          "parc opening",
          "status title",
-         "Keeping things clean !",
          "water"], subject.parent.nodes.map(&:title)
       end
     end # and a found remote node
@@ -298,7 +304,7 @@ class RemoteTest < Zena::Integration::TestCase
             subject.save
           end
 
-          assert_equal subject.id, tag.first("tagged where title = 'lion'").id
+          assert_equal subject.id, tag.first("tagged where title = 'Panthera Leo Verneyi'").id
         end
       end # with a new relation
 

data/test/unit/role_test.rb

@@ -117,6 +117,15 @@ class RoleTest < Zena::Unit::TestCase
       end
     end # with an admin visitor
   end # Creating a new Role
+  
+  context 'with a role' do
+    subject do
+      roles(:Original)
+    end
 
+    should 'return all defined safe columns' do
+      assert_equal %w{origin tz weight}, subject.defined_safe_columns.map(&:name)
+    end
+  end # with a virtual class
   # Indexed columns in role tested in NodeTest
 end

data/test/unit/site_test.rb

@@ -4,25 +4,33 @@ class SiteTest < Zena::Unit::TestCase
 
   context 'on site creation' do
     setup do
-      @site = Site.create_for_host('super.host', 'secret')
+      Thread.current[:visitor] = nil
     end
 
-    should 'populate super user' do
-      assert_equal "Super User", @site.su.fullname
-      assert_not_equal users(:su), @site.su[:id]
+    subject do
+      Site.create_for_host('super.host', 'secret')
     end
 
-    should 'populate anonymous user' do
-      assert_equal "Anonymous User", @site.anon.fullname
-      assert_not_equal users(:anon), @site.anon[:id]
-    end
+    should 'create valid site' do
+      # should populate site
+      assert_difference('Node.count', 18) do
+        subject
+      end
 
-    should 'populate 2 admin users' do
-      assert_equal 2, @site.admin_user_ids.size
-    end
+      # should create anon user
+      assert_nil subject.anon.login
+
+      assert_equal 'Anonymous User', subject.anon.node.title
+
+      # should create an admin user
+      assert_equal 1, subject.admin_user_ids.size
 
-    should 'return a new project as root node' do
-      assert_kind_of Project, @site.root_node
+      admin = secure(User) { User.find(:first, :conditions => "status >= #{User::Status[:admin]}") }
+
+      assert_equal 'Admin User', admin.node.title
+
+      # should return a new project as root node
+      assert_kind_of Project, subject.root_node
     end
   end
 
@@ -103,7 +111,7 @@ class SiteTest < Zena::Unit::TestCase
     anon = site.anon
     assert_kind_of User, anon
     assert anon.is_anon?
-    assert_equal 'Anonymous', anon.first_name
+    assert_equal 'Mr nobody', anon.node.title
     assert_equal users_id(:anon), anon[:id]
     anon.site = site
     assert anon.is_anon?
@@ -111,51 +119,34 @@ class SiteTest < Zena::Unit::TestCase
     login(:incognito)
     site = sites(:ocean)
     anon = site.anon
-    assert_equal 'Miss', anon.first_name
+    assert_equal 'Miss incognito', anon.node.title
     assert_equal users_id(:incognito), anon[:id]
     anon.site = site
     assert anon.is_anon?
   end
 
-  def test_su
-    login(:anon)
-    site = sites(:zena)
-    su = site.su
-    assert_kind_of User, su
-    assert_equal 'Super', su.first_name
-    assert_equal users_id(:su), su[:id]
-    su.site = site
-    assert su.is_su?
-
-    login(:incognito)
-    site = sites(:ocean)
-    su = site.su
-    assert_kind_of User, su
-    assert_equal 'Hyper', su.first_name
-    assert_equal users_id(:ocean_su), su[:id]
-    su.site = site
-    assert su.is_su?
-  end
-
   def test_public_group
+    login(:anon)
     site = sites(:zena)
     grp = site.public_group
     assert_kind_of Group, grp
     assert_equal groups_id(:public), grp[:id]
 
+    login(:incognito)
     site = sites(:ocean)
-    $_test_site = 'ocean'
     grp = site.public_group
     assert_kind_of Group, grp
     assert_equal groups_id(:public), grp[:id]
   end
 
   def test_site_group
+    login(:anon)
     site = sites(:zena)
     grp = site.site_group
     assert_kind_of Group, grp
     assert_equal groups_id(:workers), grp[:id]
-    $_test_site = 'ocean'
+
+    login(:incognito)
     site = sites(:ocean)
     grp = site.site_group
     assert_kind_of Group, grp
@@ -236,19 +227,19 @@ class SiteTest < Zena::Unit::TestCase
     opening = secure(Node) { nodes(:opening) }
     cleanWater = secure(Node) { nodes(:cleanWater) }
     art = secure(Node) { nodes(:art) }
-    assert_equal 'projects/cleanWater/status', status.fullpath
-    assert_equal 'projects/cleanWater', status.basepath
+    assert_equal fullpath(:projects, :cleanWater, :status), status.fullpath
+    assert_equal fullpath(:projects, :cleanWater), status.basepath
     assert_equal false, status.custom_base
 
-    assert_equal 'projects/cleanWater/opening', opening.fullpath
-    assert_equal 'projects/cleanWater', opening.basepath
+    assert_equal fullpath(:projects, :cleanWater, :opening), opening.fullpath
+    assert_equal fullpath(:projects, :cleanWater), opening.basepath
     assert_equal false, opening.custom_base
 
-    assert_equal 'projects/cleanWater', cleanWater.fullpath
-    assert_equal 'projects/cleanWater', cleanWater.basepath
+    assert_equal fullpath(:projects, :cleanWater), cleanWater.fullpath
+    assert_equal fullpath(:projects, :cleanWater), cleanWater.basepath
     assert_equal true, cleanWater.custom_base
 
-    assert_equal 'collections/art', art.fullpath
+    assert_equal fullpath(:collections, :art), art.fullpath
     assert_equal '', art.basepath
     assert_equal false, art.custom_base
   end
@@ -264,10 +255,10 @@ class SiteTest < Zena::Unit::TestCase
 
     should 'not alter fullpath' do
       node = secure!(Node) { nodes(:status) }
-      assert_equal 'projects/cleanWater/status', node.fullpath
+      assert_equal fullpath(:projects, :cleanWater, :status), node.fullpath
       subject.clear_cache
       node = secure!(Node) { nodes(:status) }
-      assert_equal 'projects/cleanWater/status', node.fullpath
+      assert_equal fullpath(:projects, :cleanWater, :status), node.fullpath
     end
   end
 
@@ -288,7 +279,12 @@ class SiteTest < Zena::Unit::TestCase
     end
 
     should 'rebuild visible entries for all objects' do
-      assert_difference('IdxNodesMlString.count', subject.lang_list.count * Node.count(:conditions => {:site_id => subject.id})) do
+      assert_difference('IdxNodesMlString.count',
+        # title index on all nodes
+        subject.lang_list.count * Node.count(:conditions => {:site_id => subject.id}) +
+        # search index on Letter nodes
+        subject.lang_list.count * Node.count(:conditions => ['site_id = ? AND kpath like ?', subject.id, 'NNL%'])
+        ) do
         subject.rebuild_index
       end
     end
@@ -303,4 +299,10 @@ class SiteTest < Zena::Unit::TestCase
         'en'=>'status title'], ml_indices
     end
   end
+
+
+  private
+    def fullpath(*args)
+      args.map {|sym| nodes_zip(sym).to_s}.join('/')
+    end
 end

data/test/unit/skin_test.rb

@@ -1,5 +1,21 @@
 require 'test_helper'
 
 class SkinTest < Zena::Unit::TestCase
+  context 'With a writer' do
+    setup do
+      login(:tiger)
+    end
+
+    context 'creating new objects' do
+      subject do
+        secure(Page) { Page.create(:parent_id => nodes_id(:zena), :title => 'snow') }
+      end
+
+      should 'inherit skin_id' do
+        assert_equal nodes_id(:default), subject.skin_id
+      end
+    end # creating new objects
+
+  end # With a writer
 
 end

data/test/unit/template_test.rb

@@ -21,8 +21,8 @@ class TemplateTest < Zena::Unit::TestCase
       assert_equal 'Project', subject.target_klass
     end
 
-    should 'remove extension from node_name' do
-      assert_equal 'Project-collab-xml', subject.node_name
+    should 'remove extension from title' do
+      assert_equal 'Project-collab-xml', subject.title
     end
 
     should 'set extension to zafu' do
@@ -53,9 +53,9 @@ class TemplateTest < Zena::Unit::TestCase
 
     context 'creating a template' do
 
-      context 'with a capitalized node_name' do
+      context 'with a capitalized title' do
         subject do
-          secure(Template) { Template.create(:parent_id => nodes_id(:default), :node_name => 'Project.zafu') }
+          secure(Template) { Template.create(:parent_id => nodes_id(:default), :title => 'Project.zafu') }
         end
 
         should 'create a new Template' do
@@ -70,7 +70,7 @@ class TemplateTest < Zena::Unit::TestCase
           end
         end
 
-        should 'use node_name as target class' do
+        should 'use title as target class' do
           assert_equal 'Project', subject.target_klass
         end
 
@@ -85,7 +85,7 @@ class TemplateTest < Zena::Unit::TestCase
 
       context 'with minimal arguments' do
         subject do
-          secure(Document) { Document.create(:parent_id => nodes_id(:default), :node_name => 'foo.zafu') }
+          secure(Document) { Document.create(:parent_id => nodes_id(:default), :title => 'foo.zafu') }
         end
 
         should 'create a new Template' do
@@ -105,15 +105,14 @@ class TemplateTest < Zena::Unit::TestCase
           assert_equal 'text/zafu', subject.content_type
         end
 
-        should 'remove extension from node_name' do
+        should 'remove extension from title' do
           assert_equal 'foo', subject.title
-          assert_equal 'foo', subject.node_name
         end
       end
 
       context 'with a blank mode' do
         subject do
-          secure(Document) { Document.create(:parent_id => nodes_id(:default), :node_name => 'super.zafu', :mode => '') }
+          secure(Document) { Document.create(:parent_id => nodes_id(:default), :title => 'super.zafu', :mode => '') }
         end
 
         should 'not complain' do
@@ -122,43 +121,35 @@ class TemplateTest < Zena::Unit::TestCase
         end
       end # with a blank mode
 
-      context 'with a blank node_name' do
+      context 'with a blank title' do
         subject do
           secure(Template) { Template.create(:parent_id=>nodes_id(:default), :target_klass => 'Section') }
         end
 
-        should 'use target_klass as node_name' do
+        should 'use target_klass as title' do
           assert !subject.new_record?
-          assert_equal 'Section', subject.node_name
+          assert_equal 'Section', subject.title
         end
-      end # with a blank node_name
+      end # with a blank title
 
       context 'with a format' do
         subject do
-          secure(Template) { Template.create(:parent_id=>nodes_id(:default), :node_name => 'Node-tree', :format => 'xml') }
+          secure(Template) { Template.create(:parent_id=>nodes_id(:default), :title => 'Node-tree', :format => 'xml') }
         end
 
-        should 'use format in node_name' do
+        should 'use format in title' do
           assert !subject.new_record?
-          assert_equal 'Node-tree-xml', subject.node_name
+          assert_equal 'Node-tree-xml', subject.title
         end
-      end # with a blank node_name
+      end # with a blank title
 
       context 'with class format and mode in title' do
         subject do
           secure!(Document) { Document.create(:parent_id => nodes_id(:default), :title => 'Project-collab-xml.zafu')}
-        end # with class format and mode in title
-
-        should_set_target_class_mode_and_format
-      end
-
-      context 'with class format and mode in node_name' do
-        subject do
-          secure!(Document) { Document.create(:parent_id => nodes_id(:default), :node_name => 'Project-collab-xml.zafu')}
         end
 
         should_set_target_class_mode_and_format
-      end # with class format and mode in node_name
+      end # with class format and mode in title
 
       context 'with a file' do
         subject do
@@ -173,14 +164,14 @@ class TemplateTest < Zena::Unit::TestCase
           assert_kind_of Template, subject
         end
 
-        should 'use title for node_name' do
-          assert_equal 'skiny', subject.node_name
+        should 'use title for title' do
+          assert_equal 'skiny', subject.title
         end
       end # with a file
 
       context 'with an html extension' do
         subject do
-          secure!(Document) { Document.create(:parent_id => nodes_id(:default), :node_name => 'sub.html')}
+          secure!(Document) { Document.create(:parent_id => nodes_id(:default), :title => 'sub.html')}
         end
 
         should 'create a Template' do
@@ -191,7 +182,7 @@ class TemplateTest < Zena::Unit::TestCase
 
       context 'not in a Skin section' do
         subject do
-          secure!(Document) { Document.create(:parent_id => nodes_id(:cleanWater), :node_name => 'super.zafu')}
+          secure!(Document) { Document.create(:parent_id => nodes_id(:cleanWater), :title => 'super.zafu')}
         end
 
         should 'return an error on parent' do
@@ -282,92 +273,92 @@ class TemplateTest < Zena::Unit::TestCase
   end # A visitor with drive access
 
 
-  def test_set_by_node_name_without_mode
+  def test_set_by_title_without_mode
     login(:tiger)
-    doc = secure!(Document) { Document.create(:parent_id=>nodes_id(:default), :node_name => 'Project--xml.zafu')}
+    doc = secure!(Document) { Document.create(:parent_id=>nodes_id(:default), :title => 'Project--xml.zafu')}
     assert_kind_of Template, doc
     assert !doc.new_record?, "Saved"
     assert_nil doc.mode
     assert_equal 'xml', doc.format
     assert_equal 'NPP', doc.tkpath
     assert_equal 'Project', doc.target_klass
-    assert_equal 'Project--xml', doc.node_name
+    assert_equal 'Project--xml', doc.title
   end
 
 
-  def test_set_blank_node_name
+  def test_set_blank_title
     login(:tiger)
-    doc = secure!(Template) { Template.create(:parent_id=>nodes_id(:default), 'mode' => 'collab', 'target_klass' => 'Page', 'node_name' => '', 'format' => '')}
+    doc = secure!(Template) { Template.create(:parent_id=>nodes_id(:default), 'mode' => 'collab', 'target_klass' => 'Page', 'title' => '', 'format' => '')}
     assert_kind_of Template, doc
     assert !doc.new_record?, "Saved"
     assert_equal 'collab', doc.mode
     assert_equal 'html', doc.format
     assert_equal 'NP', doc.tkpath
     assert_equal 'Page', doc.target_klass
-    assert_equal 'Page-collab', doc.node_name
+    assert_equal 'Page-collab', doc.title
   end
 
-  def test_change_node_name
+  def test_change_title
     login(:tiger)
-    doc = secure!(Template) { Template.create(:parent_id=>nodes_id(:default), :node_name => 'Project-collab-xml.zafu')}
+    doc = secure!(Template) { Template.create(:parent_id=>nodes_id(:default), :title => 'Project-collab-xml.zafu')}
     assert_kind_of Template, doc
     assert !doc.new_record?, "Saved"
     doc = secure!(Node) { Node.find(doc[:id]) } # reload
-    assert doc.update_attributes(:node_name => "Page-super")
+    assert doc.update_attributes(:title => "Page-super")
     assert_equal 'super', doc.mode
     assert_equal 'html', doc.format
     assert_equal 'NP', doc.tkpath
     assert_equal 'Page', doc.target_klass
-    assert_equal 'Page-super', doc.node_name
+    assert_equal 'Page-super', doc.title
   end
 
   def test_update_title_blank_mode
     login(:tiger)
-    doc = secure!(Template) { Template.create(:parent_id=>nodes_id(:default), :node_name => 'Project-collab-xml.zafu')}
+    doc = secure!(Template) { Template.create(:parent_id=>nodes_id(:default), :title => 'Project-collab-xml.zafu')}
     assert_kind_of Template, doc
     assert !doc.new_record?, "Saved"
     assert doc.update_attributes(:mode => "", :title=> "Project-collab-xml")
     assert_nil doc.mode
     assert_equal 'xml', doc.format
-    assert_equal 'Project--xml', doc.node_name
+    assert_equal 'Project--xml', doc.title
     assert_equal 'Project--xml', doc.title
   end
 
   def test_update_blank_mode
     login(:tiger)
-    doc = secure!(Template) { Template.create(:parent_id=>nodes_id(:default), :node_name => 'Project-collab-xml.zafu')}
+    doc = secure!(Template) { Template.create(:parent_id=>nodes_id(:default), :title => 'Project-collab-xml.zafu')}
     assert_kind_of Template, doc
     assert !doc.new_record?, "Saved"
     assert_equal 'collab', doc.mode
     doc = secure!(Node) { Node.find(doc[:id]) } # reload
-    assert doc.update_attributes(:mode => "", :node_name => "Project-collab-xml") # name does not change, only mode is updated
+    assert doc.update_attributes(:mode => "", :title => "Project-collab-xml") # name does not change, only mode is updated
     assert_nil doc.mode
     assert_equal 'xml', doc.format
     assert_equal 'Project', doc.target_klass
-    assert_equal 'Project--xml', doc.node_name
+    assert_equal 'Project--xml', doc.title
     assert_equal 'Project--xml', doc.title
   end
 
-  def test_cannot_change_node_name_not_master
+  def test_cannot_change_title_not_master
     login(:tiger)
-    doc = secure!(Template) { Template.create(:parent_id=>nodes_id(:default), :node_name => 'Project-collab-xml.zafu')}
+    doc = secure!(Template) { Template.create(:parent_id=>nodes_id(:default), :title => 'Project-collab-xml.zafu')}
     assert_kind_of Template, doc
     assert !doc.new_record?, "Saved"
     doc = secure!(Node) { Node.find(doc[:id]) } # reload
-    assert doc.update_attributes(:node_name => "simple-thing", :v_status => Zena::Status[:pub])
+    assert doc.update_attributes(:title => "simple-thing", :v_status => Zena::Status[:pub])
     assert_nil doc.target_klass
     assert_nil doc.mode
     assert_nil doc.format
     assert_nil doc.tkpath
-    assert_equal 'Project-collab-xml', doc.node_name
+    assert_equal 'simple-thing', doc.title
   end
 
-  def test_set_node_name_no_extension
+  def test_set_title_no_extension
     login(:tiger)
-    doc = secure!(Template) { Template.create(:parent_id=>nodes_id(:default), :node_name => 'Project-collab')}
+    doc = secure!(Template) { Template.create(:parent_id=>nodes_id(:default), :title => 'Project-collab')}
     assert_kind_of Template, doc
     assert !doc.new_record?, "Saved"
-    assert_equal 'Project-collab', doc.node_name
+    assert_equal 'Project-collab', doc.title
     assert_equal 'collab', doc.mode
     assert_equal 'html', doc.format
     assert_equal 'NPP', doc.tkpath
@@ -376,58 +367,58 @@ class TemplateTest < Zena::Unit::TestCase
 
   def test_set_target_klass
     login(:tiger)
-    doc = secure!(Template) { Template.create(:parent_id=>nodes_id(:default), :node_name => 'Spider-man-xml',
+    doc = secure!(Template) { Template.create(:parent_id=>nodes_id(:default), :title => 'Spider-man-xml',
                                              :target_klass => 'Page',
                                              :format => 'ical')}
     assert_kind_of Template, doc
     assert !doc.new_record?, "Saved"
-    assert_equal 'Page-man-ical', doc.node_name
+    assert_equal 'Page-man-ical', doc.title
     assert_equal 'man', doc.mode
     assert_equal 'ical', doc.format
     assert_equal 'NP', doc.tkpath
     assert_equal 'Page', doc.target_klass
   end
 
-  def test_set_blank_node_name_not_unique
+  def test_set_blank_title_not_unique
     login(:tiger)
-    doc = secure!(Template) { Template.create(:parent_id=>nodes_id(:default), 'mode' => '', 'target_klass' => 'BaseContact', 'node_name' => '', 'format' => '')}
+    doc = secure!(Template) { Template.create(:parent_id=>nodes_id(:default), 'mode' => '', 'target_klass' => 'Contact', 'title' => '', 'format' => '')}
     assert_kind_of Template, doc
     assert !doc.new_record?, "Saved"
     assert_nil doc.mode
     assert_equal 'html', doc.format
     assert_equal 'NRC', doc.tkpath
-    assert_equal 'BaseContact', doc.target_klass
-    assert_equal 'BaseContact', doc.node_name
-    doc = secure!(Template) { Template.create(:parent_id=>nodes_id(:default), 'mode' => '', 'target_klass' => 'BaseContact', 'node_name' => '', 'format' => 'vcard')}
+    assert_equal 'Contact', doc.target_klass
+    assert_equal 'Contact', doc.title
+    doc = secure!(Template) { Template.create(:parent_id=>nodes_id(:default), 'mode' => '', 'target_klass' => 'Contact', 'title' => '', 'format' => 'vcard')}
     assert_kind_of Template, doc
     assert !doc.new_record?, "Saved"
     assert_nil doc.mode
     assert_equal 'vcard', doc.format
     assert_equal 'NRC', doc.tkpath
-    assert_equal 'BaseContact', doc.target_klass
-    assert_equal 'BaseContact--vcard', doc.node_name
+    assert_equal 'Contact', doc.target_klass
+    assert_equal 'Contact--vcard', doc.title
   end
 
-  def test_update_format_updates_node_name
+  def test_update_format_updates_title
     login(:lion)
-    doc = secure!(Template) { Template.create(:parent_id=>nodes_id(:default), 'mode' => '', 'target_klass' => 'BaseContact', 'node_name' => '', 'format' => 'vcard')}
+    doc = secure!(Template) { Template.create(:parent_id=>nodes_id(:default), 'mode' => '', 'target_klass' => 'Contact', 'title' => '', 'format' => 'vcard')}
     assert_kind_of Template, doc
     assert !doc.new_record?, "Saved"
     assert_nil doc.mode
     assert_equal 'vcard', doc.format
     assert_equal 'NRC', doc.tkpath
-    assert_equal 'BaseContact', doc.target_klass
-    assert_equal 'BaseContact--vcard', doc.node_name
+    assert_equal 'Contact', doc.target_klass
+    assert_equal 'Contact--vcard', doc.title
     assert doc.update_attributes(:format => 'vcf')
     assert_equal 'vcf', doc.format
     assert_equal 'NRC', doc.tkpath
-    assert_equal 'BaseContact', doc.target_klass
-    assert_equal 'BaseContact--vcf', doc.node_name
+    assert_equal 'Contact', doc.target_klass
+    assert_equal 'Contact--vcf', doc.title
   end
 
   def test_default_text_Node
     login(:lion)
-    doc = secure!(Template) { Template.create(:parent_id=>nodes_id(:default), 'target_klass' => 'Node', 'node_name' => '')}
+    doc = secure!(Template) { Template.create(:parent_id=>nodes_id(:default), 'target_klass' => 'Node', 'title' => '')}
     assert_kind_of Template, doc
     assert !doc.new_record?, "Saved"
     assert_match %r{xmlns.*www\.w3\.org.*body}m, doc.text
@@ -435,7 +426,7 @@ class TemplateTest < Zena::Unit::TestCase
 
   def test_default_text_other_format
     login(:lion)
-    doc = secure!(Template) { Template.create(:parent_id=>nodes_id(:default), 'format' => 'vcard', 'target_klass' => 'Node', 'node_name' => '')}
+    doc = secure!(Template) { Template.create(:parent_id=>nodes_id(:default), 'format' => 'vcard', 'target_klass' => 'Node', 'title' => '')}
     assert_kind_of Template, doc
     assert !doc.new_record?, "Saved"
     assert doc.text.blank?