zena 0.16.9 → 1.0.0.beta1

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

@@ -1,34 +1,64 @@
 require 'test_helper'
 
 class I18nTest < Zena::View::TestCase
-  include Zena::Use::I18n::ViewMethods
-  include Zena::Use::Refactor::ViewMethods # fquote
-  include Zena::Use::I18n::ViewMethods # _
-  include Zena::Use::Urls::ViewMethods # data_path
+  
+  context 'With a logged in user' do
+    setup do
+      login(:lion)
+      visiting(:cleanWater)
+      I18n.locale = 'en'
+    end
+    
+    context 'translating with _' do
+      should 'return translation for current lang' do
+        assert_equal '%A, %B %d %Y', _('full_date')
+        I18n.locale = 'fr'
+        assert_equal '%A, %d %B %Y', _('full_date')
+      end
 
-  def setup
-    super
-    I18n.locale = 'en'
-  end
+      should 'return key on missing translation' do
+        assert_equal 'yoba', _('yoba')
+      end
+    end # translating with _
+    
+    context 'on lang_links' do
+      should 'highlight current lang with em' do
+        assert_match %r{<em>en</em>}, lang_links
+      end
 
-  def test_trans
-    assert_equal 'yoba', _('yoba')
-    assert_equal '%A, %B %d %Y', _('full_date')
-    I18n.locale = 'fr'
-    assert_equal '%A, %d %B %Y', _('full_date')
-  end
+      should 'change lang with lang param' do
+        assert_match %r{href=.*/oo/projects/cleanWater\?lang=.*fr.*}, lang_links
+      end
+    end # on lang_links
+  end # With a logged in user
 
-  def test_check_lang_same
-    I18n.locale = 'en'
-    obj = secure!(Node) { nodes(:zena) }
-    assert_equal 'en', obj.v_lang
-    assert_no_match /\[en\]/, check_lang(obj)
-  end
+  context 'Without a login' do
+    setup do
+      login(:anon)
+      I18n.locale = 'en'
+      visiting(:cleanWater)
+    end
+    
+    context 'translating with _' do
+      should 'return translation for current lang' do
+        assert_equal '%A, %B %d %Y', _('full_date')
+        I18n.locale = 'fr'
+        assert_equal '%A, %d %B %Y', _('full_date')
+      end
 
-  def test_check_other_lang
-    visitor.lang = 'es'
-    I18n.locale = 'es'
-    obj = secure!(Node) { nodes(:zena) }
-    assert_match /\[en\]/, check_lang(obj)
-  end
+      should 'return key on missing translation' do
+        assert_equal 'yoba', _('yoba')
+      end
+    end # translating with _
+    
+    context 'on lang_links' do
+      should 'highlight current lang with em' do
+        assert_match %r{<em>en</em>}, lang_links
+      end
+
+      should 'change lang with prefix' do
+        assert_match %r{href=.*/fr/projects/cleanWater.*fr.*}, lang_links
+      end
+    end # on lang_links
+  end # Without a login
 end

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

@@ -0,0 +1,129 @@
+require 'test_helper'
+
+class MLIndexTest < Zena::Unit::TestCase
+  context 'A visitor with write access' do
+    setup do
+      login(:tiger)
+    end
+
+    context 'creating a node' do
+      # Node has 'title' as multilingual index
+      subject do
+        secure(Node) { Node.create(
+          :title     => 'Piksel',
+          :parent_id => nodes_id(:cleanWater)
+        )}
+      end
+
+      should 'write index for every language available' do
+        assert_difference('IdxNodesMlString.count', 4) do
+          subject
+        end
+      end
+
+      context 'with non ML indices' do
+        subject do
+          k = Class.new(Node) do
+            property.string 'foo', :index => true
+          end
+          secure(k) { k.create(
+            :title     => 'Zanzibar',
+            :foo       => 'bar',
+            :parent_id => nodes_id(:cleanWater)
+          )}
+        end
+
+        should 'insert single value' do
+          assert_difference('IdxNodesString.count', 1) do
+            # title = 4, name = 1
+            assert subject
+          end
+        end
+      end # with non ML indices
+
+    end # creating a node
+
+    context 'updating a node' do
+      setup do
+        visitor.lang = 'fr'
+      end
+
+      subject do
+        secure(Node) { nodes(:news) }
+      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'
+        end
+
+        should 'write index for concerned language only' do
+          assert_difference('IdxNodesMlString.count', 1) do
+            subject.update_attributes('title' => 'Nouvelles')
+          end
+        end
+      end # with multi lingual indices removed
+    end # updating a node
+
+    context 'on a node' do
+      subject do
+        secure(Node) { nodes(:status) }
+      end
+
+      context 'without indices in table' do
+        setup do
+          IdxNodesMlString.connection.execute "DELETE from idx_nodes_ml_strings"
+        end
+
+        should 'rebuild index for all langs' do
+          assert_difference('IdxNodesMlString.count', 4) do
+            subject.rebuild_index!
+          end
+        end
+
+        should 'set proper content for each lang' do
+          subject.rebuild_index!
+          ml_indices = Hash[*IdxNodesMlString.find(:all, :conditions => {:node_id => nodes_id(:status), :key => 'title'}).map {|r| [r.lang, r.value]}.flatten]
+          assert_equal Hash[
+            'de'=>'status title',
+            'fr'=>'Etat des travaux',
+            'es'=>'status title',
+            'en'=>'status title'], ml_indices
+        end
+
+        context 'with idx_text_high defined for vclass' do
+          subject do
+            secure(Node) { nodes(:letter) }
+          end
+
+          should 'set title index from idx_text_high' do
+            subject.rebuild_index!
+            ml_indices = Hash[*IdxNodesMlString.find(:all, :conditions => {:node_id => subject.id, :key => 'title'}).map {|r| [r.lang, r.value]}.flatten]
+            assert_equal Hash[
+              'de'=>'zena enhancements paper:Kraft',
+              'fr'=>'zena enhancements paper:Kraft',
+              'es'=>'zena enhancements paper:Kraft',
+              'en'=>'zena enhancements paper:Kraft'], ml_indices
+          end
+        end # with idx_text_high defined for vclass
+
+      end # without indices in table
+
+    end # on a node
+
+  end # A visitor with write access
+end

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

@@ -57,43 +57,43 @@ class NestedAttributesAliasViewTest < Zena::View::TestCase
   end
 
   def test_text_field_should_find_value
-    assert_css 'input#foo_v_title[@name="foo[v_title]"][@value="version title"][@type="text"]', text_field('foo', 'v_title')
+    assert_match 'input#foo_v_title[@name="foo[v_title]"][@value="version title"][@type="text"]', text_field('foo', 'v_title')
   end
 
   def test_text_field_should_find_value_through_proc
-    assert_css 'input#foo_friend_id[@name="foo[friend_id]"][@value="1234"]', text_field('foo', 'friend_id')
+    assert_match 'input#foo_friend_id[@name="foo[friend_id]"][@value="1234"]', text_field('foo', 'friend_id')
   end
 
   def test_text_field_should_find_value_deeply_nested
-    assert_css 'input#foo_c_width[@name="foo[c_width]"][@value="33"]', text_field('foo', 'c_width')
+    assert_match 'input#foo_c_width[@name="foo[c_width]"][@value="33"]', text_field('foo', 'c_width')
   end
 
   def test_password_field_should_find_value
     @foo.version.dyn = HashAsMethods.new('secret' => 'yellow')
-    assert_css 'input#foo_d_secret[@name="foo[d_secret]"][@value="yellow"][@type="password"]', password_field('foo', 'd_secret')
+    assert_match 'input#foo_d_secret[@name="foo[d_secret]"][@value="yellow"][@type="password"]', password_field('foo', 'd_secret')
   end
 
   def test_hidden_field_should_find_value
-    assert_css 'input#foo_v_title[@name="foo[v_title]"][@value="version title"][@type="hidden"]', hidden_field('foo', 'v_title')
+    assert_match 'input#foo_v_title[@name="foo[v_title]"][@value="version title"][@type="hidden"]', hidden_field('foo', 'v_title')
   end
 
   def test_file_field_should_find_value
-    assert_css 'input#foo_v_title[@name="foo[v_title]"][@type="file"]', file_field('foo', 'v_title')
+    assert_match 'input#foo_v_title[@name="foo[v_title]"][@type="file"]', file_field('foo', 'v_title')
   end
 
   def test_text_area_should_find_value
-    assert_css 'textarea#foo_v_title[@name="foo[v_title]"]', tag = text_area('foo', 'v_title')
+    assert_match 'textarea#foo_v_title[@name="foo[v_title]"]', tag = text_area('foo', 'v_title')
     assert_match %r{version title}, tag
   end
 
   def test_check_box_should_find_value
     tag = check_box('foo', 'v_title', {}, 'version title', '')
-    assert_css 'input[@name="foo[v_title]"][@value=""][@type="hidden"]', tag
-    assert_css 'input#foo_v_title[@name="foo[v_title]"][@value="version title"][@type="checkbox"][@checked="checked"]', tag
+    assert_match 'input[@name="foo[v_title]"][@value=""][@type="hidden"]', tag
+    assert_match 'input#foo_v_title[@name="foo[v_title]"][@value="version title"][@type="checkbox"][@checked="checked"]', tag
   end
 
   def test_radio_button_should_find_value
     tag = radio_button('foo', 'v_title', 'version title')
-    assert_css 'input[@name="foo[v_title]"][@value="version title"][@type="radio"][@checked="checked"]', tag
+    assert_match 'input[@name="foo[v_title]"][@value="version title"][@type="radio"][@checked="checked"]', tag
   end
 end

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

@@ -0,0 +1,104 @@
+require 'test_helper'
+
+class QueryNodeTest < Zena::Unit::TestCase
+  Compiler = Zena::Use::QueryNode::Compiler
+  Query = QueryBuilder::Query
+
+  context 'A class with QueryNode::ModelMethods included' do
+    setup do
+      login(:tiger)
+    end
+
+    subject do
+      Node
+    end
+
+    should 'return compiler class on query_compiler' do
+      assert_equal Compiler, subject.query_compiler
+    end
+
+    should 'return a query object on build_query' do
+      assert_kind_of Query, subject.build_query(:all, 'nodes')
+    end
+
+    should 'implement db_attr' do
+      assert subject.new.respond_to?(:db_attr)
+    end
+
+    should 'declare db_attr as safe RubyLess' do
+      assert_equal Hash[:class => Zena::Use::QueryNode::StringDictionary, :method => 'db_attr'],
+        subject.safe_method_type(['db_attr'])
+    end
+  end # A class with QueryNode::ModelMethods included
+
+  context 'An object with QueryNode::ModelMethods' do
+
+    setup do
+      login(:tiger)
+    end
+
+    subject do
+      secure!(Node) { nodes(:status) }
+    end
+
+    should 'return an empty hash on db_attr' do
+      assert_nothing_raised do
+        assert_equal Hash[], subject.db_attr
+      end
+    end
+
+    context 'found with an SQL query' do
+      subject do
+        secure!(Node) { Node.first(
+          :select     => 'count(versions.id) AS versions_count',
+          :joins      => 'LEFT JOIN versions ON versions.node_id = nodes.id',
+          :conditions => {'nodes.id' => nodes_id(:status)})
+        }
+      end
+
+      should 'reflect AS from query in db_attr' do
+        assert_equal Hash['versions_count', '2'], subject.db_attr
+      end
+    end
+  end # An object with QueryNode::ModelMethods
+
+  context 'Building a query' do
+    context 'with a real class filter' do
+      subject do
+        Node.build_query(:all, 'documents')
+      end
+
+      should 'set main_class' do
+        assert subject.main_class < Document
+      end
+    end # with a real class filter
+    
+    context 'with root' do
+      subject do
+        Node.build_query(:all, 'root')
+      end
+
+      should 'set main_class to Project' do
+        assert subject.main_class < Project
+      end
+    end # with a real class filter
+
+    context 'with a virtual class filter' do
+      subject do
+        Node.build_query(:all, 'letters')
+      end
+
+      should 'set main_class with real_class' do
+        assert subject.main_class < Note
+      end
+
+      should 'load roles' do
+        assert subject.main_class.safe_method_type(['assigned'])
+      end
+
+      should 'set kpath' do
+        assert_equal 'NNL', subject.main_class.kpath
+      end
+    end # with real class filter
+  end # Building a query
+end

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

@@ -1,18 +1,13 @@
 require 'test_helper'
 
 class RefactorTest < Zena::View::TestCase
-  tests Zena::Use::Refactor::ViewMethods # fquote
-
-  def _(k)
-    k
-  end
-
-  def zen_path(obj, opts)
-    "/#{opts[:lang]}/#{obj.zip}.html"
+  def setup
+    login(:anon)
+    visiting(:status)
   end
 
   def test_render_to_string
-    assert_match 'stupid test 25',  render_to_string(:inline=>'stupid <%= "test" %> <%= 5*5 %>')
+    assert_equal 'stupid test 25',  render_to_string(:inline=>'stupid <%= "test" %> <%= 5*5 %>')
   end
 
   def test_fsize
@@ -27,12 +22,6 @@ class RefactorTest < Zena::View::TestCase
     assert ((Time.now.to_i-1 <= rnd) && (rnd <= Time.now.to_i+2))
   end
 
-  def test_change_lang
-    assert_equal ({:overwrite_params=>{:prefix=>'io'}}), change_lang('io')
-    login(:ant)
-    assert_equal ({:overwrite_params=>{:lang=>'io'}}), change_lang('io')
-  end
-
   def test_traductions
     visitor.lang = 'en'
     # we must initialize an url for url_rewriting in 'traductions'

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

@@ -1,24 +1,31 @@
 require 'test_helper'
 
 class RenderingTest < Zena::View::TestCase
-  def self.layout(*args); ''; end # Called by Rendering::ControllerMethods
-  include Zena::Use::Rendering::ControllerMethods
-  include Zena::Use::Zafu::ControllerMethods # template_url
-  include Zena::Acts::Secure # secure
+  context 'With a node and skin' do
+    setup do
+      login(:anon)
+      visiting(:status)
+    end
 
-  def params;  {}; end
-  def dev_mode?; false; end
-  def lang;  'en'; end
-  def zafu_helper; self; end
-  def method_missing(*args); ''; end
+    context 'resolving template_url' do
 
-  def setup
-    super
-    @node = secure!(Node) { Node.new }
-  end
+      should 'append host and insert lang on template_path_from_template_url' do
+        assert_equal '/test.host/zafu/SKIN/TEMPLATE/en/DOM_ID', template_path_from_template_url('SKIN/TEMPLATE/DOM_ID')
+      end
 
-  def test_admin_layout_should_be_a_relative_path_in_sites
-    assert_equal "/test.host/zafu/default/Node-+adminLayout/en/_main.erb", admin_layout
-  end
+      should 'return a fullpath on fullpath_from_template_url' do
+        assert_equal "#{SITES_ROOT}/test.host/zafu/SKIN/TEMPLATE/en/DOM_ID", fullpath_from_template_url('SKIN/TEMPLATE/DOM_ID')
+      end
 
+      should 'return a relative path on admin_layout' do
+        assert_equal "/test.host/zafu/default/Node-+adminLayout/en/_main.erb", controller.admin_layout
+      end
+    end # Rendering
+
+    context 'compiling a template' do
+      should 'end with render_js inclusion' do
+        assert_match %r{<%= render_js %></body>}, File.read(File.join(SITES_ROOT, controller.template_url))
+      end
+    end # compiling a template
+  end # With a node and skin
 end