zena 1.0.0.beta3 → 1.0.0.rc1

data/test/unit/workflow_test.rb

@@ -4,7 +4,7 @@ require 'test_helper'
 class WorkflowTest < Zena::Unit::TestCase
 
   def defaults
-    { :node_name => 'hello',
+    { :title     => 'hello',
       :parent_id => nodes_id(:zena) }
   end
 
@@ -188,6 +188,15 @@ class WorkflowTest < Zena::Unit::TestCase
           should 'get a warning if editing would change original' do
             assert subject.would_change_original?
           end
+
+          should 'not create a new redaction' do
+            # Create page
+            subject
+            assert_difference('Version.count', 0) do
+              # update in redit time
+              assert subject.update_attributes(:title => 'Artificial Intelligence')
+            end
+          end
         end # in redit time
 
         context 'not in redit time' do
@@ -196,14 +205,6 @@ class WorkflowTest < Zena::Unit::TestCase
           end
         end # not in redit time
 
-
-        should 'not create a new redaction when editing in redit time' do
-          subject.version.created_at = Time.now
-          assert_difference('Version.count', 0) do
-            assert subject.update_attributes(:title => 'Artificial Intelligence')
-          end
-        end
-
         should 'create a new redaction when editing out of redit time' do
           subject.version.created_at = Time.now.advance(:days => -1)
           assert_difference('Version.count', 1) do
@@ -328,6 +329,23 @@ class WorkflowTest < Zena::Unit::TestCase
         should 'not get a warning if editing would change original' do
           assert !subject.would_change_original?
         end
+
+        context 'in redit time' do
+          subject do
+            secure(Page) { Page.create(:parent_id => nodes_id(:zena), :title => 'hop', :v_status => Zena::Status[:pub])}
+          end
+
+          should 'create a new redaction on edit' do
+            # create page and make sure it is published
+            assert_equal Zena::Status[:pub], subject.v_status
+            # reload
+            page = secure(Node) { Node.find(subject.id) }
+            assert_difference('Version.count', 1) do
+              page.update_attributes(:title => 'hip')
+            end
+          end
+        end # in redit time
+
       end # that she owns
 
       should 'not get a warning if editing would change original' do
@@ -353,10 +371,10 @@ class WorkflowTest < Zena::Unit::TestCase
       should 'be able to write new attributes using properties' do
         assert_difference('Version.count', 1) do
           node = secure!(Node) { nodes(:lake) }
-          assert node.update_attributes(:title => 'Mea Lua', :country => 'Brazil')
+          assert node.update_attributes(:first_name => 'Mea Lua', :country => 'Brazil')
           node = secure!(Node) { nodes(:lake) } # reload
-          assert_equal 'Mea Lua', node.title
-          assert_equal 'Brazil', node.country
+          assert_equal 'Mea Lua we love', node.title
+          assert_equal 'Brazil', node.prop['country']
         end
       end
 
@@ -603,8 +621,27 @@ class WorkflowTest < Zena::Unit::TestCase
               assert subject.update_attributes(:title => 'Equal.', :v_status => Zena::Status[:pub])
             end
           end
+        end # setting v_status to autopublish
+      end # that she owns
+      
+      # Basic tests for property integration in Node.
+      context 'changing attributes' do
+        should 'mark version as edited' do
+          subject.attributes = {'title' => 'foo'}
+          assert subject.version.edited?
         end
-      end
+        
+        should 'mark properties as changed' do
+          subject.attributes = {'title' => 'foo'}
+          assert subject.prop.changed?
+        end
+        
+        should 'show property changes on chages' do
+          subject.attributes = {'title' => 'foo'}
+          assert_equal Hash['title'=> ['status title', 'foo']], subject.changes
+        end
+      end # changing attributes
+      
     end # A visitor with drive access on a publication
 
 
@@ -790,7 +827,7 @@ class WorkflowTest < Zena::Unit::TestCase
 
   def test_can_man_cannot_publish
     login(:ant)
-    node = secure!(Note) { Note.create(:node_name => 'hello', :parent_id=>nodes_id(:cleanWater)) }
+    node = secure!(Note) { Note.create(:title => 'hello', :parent_id=>nodes_id(:cleanWater)) }
     assert !node.new_record?
     assert node.can_drive?, "Can drive"
     assert node.can_drive?, "Can manage"
@@ -815,7 +852,7 @@ class WorkflowTest < Zena::Unit::TestCase
     node = secure!(Node) { nodes(:lion) }
     pub_version = node.version
     assert node.can_unpublish?
-    assert node.update_attributes(:title=>'leopard')
+    assert node.update_attributes(:name => 'Leopard')
     assert_equal Zena::Status[:red], node.version.status
     assert !node.can_unpublish?
   end
@@ -960,16 +997,16 @@ class WorkflowTest < Zena::Unit::TestCase
     visitor.lang = 'en'
     node = secure!(Node) { nodes(:tiger) }
     assert_equal Zena::Status[:pub], node.version.status
-    assert_equal 'Tiger', node.title
+    assert_equal 'Panthera Tigris Sumatran', node.title
     assert_equal 1, node.version.number
     assert_equal users_id(:tiger), node.version.user_id
     assert node.version.created_at < Time.now + 600
     assert node.version.created_at > Time.now - 600
-    assert node.update_attributes(:title => "Puma")
+    assert node.update_attributes(:name => "Puma")
     assert_equal Zena::Status[:pub], node.version.status
     assert_equal 1, node.version.number
     assert_equal versions_id(:tiger_en), node.version.id
-    assert_equal 'Puma', node.title
+    assert_equal 'Panthera Puma', node.title
   end
 
   def test_publish_after_save_in_redit_time_can_publish
@@ -981,16 +1018,16 @@ class WorkflowTest < Zena::Unit::TestCase
     visitor.lang = 'en'
     node = secure!(Node) { nodes(:tiger) }
     assert_equal Zena::Status[:pub], node.version.status
-    assert_equal 'Tiger', node.title
+    assert_equal 'Panthera Tigris Sumatran', node.title
     assert_equal 1, node.version.number
     assert_equal users_id(:tiger), node.version.user_id
     assert node.version.created_at < Time.now + 600
     assert node.version.created_at > Time.now - 600
-    assert node.update_attributes(:title => "Puma", :v_status => Zena::Status[:pub])
+    assert node.update_attributes(:name => "Puma", :v_status => Zena::Status[:pub])
     assert_equal Zena::Status[:pub], node.version.status
     assert_equal 1, node.version.number
     assert_equal versions_id(:tiger_en), node.version.id
-    assert_equal 'Puma', node.title
+    assert_equal 'Panthera Puma', node.title
   end
 
 

data/test/unit/zena/acts/enrollable_test.rb

@@ -11,72 +11,12 @@ class EnrollableTest < Zena::Unit::TestCase
       login(:tiger)
     end
 
-    context 'on a class' do
-      subject do
-        Class.new(Document)
-      end
-
-      should 'respond to load_roles!' do
-        assert_nothing_raised do
-          subject.load_roles!
-        end
-      end
-
-      context 'with roles loaded' do
-        setup do
-          subject.load_roles!
-        end
-
-        should 'consider role methods as safe' do
-          assert_equal Hash[:class=>String, :method=>"prop['assigned']", :nil=>true], subject.safe_method_type(['assigned'])
-        end
-      end # with roles loaded
-
-      context 'without roles loaded' do
-
-        should 'not consider role methods as safe' do
-          assert_equal nil, subject.safe_method_type(['assigned'])
-        end
-      end # without roles loaded
-    end # on a class
-
     context 'on a node' do
       context 'from a class with roles' do
         subject do
           secure(Node) { nodes(:letter) }
         end
-
-        should 'raise an error before role is loaded' do
-          assert_raise(NoMethodError) do
-            subject.assigned = 'flat Eric'
-          end
-        end
-
-        should 'load all roles on set attributes' do
-          assert_nothing_raised do
-            subject.attributes = {'assigned' => 'flat Eric'}
-          end
-        end
-
-        should 'load all roles on set properties' do
-          subject.properties = {'assigned' => 'flat Eric'}
-          assert subject.save
-          assert_equal 'flat Eric', subject.assigned
-        end
-
-        should 'load all roles on update_attributes' do
-          assert_nothing_raised do
-            assert subject.update_attributes('assigned' => 'flat Eric', 'origin' => '2D')
-          end
-        end
-
-        should 'accept properties in update_attributes' do
-          assert_nothing_raised do
-            assert subject.update_attributes('properties' => {'assigned' => 'flat Eric'})
-            assert_equal 'flat Eric', subject.assigned
-          end
-        end
-
+        
         should 'add role on property set' do
           assert_difference('NodesRoles.count', 1) do
             assert subject.update_attributes('properties' => {'assigned' => 'flat Eric'})
@@ -84,23 +24,7 @@ class EnrollableTest < Zena::Unit::TestCase
             assert_equal [roles_id(:Task)], subject.cached_role_ids
           end
         end
-
-        context 'with roles loaded' do
-          setup do
-            subject.load_roles!
-          end
-
-          should 'consider role methods as safe' do
-            assert_equal Hash[:class=>String, :method=>"prop['paper']", :nil=>true], subject.safe_method_type(['paper'])
-          end
-        end # with roles loaded
-
-        context 'without roles loaded' do
-          should 'not consider role methods as safe' do
-            assert_equal nil, subject.safe_method_type(['paper'])
-          end
-        end # without roles loaded
-
+        
         context 'with roles assigned' do
           subject do
             secure(Node) { nodes(:tree_jpg) }
@@ -155,13 +79,13 @@ class EnrollableTest < Zena::Unit::TestCase
             end
           end
 
-          should 'respond to zafu_roles' do
-            assert_equal %w{Original}, subject.zafu_roles.map(&:name)
+          should 'respond to assigned_roles' do
+            assert_equal %w{Original}, subject.assigned_roles.map(&:name)
           end
 
-          should 'use cached_role_ids in zafu_roles' do
+          should 'use cached_role_ids in assigned_roles' do
             Role.connection.execute("DELETE FROM nodes_roles")
-            assert_equal %w{Original}, subject.zafu_roles.map(&:name)
+            assert_equal %w{Original}, subject.assigned_roles.map(&:name)
           end
 
           context 'with new property index defined in role' do
@@ -175,66 +99,51 @@ class EnrollableTest < Zena::Unit::TestCase
             end
 
             should 'rebuild property index on rebuild_index' do
-              # Make sure that load_roles! is called before index rebuild
+              # Makes sure that load_roles! is called before index rebuilt
               assert_difference('IdxNodesString.count', 1) do
+                # New key = paper
                 subject.rebuild_index!
               end
+            
+              indices = Hash[*IdxNodesString.find(:all, :conditions => {:node_id => subject.id}).map {|r| [r.key, r.value]}.flatten]
+              assert_equal Hash[
+                'search_mono'=>'Kraft mono',
+                'paper'=>'Kraft'], indices
             end
           end # with new property index defined in role
         end # with roles assigned
 
-        should 'not allow arbitrary attributes' do
-          assert !subject.update_attributes('assigned' => 'flat Eric', 'bad' => 'property')
-        end
-        
-        should 'not raise on bad attributes' do
-          assert_nothing_raised do
-            subject.attributes = {'elements' => 'Statistical Learning'}
-          end
-        end
-
-        should 'add an error on first bad attributes' do
-          subject.attributes = {'elements' => 'Statistical Learning'}
-          assert !subject.save
-          assert_equal 'unknown attribute', subject.errors[:elements]
-        end
-
-        should 'not allow property bypassing' do
-          assert !subject.update_attributes('properties' => {'bad' => 'property'})
-          assert_equal 'property not declared', subject.errors[:bad]
-        end
-
-        context 'with properties assigned through role' do
-          subject do
-            secure(Node) { nodes(:tree_jpg) }
-          end
-
-          should 'read attributes without loading roles' do
-            assert_equal 'Big Bang', subject.prop['origin']
-            assert !subject.respond_to?(:origin)
-          end
-        end # with properties assigned through role
 
         should 'respond to zafu_possible_roles' do
-          assert_equal %w{Original Task Letter}, subject.zafu_possible_roles.map {|r| r.name}
+          assert_equal %w{Original Task}, subject.zafu_possible_roles.map {|r| r.name}
         end
       end # from a class with roles
     end # on a node
+    
+    context 'A safe method returning a sub-class of Node' do
+      subject do
+        ['section']
+      end
 
-    context 'creating a node' do
-      context 'with properties from roles' do
-        subject do
-          secure(Node) { Node.create(:parent_id => nodes_id(:zena), :title => 'foo', :origin => 'Hop')}
-        end
+      should 'return a virtual class on safe_method_type' do
+        type = Node.safe_method_type(subject)
+        assert_kind_of VirtualClass, type[:class]
+        assert_equal VirtualClass['Section'], type[:class]
+        assert_equal %w{assigned cached_role_ids origin summary text title tz weight}, type[:class].columns.keys.sort
+      end
+    end # A safe method returning a sub-class of Node
 
-        should 'add roles' do
-          assert_difference('NodesRoles.count', 1) do
-            assert_equal [roles_id(:Original)], subject.cached_role_ids
-          end
+    context 'A class with a safe_node_context to a virtual class' do
+      subject do
+        Class.new(Page) do
+          safe_node_context :foo => :Post
         end
-      end # with properties from roles
-
-    end # creating a node
+      end
 
+      should 'properly resolve type' do
+        type = subject.safe_method_type(['foo'])
+        assert_equal VirtualClass['Post'], type[:class]
+      end
+    end # A class with a safe_node_context to a virtual class
   end # A visitor with write access
 end

data/test/unit/zena/acts/secure_test.rb

@@ -6,7 +6,7 @@ class SecureTest < Zena::Unit::TestCase
     login(opts[:login] || :ant)
     # create new node
     attrs =  {
-      :node_name => 'hello',
+      :title     => 'hello',
       :parent_id => nodes_id(:cleanWater)
     }.merge(opts[:node] || {})
 
@@ -17,16 +17,6 @@ class SecureTest < Zena::Unit::TestCase
     [node, ref]
   end
 
-  context 'A class path (kpath)' do
-    should 'represent the class hierarchy' do
-      assert_equal 'N', Node.kpath
-      assert_equal 'NP', Page.kpath
-      assert_equal 'U', PagerDummy.ksel
-      assert_equal 'NU', PagerDummy.kpath
-      assert_equal 'NUS', SubPagerDummy.kpath
-    end
-  end
-
   context 'A visitor' do
     setup do
       login(:anon)
@@ -293,13 +283,13 @@ class SecureTest < Zena::Unit::TestCase
     should 'be allowed to drive' do
       node = secure!(Node) { nodes(:bananas) }
       assert node.can_drive?
-      assert node.update_attributes(:node_name => 'NamWa')
+      assert node.update_attributes(:log_at => Time.now)
     end
   end # A visitor in the read and drive groups
 
 
   def defaults
-    { :node_name => 'hello',
+    { :title => 'hello',
       :parent_id => nodes_id(:zena) }
   end
 
@@ -403,7 +393,7 @@ class SecureTest < Zena::Unit::TestCase
     end
 
     should 'not be allowed to create circular references' do
-      # status is a child of projects/cleanWater
+      # status is a child of projects-list/Clean-Water-project
       node = secure!(Node) { nodes(:projects) }
       assert !node.update_attributes(:parent_id => nodes_id(:status))
       assert_equal 'circular reference', node.errors[:parent_id]
@@ -530,12 +520,6 @@ class SecureTest < Zena::Unit::TestCase
       assert_equal 'You do not have the rights to do this.', @node.errors[:base]
     end
 
-    should 'not be allowed to change node_name' do
-      @node.node_name = 'slitherin'
-      assert !@node.save
-      assert_equal 'You do not have the rights to do this.', @node.errors[:base]
-    end
-
     should 'not be allowed to change dates' do
       @node.event_at = Time.now
       assert !@node.save
@@ -821,7 +805,7 @@ class SecureTest < Zena::Unit::TestCase
           versions_id(:status_en),
           versions_id(:strange_en_red),
           versions_id(:ant_en)]],
-        :order      => 'node_name ASC')
+        :order      => 'zip ASC')
     end
 
     context 'with secure' do
@@ -856,7 +840,7 @@ class SecureTest < Zena::Unit::TestCase
 
   context 'Using clean_options to prepare queries' do
     should 'remove anything that might disturb ActiveRecord' do
-      assert_equal Hash[:conditions => ['id = ?', 3], :order => 'node_name ASC'], Node.clean_options(:conditions => ['id = ?', 3], :funky => 'bad', :order => 'node_name ASC', :from => 'users')
+      assert_equal Hash[:conditions => ['id = ?', 3], :order => 'zip ASC'], Node.clean_options(:conditions => ['id = ?', 3], :funky => 'bad', :order => 'zip ASC', :from => 'users')
     end
   end # Using clean_options to prepare queries