zena 1.0.0.rc2 → 1.0.0.rc3

data/test/unit/node_test.rb

@@ -17,19 +17,19 @@ class NodeTest < Zena::Unit::TestCase
     end
 
     context 'with a sub-node' do
-      should 'return true on ancestor?' do
-        assert subject.ancestor?(secure!(Node) { nodes(:status) })
+      should 'return true on is_ancestor?' do
+        assert subject.is_ancestor?(secure!(Node) { nodes(:status) })
       end
     end # with a sub-node
 
     context 'with a node that is not a sub-node' do
-      should 'return false on ancestor?' do
-        assert !subject.ancestor?(secure!(Node) { nodes(:people) })
+      should 'return false on is_ancestor?' do
+        assert !subject.is_ancestor?(secure!(Node) { nodes(:people) })
       end
     end # with a node that is not a sub-node
 
-    should 'return true on ancestor? on self' do
-      assert subject.ancestor?(subject)
+    should 'return true on is_ancestor? on self' do
+      assert subject.is_ancestor?(subject)
     end
   end # On a node
 
@@ -117,7 +117,7 @@ class NodeTest < Zena::Unit::TestCase
 
         should 'transform zip in parent_id' do
           assert subject.update_attributes_with_transformation('parent_id' => 'lake+')
-          assert_equal nodes_id(:lake_jpg), subject.parent_id
+          assert_equal nodes_id(:lake), subject.parent_id
         end
 
         should 'add error on bad zip in parent_id' do
@@ -147,7 +147,7 @@ class NodeTest < Zena::Unit::TestCase
   # This is a stupid test because the result is not the same in production...
   def test_match_query
     query = Node.match_query('smala')
-    assert_equal "nodes._id LIKE 'smala%'", query[:conditions]
+    assert_equal "vs.idx_text_high LIKE '%smala%'", query[:conditions]
     query = Node.match_query('.', :node => nodes(:wiki))
     assert_equal ["parent_id = ?", nodes_id(:wiki)], query[:conditions]
   end
@@ -384,6 +384,18 @@ class NodeTest < Zena::Unit::TestCase
         assert_equal Zena::Status[:rem], versions(:bird_jpg_en).status
         assert_equal Zena::Status[:rem], versions(:flower_jpg_en).status
       end
+
+      should 'sync documents with node' do
+        assert subject.unpublish
+        assert_equal Zena::Status[:rem], versions(:bird_jpg_en).status
+        assert_equal Zena::Status[:rem], versions(:flower_jpg_en).status
+        assert subject.redit
+        assert_equal Zena::Status[:red], versions(:bird_jpg_en).status
+        assert_equal Zena::Status[:red], versions(:flower_jpg_en).status
+        assert subject.publish
+        assert_equal Zena::Status[:pub], versions(:bird_jpg_en).status
+        assert_equal Zena::Status[:pub], versions(:flower_jpg_en).status
+      end
     end
 
     context 'on a removed node with removed documents' do
@@ -1076,19 +1088,19 @@ done: \"I am done\""
         assert_equal Document, Node.native_classes['ND']
         assert_equal Image, Node.native_classes['NDI']
       end
-      
+
       should 'return nil for vclass kpath' do
         assert_nil Node.native_classes['NNP']
       end
     end # by kpath
-    
+
     context 'by name' do
       should 'find class' do
         assert_equal Page, Node.native_classes_by_name['Page']
         assert_equal Document, Node.native_classes_by_name['Document']
         assert_equal Image, Node.native_classes_by_name['Image']
       end
-      
+
       should 'return nil for vclass kpath' do
         assert_nil Node.native_classes['Post']
       end
@@ -1385,24 +1397,24 @@ done: \"I am done\""
       end
 
       should 'parse pseudo ids' do
-        assert_transforms "Hi, this is just a simple \"test\":25 or \"\":29_life.rss. OK ?\n\n!24_pv!",
-                          "Hi, this is just a simple \"test\"::w or \"\"::w+_life.rss. OK ?\n\n!:lake+_pv!"
+        assert_transforms "Hi, this is just a simple \"test\":49 or \"\":43_life.rss. OK ?\n\n!24_pv!",
+                          "Hi, this is just a simple \"test\"::w or \"\"::w++_life.rss. OK ?\n\n!:lake_pv!"
       end
 
       should 'parse pseudo ids with offset in gallery' do
-        assert_transforms "Hi ![30,24]! ![]!",
+        assert_transforms "Hi ![30,23]! ![]!",
                           "Hi ![30,:lake+]! ![]!"
       end
 
       should 'parse pseudo ids in doc_list' do
-        assert_transforms "Hi !{30,24}! !{}!",
+        assert_transforms "Hi !{30,23}! !{}!",
                           "Hi !{:bird,:lake+}! !{}!"
 
       end
 
       should 'parse pseudo ids in links' do
-        assert_transforms "Hi !30!:21 !30!:21 !30/nice bird!:21 !30_pv/hello ladies!:21",
-                          "Hi !30!::clean !:bird!::clean !:bird/nice bird!:21 !30_pv/hello ladies!:21"
+        assert_transforms "Hi !30!:21 !30!:37 !30/nice bird!:21 !30_pv/hello ladies!:21",
+                          "Hi !30!::clean+ !:bird!::clean !:bird/nice bird!:21 !30_pv/hello ladies!:21"
       end
 
       should 'not alter existing code without pseudo ids' do

data/test/unit/note_test.rb

@@ -7,7 +7,7 @@ class NoteTest < Zena::Unit::TestCase
     test_page = secure!(Note) { Note.create(:title => "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 '18/21/64', test_page.fullpath
+    assert_equal "18/21/#{test_page.zip}", test_page.fullpath
     assert_equal '18/21', test_page.basepath
   end
 

data/test/unit/relation_proxy_test.rb

@@ -508,7 +508,7 @@ class RelationProxyTest < Zena::Unit::TestCase
       assert node.update_attributes_with_transformation('rel_attributes' => {'reference_attributes' => {'other_id' => 33, 'date' => '2009-7-18 8:0'}})
       assert node.update_attributes_with_transformation('rel_attributes' => {'reference_attributes' => {'other_id' => 33, 'date' => '2009-7-18 9:0'}})
     end
-    
+
     subject do
       secure!(Node) { nodes(:cleanWater) }
     end
@@ -517,15 +517,15 @@ class RelationProxyTest < Zena::Unit::TestCase
       assert_difference('Link.count', -1) do
         # remove 9:0
         assert subject.update_attributes_with_transformation('rel_attributes' => {'reference_attributes' => {'other_id' => '', 'date' => '2009-7-18 9:0'}})
-      end      
-      
+      end
+
       assert references = subject.find(:all, 'references')
       assert_equal 2, references.size
       assert_equal Time.gm(2009,7,17), references.first.l_date
       assert_equal Time.gm(2009,7,18,8), references.last.l_date
     end
   end # with many dates for a given target
-  
+
   def test_attr_public
     assert Node.safe_method_type(['l_status'])
     assert Node.safe_method_type(['l_comment'])
@@ -554,5 +554,4 @@ class RelationProxyTest < Zena::Unit::TestCase
       assert_equal 100, subject.find(:first, 'reference where l_status = 100').l_status
     end
   end # With many links
-
 end

data/test/unit/relation_test.rb

@@ -196,5 +196,21 @@ class RelationTest < Zena::Unit::TestCase
     relation.update_attributes(:site_id => 1234)
     assert_equal original_site_id, relation.site_id
   end
+  
+
+  context 'Exporting a relation' do
+    subject do
+      relations(:node_has_tags)
+    end
+
+    should 'create a hash' do
+      assert_equal({
+        'rel_group'    => 'doc.tags',
+        'source_role'  => 'tagged',
+        'target_kpath' => 'NPT',
+        'target_icon'  => "<img src='/images/tag_blue.png' alt='tag'/>",
+      }, subject.export)
+    end
+  end # Exporting a relation
 
 end

data/test/unit/remote_test.rb

@@ -218,11 +218,11 @@ class RemoteTest < Zena::Integration::TestCase
 
       context 'nodes with search' do
         subject do
-          @app.search('la')
+          @app.search('lake')
         end
 
         should 'find through fulltext search' do
-          assert_equal ["The lake we love", "it's a lake"], subject.map(&:title)
+          assert_equal ["it's a lake", "The lake we love"], subject.map(&:title)
         end
       end
     end # finding

data/test/unit/role_test.rb

@@ -41,7 +41,7 @@ class RoleTest < Zena::Unit::TestCase
 
   context 'Creating a new Role' do
     subject do
-      Role.create('name' => 'WriteTests')
+      Role.create('name' => 'WriteTests', 'superclass' => 'Node')
     end
 
     context 'with an anonymous visitor' do
@@ -77,6 +77,7 @@ class RoleTest < Zena::Unit::TestCase
         assert_difference('Role.count', 1) do
           subject
         end
+        assert_equal 'N', subject.kpath
       end
     end # with an admin visitor
   end # Creating a new Role
@@ -117,8 +118,8 @@ class RoleTest < Zena::Unit::TestCase
       end
     end # with an admin visitor
   end # Creating a new Role
-  
-  context 'with a role' do
+
+  context 'with a Role' do
     subject do
       roles(:Original)
     end
@@ -126,6 +127,293 @@ class RoleTest < Zena::Unit::TestCase
     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
+  end # with a Role
+
+
+
+  context 'An admin' do
+    setup do
+      login(:lion)
+    end
+
+    context 'exporting a virtual class' do
+      setup do
+        login(:lion)
+      end
+
+      subject do
+        VirtualClass['Post'].export
+      end
+
+      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 sub classes' do
+      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'])
+      end
+
+      context 'with linked roles' do
+        setup do
+          secure!(::Role) { ::Role.create('name' => 'Foo', 'superclass' => 'Page')}
+        end
+
+        should 'export linked roles' do
+          assert_equal('Role', subject['Foo']['type'])
+        end
+      end # with linked roles
+
+    end # exporting a real class
+
+    context 'exporting a role' do
+      subject do
+        roles(:Original).export
+      end
+
+      should 'description' do
+
+      end
+    end # exporting a role
+
+    context 'importing columns' do
+      subject do
+        roles(:Post)
+      end
+
+      should 'create properties' do
+        assert_difference('Column.count', 2) do
+          subject.import_columns({
+            'one' => {
+              'ptype' => 'string',
+              'index' => 'ml_string',
+            },
+            'two' => {
+              'ptype' => 'integer',
+            },
+          })
+        end
+      end
+
+      should 'not create or move existing property in different role' do
+        data = Zafu::OrderedHash.new
+        data['one'] = {
+            'ptype' => 'string',
+            'index' => 'ml_string',
+        }
+        data['tz'] = {
+            'ptype' => 'integer',
+        }
+        assert_difference('Column.count', 0) do
+          # rollback 'one' creation
+          assert_raise(Exception) do
+            subject.import_columns(data)
+          end
+        end
+      end
+
+      should 'set property type and index' do
+        subject.import_columns({
+          'one' => {
+            'ptype' => 'string',
+            'index' => 'ml_string',
+          },
+          'two' => {
+            'ptype' => 'integer',
+          },
+        })
+        one = ::Column.find_by_name('one')
+        two = ::Column.find_by_name('two')
+        assert_equal('string', one.ptype)
+        assert_equal('ml_string', one.index)
+        assert_equal('integer', two.ptype)
+        assert_nil(two.index)
+      end
+
+      context 'with invalid index' do
+        should 'raise errors' do
+          e = nil
+          assert_difference('Column.count', 0) do
+            e = assert_raise(ActiveRecord::RecordInvalid) do
+              subject.import_columns({
+                'one' => {
+                  'ptype' => 'stringbar',
+                },
+                'two' => {
+                  'ptype' => 'integer',
+                  'index' => 'bad',
+                },
+              })
+            end
+          end
+
+          r = e.record
+          assert_equal "Column 'two' Validation failed: Index invalid", "#{r.class} '#{r.name}' #{e.message}"
+        end
+      end # with invalid index
+
+      context 'with invalid column name' do
+        should 'raise errors' do
+          e = nil
+          assert_difference('Column.count', 0) do
+            e = assert_raise(Exception) do
+              subject.import_columns({
+                'one' => {
+                  'ptype' => 'stringbar',
+                },
+                'paper' => {
+                  'ptype' => 'integer',
+                },
+              })
+            end
+          end
+          assert_equal "Cannot set property 'paper' in 'Post': already defined in 'Letter'.", e.message
+        end
+      end # with invalid data
+    end
+
+    context 'importing roles' do
+      subject do
+        { 'Node' => {
+            'Foo' => {
+              'type'       => 'Role',
+              'columns'    => {
+                'foo' => {'index' => '',       'ptype' => 'integer'},
+                'bar' => {'index' => '',       'ptype' => 'string'},
+                'baz' => {'index' => 'string', 'ptype' => 'string'},
+              },
+            },
+          },
+        }
+      end
+
+      should 'create roles' do
+        assert_difference('Role.count', 1) do
+          ::Role.import(subject)
+        end
+        role = Role.find_by_name 'Foo'
+        assert_equal 'N', role.kpath
+      end
+
+      should 'create columns' do
+        assert_difference('Column.count', 3) do
+          ::Role.import(subject)
+        end
+      end
+    end # importing roles
+
+    context 'importing virtual classes' do
+      setup do
+        VirtualClass.expire_cache!
+      end
+
+      subject do
+        { 'Node' => {
+            'Note' => {
+              'Foo' => {
+                'type'       => 'VirtualClass',
+                'idx_scope'  => "{'reference' => 'references', 'contact' => 'project'}",
+                'columns'    => {
+                  'foo' => {'index' => '',       'ptype' => 'integer'},
+                  'bar' => {'index' => '',       'ptype' => 'string'},
+                  'baz' => {'index' => 'string', 'ptype' => 'string'},
+                },
+              },
+            },
+          },
+        }
+      end
+
+      should 'create virtual class' do
+        assert_difference('VirtualClass.count', 1) do
+          ::Role.import(subject)
+        end
+      end
+
+      should 'set attributes' do
+        ::Role.import(subject)
+        assert_equal(
+          "{'reference' => 'references', 'contact' => 'project'}",
+          VirtualClass['Foo'].idx_scope
+        )
+        assert_equal('NNF', VirtualClass['Foo'].kpath)
+      end
+
+      should 'create columns' do
+        assert_difference('Column.count', 3) do
+          ::Role.import(subject)
+        end
+      end
+
+      context 'with duplicate column names' do
+        subject do
+          { 'Node' => {
+              'Foo' => {
+                'type'       => 'Role',
+                'columns'    => {
+                  'foo' => {'ptype' => 'integer'},
+                  'tz'  => {'ptype' => 'string'},
+                },
+              },
+            },
+          }
+        end
+
+        should 'raise an error' do
+          assert_difference('Column.count', 0) do
+            e = assert_raise(Exception) do
+              ::Role.import(subject)
+            end
+            assert_equal "Cannot set property 'tz' in 'Foo': already defined in 'Original'.", e.message
+          end
+        end
+      end # with duplicate column names
+
+
+      context 'with bad types' do
+        subject do
+          { 'Node' => {
+              'Note' => {
+                'type' => 'Capoff',
+                'Foo' => {
+                  'type'       => 'Role',
+                },
+              },
+            },
+          }
+        end
+
+        should 'raise an error' do
+          assert_difference('Column.count', 0) do
+            e = assert_raise(Exception) do
+              ::Role.import(subject)
+            end
+            assert_equal "Cannot create 'Note': invalid type 'Capoff'.", e.message
+          end
+        end
+      end # with duplicate column names
+    end # importing virtual classes
+  end # An admin
+
   # Indexed columns in role tested in NodeTest
+
 end

data/test/unit/site_test.rb

@@ -129,6 +129,18 @@ class SiteTest < Zena::Unit::TestCase
     anon.site = site
     assert anon.is_anon?
   end
+  
+  context 'A site' do
+    subject do
+      sites(:zena)
+    end
+
+    should 'respond to any_admin' do
+      assert_kind_of User, subject.any_admin
+      assert_equal users(:lion), subject.any_admin
+    end
+  end # A site
+  
 
   def test_public_group
     login(:anon)

data/test/unit/template_test.rb

@@ -238,7 +238,7 @@ class TemplateTest < Zena::Unit::TestCase
 
         should 'destroy index if target_klass is removed' do
           assert_difference('IdxTemplate.count', -1) do
-            assert subject.update_attributes(:target_klass => '')
+            assert subject.update_attributes(:target_klass => '', :v_status => Zena::Status[:pub])
           end
         end
       end # with target_klass

data/test/unit/text_document_test.rb

@@ -129,7 +129,7 @@ class TextDocumentTest < Zena::Unit::TestCase
     #header { background:url('bird.jpg') }
     #pv     { background:url('bird_pv.jpg') }
     #footer { background:url('/projects list/a wiki with Zena/flower.jpg') }
-    #back   { background:url('../../projects list/a wiki with Zena/flower.jpg') }
+    #back   { background:url('../../../projects list/a wiki with Zena/flower.jpg') }
     #no_stamp { background:url('/en/image30_pv.jpg') }
     END_CSS
     node.text = start.dup