zena 1.0.0.rc2 → 1.0.0.rc3

data/test/unit/virtual_class_test.rb

@@ -187,6 +187,85 @@ class VirtualClassTest < Zena::Unit::TestCase
     assert_equal 'NPU', vclass.kpath
   end
 
+  context 'Updating a VirtualClass' do
+    setup do
+      login(:lion)
+    end
+
+    subject do
+      roles(:Post)
+    end
+
+    should 'update kpaths in nodes' do
+      # kpath NNP => NO
+      assert subject.update_attributes(:superclass => 'Page')
+      assert_equal 'NPO', subject.kpath
+      n = nodes(:opening)
+      assert_equal 'NPO', n.kpath
+    end
+
+    context 'with a related template' do
+      setup do
+        @template = secure(Template) { Template.create(:parent_id => nodes_id(:default), :title => 'Post-foobar.zafu') }
+        assert !@template.new_record?
+      end
+
+      should 'update kpaths in templates' do
+        # kpath NNP => NO
+        assert subject.update_attributes(:superclass => 'Page')
+        assert_equal 'NPO', subject.kpath
+        t = secure(Template) { Template.find(@template) }
+        assert_equal 'NPO', t.tkpath
+        idx = IdxTemplate.first(:conditions => {:node_id => t.id})
+        assert_equal 'NPO', idx.tkpath
+      end
+
+      should 'rename templates' do
+        # kpath NNP => NO
+        assert subject.update_attributes(:name => 'Fast')
+        assert_equal 'NNF', subject.kpath
+        t = secure(Template) { Template.find(@template) }
+        assert_equal 'NNF', t.tkpath
+        assert_equal 'Fast-foobar', t.title
+        idx = IdxTemplate.first(:conditions => {:node_id => t.id})
+        assert_equal 'NNF', idx.tkpath
+      end
+    end # with a related template
+
+    context 'with sub vclasses' do
+      setup do
+        @sub = secure(VirtualClass) { VirtualClass.create(:superclass => subject, :name => 'Dog') }
+        assert !@sub.new_record?
+      end
+
+      should 'update kpaths in sub vclass' do
+        # kpath NNP => NO
+        assert subject.update_attributes(:superclass => 'Page')
+        assert_equal 'NPO', subject.kpath
+        sub = VirtualClass.find(@sub)
+        assert_equal 'NPOD', sub.kpath
+      end
+    end # with a related template
+
+
+    context 'with linked role' do
+      setup do
+        @role = ::Role.create('name' => 'Foobar', 'superclass' => 'Post')
+        assert !@role.new_record?
+        assert_equal 'NNP', @role.kpath
+      end
+
+      should 'update linked role kpath' do
+        # kpath NNP => NO
+        assert subject.update_attributes(:superclass => 'Page')
+        assert_equal 'NPO', subject.kpath
+        role = ::Role.find(@role)
+        assert_equal 'NPO', role.kpath
+      end
+    end # with linked role
+
+  end # Updating a VirtualClass
+
   def test_update_name
     # add a sub class
     login(:lion)
@@ -655,7 +734,7 @@ class VirtualClassTest < Zena::Unit::TestCase
         assert_equal %w{reference reference_for set_tag}, subject.map(&:other_role).sort
       end
     end # on relations
-    
+
     context 'on new_instance' do
       subject do
         VirtualClass['Letter'].new_instance(
@@ -774,108 +853,146 @@ class VirtualClassTest < Zena::Unit::TestCase
     end # on a node
   end # A visitor with write access
 
-  context 'importing virtual class definitions' do
+
+  context 'An admin' do
     setup do
       login(:lion)
     end
 
-    context 'with an existing superclass' do
+    context 'exporting a virtual class' do
       setup do
-        @data = {"Foo" => {'superclass' => 'Page'}}
+        login(:lion)
       end
 
-      should 'create a new virtual class with the given name' do
-        res = nil
-        assert_difference('VirtualClass.count', 1) do
-          res = secure(VirtualClass) { VirtualClass.import(@data) }
-        end
-        assert_equal 'Foo', res.first.name
-        assert_equal 'new', res.first.import_result
-        assert_equal 'NPF', res.first.kpath
+      subject do
+        VirtualClass['Post'].export
       end
 
-      context 'and an existing virtual class' do
-        setup do
-          @data = {'Post' => {'superclass' => 'Note'}}
+      should 'export attributes' do
+        assert_equal('VirtualClass', subject['type'])
+      end
+
+      should 'export columns' do
+        assert_equal({
+            'date' => {'index' => '.idx_datetime1', 'ptype' => 'datetime'},
+        }, subject['columns'])
+      end
+
+      should 'export relations' do
+        assert_equal({
+          'blogs' => {'target_kpath'=>'NPP', 'source_role'=>'added_note'}
+        }, subject['relations'])
+      end
+
+      should 'export sub classes' do
+        assert_equal(%w{Contact}, VirtualClass['Reference'].export.keys.select{|k| k=~/\A[A-Z]/})
+      end
+    end # exporting a virtual class
+
+    context 'exporting a real class' do
+      subject do
+        VirtualClass['Page'].export
+      end
+
+      should 'export type as Class' do
+        assert_equal('Class', subject['type'])
+      end
+
+      should 'export sub classes' do
+        assert_equal(%w{Tracker Project Section Tag}, subject.keys.select{|k| k=~/\A[A-Z]/})
+        assert_equal('VirtualClass', subject['Tracker']['type'])
+        assert_equal('Class', subject['Project']['type'])
+      end
+
+      context 'with relations' do
+        subject do
+          VirtualClass['Project'].export
         end
 
-        should 'update the virtual class if the superclass match' do
-          res = nil
-          assert_difference('VirtualClass.count', 0) do
-            res = secure(VirtualClass) { VirtualClass.import(@data) }
-          end
-          assert_equal 'Post', res.first.name
-          assert_equal 'same', res.first.import_result
-          assert_equal 'NNP', res.first.kpath
+        should 'export relations' do
+          assert_equal(%w{collaborators home hot}, subject['relations'].keys)
         end
+      end # with relations
 
-        context 'if the superclasses do not match' do
-          setup do
-            @data['Post']['superclass'] = 'Page'
-          end
 
-          should 'return a conflict error' do
-            res = nil
-            assert_difference('VirtualClass.count', 0) do
-              res = secure(VirtualClass) { VirtualClass.import(@data) }
-            end
-            assert_equal 'Post', res.first.name
-            assert_equal 'conflict', res.first.import_result
-          end
+      context 'with linked roles' do
+        setup do
+          secure(::Role) { ::Role.create('name' => 'Foo', 'superclass' => 'Page')}
+        end
 
-          should 'propagate the conflict error to subclasses in the definitions' do
-            @data['Foo'] = {'superclass' => 'Post'}
-            @data['Bar'] = {'superclass' => 'Foo'}
-            res = nil
-            assert_difference('VirtualClass.count', 0) do
-              res = secure(VirtualClass) { VirtualClass.import(@data) }
-            end
-            post = res.detect {|r| r.name == 'Post'}
-            foo  = res.detect {|r| r.name == 'Foo'}
-            bar  = res.detect {|r| r.name == 'Bar'}
-            assert foo.new_record?
-            assert_equal 'Foo', foo.name
-            assert_equal 'conflict in superclass', foo.import_result
-            assert_equal 'Post', post.name
-            assert_equal 'conflict', post.import_result
-            assert bar.new_record?
-            assert_equal 'Bar', bar.name
-            assert_equal 'conflict in superclass', bar.import_result
-          end
+        should 'export linked roles' do
+          assert(subject.keys.include?('Foo'))
+          assert_equal('Role', subject['Foo']['type'])
         end
-      end
-    end # with an existing superclass
+      end # with linked roles
 
-    context 'without an existing superclass' do
-      setup do
-        @data = {'Foo' => {'superclass' => 'Baz'}, 'Baz' => {'superclass' => 'Post'}}
-      end
+    end # exporting a real class
 
-      should 'create the superclass first if it is in the definitions' do
-        res = nil
-        assert_difference('VirtualClass.count', 2) do
-          res = secure(VirtualClass) { VirtualClass.import(@data) }
+    context 'importing definitions' do
+      subject do
+        {'Note' => {
+          'type' => 'Class',
+          'Bar' => {
+            'type' => 'Role',
+          },
+          'Baz' => {
+            'type' => 'VirtualClass',
+            'Plop' => {
+              'type' => 'VirtualClass',
+            },
+          },
+        }}
+      end
+
+      should 'create roles and VirtualClasses' do
+        assert_difference('Role.count', 3) do
+          assert_difference('VirtualClass.count', 2) do
+            VirtualClass.import(subject)
+          end
         end
-        foo = res.detect {|r| r.name == 'Foo'}
-        baz = res.detect {|r| r.name == 'Baz'}
-        assert_equal 'Foo', foo.name
-        assert_equal 'new', foo.import_result
-        assert_equal 'NNPBF', foo.kpath
-        assert_equal 'Baz', baz.name
-        assert_equal 'new', baz.import_result
-        assert_equal 'NNPB', baz.kpath
       end
 
-      should 'return an error if the superclass is not in the definitions' do
-        @data.delete('Baz')
-        res = nil
-        assert_difference('VirtualClass.count', 0) do
-          res = secure(VirtualClass) { VirtualClass.import(@data) }
+      context 'with relations' do
+        subject do
+          s = Zafu::OrderedHash.new
+          s['Note'] = Zafu::OrderedHash.new
+          # created first with relations to next class
+          s['Note']['Foo'] = {
+            'type' => 'VirtualClass',
+            'relations' => {
+              'babar' => {
+                'target_kpath'  => 'NNB',
+                'target_unique' => true,
+                'source_role'   => 'fool',
+                'rel_group'     => 'foo.bar',
+              },
+            },
+          }
+
+          s['Note']['Bar'] = {
+            'type' => 'VirtualClass',
+          }
+          s
+        end
+
+        should 'create or update relations after vclass creation' do
+          assert_difference('Relation.count', 1) do
+            assert_difference('Role.count', 2) do
+              VirtualClass.import(subject)
+            end
+          end
+          assert foo = VirtualClass['Foo']
+          assert bar = VirtualClass['Bar']
+          rel = Relation.first(
+            :conditions => ['source_kpath = ? AND target_role = ?', 'NNF', 'babar'])
+          assert_equal 'NNB',   rel.target_kpath
+          assert_equal 'fools', rel.source_role
+          assert_equal 'babar', rel.target_role
+          assert_equal 'foo.bar', rel.rel_group
         end
-        foo = res.first
-        assert_equal 'Foo', foo.name
-        assert_equal 'missing superclass', foo.import_result
-      end
-    end # without an existing superclass
-  end # importing virtual class definitions
+      end # with relations
+
+    end
+  end # An admin
+
 end

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

@@ -16,7 +16,7 @@ class EnrollableTest < Zena::Unit::TestCase
         subject do
           secure(Node) { nodes(:letter) }
         end
-        
+
         should 'add role on property set' do
           assert_difference('NodesRoles.count', 1) do
             assert subject.update_attributes('properties' => {'assigned' => 'flat Eric'})
@@ -24,7 +24,30 @@ class EnrollableTest < Zena::Unit::TestCase
             assert_equal [roles_id(:Task)], subject.cached_role_ids
           end
         end
-        
+
+        context 'with new property index defined' do
+          setup do
+            column = secure(Column) { columns(:Letter_paper) }
+            column.update_attributes(:index => 'string')
+          end
+
+          should 'rebuild property index on rebuild_index' do
+            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
+
+        should 'respond to zafu_possible_roles' do
+          assert_equal %w{Original Task}, subject.zafu_possible_roles.map {|r| r.name}
+        end
+
         context 'with roles assigned' do
           subject do
             secure(Node) { nodes(:tree_jpg) }
@@ -87,39 +110,11 @@ class EnrollableTest < Zena::Unit::TestCase
             Role.connection.execute("DELETE FROM nodes_roles")
             assert_equal %w{Original}, subject.assigned_roles.map(&:name)
           end
-
-          context 'with new property index defined in role' do
-            setup do
-              column = secure(Column) { columns(:Letter_paper) }
-              column.update_attributes(:index => 'string')
-            end
-
-            subject do
-              secure(Node) { nodes(:letter) }
-            end
-
-            should 'rebuild property index on rebuild_index' do
-              # 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 'respond to zafu_possible_roles' do
-          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']

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

@@ -6,44 +6,97 @@ class CalendarTest < Zena::View::TestCase
   include Zena::Use::I18n::ViewMethods # _
   include Zena::Use::Urls::ViewMethods # data_path
 
-  def test_cal_weeks
-    login(:tiger)
-    weeks = []
-    event_hash = nil
-    assert_equal "0", _('week_start_day') # week starts on Sunday
-    start_date, end_date = cal_start_end(Time.utc(2006,3,18), :month)
-    assert_equal Date.civil(2006,02,26), start_date
-    assert_equal Date.civil(2006,04,01), end_date
-    secure!(Note) { Note.create(:parent_id => nodes_id(:zena), :title => 'foobar', :event_at => Time.utc(2006,03,20))}
-    nodes = secure!(Note) { Note.find(:all, :conditions => ["nodes.event_at >= ? AND nodes.event_at <= ?", start_date, end_date])}
-    res = cal_weeks('event_at', nodes, start_date, end_date) do |week, hash|
-      weeks << week
-      event_hash = hash
-    end
-    assert_equal ["2006-03-18 00", "2006-03-20 00"], event_hash.keys.sort
-    assert_equal ['parc opening'], event_hash["2006-03-18 00"].map{|r| r.title}
-    assert_equal ['foobar'], event_hash["2006-03-20 00"].map{|r| r.title}
+  def fmt(date)
+    date.strftime('%Y-%m-%d %H:%M')
   end
 
-  def test_cal_weeks_hours
-    login(:tiger)
-    weeks = []
-    event_hash = nil
-    hours = [0,12]
-    assert_equal "0", _('week_start_day') # week starts on Sunday
-    start_date, end_date = cal_start_end(Time.utc(2006,3,18), :month)
-    assert_equal Date.civil(2006,02,26), start_date
-    assert_equal Date.civil(2006,04,01), end_date
-    secure!(Note) { Note.create(:parent_id => nodes_id(:zena), :title => 'morning', :event_at => Time.utc(2006,03,20,9))}
-    secure!(Note) { Note.create(:parent_id => nodes_id(:zena), :title => 'afternoon', :event_at => Time.utc(2006,03,20,14))}
-    nodes = secure!(Note) { Note.find(:all, :conditions => ["nodes.event_at >= ? AND nodes.event_at <= ?", start_date, end_date])}
-    res = cal_weeks('event_at', nodes, start_date, end_date, hours) do |week, hash|
-      weeks << week
-      event_hash = hash
+  context 'With a timezone' do
+    setup do
+      login(:tiger)
+      @tz = TZInfo::Timezone.get('Asia/Jakarta')
     end
-    assert_equal ["2006-03-18 12", "2006-03-20 00", "2006-03-20 12"], event_hash.keys.sort
-    assert_equal ['parc opening'], event_hash["2006-03-18 12"].map{|r| r.title}
-    assert_equal ['morning'], event_hash["2006-03-20 00"].map{|r| r.title}
-    assert_equal ['afternoon'], event_hash["2006-03-20 12"].map{|r| r.title}
-  end
+
+    should 'map start on first' do
+      # 1st of May, 2 hours in the morning for the visitor
+      # October 2000 is a month starting on a Sunday 1st
+      visitor_time = Time.utc(2000, 10, 1, 2)
+      # UTC = 2000-09-30 19:00
+      utc_time = @tz.local_to_utc(visitor_time)
+
+      # 0 = week starts on Sunday
+      start_date, end_date = cal_start_end(utc_time, :month, @tz, 0)
+      assert_equal '2000-09-30 17:00', fmt(start_date)
+      assert_equal '2000-11-04 17:00', fmt(end_date)
+
+      # This is what the visitor sees:
+      assert_equal '2000-10-01 00:00', fmt(@tz.utc_to_local(start_date))
+      assert_equal '2000-11-05 00:00', fmt(@tz.utc_to_local(end_date))
+    end
+
+    should 'map start on previous month' do
+      # 18st of May, 2 hours in the morning for the visitor
+      # March 2006 is a month starting on a Sunday 26th of February
+      visitor_time = Time.utc(2006, 03, 18)
+      # UTC = 2006-03-17 17:00
+      utc_time = @tz.local_to_utc(visitor_time)
+
+      start_date, end_date = cal_start_end(utc_time, :month, @tz, 0)
+      assert_equal '2006-02-25 17:00', fmt(start_date)
+      assert_equal '2006-04-01 17:00', fmt(end_date)
+
+      # This is what the visitor sees:
+      assert_equal '2006-02-26 00:00', fmt(@tz.utc_to_local(start_date))
+      assert_equal '2006-04-02 00:00', fmt(@tz.utc_to_local(end_date))
+    end
+
+    context 'with a date' do
+      setup do
+        assert_equal 0, _('week_start_day').to_i
+        # 18st of May, 2 hours in the morning for the visitor
+        # April 2011 is a month ending on Saturday 30th.
+        visitor_time = Time.utc(2011, 04, 21)
+        # UTC = 2006-03-17 17:00
+        @utc_time = @tz.local_to_utc(visitor_time)
+      end
+
+      subject do
+        cal_start_end(@utc_time, :month, @tz, 0)
+      end
+
+      should 'not overlap on next month' do
+        start_date, end_date = subject
+        assert_equal '2011-03-26 17:00', fmt(start_date)
+        assert_equal '2011-04-30 17:00', fmt(end_date)
+
+        # This is what the visitor sees:
+        assert_equal '2011-03-27 00:00', fmt(@tz.utc_to_local(start_date))
+        assert_equal '2011-05-01 00:00', fmt(@tz.utc_to_local(end_date))
+      end
+
+      should 'not include last date in cal_weeks' do
+        start_date, end_date = subject
+
+        sundays = []
+        cal_weeks('', [], start_date, end_date, @tz) do |week, list|
+          sundays << fmt(week)
+        end
+
+        assert_equal [
+          '2011-03-26 17:00',
+          '2011-04-02 17:00',
+          '2011-04-09 17:00',
+          '2011-04-16 17:00',
+          '2011-04-23 17:00'], sundays
+
+      end
+
+      should 'map week names starting Sunday' do
+        assert_equal "<th class='sun'>Sunday</th><th>Monday</th><th>Tuesday</th><th>Wednesday</th><th>Thursday</th><th>Friday</th><th class='sat'>Saturday</th>", cal_day_names('large', 0)
+      end
+      
+      should 'map week names starting Monday' do
+        assert_equal "<th>Monday</th><th>Tuesday</th><th>Wednesday</th><th>Thursday</th><th>Friday</th><th class='sat'>Saturday</th><th class='sun'>Sunday</th>", cal_day_names('large', 1)
+      end
+    end # with a date
+  end # With a timezone
 end

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

@@ -0,0 +1,28 @@
+require 'test_helper'
+
+class FieldIndexTest < Zena::Unit::TestCase
+  context 'A visitor with write access' do
+    setup do
+      login(:lion)
+    end
+
+    context 'creating a node' do
+
+      context 'that is not published' do
+        # Post has 'date' as field index
+        subject do
+          secure(Node) { Node.create_node(
+            :title     => 'Piksel',
+            :parent_id => nodes_zip(:cleanWater),
+            :class     => 'Post',
+            :date      => '2011-05-25'
+          )}
+        end
+
+        should 'write index in field' do
+          assert_equal '2011-05-25', subject.idx_datetime1.strftime('%Y-%m-%d')
+        end
+      end # that is not published
+    end # creating a node
+  end # A visitor with write access
+end

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

@@ -113,7 +113,7 @@ class HtmlTagsTest < Zena::View::TestCase
 
       context 'receiving flash_messages' do
         should 'wrap flash messages in div' do
-          assert_match 'div#messages', flash_messages(:show => 'both')
+          assert_match 'div#flash_messages', flash_messages(:show => 'both')
         end
 
         should 'not show notice or error divs' do
@@ -126,7 +126,11 @@ class HtmlTagsTest < Zena::View::TestCase
           end
 
           should 'wrap notices in div' do
-            assert_match 'div#messages div#notice', flash_messages(:show => 'both')
+            assert_match 'div#flash_messages div.notice', flash_messages(:show => 'both')
+          end
+          
+          should 'auto fade notices' do
+            assert_match 'div#flash_messages div.notice.auto_fade', flash_messages(:show => 'both')
           end
 
           should 'show notice' do
@@ -140,7 +144,7 @@ class HtmlTagsTest < Zena::View::TestCase
           end
 
           should 'wrap errors in div' do
-            assert_match 'div#messages div#error', flash_messages(:show => 'both')
+            assert_match 'div#flash_messages div.error', flash_messages(:show => 'both')
           end
 
           should 'show error' do

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

@@ -28,12 +28,12 @@ class MLIndexTest < Zena::Unit::TestCase
           col = Column.create(:role_id => buz.id, :ptype => 'string', :name => 'foo', :index => 'string')
           assert !col.new_record?
         end
-        
+
         teardown do
           # avoid test leakage
           VirtualClass.expire_cache!
         end
-        
+
         subject do
           secure(Node) { Node.create_node(
             :class     => 'Buz',
@@ -72,20 +72,6 @@ class MLIndexTest < Zena::Unit::TestCase
         assert_equal 'fabula', idx.value
       end
 
-      context 'with std indices removed' do
-        setup do
-          IdxNodesString.connection.execute 'DELETE from idx_nodes_strings'
-        end
-
-        should 'not write std index on skip_std_index' do
-          subject = secure(Node) { nodes(:ant) }
-          subject.instance_variable_set(:@skip_std_index, true)
-          assert_difference('IdxNodesString.count', 0) do
-            subject.update_attributes(:name => 'New')
-          end
-        end
-      end # with std indices removed
-
       context 'with multi lingual indices removed' do
         setup do
           IdxNodesMlString.connection.execute 'DELETE from idx_nodes_ml_strings'

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

@@ -39,13 +39,13 @@ class NestedAttributesAliasViewTest < Zena::View::TestCase
     end
 
     def link
-      @link ||= returning(HashAsMethods.new) do |l|
+      @link ||= HashAsMethods.new.tap do |l|
         l.friend = HashAsMethods.new('other_id' => 1234)
       end
     end
 
     def version
-      @version ||= returning(HashAsMethods.new('title' => 'version title')) do |v|
+      @version ||= HashAsMethods.new('title' => 'version title').tap do |v|
         v.content = HashAsMethods.new('width' => 33)
       end
     end