zena 0.15.2 → 0.16.0

data/test/unit/cached_page_test.rb

@@ -24,7 +24,7 @@ class CachedPageTest < Zena::Unit::TestCase
           assert File.exists?(path), "Cache file created"
           data = File.open(path) {|f| f.read }
           assert_equal "this is the cached content", data
-          assert_equal [nodes_id(:status).to_s, nodes_id(:bird_jpg).to_s], cache.node_ids
+          assert_equal [nodes_id(:status), nodes_id(:bird_jpg)], cache.node_ids
           # test expire
           login(:tiger)
           node = secure!(Node) { nodes(:status) }
@@ -88,7 +88,7 @@ class CachedPageTest < Zena::Unit::TestCase
         assert File.exists?(path), "Cache file created"
         data = File.open(path) {|f| f.read }
         assert_equal "this is the cached content", data
-        assert_equal [nodes_id(:status).to_s, nodes_id(:bird_jpg).to_s], cache.node_ids
+        assert_equal [nodes_id(:status), nodes_id(:bird_jpg)], cache.node_ids
         # test expire
         CachedPage.expire_old
         assert !File.exists?(path), "Cache file removed"

data/test/unit/comment_test.rb

@@ -124,7 +124,6 @@ class CommentTest < Zena::Unit::TestCase
     comment = comments(:public_says_in_en)
     prop_reply = secure!(Comment) { Comment.create(:discussion_id => comment[:discussion_id], :reply_to=>comment[:id], :title=>'bob', :author_name=>'any', :text=>'blah') }
 
-    err prop_reply
     assert !prop_reply.new_record?, "Not a new record"
     assert_equal Zena::Status[:prop], prop_reply[:status]
 

data/test/unit/document_test.rb

@@ -7,22 +7,34 @@ class DocumentTest < Zena::Unit::TestCase
     without_files('/test.host/data') do
       login(:ant)
       doc = secure!(Document) { Document.create( :parent_id=>nodes_id(:cleanWater),
-                                                :name=>'report',
-                                                :c_file => uploaded_pdf('water.pdf') ) }
+                                                :c_file => uploaded_pdf('water.pdf', 'report.pdf') ) }
       assert_kind_of Document , doc
-      assert ! doc.new_record? , "Not a new record"
-      assert_equal "report", doc.name
-      assert_equal "report", doc.version.title
-      assert_equal "report.pdf", doc.filename
+      assert ! doc.new_record?
+      assert_equal 'report', doc.name
+      assert_equal 'projects/cleanWater/report', doc.fullpath
+      assert_equal 'report', doc.version.title
+      assert_equal 'report.pdf', doc.filename
       assert_equal 'pdf', doc.version.content.ext
-      assert ! doc.version.new_record? , "Version is not a new record"
-      assert_not_nil doc.version.content.id , "Content id is set"
-      assert_kind_of DocumentContent , doc.version.content
+      assert ! doc.version.new_record?
+      assert_not_nil doc.version.content.id
+      assert_kind_of DocumentContent, doc.version.content
       assert File.exist?(doc.version.content.filepath)
       assert_equal File.stat(doc.version.content.filepath).size, doc.version.content.size
     end
   end
 
+  def test_create_same_name
+    without_files('/test.host/data') do
+      login(:tiger)
+      node = secure!(Document) { Document.create( :parent_id => nodes_id(:cleanWater),
+                                                 :v_title => 'lake',
+                                                 :c_file  => uploaded_pdf('water.pdf') ) }
+      assert !node.new_record?
+      assert_equal 'lake-1', node.name
+      assert_equal 'lake-1', node.version.title
+    end
+  end
+
   def test_create_with_bad_filename
     preserving_files('/test.host/data') do
       login(:ant)
@@ -176,7 +188,7 @@ class DocumentTest < Zena::Unit::TestCase
     without_files('/test.host/data') do
       login(:ant)
       doc = secure!(Document) { Document.create( :parent_id=>nodes_id(:cleanWater),
-                                                :c_file  => uploaded_file("some.txt", 'application/octet-stream', "super.zz") ) }
+                                                :c_file  => uploaded_fixture("some.txt", 'application/octet-stream', "super.zz") ) }
       assert_kind_of Document , doc
       assert ! doc.new_record? , "Not a new record"
       assert_equal "super", doc.name
@@ -219,7 +231,7 @@ class DocumentTest < Zena::Unit::TestCase
     without_files('/test.host/data') do
       login(:ant)
       doc = secure!(Document) { Document.create( :parent_id=>nodes_id(:cleanWater),
-                                                :c_file  => uploaded_file('water.pdf', 'application/pdf', 'wat'), :v_title => "lazy waters.pdf") }
+                                                :c_file  => uploaded_fixture('water.pdf', 'application/pdf', 'wat'), :v_title => "lazy waters.pdf") }
       assert_kind_of Document , doc
       assert ! doc.new_record? , "Not a new record"
       assert_equal "lazyWaters", doc.name

data/test/unit/helpers/ping_helper_test.rb

@@ -0,0 +1,4 @@
+require 'test_helper'
+
+class PingHelperTest < ActionView::TestCase
+end

data/test/unit/multiversion_test.rb

@@ -41,16 +41,20 @@ class MultiVersionTest < Zena::Unit::TestCase
     context 'when there is only a redaction for the current language' do
       setup do
         login(:tiger)
-        version = secure!(Version) { versions(:opening_fr) }
-        node = version.node
-        assert node.destroy_version
-        assert_equal [:opening_red_fr, :opening_en].map{|s| versions_id(s)}.sort, node.versions.map{|v| v.id}.sort
-        login(:anon)
+        version = secure!(Version) { versions(:opening_en) }
+        @node = version.node
+        @node.destroy_version
       end
 
       should 'see a default publication' do
+        login(:anon)
         node = secure!(Node) { nodes(:opening) }
-        assert_equal versions_id(:opening_en), node.version.id
+        assert_equal versions_id(:opening_fr), node.version.id
+      end
+
+      should 'see other redaction an publication in another language ' do
+        login(:tiger)
+        assert_equal [:opening_red_fr, :opening_fr].map{|s| versions_id(s)}.sort, @node.versions.map{|v| v.id}.sort
       end
     end
   end # A visitor without write access
@@ -81,18 +85,22 @@ class MultiVersionTest < Zena::Unit::TestCase
     context 'in a language not supported' do
       setup do
         login(:tiger)
-        version = secure!(Version) { versions(:opening_fr) }
-        node = version.node
-        assert node.destroy_version
-        assert_equal [:opening_red_fr, :opening_en].map{|s| versions_id(s)}.sort, node.versions.map{|v| v.id}.sort
-        login(:ant)
+        version = secure!(Version) { versions(:opening_en) }
+        @node = version.node
+        @node.destroy_version
       end
 
       should 'see redaction from another language' do
+        login(:ant)
         visitor.lang = 'de'
         node = secure!(Node) { nodes(:opening) }
         assert_equal versions_id(:opening_red_fr), node.version.id
       end
+
+      should 'see redaction and publication from another language' do
+        login(:tiger)
+        assert_equal [:opening_red_fr, :opening_fr].map{|s| versions_id(s)}.sort, @node.versions.map{|v| v.id}.sort
+      end
     end
 
     should 'see a redaction if there are no publications' do
@@ -118,7 +126,7 @@ class MultiVersionTest < Zena::Unit::TestCase
       login(:ant)
       visitor.status = User::Status[:moderated]
     end
-    
+
     context 'on an unpublished node' do
       setup do
         @node = secure!(Node) { nodes(:nature) }
@@ -128,7 +136,7 @@ class MultiVersionTest < Zena::Unit::TestCase
         assert_equal versions_id(:nature_red_en), @node.version.id
       end
     end
-    
+
     context 'on a published node with a redaction' do
       setup do
         visitor.lang = 'fr'
@@ -139,8 +147,8 @@ class MultiVersionTest < Zena::Unit::TestCase
         assert_equal versions_id(:opening_red_fr), @node.version.id
       end
     end
-    
-    
+
+
   end
   # =========== UPDATE VERSION TESTS =============
 
@@ -514,7 +522,7 @@ class MultiVersionTest < Zena::Unit::TestCase
               assert @node.update_attributes(:v_title => 'Larry Summers is a jerk.')
             end
           end
-          
+
           should 'replace old publication autopublishing' do
             @node.update_attributes(:v_title => 'Is not very apt at the high end.')
             assert_equal Zena::Status[:rep], versions(:collections_en).status

data/test/unit/node_test.rb

@@ -10,15 +10,28 @@ class NodeTest < Zena::Unit::TestCase
     :parent_id  => Zena::FoxyParser::id('zena', 'cleanWater'),
   }.freeze
 
-  def test_find_by_path
+  def test_rebuild_fullpath
     Node.connection.execute "UPDATE nodes SET fullpath = NULL, basepath = NULL WHERE id = #{nodes_id(:wiki)}"
     login(:ant)
     node = nodes(:wiki)
     assert_nil node[:fullpath]
-    node = secure!(Node) { Node.find_by_path('projects/wiki') }
+    node.send(:rebuild_fullpath)
     assert_equal 'projects/wiki', node.fullpath
+  end
+
+  def test_rebuild_fullpath_in_custom_base
+    Node.connection.execute "UPDATE nodes SET fullpath = NULL, basepath = NULL WHERE id = #{nodes_id(:status)}"
+    login(:ant)
+    node = nodes(:status)
+    assert_nil node[:fullpath]
+    node.send(:rebuild_fullpath)
+    assert_equal 'projects/cleanWater/status', node.fullpath
+  end
+
+  def test_find_by_path
+    login(:ant)
     node = secure!(Node) { Node.find_by_path('projects/wiki') }
-    assert_equal 'projects/wiki', node[:fullpath]
+    assert_equal nodes_id(:wiki), node.id
   end
 
   def test_match_query
@@ -73,38 +86,12 @@ class NodeTest < Zena::Unit::TestCase
     end
   end
 
-  def test_get_fullpath
-    Node.connection.execute "UPDATE nodes SET fullpath = NULL, basepath = NULL WHERE id IN (#{nodes_id(:lake)},#{nodes_id(:cleanWater)})"
-    login(:ant)
-    node = secure!(Node) { nodes(:lake)  }
-    parent = node.parent
-    assert_nil parent[:fullpath]
-    assert_nil node[:fullpath]
-    assert_equal 'projects/cleanWater/lakeAddress', node.fullpath
-    node.reload
-    assert_equal 'projects/cleanWater/lakeAddress', node[:fullpath]
-    parent.reload
-    assert_equal 'projects/cleanWater', parent[:fullpath]
-  end
-
   def test_get_fullpath_rebuild
-    login(:ant)
+    login(:lion)
     node = secure!(Node) { nodes(:lake)  }
     assert_equal 'projects/cleanWater/lakeAddress', node.fullpath
-    Node.connection.execute "UPDATE nodes SET parent_id = #{nodes_id(:collections)} WHERE id = #{node[:id]}"
-    node.reload
-    assert_equal 'projects/cleanWater/lakeAddress', node.fullpath
-    assert_equal 'collections/lakeAddress', node.fullpath(true)
-  end
-
-  def test_get_fullpath_after_private
-    Node.connection.execute "UPDATE nodes SET parent_id = #{nodes_id(:ant)} WHERE id = #{nodes_id(:status)}" # put 'status' page inside private 'ant' page
-    node = nil
-    login(:tiger)
-    assert_nothing_raised { node = secure!(Node) { nodes(:status) } }
-    assert_kind_of Node, node
-    assert_nothing_raised { node = secure!(Node) { Node.find_by_path('people/ant') } }
-    assert_nothing_raised { node = secure!(Node) { Node.find_by_path('people/ant/status')}}
+    assert node.update_attributes(:parent_id => nodes_id(:collections))
+    assert_equal 'collections/lakeAddress', node.fullpath
   end
 
   def test_fullpath_updated_on_parent_rename
@@ -119,8 +106,7 @@ class NodeTest < Zena::Unit::TestCase
     assert node.publish
     assert_equal 'nicePeople', node.name # sync name
     node = secure!(Node) { nodes(:tiger) }
-    assert_nil node[:fullpath] # cache empty
-    assert_equal 'nicePeople/tiger', node.fullpath
+    assert_equal 'nicePeople/tiger', node[:fullpath]
   end
 
   def test_rootpath
@@ -174,6 +160,10 @@ class NodeTest < Zena::Unit::TestCase
     test_page = secure!(Node) { Node.create(: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
+    assert_equal 'projects/cleanWater', test_page.basepath
+    parent = secure!(Node) { nodes(:cleanWater) }
+    assert_equal 'projects/cleanWater', parent.fullpath
   end
 
   def test_cannot_update_v_status
@@ -637,7 +627,7 @@ class NodeTest < Zena::Unit::TestCase
     login(:lion)
     node = secure!(Node) { nodes(:art) }
     assert node.update_attributes('tagged_ids' => [nodes_id(:status), nodes_id(:people)])
-    assert_equal 2, node.find(:all, 'tagged').size
+    assert_equal 2, node.find(:all, 'tagged', :skip_rubyless => true).size
     stat = secure!(Node) { nodes(:status) }
     peop = secure!(Node) { nodes(:people) }
     assert_equal node[:id], stat.find(:first, 'set_tags')[:id]
@@ -994,9 +984,9 @@ done: \"I am done\""
   end
 
   def test_to_yaml
-    test_site('zena')
-    User.connection.execute "UPDATE users SET time_zone = 'Asia/Jakarta' WHERE id = #{users_id(:tiger)}"
+    #test_site('zena')
     login(:tiger)
+    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)}!")
@@ -1004,7 +994,11 @@ done: \"I am done\""
     assert_match %r{v_text:\s+\"?This is a "link":\(\.\./\.\.\)\.}, yaml
     assert_match %r{d_foo:\s+\"?A picture: !\(\.\./\.\./wiki/bird\)!}, yaml
     assert_no_match %r{log_at}, yaml
+  end
 
+  def test_to_yaml_with_change_log_at
+    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_equal Time.gm(2008,10,20,7,53), prop.log_at
@@ -1090,61 +1084,6 @@ done: \"I am done\""
     assert_equal nodes_id(:opening), match[0][:id]
   end
 
-  def find_nodes_with_pagination_in_cleanWaterProject(page, per_page = 3, opts=nil)
-    previous_page, collection, next_page = nil, nil, nil
-    opts ||= {:conditions => ['project_id = ?', nodes_id(:cleanWater)], :order=>'name ASC'}
-    collection = secure(Node) do
-      previous_page, collection, next_page = Node.find_with_pagination(:all, opts.merge(:page=>page, :per_page=>per_page))
-      collection
-    end
-    [previous_page, collection, next_page]
-  end
-
-  def test_find_with_pagination_page_1
-    login(:tiger)
-    previous_page, collection, next_page = find_nodes_with_pagination_in_cleanWaterProject(1,3)
-    assert_nil previous_page
-    assert_equal 2, next_page
-    assert_equal 3, collection.size
-    assert_equal [:bananas, :crocodiles, :lake_jpg].map{|s| nodes_id(s)}, collection.map{|r| r[:id]}
-  end
-
-  def test_find_with_pagination_page_2
-    login(:tiger)
-    previous_page, collection, next_page = find_nodes_with_pagination_in_cleanWaterProject(2,3)
-    assert_equal 1, previous_page
-    assert_equal 3, next_page
-    assert_equal 3, collection.size
-    assert_equal [:lake, :opening, :status].map{|s| nodes_id(s)}, collection.map{|r| r[:id]}
-  end
-
-  def test_find_with_pagination_page_3
-    login(:tiger)
-    previous_page, collection, next_page = find_nodes_with_pagination_in_cleanWaterProject(3,3)
-    assert_equal 2, previous_page
-    assert_nil next_page
-    assert_equal 2, collection.size
-    assert_equal [:track, :water_pdf].map{|s| nodes_id(s)}, collection.map{|r| r[:id]}
-  end
-
-  def test_find_with_pagination_page_4
-    login(:tiger)
-    previous_page, collection, next_page = find_nodes_with_pagination_in_cleanWaterProject(4,3)
-    assert_equal 3, previous_page
-    assert_nil next_page
-    assert_nil collection
-  end
-
-  def test_find_match_with_pagination
-    login(:tiger)
-    previous_page, match, next_page, count_all = secure!(Node) { Node.find_with_pagination(:all, Node.match_query('opening').merge(:page => 1, :per_page => 3)) }
-    assert_equal 1, match.size
-    assert_equal 1, count_all
-    assert_nil previous_page
-    assert_nil next_page
-    assert_equal nodes_id(:opening), match[0][:id]
-  end
-
   def test_data
     login(:ant)
     node = secure!(Node) { nodes(:cleanWater) }
@@ -1245,7 +1184,7 @@ done: \"I am done\""
 
     # 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_file('water.pdf', 'application/pdf', 'wat'), :v_title => "lazy waters.pdf") }
+                                              :c_file  => uploaded_fixture('water.pdf', 'application/pdf', 'wat'), :v_title => "lazy waters.pdf") }
     assert !doc.new_record?
     assert_equal 0.0, doc.position
 

data/test/unit/note_test.rb

@@ -1,6 +1,15 @@
 require 'test_helper'
 
 class NoteTest < Zena::Unit::TestCase
+  
+  def test_create_simplest
+    login(:ant)
+    test_page = secure!(Note) { Note.create(: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
+    assert_equal 'projects/cleanWater', test_page.basepath
+  end
 
   def test_create_with_name
     login(:tiger)

data/test/unit/page_test.rb

@@ -73,7 +73,7 @@ class PageTest < Zena::Unit::TestCase
     assert_equal node[:id], bird[:parent_id]
     assert node.update_attributes(:custom_base => true)
     assert_equal 'projects/aWikiWithZena', node.basepath
-    bird = secure!(Node) { nodes(:bird_jpg)} # avoid @parent caching
-    assert_equal 'projects/aWikiWithZena', bird.basepath(true)
+    bird = secure!(Node) { nodes(:bird_jpg)}
+    assert_equal 'projects/aWikiWithZena', bird.basepath
   end
 end

data/test/unit/secure_test.rb

@@ -74,7 +74,7 @@ class SecureTest < Zena::Unit::TestCase
     context 'loaded without secure' do
       setup do
         @node = nodes(:secret)
-        @visitor.visit(@node)
+        #@visitor.visit(@node)
       end
 
       should 'receive false when asking can_read?' do
@@ -256,7 +256,7 @@ class SecureTest < Zena::Unit::TestCase
     context 'without secure' do
       should 'not be allowed to build new children' do
         node = Node.new(defaults)
-        assert !node.save
+        assert_raise ActiveRecord::RecordInvalid do node.save! end
         assert_equal 'record not secured', node.errors[:base]
       end
 
@@ -926,14 +926,4 @@ class SecureTest < Zena::Unit::TestCase
     end
   end # A visitor with reader status
 
-  context 'A visitor with deleted status' do
-    setup do
-      User.connection.execute "UPDATE users SET status = #{User::Status[:deleted]} WHERE id = #{users_id(:tiger)} AND site_id = #{sites_id(:zena)}"
-    end
-
-    should 'not be able to login' do
-      login(:tiger)
-      assert_equal users(:anon), visitor
-    end
-  end # A visitor with deleted status
 end

data/test/unit/site_test.rb

@@ -2,34 +2,28 @@ require 'test_helper'
 
 class SiteTest < Zena::Unit::TestCase
 
-  def test_create_site
-    site = nil
-    assert_nothing_raised { site = Site.create_for_host('super.host', 'secret') }
-    site = Site.find(site[:id]) # reload
-    assert_equal "Anonymous User", site.anon.fullname
-    assert_not_equal users(:anon), site.anon[:id]
-    assert admin = User.login('admin', 'secret', 'super.host'), "Admin user can login"
-
-    assert_equal 3, admin.group_ids.size
-    root = secure!(Node) { Node.find(site[:root_id]) }
-    assert_kind_of Project, root
-    assert_equal Zena::Status[:pub], root.version.status
-    assert_equal 'default', root.skin
+  context 'on site creation' do
+    setup do
+      @site = Site.create_for_host('super.host', 'secret')
+    end
 
-    assert Time.now >= root.publish_from
-    User.make_visitor(:host => 'super.host') # anonymous
+    should 'populate super user' do
+      assert_equal "Super User", @site.su.fullname
+      assert_not_equal users(:su), @site.su[:id]
+    end
 
-    assert secure!(Node) { Node.find(site[:root_id]) }
-    assert_nothing_raised { Zena::Db.next_zip(site[:id]) }
+    should 'populate anonymous user' do
+      assert_equal "Anonymous User", @site.anon.fullname
+      assert_not_equal users(:anon), @site.anon[:id]
+    end
 
-    admin = secure!(User) { User.find(admin[:id]) }
-    assert_kind_of Contact, admin.contact
-    anon  = secure!(User) { User.find(site.anon[:id]) }
-    assert_kind_of Contact, anon.contact
+    should 'populate 2 admin users' do
+      assert_equal 2, @site.admin_user_ids.size
+    end
 
-    skin  = secure!(Skin) { Skin.find_by_name('default') }
-    assert_kind_of Skin, skin
-    assert_equal 'default', skin.skin
+    should 'return a new project as root node' do
+      assert_kind_of Project, @site.root_node
+    end
   end
 
   def test_create_site_with_opts
@@ -233,4 +227,29 @@ class SiteTest < Zena::Unit::TestCase
     assert_equal Hash['w'=>{'fr' => versions_id(:opening_red_fr), 'en' => versions_id(:opening_en)},
                       'r'=>{'fr' => versions_id(:opening_fr),     'en' => versions_id(:opening_en)}], opening.vhash
   end
+  
+  def test_rebuild_fullpath
+    login(:tiger)
+    Node.connection.execute "UPDATE nodes SET fullpath = NULL"
+    visitor.site.rebuild_fullpath
+    status  = secure(Node) { nodes(:status)  }
+    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 false, status.custom_base
+    
+    assert_equal 'projects/cleanWater/opening', opening.fullpath
+    assert_equal 'projects/cleanWater', opening.basepath
+    assert_equal false, opening.custom_base
+    
+    assert_equal 'projects/cleanWater', cleanWater.fullpath
+    assert_equal 'projects/cleanWater', cleanWater.basepath
+    assert_equal true, cleanWater.custom_base
+    
+    assert_equal 'collections/art', art.fullpath
+    assert_equal '', art.basepath
+    assert_equal false, art.custom_base
+  end
 end