zena 1.0.0.beta3 → 1.0.0.rc1

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

@@ -3,7 +3,7 @@ require 'test_helper'
 class MLIndexTest < Zena::Unit::TestCase
   context 'A visitor with write access' do
     setup do
-      login(:tiger)
+      login(:lion)
     end
 
     context 'creating a node' do
@@ -22,21 +22,31 @@ class MLIndexTest < Zena::Unit::TestCase
       end
 
       context 'with non ML indices' do
+        setup do
+          buz = VirtualClass.create(:superclass => 'Node', :name => 'Buz', :create_group_id => groups_id(:public))
+          assert !buz.new_record?
+          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
-          k = Class.new(Node) do
-            property.string 'foo', :index => true
-          end
-          secure(k) { k.create(
+          secure(Node) { Node.create_node(
+            :class     => 'Buz',
             :title     => 'Zanzibar',
             :foo       => 'bar',
-            :parent_id => nodes_id(:cleanWater)
+            :parent_id => nodes_zip(:cleanWater)
           )}
         end
 
         should 'insert single value' do
           assert_difference('IdxNodesString.count', 1) do
-            # title = 4, name = 1
-            assert subject
+            # title = 4, foo = 1
+            assert !subject.new_record?
           end
         end
       end # with non ML indices
@@ -52,6 +62,16 @@ class MLIndexTest < Zena::Unit::TestCase
         secure(Node) { nodes(:news) }
       end
 
+      should 'rebuild index for current lang' do
+        assert_difference('IdxNodesMlString.count', 0) do
+          subject.update_attributes(:title => 'fabula', :v_status => Zena::Status[:pub])
+        end
+        idx = IdxNodesMlString.find(:first,
+          :conditions => {:node_id => subject.id, :lang => visitor.lang, :key => 'title'}
+        )
+        assert_equal 'fabula', idx.value
+      end
+
       context 'with std indices removed' do
         setup do
           IdxNodesString.connection.execute 'DELETE from idx_nodes_strings'
@@ -77,6 +97,34 @@ class MLIndexTest < Zena::Unit::TestCase
           end
         end
       end # with multi lingual indices removed
+
+      context 'in a class with evaluated properties' do
+        subject do
+          secure(Node) { nodes(:ant) }
+        end
+
+        should 'index commputed value' do
+          assert subject.update_attributes(:first_name => 'Superman')
+          assert_equal 'Superman Invicta', subject.title
+          idx = IdxNodesMlString.find(:first, :conditions => ["lang = ? AND `key` = ? AND node_id = ?", visitor.lang, 'title', subject.id])
+          assert_equal 'Superman Invicta', idx.value
+        end
+
+        context 'with changes overwritten by computed values' do
+          should 'not touch index' do
+            assert_difference('IdxNodesMlString.count', 0) do
+              subject.update_attributes(:title => 'fabula', :v_status => Zena::Status[:pub])
+            end
+            idx = IdxNodesMlString.find(:first,
+              :conditions => {:node_id => subject.id, :lang => visitor.lang, :key => 'title'}
+            )
+
+            assert_equal 'Solenopsis Invicta', idx.value
+          end
+        end # with changes overwritten by computed values
+
+      end # in a class with evaluated properties
+
     end # updating a node
 
     context 'on a node' do
@@ -105,17 +153,17 @@ class MLIndexTest < Zena::Unit::TestCase
             'en'=>'status title'], ml_indices
         end
 
-        context 'with idx_text_high defined for vclass' do
+        context 'with prop_eval defined for vclass' do
           subject do
             secure(Node) { nodes(:letter) }
           end
 
-          should 'set title index from idx_text_high' do
+          should 'set index from computed value' do
             subject.rebuild_index!
-            ml_indices = Hash[*IdxNodesMlString.find(:all, :conditions => {:node_id => subject.id, :key => 'title'}).map {|r| [r.lang, r.value]}.flatten]
+            ml_indices = Hash[*IdxNodesMlString.find(:all, :conditions => {:node_id => subject.id, :key => 'search'}).map {|r| [r.lang, r.value]}.flatten]
             assert_equal Hash[
-              'de'=>'zena enhancements paper:Kraft',
               'fr'=>'zena enhancements paper:Kraft',
+              'de'=>'zena enhancements paper:Kraft',
               'es'=>'zena enhancements paper:Kraft',
               'en'=>'zena enhancements paper:Kraft'], ml_indices
           end

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

@@ -0,0 +1,170 @@
+require 'test_helper'
+
+class PropEvalTest < Zena::Unit::TestCase
+
+  class NodesRoles < ActiveRecord::Base
+    set_table_name :nodes_roles
+  end
+
+  context 'A visitor with admin rights' do
+    setup do
+      login(:lion)
+    end
+
+    context 'updating a virtual_class' do
+      subject do
+        secure(VirtualClass) { virtual_classes(:Letter) }
+      end
+
+      context 'with valid code' do
+        should 'succeed' do
+          # TODO: support queries as safe method directly on nodes (also change zena/use/query_builder.rb).
+          # subject.update_attributes(:prop_eval => %q[{'title' => "#{paper} #{recipient.name}"}])
+          subject.update_attributes(:prop_eval => %q[{'paper' => (paper.blank? ? 'Chiyogami' : paper), 'title' => 'booh'}])
+        end
+      end # with valid code
+
+      context 'with syntax errors' do
+        should 'fail' do
+          assert !subject.update_attributes(:prop_eval => %q[{foo:#{tit}le} paper:#{paper}}])
+          assert_match %r{parse error}, subject.errors[:prop_eval]
+        end
+      end # with syntax errors
+
+      context 'with invalid final type' do
+        should 'fail' do
+          assert !subject.update_attributes(:prop_eval => %q[45])
+          assert_equal 'Compilation should produce a Hash (Found Number).', subject.errors[:prop_eval]
+        end
+      end # with syntax errors
+    end # updating a virtual_class
+  end # A visitor with admin rights
+
+  context 'A visitor with write access' do
+    setup do
+      login(:lion)
+    end
+
+    context 'creating a node from a class with prop eval' do
+      subject do
+        secure(Node) { Node.create_node(:class => 'Contact', :name => 'foo', :parent_id => nodes_zip(:projects)) }
+      end
+
+      should 'set evaluated prop on create' do
+        assert_difference('Node.count', 1) do
+          node = subject
+          assert_equal ' foo', node.title
+        end
+      end
+    end # creating a node from a class with prop eval
+
+
+    context 'unpublishing a node from a class with prop eval' do
+      subject do
+        secure(Node) { nodes(:ant) }
+      end
+
+      should 'succeed' do
+        assert subject.unpublish
+      end
+    end # unpublishing a node from a class with prop eval
+
+    context 'on a node' do
+      setup do
+        VirtualClass.expire_cache!
+      end
+
+      context 'from a class with evaluated properties' do
+        subject do
+          secure(Node) { nodes(:ant) }.tap do |n|
+            n.update_attributes(:first_name => 'Dan', :name => 'Simmons')
+          end
+        end
+
+        context 'updating attributes' do
+          should 'update evaluated prop on save' do
+            assert_equal 'Dan Simmons', subject.title
+          end
+
+          should 'use evaluated prop in fulltext indices' do
+            assert_equal 'Dan Simmons', subject.version.idx_text_high
+          end
+
+          context 'with property indices' do
+            subject do
+              secure(Node) { nodes(:letter) }.tap do |n|
+                assert n.update_attributes(:paper => 'Origami', :v_status => Zena::Status[:pub])
+              end
+            end
+
+            should 'use evaluated prop in ml prop indices' do
+              idx = IdxNodesMlString.find(:first,
+                :conditions => {:node_id => subject.id, :lang => visitor.lang, :key => 'search'}
+              )
+              assert_equal 'zena enhancements paper:Origami', idx.value
+            end
+
+            should 'use evaluated prop in prop indices' do
+              idx = IdxNodesString.find(:first,
+                :conditions => {:node_id => subject.id, :key => 'search_mono'}
+              )
+              assert_equal 'Origami mono', idx.value
+            end
+          end # with property indices
+
+        end # updating attributes
+      end # from a class with evaluated properties
+
+      context 'from a class with prop eval used as default' do
+        setup do
+          vclass = secure(Role) { roles(:Contact) }
+          assert vclass.update_attributes(:prop_eval => %q[{'title' => (title.blank? ? 'Bikura' : title)}])
+        end
+
+        subject do
+          secure(Node) { nodes(:ant) }
+        end
+
+        should 'not set default if not blank' do
+          assert subject.update_attributes(:title => 'Super Man')
+          assert_equal 'Super Man', subject.title
+        end
+
+        should 'set default if blank' do
+          assert subject.update_attributes(:title => '')
+          assert_equal 'Bikura', subject.title
+        end
+      end # from a class with prop eval used as default
+
+      context 'from a class with query in prop eval' do
+        setup do
+          vclass = secure(Role) { roles(:Contact) }
+          assert vclass.update_attributes(:prop_eval => %q[{'title' => first('project in site').title}])
+        end
+
+        subject do
+          secure(Node) { nodes(:ant) }
+        end
+
+        should 'execute query to set property' do
+          assert subject.update_attributes(:title => '')
+          assert_equal 'Zena the wild CMS', subject.title
+        end
+      end # from a class with prop eval used as default
+
+      context 'from a native class' do
+        subject do
+          secure(Node) { nodes(:projects) }
+        end
+
+        should 'not raise on save' do
+          assert_nothing_raised do
+            assert subject.update_attributes(:title => 'Hyperion')
+          end
+          assert_equal 'Hyperion', subject.title
+        end
+      end # from a native class
+
+    end # on a node
+  end # A visitor with write access
+end

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

@@ -29,6 +29,12 @@ class QueryNodeTest < Zena::Unit::TestCase
       assert_equal Hash[:class => Zena::Use::QueryNode::StringDictionary, :method => 'db_attr'],
         subject.safe_method_type(['db_attr'])
     end
+
+    should 'declare first as safe RubyLess' do
+      assert_equal Hash[:class => Node, :method => 'safe_first', :nil => true],
+        subject.safe_method_type(['first', String])
+      assert_kind_of Image, subject.new.safe_eval('first("image in site")')
+    end
   end # A class with QueryNode::ModelMethods included
 
   context 'An object with QueryNode::ModelMethods' do
@@ -81,7 +87,7 @@ class QueryNodeTest < Zena::Unit::TestCase
       end
 
       should 'set main_class' do
-        assert subject.main_class < Document
+        assert_equal VirtualClass['Document'], subject.main_class
       end
     end # with a real class filter
 
@@ -91,7 +97,7 @@ class QueryNodeTest < Zena::Unit::TestCase
       end
 
       should 'set main_class to Project' do
-        assert subject.main_class < Project
+        assert subject.main_class <= Project
       end
     end # with a real class filter
 
@@ -101,6 +107,7 @@ class QueryNodeTest < Zena::Unit::TestCase
       end
 
       should 'set main_class with real_class' do
+        assert_equal VirtualClass['Letter'], subject.main_class
         assert subject.main_class < Note
       end
 

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

@@ -18,7 +18,7 @@ class RenderingTest < Zena::View::TestCase
       end
 
       should 'return a relative path on admin_layout' do
-        assert_equal "/test.host/zafu/default/Node-+adminLayout/en/_main.erb", controller.admin_layout
+        assert_equal "/test.host/zafu/Default skin/Node-%2BadminLayout/en/_main.erb", controller.admin_layout
       end
     end # Rendering
 
@@ -28,4 +28,101 @@ class RenderingTest < Zena::View::TestCase
       end
     end # compiling a template
   end # With a node and skin
+end
+
+class RenderingInControllerTest < Zena::Controller::TestCase
+  tests NodesController
+
+  class MockSession < ActiveRecord::Base
+    set_table_name :sessions
+    before_save :set_session_id
+    def set_session_id
+      self[:session_id] = UUIDTools::UUID.random_create.to_s
+    end
+  end
+
+  context 'A custom rendering engine' do
+    setup do
+      login(:anon)
+      self.session.session_id = MockSession.create.session_id
+      class << @controller
+        attr_reader :custom_rendering
+        def render_to_xml(opts)
+          @custom_rendering = true
+          {
+            :type => 'text/html',
+            :data => render_to_string(:inline => %Q{<%= zazen(%q{Hello !30! "a link":30}) %>}),
+          }
+        end
+      end
+    end
+
+    subject do
+      {:action => 'show', :controller => 'nodes', :path => ["page#{nodes_zip(:projects)}.xml"], :prefix => 'en'}
+    end
+
+    should 'call render_to_format' do
+      get_subject
+      assert @controller.custom_rendering
+    end
+
+    context 'with debug' do
+      subject do
+        {:action => 'show', :controller => 'nodes', :path => ["page#{nodes_zip(:projects)}.xml"], :prefix => 'en', :debug => 'true'}
+      end
+
+      should 'not call render_to_format on debug' do
+        get_subject
+        assert_nil @controller.custom_rendering
+      end
+    end # with debug
+
+  end # A custom rendering engine
+
+  context 'Custom rendering options' do
+    subject do
+      login(:lion)
+      # create template for 'special' mode
+      t = secure(Template) { Template.create(:parent_id => nodes_id(:default), :title => 'Node--csv.zafu', :text => @zafu, :v_status => Zena::Status[:pub]) }
+      login(:anon)
+      {:action => 'show', :controller => 'nodes', :path => ["section#{nodes_zip(:people)}.csv"], :prefix => 'en'}
+    end
+
+    should 'set type and disposition headers' do
+      @zafu = %q{<r:headers X-Foobar='my thing' Content-Type='text/css' Content-Disposition='attachment; filename=special_#{title}.csv'/>}
+      get_subject
+      assert_response :success
+      {
+        "X-Foobar"            => "my thing",
+        "Content-Type"        => "text/css; charset=utf-8",
+        "Content-Disposition" => "attachment; filename=special_people.csv",
+      }.each do |k, v|
+        assert_equal v, @response.headers[k]
+      end
+    end
+  end # Custom rendering options
+
+  context 'Custom rendering options on html' do
+    subject do
+      login(:lion)
+      # create template for 'special' mode
+      t = secure(Template) { Template.create(:parent_id => nodes_id(:default), :title => 'Node-bar.zafu', :text => @zafu, :v_status => Zena::Status[:pub]) }
+      login(:anon)
+      {:action => 'show', :controller => 'nodes', :path => ["section#{nodes_zip(:people)}_bar.html"], :prefix => 'en'}
+    end
+
+    should 'type and disposition headers' do
+      @zafu = %q{<r:headers X-Foobar='my thing' Content-Type='text/css' Content-Disposition='attachment; filename=special_#{title}.csv'/>}
+      get_subject
+      assert_response :success
+      {
+        "X-Foobar"            => "my thing",
+        "Content-Type"        => "text/css; charset=utf-8",
+        "Content-Disposition" => "attachment; filename=special_people.csv",
+      }.each do |k, v|
+        assert_equal v, @response.headers[k]
+      end
+    end
+  end # Custom rendering options
+
 end

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

@@ -0,0 +1,464 @@
+require 'test_helper'
+
+class ScopeIndexTest < Zena::Unit::TestCase
+  context 'Creating a scope indexed blog' do
+    setup do
+      login(:lion)
+    end
+
+    subject do
+      secure(Node) { Node.create_node(:title => 'NewThoughts', :klass => 'Blog', :parent_id => nodes_zip(:zena), :v_status => Zena::Status[:pub]) }
+    end
+
+    should 'create' do
+      assert !subject.new_record?
+    end
+
+    should 'create index entry with values from project' do
+      assert_difference('IdxProject.count', 1) do
+        subject
+      end
+    end
+
+    should 'insert entries related to project' do
+      subject
+      index = subject.scope_index
+      assert_equal 'NewThoughts', index.blog_title
+      assert_equal subject.id, index.blog_id
+    end
+  end # Creating a scope indexed project
+
+  context 'In an indexed project' do
+    setup do
+      login(:lion)
+      @project = secure(Node) { nodes(:wiki) }
+    end
+
+    context 'inserting a sub node without publishing' do
+      subject do
+        secure(Node) { Node.create_node(:klass => 'Tag', :title => 'Knock Knock', :parent_id => @project.zip)}
+      end
+
+      should 'not update project index' do
+        assert_difference('IdxProject.count', 0) do
+          subject
+          assert_nil IdxProject.find(@project.scope_index).tag_created_at
+        end
+      end
+    end # inserting a sub node
+
+    context 'creating a sub node' do
+      subject do
+        secure(Node) { Node.create_node(:klass => 'Contact', :name => 'Gods', :first_name => 'Young', :parent_id => @project.zip, :v_status => Zena::Status[:pub])}
+      end
+
+      should 'update project index through relation' do
+        assert_difference('IdxProject.count', 0) do
+          subject
+          idx = IdxProject.find(@project.scope_index)
+          assert_equal 'Young',    idx.contact_first_name
+          assert_equal 'Gods',     idx.contact_name
+        end
+      end
+
+      should 'not update other relations' do
+        assert_difference('IdxProject.count', 0) do
+          subject
+          idx = IdxProject.find(@project.scope_index)
+          assert_equal 'ref',      idx.reference_name
+          assert_nil               idx.reference_title
+          assert_nil               idx.reference_id
+        end
+      end
+
+      should 'set group key id' do
+        assert_equal subject.id, IdxProject.find(@project.scope_index).contact_id
+      end
+    end # creating a sub node
+
+    context 'moving a sub node' do
+      subject do
+        secure(Node) { VirtualClass['Contact'].create_instance(:first_name => 'Friedrich', :name => 'Hölderlin', :parent_id => nodes_id(:zena), :v_status => Zena::Status[:pub]) }
+      end
+
+      should 'update project index' do
+        assert_equal 'cont', @project.scope_index.contact_name
+        assert subject.update_attributes(:parent_id => @project.id)
+        assert_equal 'Hölderlin', IdxProject.find(@project.scope_index).contact_name
+      end
+    end # moving a sub node
+
+    context 'linking a remote node' do
+      subject do
+        secure(Node) { VirtualClass['Contact'].create_instance(:first_name => 'Friedrich', :name => 'Hölderlin', :parent_id => nodes_id(:zena), :v_status => Zena::Status[:pub]) }
+      end
+
+      should 'update project index' do
+        assert_equal 'ref', @project.scope_index.reference_name
+        assert subject.update_attributes(:reference_id => @project.id)
+        assert_equal 'Hölderlin', IdxProject.find(@project.scope_index).reference_name
+      end
+    end # linking a remote node
+
+    context 'reverse linking a remote node' do
+      subject do
+        secure(Node) { VirtualClass['Contact'].create_instance(:first_name => 'Friedrich', :name => 'Hölderlin', :parent_id => nodes_id(:zena), :v_status => Zena::Status[:pub]) }
+      end
+
+      should 'trigger remote update idx' do
+        assert_equal 'ref', @project.scope_index.reference_name
+        assert @project.update_attributes(:reference_for_id => subject.id)
+        assert_equal 'Hölderlin', IdxProject.find(@project.scope_index).reference_name
+      end
+    end # reverse linking a remote node
+
+    context 'updating a sub node' do
+      setup do
+        @old_tag = secure(Node) { Node.create_node(:klass => 'Contact', :title => 'Tadam', :parent_id => @project.zip, :v_status => Zena::Status[:pub])}
+        @tag = secure(Node) { Node.create_node(:klass => 'Tag', :title => 'Friendly ghosts', :parent_id => @project.zip, :v_status => Zena::Status[:pub])}
+      end
+
+      subject do
+        @tag
+      end
+
+      should 'update project index through relation' do
+        subject.update_attributes(:title => 'Mean ghosts', :v_status => Zena::Status[:pub])
+        assert_equal 'Mean ghosts', IdxProject.find(@project.scope_index).tag_title
+      end
+
+      should 'keep group key id' do
+        subject.update_attributes(:title => 'Mean ghosts', :v_status => Zena::Status[:pub])
+        assert_equal @tag.id, IdxProject.find(@project.scope_index).tag_id
+      end
+
+      should 'not update project index if not published' do
+        subject.update_attributes(:title => 'Mean ghosts')
+        assert_equal 'Friendly ghosts', IdxProject.find(@project.scope_index).tag_title
+      end
+
+      should 'update project index on publish' do
+        subject.update_attributes(:title => 'Mean ghosts')
+        assert_equal 'Friendly ghosts', IdxProject.find(@project.scope_index).tag_title
+        subject.publish
+        assert_equal 'Mean ghosts', IdxProject.find(@project.scope_index).tag_title
+      end
+
+      context 'that is not the latest of its kind' do
+        subject do
+          @old_tag
+        end
+
+        should 'not update project index' do
+          subject.update_attributes(:title => 'China', :v_status => Zena::Status[:pub])
+          assert_equal 'Friendly ghosts', IdxProject.find(@project.scope_index).tag_title
+        end
+
+        should 'not change group id' do
+          subject.update_attributes(:title => 'China', :v_status => Zena::Status[:pub])
+          assert_equal @tag.id, IdxProject.find(@project.scope_index).tag_id
+        end
+      end # that is not the latest of its kind
+
+    end # updating a sub node
+
+    context 'creating a related node' do
+      subject do
+        secure(Node) { Node.create_node(:klass => 'Contact', :name => 'Gods', :first_name => 'Young', :parent_id => nodes_zip(:zena), :reference_id => @project.zip, :v_status => Zena::Status[:pub])}
+      end
+
+      should 'update related index' do
+        assert_difference('IdxProject.count', 0) do
+          subject
+          idx = IdxProject.find(@project.scope_index)
+          assert_equal 'Gods',       idx.reference_name
+          assert_equal 'Young Gods', idx.reference_title
+        end
+      end
+
+      should 'not update other relations' do
+        assert_difference('IdxProject.count', 0) do
+          subject
+          idx = IdxProject.find(@project.scope_index)
+          assert_nil                 idx.contact_first_name
+          assert_equal 'cont',       idx.contact_name
+          assert_nil                 idx.contact_id
+        end
+      end
+
+      should 'set group key id' do
+        assert_equal subject.id, IdxProject.find(@project.scope_index).reference_id
+      end
+    end # creating a related node
+
+    context 'updating a related node' do
+      subject do
+        secure(Node) { Node.create_node(:klass => 'Contact', :name => 'Gods', :first_name => 'Young', :parent_id => nodes_zip(:zena), :reference_id => @project.zip, :v_status => Zena::Status[:pub])}
+      end
+
+      should 'update all entries in related index' do
+        assert_difference('IdxProject.count', 0) do
+          subject.update_attributes(:first_name => 'Old', :v_status => Zena::Status[:pub])
+          assert_equal 'Old Gods', IdxProject.find(@project.scope_index).reference_title
+          assert_equal 'Gods', IdxProject.find(@project.scope_index).reference_name
+        end
+      end
+
+      context 'without publishing' do
+        should 'not update related index' do
+          assert_difference('IdxProject.count', 0) do
+            subject.update_attributes(:first_name => 'Old')
+            assert_equal 'Young Gods', IdxProject.find(@project.scope_index).reference_title
+          end
+        end
+      end # without publishing
+
+      context 'without all attributes' do
+        subject do
+          secure(Node) { Node.create_node(:klass => 'Reference', :title => 'Burn these tests', :parent_id => nodes_zip(:zena), :reference_id => @project.zip, :v_status => Zena::Status[:pub])}
+        end
+
+        should 'update related index' do
+          assert_difference('IdxProject.count', 0) do
+            assert subject.update_attributes(:title => 'Ashes', :v_status => Zena::Status[:pub])
+            assert_equal 'Ashes', IdxProject.find(@project.scope_index).reference_title
+            assert_equal 'ref', IdxProject.find(@project.scope_index).reference_name
+          end
+        end
+      end # without all attributes
+
+    end # updating a related node
+
+    context 'updating the project' do
+      subject do
+        @project
+      end
+
+      should 'update index' do
+        subject.update_attributes(:title => 'Wacky', :v_status => Zena::Status[:pub])
+        assert_equal 'Wacky', IdxProject.find(@project.scope_index).blog_title
+      end
+    end # updating the project
+  end # In an indexed project
+
+  context 'In a non-indexed project' do
+    setup do
+      login(:lion)
+    end
+
+    subject do
+      secure(Node) { nodes(:cleanWater) }
+    end
+
+    should 'return nil on scope_index' do
+      assert_nil subject.scope_index
+    end
+  end # In a non-indexed project
+
+  context 'With an index class' do
+    subject do
+      IdxProject
+    end
+
+    should 'build key groups' do
+      assert_equal Hash['reference' => %w{id name title}, 'blog' => %w{id title}, 'tag' => %w{id created_at title}, 'contact' => %w{id first_name name}], subject.groups
+    end
+  end # With an index model
+
+  context 'Using RubyLess with an indexed model' do
+    subject do
+      VirtualClass['Blog']
+    end
+
+    should 'return model class on scope_index' do
+      code = RubyLess.translate(subject, 'scope_index')
+      assert_equal 'scope_index', code.to_s
+      assert_equal IdxProject, code.klass
+    end
+
+    should 'allow index access on scope_index object' do
+      code = RubyLess.translate(subject, 'scope_index.tag_title')
+      assert_equal '(scope_index ? scope_index.tag_title : nil)', code.to_s
+      assert_equal String, code.klass
+    end
+  end # Using RubyLess with an indexed model
+
+  context 'Using RubyLess without an indexed model' do
+    subject do
+      VirtualClass['Project']
+    end
+
+    should 'raise an error' do
+      assert_raise(::RubyLess::NoMethodError) do
+        RubyLess.translate(subject, 'scope_index')
+      end
+    end
+  end # Using RubyLess with an indexed model
+
+  context 'Using RubyLess not on a Project or Section' do
+    subject do
+      VirtualClass['Page']
+    end
+
+    should 'raise an error' do
+      assert_raise(::RubyLess::NoMethodError) do
+        RubyLess.translate(subject, 'scope_index')
+      end
+    end
+  end # Using RubyLess with an indexed model
+
+  context 'Creating a virtual class' do
+    setup do
+      login(:lion)
+    end
+
+    context 'with a valid idx_class' do
+      subject do
+        {:name => 'Concert', :superclass => 'Project', :idx_class => 'IdxProject', :create_group_id => groups_id(:public) }
+      end
+
+      should 'create' do
+        assert_difference('VirtualClass.count', 1) do
+          VirtualClass.create(subject)
+        end
+      end
+    end # with a valid idx_class
+
+    context 'with an invalid idx_class' do
+      subject do
+        {:name => 'Concert', :superclass => 'Project', :idx_class => 'Page', :create_group_id => groups_id(:public) }
+      end
+
+      should 'not create' do
+        assert_difference('VirtualClass.count', 0) do
+          VirtualClass.create(subject)
+        end
+      end
+
+      should 'add errors to idx_class' do
+        vclass = VirtualClass.create(subject)
+        assert_equal 'invalid class (should include ScopeIndex::IndexMethods)', vclass.errors[:idx_class]
+      end
+
+      should 'not evaluate bad idx_class' do
+        vclass = VirtualClass.create(subject.merge(:idx_class => 'puts "BAD!"'))
+        assert_equal 'invalid class name', vclass.errors[:idx_class]
+      end
+    end # with an invalid idx_class
+
+
+    context 'with a valid idx_scope' do
+      subject do
+        {:name => 'Song', :superclass => 'Post', :idx_scope => "{'reference' => 'project'}", :create_group_id => groups_id(:public) }
+      end
+
+      should 'create' do
+        assert_difference('VirtualClass.count', 1) do
+          VirtualClass.create(subject)
+        end
+      end
+
+      context 'containing array keys' do
+        subject do
+          {:name => 'Song', :superclass => 'Post', :idx_scope => "{'reference,baz' => 'project'}", :create_group_id => groups_id(:public) }
+        end
+
+        should 'create' do
+          assert_difference('VirtualClass.count', 1) do
+            # RubyLess does not allow Array as key (%w{reference baz}).
+            VirtualClass.create(subject)
+          end
+        end
+      end # containing array keys
+
+      context 'containing array scopes' do
+        subject do
+          {:name => 'Song', :superclass => 'Post', :idx_scope => "{'reference' => %w{project self}}", :create_group_id => groups_id(:public) }
+        end
+
+        should 'create' do
+          assert_difference('VirtualClass.count', 1) do
+            VirtualClass.create(subject)
+          end
+        end
+      end # containing array keys
+
+      context 'containing array keys and scopes' do
+        subject do
+          {:name => 'Song', :superclass => 'Post', :idx_scope => "{'reference,baz' => %w{project self}}", :create_group_id => groups_id(:public) }
+        end
+
+        should 'create' do
+          assert_difference('VirtualClass.count', 1) do
+            # RubyLess does not allow Array as key (%w{reference baz}).
+            VirtualClass.create(subject)
+          end
+        end
+      end # containing array keys
+    end # with a valid idx_scope
+
+    context 'with an invalid idx_scope' do
+      subject do
+        {:name => 'Song', :superclass => 'Post', :idx_scope => "{1 => 'project'}", :create_group_id => groups_id(:public) }
+      end
+
+      should 'not create' do
+        assert_difference('VirtualClass.count', 0) do
+          VirtualClass.create(subject)
+        end
+      end
+
+      should 'add errors to idx_scope' do
+        vclass = VirtualClass.create(subject)
+        assert_equal "Invalid entry: keys should be a String and query should be a String or an Array of strings (1 => \"project\")", vclass.errors[:idx_scope]
+      end
+      
+      context 'with array keys' do
+        subject do
+          {:name => 'Song', :superclass => 'Post', :idx_scope => "{%w{self project} => 'project'}", :create_group_id => groups_id(:public) }
+        end
+
+        should 'add errors to idx_scope' do
+          vclass = VirtualClass.create(subject)
+          assert_equal "Invalid rubyless: Invalid key type for hash (should be a literal value, was :array)", vclass.errors[:idx_scope]
+        end
+      end # with array keys
+      
+    end # with an invalid idx_scope
+
+    context 'with an invalid idx_scope type' do
+      subject do
+        {:name => 'Song', :superclass => 'Post', :idx_scope => "project", :create_group_id => groups_id(:public) }
+      end
+
+      should 'not create' do
+        assert_difference('VirtualClass.count', 0) do
+          VirtualClass.create(subject)
+        end
+      end
+
+      should 'add errors to idx_scope' do
+        vclass = VirtualClass.create(subject)
+        assert_equal "Invalid type: should be a hash.", vclass.errors[:idx_scope]
+      end
+    end # with an invalid idx_scope type
+
+    context 'with an invalid query in idx_scope' do
+      subject do
+        {:name => 'Song', :superclass => 'Post', :idx_scope => "{'reference' => 'project where foo is null'}", :create_group_id => groups_id(:public) }
+      end
+
+      should 'not create' do
+        assert_difference('VirtualClass.count', 0) do
+          VirtualClass.create(subject)
+        end
+      end
+
+      should 'add errors to idx_scope' do
+        vclass = VirtualClass.create(subject)
+        assert_equal "Invalid query: Unknown field 'foo'.", vclass.errors[:idx_scope]
+      end
+    end # with an invalid query in idx_scope
+  end # Creating a virtual class
+
+end