spontaneous 0.1.0.alpha1 → 0.2.0.alpha1

data/test/unit/test_page.rb

@@ -1,11 +1,19 @@
 # encoding: UTF-8
 
-require 'test_helper'
+require File.expand_path('../../test_helper', __FILE__)
 
 
 class PageTest < MiniTest::Spec
   include Spontaneous
 
+  def setup
+    @site = setup_site
+  end
+
+  def teardown
+    teardown_site
+  end
+
   context "All pages" do
     # should "have a pre-defined 'title' field" do
     #   p = Page.new
@@ -16,13 +24,15 @@ class PageTest < MiniTest::Spec
   context "Pages:" do
     setup do
       Content.delete
-      S::Schema.reset!
       class Page < Spot::Page
         field :title, :string
+        box :sub
       end
+      class Piece < Spontaneous::Piece; end
     end
     teardown do
       PageTest.send(:remove_const, :Page)
+      PageTest.send(:remove_const, :Piece)
     end
     context "Root page" do
       setup do
@@ -71,11 +81,11 @@ class PageTest < MiniTest::Spec
         o = Page.create(:title => "New Page")
         p = Page.create(:title => "New Page")
         o.slug.should == slug
-        r << o
+        r.sub << o
         o.save
         o = Page[o.id]
         o.slug.should == slug
-        o << p
+        o.sub << p
         o.save
         o = Page[o.id]
         o.slug.should == slug
@@ -88,6 +98,14 @@ class PageTest < MiniTest::Spec
         o.reload
         o.slug.should == "new-title"
       end
+
+      should "not be longer than 255 chars" do
+        o = Page.create
+        long_slug = (["bang"]*100)
+        o.slug = long_slug.join(' ')
+        o.slug.length.should == 255
+        o.slug.should == long_slug.join('-')[0..254]
+      end
     end
 
     context "Pages in tree" do
@@ -95,14 +113,14 @@ class PageTest < MiniTest::Spec
         Content.delete
         @p = Page.create
         @p.root?.should be_true
-        @q = Page.new
-        @r = Page.new
-        @s = Page.new
-        @t = Page.new
-        @p << @q
-        @q << @r
-        @q << @s
-        @s << @t
+        @q = Page.new(:slug => 'q')
+        @r = Page.new(:slug => 'r')
+        @s = Page.new(:slug => 's')
+        @t = Page.new(:slug => 't')
+        @p.sub << @q
+        @q.sub << @r
+        @q.sub << @s
+        @s.sub << @t
         @p.save
         @q.save
         @r.save
@@ -116,12 +134,6 @@ class PageTest < MiniTest::Spec
         @t = Page[@t.id]
       end
 
-      should "have the right entry classes" do
-        @p.pieces.first.proxy_class.should == Spontaneous::PagePiece
-        @q.pieces.first.proxy_class.should == Spontaneous::PagePiece
-        @s.pieces.first.proxy_class.should == Spontaneous::PagePiece
-      end
-
       should "have a reference to their parent" do
         @p.parent.should be_nil
         @q.parent.should === @p
@@ -129,7 +141,29 @@ class PageTest < MiniTest::Spec
         @s.parent.should === @q
         @t.parent.should === @s
       end
+      should "have a reference to their owner" do
+        @p.owner.should be_nil
+        @q.owner.should === @p
+        @r.owner.should === @q
+        @s.owner.should === @q
+        @t.owner.should === @s
+      end
 
+      should "know their container" do
+        @p.container.should be_nil
+        @q.container.should == @p.sub
+        @r.container.should == @q.sub
+        @s.container.should == @q.sub
+        @t.container.should == @s.sub
+      end
+
+      should "know their containing box" do
+        @p.box.should be_nil
+        @q.box.should == @p.sub
+        @r.box.should == @q.sub
+        @s.box.should == @q.sub
+        @t.box.should == @s.sub
+      end
 
       should "have a list of their children" do
         @p.children.should == [@q]
@@ -154,12 +188,68 @@ class PageTest < MiniTest::Spec
         @t.depth.should == 3
       end
 
+      should "have the correct page hierarchy" do
+        Page.box :things1
+        Page.box :things2
+        a = Page.new
+        c = Page.new
+        d = Page.new
+        e = Page.new
+        a.things1 << c
+        a.things2 << d
+        a.things2 << e
+        a.save
+        a.reload
+        c.reload
+        d.reload
+        e.reload
+        c.parent.should == a
+        d.parent.should == a
+        e.parent.should == a
+        c.content_ancestors.should == [a, a.things1]
+        d.content_ancestors.should == [a, a.things2]
+        e.content_ancestors.should == [a, a.things2]
+        # the zeroth box is 'sub'
+        c.page_order_string.should == "00001.00000"
+        d.page_order_string.should == "00002.00000"
+        e.page_order_string.should == "00002.00001"
+      end
+
+      should "have the correct page hierarchy for pages within pieces" do
+        Page.box :things
+        Piece.box :pages
+        a = Page.new
+        b = Piece.new
+        a.things << b
+        c = Page.new
+        d = Page.new
+        b.pages << c
+        b.pages << d
+        a.save
+        a.reload
+        b.reload
+        c.reload
+        d.reload
+        c.parent.should == a
+        c.content_ancestors.should == [a, a.things, b, b.pages]
+        c.page_order_string.should == "00001.00000.00000.00000"
+        d.page_order_string.should == "00001.00000.00000.00001"
+      end
+
       should "have correct paths" do
         @p.path.should == "/"
-        @q.path.should == "/#{@q.slug}"
-        @r.path.should == "/#{@q.slug}/#{@r.slug}"
-        @s.path.should == "/#{@q.slug}/#{@s.slug}"
-        @t.path.should == "/#{@q.slug}/#{@s.slug}/#{@t.slug}"
+        @q.path.should == "/q"
+        @r.path.should == "/q/r"
+        @s.path.should == "/q/s"
+        @t.path.should == "/q/s/t"
+      end
+
+      should "update paths when being adopted" do
+        @p.sub.adopt(@s)
+        @s.reload
+        @t.reload
+        @s.path.should == "/s"
+        @t.path.should == "/s/t"
       end
 
       should "all have a reference to the root node" do
@@ -217,18 +307,42 @@ class PageTest < MiniTest::Spec
         @t.ancestor(-1).should == @s
         @t.ancestor(-2).should == @q
       end
+
+      should "test for ancestry" do
+        @t.ancestor?(@s).should be_true
+        @t.ancestor?(@q).should be_true
+        @t.ancestor?(@p).should be_true
+        @q.ancestor?(@t).should be_false
+      end
+
+      should "know if it's in the current path" do
+        @t.active?(@s).should be_true
+        @t.active?(@t).should be_true
+        @t.active?(@q).should be_true
+        @t.active?(@p).should be_true
+        @q.active?(@t).should be_false
+      end
+
+      should "provide a list of pages at any depth" do
+        @t.at_depth(2).should == [@r, @s]
+        @p.at_depth(1).should == [@q]
+        lambda { @p.at_depth(2) }.must_raise(ArgumentError)
+      end
     end
 
     context "page pieces" do
       setup do
+        Page.box :things
+        Piece.box :things
         @parent = Page.create
         @piece = Piece.new
         @child = Page.new
-        @parent << @piece
-        @piece << @child
+        @parent.things << @piece
+        @piece.things << @child
         @parent.save
         @piece.save
         @child.save
+        @page_piece = @parent.things.first.things.first
       end
 
       should "report their depth according to their position in the piece tree" do
@@ -236,9 +350,26 @@ class PageTest < MiniTest::Spec
         @parent.pieces.first.depth.should == 1
         @parent.pieces.first.pieces.first.depth.should == 2
       end
-    end
-  end
 
+      should "know their page" do
+        @page_piece.page.should == @parent
+      end
+
+      should "know their container" do
+        @page_piece.container.should == @piece.things
+      end
 
-  # context ""
+      should "know their box" do
+        @page_piece.box.should == @piece.things
+      end
+
+      should "know their parent" do
+        @page_piece.parent.should == @piece
+      end
+
+      should "know their owner" do
+        @page_piece.owner.should == @piece
+      end
+    end
+  end
 end

data/test/unit/test_permissions.rb

@@ -1,18 +1,19 @@
 # encoding: UTF-8
 
-require 'test_helper'
+require File.expand_path('../../test_helper', __FILE__)
 
 
 class PermissionsTest < MiniTest::Spec
 
   def setup
-    Spontaneous::Schema.reset!
+    @site = setup_site
     Spontaneous::Content.delete
     Permissions::UserLevel.reset!
-    Permissions::UserLevel.level_file = File.expand_path('../../fixtures/permissions', __FILE__) / 'config/user_levels.yml'
+    Permissions::UserLevel.stubs(:level_file).returns(File.expand_path('../../fixtures/permissions', __FILE__) / 'config/user_levels.yml')
   end
 
   def teardown
+    teardown_site
     Permissions::AccessGroup.delete
     Permissions::AccessKey.delete
     Permissions::User.delete
@@ -424,6 +425,7 @@ class PermissionsTest < MiniTest::Spec
 
   context "Guards" do
     setup do
+      Permissions::User.delete
       @visitor = Permissions::User.create(:email => "visitor@example.com", :login => "visitor", :name => "visitor", :password => "visitorpass", :password_confirmation => "visitorpass")
       @editor = Permissions::User.create(:email => "editor@example.com", :login => "editor", :name => "editor", :password => "editorpass", :password_confirmation => "editorpass")
       @admin = Permissions::User.create(:email => "admin@example.com", :login => "admin", :name => "admin", :password => "adminpass", :password_confirmation => "adminpass")
@@ -503,152 +505,133 @@ class PermissionsTest < MiniTest::Spec
     should "protect field reads" do
       # without user (e.g. terminal/console access) everything is always
       # possible
-      @i.field_readable?(:editor_level).should be_true
-      @i.field_readable?(:admin_level).should be_true
-      @i.field_readable?(:root_level).should be_true
-      @i.field_readable?(:mixed_level).should be_true
-      @i.field_readable?(:default_level).should be_true
-
-      Permissions.with_user(@visitor) do
-        @i.field_readable?(:editor_level).should be_false
-        @i.field_readable?(:admin_level).should be_false
-        @i.field_readable?(:root_level).should be_false
-        @i.field_readable?(:mixed_level).should be_false
-        @i.field_readable?(:default_level).should be_true
-      end
-      Permissions.with_user(@editor) do
-        @i.field_readable?(:editor_level).should be_true
-        @i.field_readable?(:admin_level).should be_false
-        @i.field_readable?(:root_level).should be_false
-        @i.field_readable?(:mixed_level).should be_true
-        @i.field_readable?(:default_level).should be_true
-      end
-      Permissions.with_user(@admin) do
-        @i.field_readable?(:editor_level).should be_true
-        @i.field_readable?(:admin_level).should be_true
-        @i.field_readable?(:root_level).should be_false
-        @i.field_readable?(:mixed_level).should be_true
-        @i.field_readable?(:default_level).should be_true
-      end
-      Permissions.with_user(@root) do
-        @i.field_readable?(:editor_level).should be_true
-        @i.field_readable?(:admin_level).should be_true
-        @i.field_readable?(:root_level).should be_true
-        @i.field_readable?(:mixed_level).should be_true
-        @i.field_readable?(:default_level).should be_true
-      end
+      @i.field_readable?(nil, :editor_level).should be_true
+      @i.field_readable?(nil, :admin_level).should be_true
+      @i.field_readable?(nil, :root_level).should be_true
+      @i.field_readable?(nil, :mixed_level).should be_true
+      @i.field_readable?(nil, :default_level).should be_true
+
+      @i.field_readable?(@visitor, :editor_level).should be_false
+      @i.field_readable?(@visitor, :admin_level).should be_false
+      @i.field_readable?(@visitor, :root_level).should be_false
+      @i.field_readable?(@visitor, :mixed_level).should be_false
+      @i.field_readable?(@visitor, :default_level).should be_true
+
+      @i.field_readable?(@editor, :editor_level).should be_true
+      @i.field_readable?(@editor, :admin_level).should be_false
+      @i.field_readable?(@editor, :root_level).should be_false
+      @i.field_readable?(@editor, :mixed_level).should be_true
+      @i.field_readable?(@editor, :default_level).should be_true
+
+      @i.field_readable?(@admin, :editor_level).should be_true
+      @i.field_readable?(@admin, :admin_level).should be_true
+      @i.field_readable?(@admin, :root_level).should be_false
+      @i.field_readable?(@admin, :mixed_level).should be_true
+      @i.field_readable?(@admin, :default_level).should be_true
+
+      @i.field_readable?(@root, :editor_level).should be_true
+      @i.field_readable?(@root, :admin_level).should be_true
+      @i.field_readable?(@root, :root_level).should be_true
+      @i.field_readable?(@root, :mixed_level).should be_true
+      @i.field_readable?(@root, :default_level).should be_true
     end
 
     should "protect field writes" do
       # without user (e.g. terminal/console access) everything is always
       # possible
-      @i.field_writable?(:editor_level).should be_true
-      @i.field_writable?(:admin_level).should be_true
-      @i.field_writable?(:root_level).should be_true
-      @i.field_writable?(:mixed_level).should be_true
-      @i.field_writable?(:default_level).should be_true
-
-      Permissions.with_user(@visitor) do
-        @i.field_writable?(:editor_level).should be_false
-        @i.field_writable?(:admin_level).should be_false
-        @i.field_writable?(:root_level).should be_false
-        @i.field_writable?(:mixed_level).should be_false
-        @i.field_writable?(:default_level).should be_false
-      end
-      Permissions.with_user(@editor) do
-        @i.field_writable?(:editor_level).should be_true
-        @i.field_writable?(:admin_level).should be_false
-        @i.field_writable?(:root_level).should be_false
-        @i.field_writable?(:mixed_level).should be_false
-        @i.field_writable?(:default_level).should be_true
-      end
-      Permissions.with_user(@admin) do
-        @i.field_writable?(:editor_level).should be_true
-        @i.field_writable?(:admin_level).should be_true
-        @i.field_writable?(:root_level).should be_false
-        @i.field_writable?(:mixed_level).should be_false
-        @i.field_writable?(:default_level).should be_true
-      end
-      Permissions.with_user(@root) do
-        @i.field_writable?(:editor_level).should be_true
-        @i.field_writable?(:admin_level).should be_true
-        @i.field_writable?(:root_level).should be_true
-        @i.field_writable?(:mixed_level).should be_true
-        @i.field_writable?(:default_level).should be_true
-      end
+      @i.field_writable?(nil, :editor_level).should be_true
+      @i.field_writable?(nil, :admin_level).should be_true
+      @i.field_writable?(nil, :root_level).should be_true
+      @i.field_writable?(nil, :mixed_level).should be_true
+      @i.field_writable?(nil, :default_level).should be_true
+
+      @i.field_writable?(@visitor, :editor_level).should be_false
+      @i.field_writable?(@visitor, :admin_level).should be_false
+      @i.field_writable?(@visitor, :root_level).should be_false
+      @i.field_writable?(@visitor, :mixed_level).should be_false
+      @i.field_writable?(@visitor, :default_level).should be_false
+
+      @i.field_writable?(@editor, :editor_level).should be_true
+      @i.field_writable?(@editor, :admin_level).should be_false
+      @i.field_writable?(@editor, :root_level).should be_false
+      @i.field_writable?(@editor, :mixed_level).should be_false
+      @i.field_writable?(@editor, :default_level).should be_true
+
+      @i.field_writable?(@admin, :editor_level).should be_true
+      @i.field_writable?(@admin, :admin_level).should be_true
+      @i.field_writable?(@admin, :root_level).should be_false
+      @i.field_writable?(@admin, :mixed_level).should be_false
+      @i.field_writable?(@admin, :default_level).should be_true
+
+      @i.field_writable?(@root, :editor_level).should be_true
+      @i.field_writable?(@root, :admin_level).should be_true
+      @i.field_writable?(@root, :root_level).should be_true
+      @i.field_writable?(@root, :mixed_level).should be_true
+      @i.field_writable?(@root, :default_level).should be_true
     end
 
     should "protect box reads" do
-      @i.box_readable?(:editor_level).should be_true
-      @i.box_readable?(:admin_level).should be_true
-      @i.box_readable?(:root_level).should be_true
-      @i.box_readable?(:mixed_level).should be_true
-      @i.box_readable?(:default_level).should be_true
-
-      Permissions.with_user(@visitor) do
-        @i.box_readable?(:editor_level).should be_false
-        @i.box_readable?(:admin_level).should be_false
-        @i.box_readable?(:root_level).should be_false
-        @i.box_readable?(:mixed_level).should be_false
-        @i.box_readable?(:default_level).should be_true
-      end
-      Permissions.with_user(@editor) do
-        @i.box_readable?(:editor_level).should be_true
-        @i.box_readable?(:admin_level).should be_false
-        @i.box_readable?(:root_level).should be_false
-        @i.box_readable?(:mixed_level).should be_true
-        @i.box_readable?(:default_level).should be_true
-      end
-      Permissions.with_user(@admin) do
-        @i.box_readable?(:editor_level).should be_true
-        @i.box_readable?(:admin_level).should be_true
-        @i.box_readable?(:root_level).should be_false
-        @i.box_readable?(:mixed_level).should be_true
-        @i.box_readable?(:default_level).should be_true
-      end
-      Permissions.with_user(@root) do
-        @i.box_readable?(:editor_level).should be_true
-        @i.box_readable?(:admin_level).should be_true
-        @i.box_readable?(:root_level).should be_true
-        @i.box_readable?(:mixed_level).should be_true
-        @i.box_readable?(:default_level).should be_true
-      end
+      @i.box_readable?(nil, :editor_level).should be_true
+      @i.box_readable?(nil, :admin_level).should be_true
+      @i.box_readable?(nil, :root_level).should be_true
+      @i.box_readable?(nil, :mixed_level).should be_true
+      @i.box_readable?(nil, :default_level).should be_true
+
+      @i.box_readable?(@visitor, :editor_level).should be_false
+      @i.box_readable?(@visitor, :admin_level).should be_false
+      @i.box_readable?(@visitor, :root_level).should be_false
+      @i.box_readable?(@visitor, :mixed_level).should be_false
+      @i.box_readable?(@visitor, :default_level).should be_true
+
+      @i.box_readable?(@editor, :editor_level).should be_true
+      @i.box_readable?(@editor, :admin_level).should be_false
+      @i.box_readable?(@editor, :root_level).should be_false
+      @i.box_readable?(@editor, :mixed_level).should be_true
+      @i.box_readable?(@editor, :default_level).should be_true
+
+      @i.box_readable?(@admin, :editor_level).should be_true
+      @i.box_readable?(@admin, :admin_level).should be_true
+      @i.box_readable?(@admin, :root_level).should be_false
+      @i.box_readable?(@admin, :mixed_level).should be_true
+      @i.box_readable?(@admin, :default_level).should be_true
+
+      @i.box_readable?(@root, :editor_level).should be_true
+      @i.box_readable?(@root, :admin_level).should be_true
+      @i.box_readable?(@root, :root_level).should be_true
+      @i.box_readable?(@root, :mixed_level).should be_true
+      @i.box_readable?(@root, :default_level).should be_true
     end
     should "protect box writes" do
-      @i.box_writable?(:editor_level).should be_true
-      @i.box_writable?(:admin_level).should be_true
-      @i.box_writable?(:root_level).should be_true
-      @i.box_writable?(:mixed_level).should be_true
-      @i.box_writable?(:default_level).should be_true
-
-      Permissions.with_user(@visitor) do
-        @i.box_writable?(:editor_level).should be_false
-        @i.box_writable?(:admin_level).should be_false
-        @i.box_writable?(:root_level).should be_false
-        @i.box_writable?(:mixed_level).should be_false
-        @i.box_writable?(:default_level).should be_false
-      end
-      Permissions.with_user(@editor) do
-        @i.box_writable?(:editor_level).should be_true
-        @i.box_writable?(:admin_level).should be_false
-        @i.box_writable?(:root_level).should be_false
-        @i.box_writable?(:mixed_level).should be_false
-        @i.box_writable?(:default_level).should be_true
-      end
-      Permissions.with_user(@admin) do
-        @i.box_writable?(:editor_level).should be_true
-        @i.box_writable?(:admin_level).should be_true
-        @i.box_writable?(:root_level).should be_false
-        @i.box_writable?(:mixed_level).should be_false
-        @i.box_writable?(:default_level).should be_true
-      end
-      Permissions.with_user(@root) do
-        @i.box_writable?(:editor_level).should be_true
-        @i.box_writable?(:admin_level).should be_true
-        @i.box_writable?(:root_level).should be_true
-        @i.box_writable?(:mixed_level).should be_true
-        @i.box_writable?(:default_level).should be_true
-      end
+      @i.box_writable?(nil, :editor_level).should be_true
+      @i.box_writable?(nil, :admin_level).should be_true
+      @i.box_writable?(nil, :root_level).should be_true
+      @i.box_writable?(nil, :mixed_level).should be_true
+      @i.box_writable?(nil, :default_level).should be_true
+
+      @i.box_writable?(@visitor, :editor_level).should be_false
+      @i.box_writable?(@visitor, :admin_level).should be_false
+      @i.box_writable?(@visitor, :root_level).should be_false
+      @i.box_writable?(@visitor, :mixed_level).should be_false
+      @i.box_writable?(@visitor, :default_level).should be_false
+
+      @i.box_writable?(@editor, :editor_level).should be_true
+      @i.box_writable?(@editor, :admin_level).should be_false
+      @i.box_writable?(@editor, :root_level).should be_false
+      @i.box_writable?(@editor, :mixed_level).should be_false
+      @i.box_writable?(@editor, :default_level).should be_true
+
+      @i.box_writable?(@admin, :editor_level).should be_true
+      @i.box_writable?(@admin, :admin_level).should be_true
+      @i.box_writable?(@admin, :root_level).should be_false
+      @i.box_writable?(@admin, :mixed_level).should be_false
+      @i.box_writable?(@admin, :default_level).should be_true
+
+
+      @i.box_writable?(@root, :editor_level).should be_true
+      @i.box_writable?(@root, :admin_level).should be_true
+      @i.box_writable?(@root, :root_level).should be_true
+      @i.box_writable?(@root, :mixed_level).should be_true
+      @i.box_writable?(@root, :default_level).should be_true
     end
 
     should "serialise only things in class viewable by the current user" do
@@ -669,60 +652,60 @@ class PermissionsTest < MiniTest::Spec
         ["default_level", expected]
       ]
 
-      Permissions.with_user(@root) do
-        C.export[:fields].map { |f| [f[:name], f[:writable]] }.should == expected
-        C.export[:boxes].map { |f| [f[:name], f[:writable]] }.should == expected
-        C.export[:boxes].map { |b| [b[:name], b[:fields].map {|f| [f[:name], f[:writable]]}] }.should == [
+      # Permissions.with_user(@root) do
+        C.export(@root)[:fields].map { |f| [f[:name], f[:writable]] }.should == expected
+        C.export(@root)[:boxes].map { |f| [f[:name], f[:writable]] }.should == expected
+        C.export(@root)[:boxes].map { |b| [b[:name], b[:fields].map {|f| [f[:name], f[:writable]]}] }.should == [
           ["editor_level", expected],
           ["admin_level", expected],
           ["root_level", expected],
           ["mixed_level", expected],
           ["default_level", expected]
         ]
-      end
+      # end
 
-      Permissions.with_user(@visitor) do
+      # Permissions.with_user(@visitor) do
         expected = [
           ["default_level", false]
         ]
-        C.export[:fields].map { |f| [f[:name], f[:writable]] }.should == expected
-        C.export[:boxes].map { |f| [f[:name], f[:writable]] }.should == expected
-        C.export[:boxes].map { |b| [b[:name], b[:fields].map {|f| [f[:name], f[:writable]]}] }.should == [
+        C.export(@visitor)[:fields].map { |f| [f[:name], f[:writable]] }.should == expected
+        C.export(@visitor)[:boxes].map { |f| [f[:name], f[:writable]] }.should == expected
+        C.export(@visitor)[:boxes].map { |b| [b[:name], b[:fields].map {|f| [f[:name], f[:writable]]}] }.should == [
           ["default_level", expected ]
         ]
-      end
+      # end
 
-      Permissions.with_user(@editor) do
+      # Permissions.with_user(@editor) do
         expected = [
           ["editor_level", true],
           ["mixed_level", false],
           ["default_level", true]
         ]
-        C.export[:fields].map { |f| [f[:name], f[:writable]] }.should == expected
-        C.export[:boxes].map { |f| [f[:name], f[:writable]] }.should == expected
-        C.export[:boxes].map { |b| [b[:name], b[:fields].map {|f| [f[:name], f[:writable]]}] }.should == [
+        C.export(@editor)[:fields].map { |f| [f[:name], f[:writable]] }.should == expected
+        C.export(@editor)[:boxes].map { |f| [f[:name], f[:writable]] }.should == expected
+        C.export(@editor)[:boxes].map { |b| [b[:name], b[:fields].map {|f| [f[:name], f[:writable]]}] }.should == [
           ["editor_level", expected],
           ["mixed_level", expected],
           ["default_level", expected]
         ]
-      end
+      # end
 
-      Permissions.with_user(@admin) do
+      # Permissions.with_user(@admin) do
         expected = [
           ["editor_level", true],
           ["admin_level", true],
           ["mixed_level", false],
           ["default_level", true]
         ]
-        C.export[:fields].map { |f| [f[:name], f[:writable]] }.should == expected
-        C.export[:boxes].map { |f| [f[:name], f[:writable]] }.should == expected
-        C.export[:boxes].map { |b| [b[:name], b[:fields].map {|f| [f[:name], f[:writable]]}] }.should == [
+        C.export(@admin)[:fields].map { |f| [f[:name], f[:writable]] }.should == expected
+        C.export(@admin)[:boxes].map { |f| [f[:name], f[:writable]] }.should == expected
+        C.export(@admin)[:boxes].map { |b| [b[:name], b[:fields].map {|f| [f[:name], f[:writable]]}] }.should == [
           ["editor_level", expected],
           ["admin_level", expected],
           ["mixed_level", expected],
           ["default_level", expected]
         ]
-      end
+      # end
     end
 
     should "only list allowed types addable by the user" do
@@ -735,32 +718,32 @@ class PermissionsTest < MiniTest::Spec
       ]
       C.export[:boxes].map { |b| [b[:name], b[:allowed_types]] }.should == expected
 
-      Permissions.with_user(@root) do
-        C.export[:boxes].map { |b| [b[:name], b[:allowed_types]] }.should == expected
-      end
-      Permissions.with_user(@visitor) do
+      # Permissions.with_user(@root) do
+        C.export(@root)[:boxes].map { |b| [b[:name], b[:allowed_types]] }.should == expected
+      # end
+      # Permissions.with_user(@visitor) do
         expected = [
           ["default_level", []]
         ]
-        C.export[:boxes].map { |b| [b[:name], b[:allowed_types]] }.should == expected
-      end
-      Permissions.with_user(@editor) do
+        C.export(@visitor)[:boxes].map { |b| [b[:name], b[:allowed_types]] }.should == expected
+      # end
+      # Permissions.with_user(@editor) do
         expected = [
           ["editor_level", ["D"]],
           ["mixed_level", []],
           ["default_level", ["C"]]
         ]
-        C.export[:boxes].map { |b| [b[:name], b[:allowed_types]] }.should == expected
-      end
-      Permissions.with_user(@admin) do
+        C.export(@editor)[:boxes].map { |b| [b[:name], b[:allowed_types]] }.should == expected
+      # end
+      # Permissions.with_user(@admin) do
         expected = [
           ["editor_level", ["D", "C"]],
           ["admin_level", ["C"]],
           ["mixed_level", []],
           ["default_level", ["C"]]
         ]
-        C.export[:boxes].map { |b| [b[:name], b[:allowed_types]] }.should == expected
-      end
+        C.export(@admin)[:boxes].map { |b| [b[:name], b[:allowed_types]] }.should == expected
+      # end
     end
 
     should "serialise only things in instance viewable by the current user" do
@@ -779,55 +762,55 @@ class PermissionsTest < MiniTest::Spec
         ["mixed_level", expected],
         ["default_level", expected]
       ]
-      Permissions.with_user(@root) do
-        @i.export[:boxes].map { |f| f[:name] }.should == expected
-        @i.export[:boxes].map { |b| [b[:name], b[:fields].map {|f| f[:name]}] }.should == [
+      # Permissions.with_user(@root) do
+        @i.export(@root)[:boxes].map { |f| f[:name] }.should == expected
+        @i.export(@root)[:boxes].map { |b| [b[:name], b[:fields].map {|f| f[:name]}] }.should == [
           ["editor_level", expected],
           ["admin_level", expected],
           ["root_level", expected],
           ["mixed_level", expected],
           ["default_level", expected]
         ]
-      end
+      # end
 
-      Permissions.with_user(@visitor) do
-        @i.export[:boxes].map { |f| f[:name] }.should == [
+      # Permissions.with_user(@visitor) do
+        @i.export(@visitor)[:boxes].map { |f| f[:name] }.should == [
           "default_level"
         ]
-        @i.export[:boxes].map { |b| [b[:name], b[:fields].map {|f| f[:name]}] }.should == [
+        @i.export(@visitor)[:boxes].map { |b| [b[:name], b[:fields].map {|f| f[:name]}] }.should == [
           ["default_level", ["default_level"]]
         ]
-      end
+      # end
 
-      Permissions.with_user(@editor) do
+      # Permissions.with_user(@editor) do
         expected = [
           "editor_level",
           "mixed_level",
           "default_level"
         ]
-        @i.export[:boxes].map { |f| f[:name] }.should == expected
-        @i.export[:boxes].map { |b| [b[:name], b[:fields].map {|f| f[:name]}] }.should == [
+        @i.export(@editor)[:boxes].map { |f| f[:name] }.should == expected
+        @i.export(@editor)[:boxes].map { |b| [b[:name], b[:fields].map {|f| f[:name]}] }.should == [
           ["editor_level", expected],
           ["mixed_level", expected],
           ["default_level", expected]
         ]
-      end
+      # end
 
-      Permissions.with_user(@admin) do
+      # Permissions.with_user(@admin) do
         expected = [
           "editor_level",
           "admin_level",
           "mixed_level",
           "default_level"
         ]
-        @i.export[:boxes].map { |f| f[:name] }.should == expected
-        @i.export[:boxes].map { |b| [b[:name], b[:fields].map {|f| f[:name]}] }.should == [
+        @i.export(@admin)[:boxes].map { |f| f[:name] }.should == expected
+        @i.export(@admin)[:boxes].map { |b| [b[:name], b[:fields].map {|f| f[:name]}] }.should == [
           ["editor_level", expected],
           ["admin_level", expected],
           ["mixed_level", expected],
           ["default_level", expected]
         ]
-      end
+      # end
 
     end
   end