zena 1.2.7 → 1.2.8

data/test/unit/virtual_class_test.rb

@@ -1207,6 +1207,61 @@ class VirtualClassTest < Zena::Unit::TestCase
       end # with relations
 
     end
+    
+    context 'with same classes in different sites' do
+      
+      setup do
+        @one = Site.create_for_host('one.host', 'secret')
+        assert_equal 'one.host', current_site.host
+        make_vclass_and_relations(current_site)
+        check_relations(@one.id)
+        
+        @two = Site.create_for_host('two.host', 'secret')
+        assert_equal 'two.host', current_site.host
+        assert_equal 'admin', visitor.login
+        make_vclass_and_relations(current_site)
+        check_relations(@two.id)
+      end
+      
+      subject do
+        VirtualClass['Cat']
+      end
+
+      should 'not make a mess on move' do
+        assert_difference('Relation.count', 0) do
+         assert subject.update_attributes(:superclass => 'Project')
+         check_relations(@one.id)
+        end
+      end
+    end
   end # An admin
+  
+  private
+    
+    def make_vclass_and_relations(site)
+      sub = VirtualClass.create(:superclass => 'Page',    :name => 'Sub', :create_group_id => site.public_group_id)
+      cat = VirtualClass.create(:superclass => 'Section', :name => 'Cat', :create_group_id => site.public_group_id)
+      
+      Relation.create(
+        :source_kpath => sub.kpath,
+        :source_role  => 'cat_sub',
+        :target_kpath => cat.kpath,
+        :target_role  => 'sub_cat'
+      )
+      
+      Relation.create(
+        :source_kpath => sub.kpath,
+        :source_role  => 'cat_page',
+        :target_kpath => Page.kpath,
+        :target_role  => 'page_cat'
+      )
+    end
 
+    def check_relations(site_id)
+      assert cat = VirtualClass.find_by_site_id_and_name(site_id, 'Cat')
+      assert sub = VirtualClass.find_by_site_id_and_name(site_id, 'Sub')
+      assert cat_sub  = Relation.find_by_site_id_and_source_role(site_id, 'cat_sub')
+      assert cat_page = Relation.find_by_site_id_and_source_role(site_id, 'cat_page')
+      assert_equal 2, Relation.count(:conditions => {:site_id => site_id})
+    end
 end

data/test/unit/workflow_test.rb

@@ -377,6 +377,181 @@ class WorkflowTest < Zena::Unit::TestCase
           assert_equal 'Brazil', node.prop['country']
         end
       end
+      
+      context 'with another user' do
+        setup do
+          login(:lion)
+        end
+        
+        context 'saving without clone' do
+          
+          should 'not create new version' do
+            node = secure!(Node) { nodes(:lake) }
+            assert_difference('Version.count', 0) do
+              assert node.update_attributes_without_clone(:first_name => 'Mea Lua', :country => 'Brazil')
+              node = secure!(Node) { nodes(:lake) } # reload
+              assert_equal 'Mea Lua we love', node.title
+              assert_equal 'Brazil', node.prop['country']
+            end
+          end
+
+          should 'not change version author' do
+            node = secure!(Node) { nodes(:lake) }
+            orig_user = node.version.user_id
+            assert_not_equal visitor.id, orig_user
+            assert_difference('Version.count', 0) do
+              assert node.update_attributes_without_clone(:first_name => 'Mea Lua', :country => 'Brazil')
+              node = secure!(Node) { nodes(:lake) } # reload
+              assert_equal orig_user, node.version.user_id
+            end
+          end
+
+          should 'not change node timestamp' do
+            node = secure!(Node) { nodes(:lake) }
+            updated_at = node.updated_at
+            assert_difference('Version.count', 0) do
+              assert node.update_attributes_without_clone(:first_name => 'Mea Lua', :country => 'Brazil')
+              node = secure!(Node) { nodes(:lake) } # reload
+              assert_equal updated_at, node.updated_at
+            end
+          end
+
+          should 'not change version timestamp' do
+            node = secure!(Node) { nodes(:lake) }
+            updated_at = node.version.updated_at
+            assert_difference('Version.count', 0) do
+              assert node.update_attributes_without_clone(:first_name => 'Mea Lua', :country => 'Brazil')
+              node = secure!(Node) { nodes(:lake) } # reload
+              assert_equal updated_at, node.version.updated_at
+            end
+          end
+
+          should 'evaluate prop_eval' do
+            node = secure!(Node) { nodes(:lake) }
+            assert_difference('Version.count', 0) do
+              assert node.update_attributes_without_clone(:first_name => 'Mea Lua', :country => 'Brazil')
+              node = secure!(Node) { nodes(:lake) } # reload
+              assert_equal 'Mea Lua we love', node.title
+            end
+          end
+
+          should 'evaluate indices' do
+            node = secure!(Node) { nodes(:opening) }
+            assert_difference('Version.count', 0) do
+              t = Time.utc(2013, 8, 21, 10, 59)
+              assert node.update_attributes_without_clone(:date => t)
+              node = secure!(Node) { nodes(:opening) } # reload
+              assert_equal t, node.idx_datetime1
+            end
+          end
+          
+          context 'with save cmd' do
+            
+            should 'not create new version' do
+              node = secure!(Node) { nodes(:lake) }
+              assert_difference('Version.count', 0) do
+                node.attributes = {:first_name => 'Mea Lua', :country => 'Brazil'}
+                assert node.save_without_clone
+                node = secure!(Node) { nodes(:lake) } # reload
+                assert_equal 'Mea Lua we love', node.title
+                assert_equal 'Brazil', node.prop['country']
+              end
+            end
+            
+            should 'evaluate prop_eval' do
+              node = secure!(Node) { nodes(:lake) }
+              assert_difference('Version.count', 0) do
+                node.attributes = {:first_name => 'Mea Lua', :country => 'Brazil'}
+                assert node.save_without_clone
+                node = secure!(Node) { nodes(:lake) } # reload
+                assert_equal 'Mea Lua we love', node.title
+              end
+            end
+
+            should 'evaluate indices' do
+              node = secure!(Node) { nodes(:opening) }
+              assert_difference('Version.count', 0) do
+                t = Time.utc(2013, 8, 21, 10, 59)
+                node.prop['date'] = t
+                assert node.save_without_clone
+                node = secure!(Node) { nodes(:opening) } # reload
+                assert_equal t, node.idx_datetime1
+              end
+            end
+          end
+        end
+        
+        context 'updating not versioned props only' do
+          
+          should 'not create new version' do
+            node = secure!(Node) { nodes(:lake) }
+            assert_difference('Version.count', 0) do
+              assert node.update_attributes(:'cart' => {'foo' => 'hello'})
+              node = secure!(Node) { nodes(:lake) } # reload
+              assert_equal 'hello', node.cart['foo']
+            end
+          end
+
+          should 'not change version author' do
+            node = secure!(Node) { nodes(:lake) }
+            orig_user = node.version.user_id
+            assert_not_equal visitor.id, orig_user
+            assert_difference('Version.count', 0) do
+              assert node.update_attributes(:'cart' => {'foo' => 'hello'})
+              node = secure!(Node) { nodes(:lake) } # reload
+              assert_equal orig_user, node.version.user_id
+            end
+          end
+
+          should 'not change node timestamp' do
+            node = secure!(Node) { nodes(:lake) }
+            updated_at = node.updated_at
+            assert_difference('Version.count', 0) do
+              assert node.update_attributes(:'cart' => {'foo' => 'hello'})
+              node = secure!(Node) { nodes(:lake) } # reload
+              assert_equal updated_at, node.updated_at
+            end
+          end
+
+          should 'not change version timestamp' do
+            node = secure!(Node) { nodes(:lake) }
+            updated_at = node.version.updated_at
+            assert_difference('Version.count', 0) do
+              assert node.update_attributes(:'cart' => {'foo' => 'hello'})
+              node = secure!(Node) { nodes(:lake) } # reload
+              assert_equal updated_at, node.version.updated_at
+            end
+          end
+
+          should 'evaluate prop_eval' do
+            node = secure!(Node) { nodes(:lake) }
+            
+            c = secure(VirtualClass) { virtual_classes(:Contact) }
+            assert c.update_attributes(:prop_eval => %q[{'cart' => {'baz' => cart['foo']}}])
+            
+            assert_difference('Version.count', 0) do
+              assert node.update_attributes(:'cart' => {'foo' => 'hello'})
+              node = secure!(Node) { nodes(:lake) } # reload
+              assert_equal 'hello', node.cart['baz']
+            end
+            
+            # Make sure to clear VirtualClass cache to avoid errors due to prop_eval propagation
+            VirtualClass.expire_cache!
+          end
+
+          should 'evaluate indices' do
+            
+            c = secure(Column) { columns(:Contact_cart) }
+            assert c.update_attributes(:index => '.idx_string1', :ptype => 'string')
+            node = secure!(Node) { nodes(:lake) }
+            assert_difference('Version.count', 0) do
+              assert node.update_attributes(:'cart' => 'Hop', :v_status => Zena::Status::Pub)
+              node = secure!(Node) { nodes(:lake) } # reload
+              assert_equal 'Hop', node.idx_string1
+            end
+          end
+        end
+      end
 
       should 'be able to create nodes using properties' do
         node = secure!(Node) { Node.create(defaults.merge(:title => 'Pandeiro')) }

data/test/unit/zena/use/ancestry_test.rb

@@ -68,12 +68,12 @@ class AncestryTest < Zena::Unit::TestCase
     end
 
     should 'rebuild fullpath in new parent' do
-      assert_equal fullpath(:people, :lion, :secret), subject.fullpath
+      assert_equal fullpath(:zena, :people, :lion, :secret), subject.fullpath
     end
 
     should 'rebuild children fullpath' do
-      assert_equal fullpath(:people, :lion, :secret, :talk), nodes(:talk).fullpath
-      assert_equal fullpath(:people, :lion, :secret, :proposition), nodes(:proposition).fullpath
+      assert_equal fullpath(:zena, :people, :lion, :secret, :talk), nodes(:talk).fullpath
+      assert_equal fullpath(:zena, :people, :lion, :secret, :proposition), nodes(:proposition).fullpath
     end
 
     context 'with custom_base set' do
@@ -93,6 +93,31 @@ class AncestryTest < Zena::Unit::TestCase
 
   end # Moving an object
 
+  context 'Moving a document' do
+    setup do
+      login(:lion)
+      # Move 'talk' inside 'tree_jpg'
+      talk = secure(Node) {nodes(:talk)}
+      
+      assert talk.update_attributes(:parent_id => subject.id)
+      
+      # Move 'tree_jpg' inside 'ant'
+      subject.update_attributes(:parent_id => nodes_id(:ant))
+    end
+    
+    subject do
+      secure(Node) { nodes(:tree_jpg) }
+    end
+    
+    should 'rebuild fullpath in new parent' do
+      assert_equal fullpath(:zena, :people, :ant, :tree_jpg), subject.fullpath
+    end
+
+    should 'rebuild children fullpath' do
+      assert_equal fullpath(:zena, :people, :ant, :tree_jpg, :talk), nodes(:talk).fullpath
+    end
+  end
+  
   context 'Finding an object from a path' do
     setup do
       login(:lion)
@@ -188,12 +213,12 @@ class AncestryTest < Zena::Unit::TestCase
       end
 
       should 'build fullpath' do
-        assert_equal [nodes_zip(:projects), subject.zip].join('/'), subject.fullpath
+        assert_equal [nodes_zip(:zena), nodes_zip(:projects), subject.zip].join('/'), subject.fullpath
       end
 
       should 'build basepath' do
         err subject
-        assert_equal [nodes_zip(:projects), subject.zip].join('/'), subject.fullpath
+        assert_equal [nodes_zip(:zena), nodes_zip(:projects), subject.zip].join('/'), subject.fullpath
       end
     end # creating a node
 
@@ -205,16 +230,33 @@ class AncestryTest < Zena::Unit::TestCase
       login(:ant)
       Node.connection.execute "UPDATE nodes SET parent_id = #{nodes_id(:status)} WHERE id = #{nodes_id(:cleanWater)}"
     end
-
+    
     subject do
-      secure(Node) { nodes(:lake_jpg) }
+      secure(Node) { nodes(:status) }
     end
-
+    
     should 'raise Invalid record on site rebuild_fullpath' do
-      assert_raise(Zena::InvalidRecord) { current_site.rebuild_fullpath(subject.parent_id) }
+      assert_raise(Zena::InvalidRecord) do
+        Zena::Use::Ancestry.rebuild_all_paths(subject)
+      end
     end
   end # A node in an ancestry loop
-
+  
+  context 'Rebuilding paths for site' do
+    setup do
+      Zena::Db.execute "UPDATE nodes SET fullpath = NULL, basepath = NULL"
+    end
+    
+    should 'Rebuild paths for all nodes' do
+      login(:lion)
+      assert_nil s.fullpath
+      assert_nil s.basepath
+      current_site.rebuild_fullpath(nil, 1)
+      s = nodes(:status)
+      assert_equal '11/18/21/22', s.fullpath
+      assert_equal '18/21', s.basepath
+    end
+  end
 
   private
     def fullpath(*args)

data/test/unit/zena/use/prop_eval_test.rb

@@ -36,6 +36,36 @@ class PropEvalTest < Zena::Unit::TestCase
         end
       end # with valid code
 
+      context 'with valid code creating empty title' do
+        setup do
+          assert subject.update_attributes(:prop_eval => %q[{'title' => ''}])
+        end
+        
+        should 'save class name as title' do
+          letter = secure(Node) { nodes(:letter) }
+          assert_equal 'zena enhancements', nodes(:letter).title
+          letter.rebuild_index!
+          assert_equal 'Letter', nodes(:letter).title
+          assert letter.update_attributes(:date => Time.now)
+          assert_equal 'Letter', nodes(:letter).title
+        end
+      end # with valid code
+      
+      context 'with valid code creating nil title' do
+        setup do
+          assert subject.update_attributes(:prop_eval => %q[{'title' => nil}])
+        end
+        
+        should 'save class name as title' do
+          letter = secure(Node) { nodes(:letter) }
+          assert_equal 'zena enhancements', nodes(:letter).title
+          letter.rebuild_index!
+          assert_equal 'Letter', nodes(:letter).title
+          assert letter.update_attributes(:date => Time.now)
+          assert_equal 'Letter', nodes(:letter).title
+        end
+      end # with valid code
+      
       context 'with valid code using vclass methods' do
         subject do
           secure(VirtualClass) { virtual_classes(:Post) }
@@ -168,6 +198,20 @@ class PropEvalTest < Zena::Unit::TestCase
             assert_equal 'LAST:Invicta FIRST:Solenopsis', idx_ml_value(subject.id, 'title')
             assert_equal 'LAST:Invicta FIRST:Solenopsis', nodes(:ant).title
           end
+          
+          context 'with a rule yielding blank title' do
+            setup do
+              v = VirtualClass['Letter']
+              v.update_attributes(:prop_eval => %q[{'title' => ''}])
+            end
+
+            should 'use class name for title' do
+              l = secure(Node) { nodes(:letter) }
+              l.rebuild_index!
+              l = secure(Node) { nodes(:letter) }
+              assert_equal 'Letter', l.title
+            end
+          end
         end # rebuilding index
 
       end # from a class with evaluated properties

data/test/unit/zena/use/rendering_test.rb

@@ -22,7 +22,53 @@ class RenderingTest < Zena::View::TestCase
         assert File.exist?(fullpath)
         FileUtils.rm(fullpath)
       end
+      
+      should 'build template partial on template_path_from_template_url' do
+        fullpath  = fullpath_from_template_url('Default skin/Node/pages', false)
+        main_path = fullpath_from_template_url('Default skin/Node/_main', false)
+        FileUtils.rm(fullpath)  if File.exist?(fullpath)
+        FileUtils.rm(main_path) if File.exist?(main_path)
+        assert_equal '/test.host/zafu/Default skin/Node/en/pages.erb', template_path_from_template_url('', 'Default skin/Node/pages', true)
+        assert File.exist?(main_path)
+        assert File.exist?(fullpath)
+        FileUtils.rm(fullpath)
+      end
+      
+      context 'with an alias site' do
+        setup do
+          setup_visitor(visitor, Site.find_by_host('alias.host'))
+        end
+        
+        should 'build template on template_path_from_template_url' do
+          fullpath = fullpath_from_template_url('wiki skin/Page-changes/_main', false)
+          if File.exist?(fullpath)
+            FileUtils.rm(fullpath)
+          end
+          assert_equal '/test.host/zafu/wiki skin/Page-changes/en/foo.erb', template_path_from_template_url('', 'wiki skin/Page-changes/foo', true)
+          assert File.exist?(fullpath)
+          FileUtils.rm(fullpath)
+        end
 
+        should 'build template partial on template_path_from_template_url' do
+          fullpath  = fullpath_from_template_url('Default skin/Node/pages', false)
+          main_path = fullpath_from_template_url('Default skin/Node/_main', false)
+          FileUtils.rm(fullpath)  if File.exist?(fullpath)
+          FileUtils.rm(main_path) if File.exist?(main_path)
+          assert_equal '/test.host/zafu/Default skin/Node/en/pages.erb', template_path_from_template_url('', 'Default skin/Node/pages', true)
+          assert File.exist?(main_path)
+          assert File.exist?(fullpath)
+          FileUtils.rm(fullpath)
+        end
+        
+        should 'find site alias on visitor site' do
+          assert_equal 'alias.host', visitor.site.host
+        end
+        
+        should 'find forced skin on any node' do
+          assert_equal 'wiki skin', visitor.get_skin(nodes(:zena)).title
+        end
+      end
+      
       should 'return a fullpath on fullpath_from_template_url' do
         assert_equal "#{SITES_ROOT}/test.host/zafu/SKIN/TEMPLATE/en/DOM_ID.erb", fullpath_from_template_url('SKIN/TEMPLATE/DOM_ID', false)
       end
@@ -168,7 +214,7 @@ class RenderingControllerTest < Zena::Controller::TestCase
           :t_url  => 'Default skin/Node-ins/foo',
           :dom_id => 'foo',
         }
-        assert_equal %Q{Element.replace(\"foo\", \"\\u003Cdiv id='foo' data-z='12'\\u003Ehello people\\u003C/div\\u003E\");\n}, @response.body
+        assert_equal %Q{if (Zena.stampOk('foo', 0)) {\nElement.replace(\"foo\", \"\\u003Cdiv id='foo' data-z='12'\\u003Ehello people\\u003C/div\\u003E\");\n\n}}, @response.body
       end
 
       context 'with insert' do
@@ -179,7 +225,7 @@ class RenderingControllerTest < Zena::Controller::TestCase
             :dom_id => 'foo',
             :insert => 'bottom',
           }
-          assert_equal %Q{Zena.insert_inner(\"foo\", \"bottom\", \"\\u003Cdiv id='foo' data-z='12'\\u003Ehello people\\u003C/div\\u003E\");\n}, @response.body
+          assert_equal %Q{if (Zena.stampOk('foo', 0)) {\nZena.insert_inner(\"foo\", \"bottom\", \"\\u003Cdiv id='foo' data-z='12'\\u003Ehello people\\u003C/div\\u003E\");\n\n}}, @response.body
         end
       end # with insert
     end # to update