wagn 1.12.13 → 1.13.0.pre

data/spec/mods/core/sets/all/permissions_spec.rb

@@ -1,16 +1,15 @@
 # -*- encoding : utf-8 -*-
-require 'wagn/spec_helper'
 
 class ::Card
   def writeable_by(user)
-    Account.as(user.id) do
-    #warn "writeable #{Account.as_id}, #{user.inspect}"
+    Card::Auth.as(user.id) do
+    #warn "writeable #{Card::Auth.as_id}, #{user.inspect}"
       ok? :update
     end
   end
 
   def readable_by(user)
-    Account.as(user.id) do
+    Card::Auth.as(user.id) do
       ok? :read
     end
   end
@@ -20,19 +19,19 @@ end
 module PermissionSpecHelper
 
   def assert_hidden_from( user, card, msg='')
-    Account.as(user.id) { assert_hidden( card, msg ) }
+    Card::Auth.as(user.id) { assert_hidden( card, msg ) }
   end
 
   def assert_not_hidden_from( user, card, msg='')
-    Account.as(user.id) { assert_not_hidden( card, msg ) }
+    Card::Auth.as(user.id) { assert_not_hidden( card, msg ) }
   end
 
   def assert_locked_from( user, card, msg='')
-    Account.as(user.id) { assert_locked( card, msg ) }
+    Card::Auth.as(user.id) { assert_locked( card, msg ) }
   end
 
   def assert_not_locked_from( user, card, msg='')
-    Account.as(user.id) { assert_not_locked( card, msg ) }
+    Card::Auth.as(user.id) { assert_not_locked( card, msg ) }
   end
 
   def assert_hidden( card, msg='' )
@@ -69,37 +68,37 @@ describe Card::Set::All::Permissions do
       card = Card.fetch('Home')
       card.read_rule_id.should == Card.fetch('*all+*read').id
       card.who_can(:read).should ==  [Card::AnyoneID]
-      Account.as(:anonymous){ card.ok?(:read).should be_true }
+      Card::Auth.as(:anonymous){ card.ok?(:read).should be_true }
     end
 
     it "should update to role ('Anyone Signed In')" do
 
       name = @perm_card.name
-      Account.as_bot { @perm_card.save! }
+      Card::Auth.as_bot { @perm_card.save! }
       pc = Card[name]
       card = Card['Home']
       #warn "card #{name}, #{card.inspect}, #{pc.inspect}"
       pc.should be
       card.read_rule_id.should == pc.id
-      card.who_can(:read).should == [Card::AuthID]
-      Account.as(:anonymous){ card.ok?(:read).should be_false }
+      card.who_can(:read).should == [Card::AnyoneSignedInID]
+      Card::Auth.as(:anonymous){ card.ok?(:read).should be_false }
     end
 
     it "should update to user ('Joe Admin')" do
       @perm_card.content = '[[Joe Admin]]'
-      Account.as_bot { @perm_card.save! }
+      Card::Auth.as_bot { @perm_card.save! }
 
       card = Card.fetch('Home')
       card.read_rule_id.should == @perm_card.id
       card.who_can(:read).should == [Card['joe_admin'].id]
-      Account.as(:anonymous) { card.ok?(:read).should be_false }
-      Account.as(:joe_user)  { card.ok?(:read).should be_false }
-      Account.as(:joe_admin) { card.ok?(:read).should be_true  }
-      Account.as_bot         { card.ok?(:read).should be_true  }
+      Card::Auth.as(:anonymous) { card.ok?(:read).should be_false }
+      Card::Auth.as(:joe_user)  { card.ok?(:read).should be_false }
+      Card::Auth.as(:joe_admin) { card.ok?(:read).should be_true  }
+      Card::Auth.as_bot         { card.ok?(:read).should be_true  }
     end
 
     it "should revert to more general rule when more specific (self) rule is deleted" do
-      Account.as_bot do
+      Card::Auth.as_bot do
         @perm_card.save!
         @perm_card.delete!
       end
@@ -109,21 +108,21 @@ describe Card::Set::All::Permissions do
 
     it "should revert to more general rule when more specific (right) rule is deleted" do
       pc = nil
-      Account.as_bot do
+      Card::Auth.as_bot do
         pc=Card.create(:name=>'B+*right+*read', :type=>'Pointer', :content=>'[[Anyone Signed In]]')
       end
       pc.should be
       card = Card.fetch('A+B')
       card.read_rule_id.should == pc.id
       pc = Card.fetch(pc.name) #important to re-fetch to catch issues with detecting change in trash status.
-      Account.as_bot { pc.delete }
+      Card::Auth.as_bot { pc.delete }
       card = Card.fetch('A+B')
       card.read_rule_id.should == Card.fetch('*all+*read').id
     end
 
     it "should revert to more general rule when more specific rule is renamed" do
 
-      Account.as_bot do
+      Card::Auth.as_bot do
         @perm_card.save!
         @perm_card = Card[@perm_card.name]
         @perm_card.name = 'Something else+*self+*read'
@@ -135,7 +134,7 @@ describe Card::Set::All::Permissions do
     end
 
     it "should not be overruled by a more general rule added later" do
-      Account.as_bot do
+      Card::Auth.as_bot do
         @perm_card.save!
         c= Card.fetch('Home')
         c.type_id = Card::PhraseID
@@ -149,7 +148,7 @@ describe Card::Set::All::Permissions do
 
     it "should get updated when trunk type change makes type-plus-right apply / unapply" do
       @perm_card.name = "Phrase+B+*type plus right+*read"
-      Account.as_bot { @perm_card.save! }
+      Card::Auth.as_bot { @perm_card.save! }
       Card.fetch('A+B').read_rule_id.should == Card.fetch('*all+*read').id
       c = Card.fetch('A')
       c.type_id = Card::PhraseID
@@ -158,20 +157,20 @@ describe Card::Set::All::Permissions do
     end
 
     it "should work with relative settings" do
-      Account.as_bot do
+      Card::Auth.as_bot do
         @perm_card.save!
         all_plus = Card.fetch '*all plus+*read', :new=>{:content=>'_left'}
         all_plus.save
       end
       c = Card.new(:name=>'Home+Heart')
-      c.who_can(:read).should == [Card::AuthID]
+      c.who_can(:read).should == [Card::AnyoneSignedInID]
       c.permission_rule_card(:read).first.id.should == @perm_card.id
       c.save
       c.read_rule_id.should == @perm_card.id
     end
 
     it "should get updated when relative settings change" do
-      Account.as_bot do
+      Card::Auth.as_bot do
         all_plus = Card.fetch '*all plus+*read', :new=>{:content=>'_left'}
         all_plus.save
       end
@@ -180,21 +179,21 @@ describe Card::Set::All::Permissions do
       c.permission_rule_card(:read).first.id.should == Card.fetch('*all+*read').id
       c.save
       c.read_rule_id.should == Card.fetch('*all+*read').id
-      Account.as_bot { @perm_card.save! }
+      Card::Auth.as_bot { @perm_card.save! }
       c2 = Card.fetch('Home+Heart')
-      c2.who_can(:read).should == [Card::AuthID]
+      c2.who_can(:read).should == [Card::AnyoneSignedInID]
       c2.read_rule_id.should == @perm_card.id
       Card.fetch('Home+Heart').read_rule_id.should == @perm_card.id
-      Account.as_bot{ @perm_card.delete }
+      Card::Auth.as_bot{ @perm_card.delete }
       Card.fetch('Home').read_rule_id.should == Card.fetch('*all+*read').id
       Card.fetch('Home+Heart').read_rule_id.should == Card.fetch('*all+*read').id
     end
 
     it "should insure that class overrides work with relative settings" do
-      Account.as_bot do
+      Card::Auth.as_bot do
         all_plus = Card.fetch '*all plus+*read', :new => { :content=>'_left' }
         all_plus.save
-        Account.as_bot { @perm_card.save! }
+        Card::Auth.as_bot { @perm_card.save! }
         c = Card.create(:name=>'Home+Heart')
         c.read_rule_id.should == @perm_card.id
         r = Card.create(:name=>'Heart+*right+*read', :type=>'Pointer', :content=>'[[Administrator]]')
@@ -213,8 +212,8 @@ describe Card::Set::All::Permissions do
 
   context '??' do
     before do
-      Account.as_bot do
-  #      Account.cache.reset
+      Card::Auth.as_bot do
+  #      Card::Auth.cache.reset
         @u1, @u2, @u3, @r1, @r2, @r3, @c1, @c2, @c3 =
           %w( u1 u2 u3 r1 r2 r3 c1 c2 c3 ).map do |x| Card[x] end
       end
@@ -222,19 +221,19 @@ describe Card::Set::All::Permissions do
 
 
     it "checking ok read should not add to errors" do
-      Account.as_bot do
-        Account.always_ok?.should == true
+      Card::Auth.as_bot do
+        Card::Auth.always_ok?.should == true
       end
-      Account.as(:joe_user) do
-        Account.always_ok?.should == false
+      Card::Auth.as(:joe_user) do
+        Card::Auth.always_ok?.should == false
       end
-      Account.as(:joe_admin) do
-        Account.always_ok?.should == true
+      Card::Auth.as(:joe_admin) do
+        Card::Auth.always_ok?.should == true
         Card.create! :name=>"Hidden"
         Card.create(:name=>'Hidden+*self+*read', :type=>'Pointer', :content=>'[[Anyone Signed In]]')
       end
 
-      Account.as(:anonymous) do
+      Card::Auth.as(:anonymous) do
         h = Card.fetch('Hidden')
         h.ok?(:read).should == false
         h.errors.empty?.should_not == nil
@@ -242,7 +241,7 @@ describe Card::Set::All::Permissions do
     end
 
     it "should be granted to admin if to anybody" do
-      Account.as_bot do
+      Card::Auth.as_bot do
         c1 = Card['c1']
         Card.create! :name=>'c1+*self+*comment', :type=>'Pointer', :content=>'[[r1]]'
         c1.who_can( :comment ).should == [Card['r1'].id]
@@ -261,7 +260,7 @@ describe Card::Set::All::Permissions do
 
 
     it "write user permissions" do
-      Account.as_bot do
+      Card::Auth.as_bot do
         @u1.fetch(:trait=>:roles, :new=>{}).items = [@r1, @r2]
         @u2.fetch(:trait=>:roles, :new=>{}).items = [@r1, @r3]
         @u3.fetch(:trait=>:roles, :new=>{}).items = [@r1, @r2, @r3]
@@ -283,7 +282,7 @@ describe Card::Set::All::Permissions do
     end
 
     it "read group permissions" do
-      Account.as_bot do
+      Card::Auth.as_bot do
         @u1.fetch(:trait=>:roles).items = [@r1, @r2]
         @u2.fetch(:trait=>:roles).items = [@r1, @r3]
 
@@ -302,7 +301,7 @@ describe Card::Set::All::Permissions do
     end
 
     it "write group permissions" do
-      Account.as_bot do
+      Card::Auth.as_bot do
         [1,2,3].each do |num|
           Card.create(:name=>"c#{num}+*self+*update", :type=>'Pointer', :content=>"[[r#{num}]]")
         end
@@ -328,7 +327,7 @@ describe Card::Set::All::Permissions do
     end
 
     it "read user permissions" do
-      Account.as_bot {
+      Card::Auth.as_bot {
         @u1.fetch(:trait=>:roles, :new=>{}).items = [@r1, @r2]
         @u2.fetch(:trait=>:roles, :new=>{}).items = [@r1, @r3]
         @u3.fetch(:trait=>:roles, :new=>{}).items = [@r1, @r2, @r3]
@@ -351,14 +350,14 @@ describe Card::Set::All::Permissions do
     
     context "create permissions" do
       before do
-        Account.as_bot do
+        Card::Auth.as_bot do
           Card.create! :name=>'*structure+*right+*create', :type=>'Pointer', :content=>'[[Anyone Signed In]]'
           Card.create! :name=>'*self+*right+*create',      :type=>'Pointer', :content=>'[[Anyone Signed In]]'
         end
       end
       
       it "should inherit" do
-        Account.as(:auth) do
+        Card::Auth.as(:anyone_signed_in) do
           Card.fetch( 'A+*self' ).ok?(:create).should be_true #explicitly granted above
           Card.fetch( 'A+*right').ok?(:create).should be_false #by default restricted   
           
@@ -372,17 +371,17 @@ describe Card::Set::All::Permissions do
 
     it "private wql" do
       # set up cards of type TestType, 2 with nil reader, 1 with role1 reader
-       Account.as_bot do
+       Card::Auth.as_bot do
          [@c1,@c2,@c3].each do |c|
            c.update_attributes :content => 'WeirdWord'
          end
          Card.create(:name=>"c1+*self+*read", :type=>'Pointer', :content=>"[[u1]]")
        end
 
-       Account.as(@u1) do
+       Card::Auth.as(@u1) do
          Card.search(:content=>'WeirdWord').map(&:name).sort.should == %w( c1 c2 c3 )
        end
-       Account.as(@u2) do
+       Card::Auth.as(@u2) do
          Card.search(:content=>'WeirdWord').map(&:name).sort.should == %w( c2 c3 )
        end
     end
@@ -391,18 +390,18 @@ describe Card::Set::All::Permissions do
       #warn "u1 roles #{Card[ @u1.id ].fetch(:trait=>:roles).item_names.inspect}"
 
       # set up cards of type TestType, 2 with nil reader, 1 with role1 reader
-      Account.as_bot do
+      Card::Auth.as_bot do
         [@c1,@c2,@c3].each do |c|
           c.update_attributes :content => 'WeirdWord'
         end
         Card.create(:name=>"c1+*self+*read", :type=>'Pointer', :content=>"[[r3]]")
       end
 
-      Account.as(@u1) do
+      Card::Auth.as(@u1) do
         Card.search(:content=>'WeirdWord').map(&:name).sort.should == %w( c1 c2 c3 )
       end
-      Account.current_id =nil # for Account.as to be effective, you can't have a logged in user
-      Account.as(@u2) do
+      Card::Auth.current_id =nil # for Card::Auth.as to be effective, you can't have a logged in user
+      Card::Auth.as(@u2) do
         Card.search(:content=>'WeirdWord').map(&:name).sort.should == %w( c2 c3 )
       end
     end
@@ -443,13 +442,13 @@ describe Card::Set::All::Permissions do
     end
 
     it "should let anonymous users view basic cards" do
-      Account.as :anonymous do
+      Card::Auth.as :anonymous do
         @c.ok?(:read).should be_true
       end
     end
 
     it "should let joe user basic cards" do
-      Account.as :joe_user do
+      Card::Auth.as :joe_user do
         @c.ok?(:read).should be_true
       end
     end
@@ -460,7 +459,7 @@ describe Card::Set::All::Permissions do
   end
 
   it "should not allow someone not signed in to create Basic Cards" do
-    Account.as :anonymous do
+    Card::Auth.as :anonymous do
       Card.new.ok?(:create).should_not be_true
     end
   end
@@ -469,7 +468,7 @@ describe Card::Set::All::Permissions do
 
   context "settings based permissions" do
     before do
-      Account.as_bot do
+      Card::Auth.as_bot do
         @delete_rule_card = Card.fetch '*all+*delete', :new=>{}
         @delete_rule_card.type_id = Card::PointerID
         @delete_rule_card.content = '[[Joe_User]]'
@@ -480,16 +479,16 @@ describe Card::Set::All::Permissions do
     it "should handle delete as a setting" do
       c = Card.new :name=>'whatever'
       c.who_can(:delete).should == [Card['joe_user'].id]
-      Account.as(:joe_user) do
+      Card::Auth.as(:joe_user) do
         c.ok?(:delete).should == true
       end
-      Account.as(:u1) do
+      Card::Auth.as(:u1) do
         c.ok?(:delete).should == false
       end
-      Account.as(:anonymous) do
+      Card::Auth.as(:anonymous) do
         c.ok?(:delete).should == false
       end
-      Account.as_bot do
+      Card::Auth.as_bot do
         c.ok?(:delete).should == true #because administrator
       end
     end

data/spec/mods/core/sets/all/phases_spec.rb

@@ -1,6 +1,5 @@
 # -*- encoding : utf-8 -*-
-require 'wagn/spec_helper'
 
 describe Card::Set::All::Phases do
-  # SPECSTUB (low priority)
+  # SPECSTUB
 end

data/spec/mods/core/sets/all/references_spec.rb

@@ -1,5 +1,4 @@
 # -*- encoding : utf-8 -*-
-require 'wagn/spec_helper'
 
 describe Card::Set::All::References do
   it "should replace references should work on inclusions inside links" do

data/spec/mods/core/sets/all/rules2_spec.rb

@@ -1,14 +1,16 @@
 # -*- encoding : utf-8 -*-
-require 'wagn/spec_helper'
 
 
 #FIXME - this seems like a LOT of testing but it doesn't cover a ton of ground
 # I think we should move the rendering tests into basic and trim this to about a quarter of its current length
 
 describe Card do
-  context 'when there is a general toc setting of 2' do
+  context 'when there is a general toc rule of 2' do
 
     before do
+      Card::Auth.as_bot do
+        Card.create! :name=>'Basic+*type+*table of contents', :content=>'2'
+      end
       (@c1 = Card['Onne Heading']).should be
       (@c2 = Card['Twwo Heading']).should be
       (@c3 = Card['Three Heading']).should be
@@ -25,13 +27,13 @@ describe Card do
 
     describe "renders with/without toc" do
       it "should not render for 'Onne Heading'" do
-        Card::Format.new(@c1).render_open_content.should_not match /Table of Contents/
+        @c1.format.render_open_content.should_not match /Table of Contents/
       end
       it "should render for 'Twwo Heading'" do
-        Card::Format.new(@c2).render_open_content.should match /Table of Contents/
+        @c2.format.render_open_content.should match /Table of Contents/
       end
       it "should render for 'Three Heading'" do
-        Card::Format.new(@c3).render_open_content.should match /Table of Contents/
+        @c3.format.render_open_content.should match /Table of Contents/
       end
     end
 
@@ -51,12 +53,12 @@ describe Card do
         sets.should == ['Cardtype A+*type', 'Cardtype A+*self', 'Cardtype A+*right']
       end
 #      it "should show type plus right sets when they exist" do
-#        Account.as_bot { Card.create :name=>'Basic+A+*type plus right', :content=>'' }
+#        Card::Auth.as_bot { Card.create :name=>'Basic+A+*type plus right', :content=>'' }
 #        sets = Card['A'].related_sets
 #        sets.should == ['A+*self', 'A+*right', 'Basic+A+*type plus right']
 #      end
 #      it "should show type plus right sets when they exist, and type" do
-#        Account.as_bot { Card.create :name=>'Basic+Cardtype A+*type plus right', :content=>'' }
+#        Card::Auth.as_bot { Card.create :name=>'Basic+Cardtype A+*type plus right', :content=>'' }
 #        sets = Card['Cardtype A'].related_sets
 #        sets.should == ['Cardtype A+*self', 'Cardtype A+*type', 'Cardtype A+*right', 'Basic+Cardtype A+*type plus right']
 #      end
@@ -65,14 +67,14 @@ describe Card do
         sets.should == ['A+B+*self']
       end
     end
-
+=begin
     # class methods
     describe ".default_rule" do
       it 'should have default rule' do
         Card.default_rule(:table_of_contents).should == '0'
       end
     end
-
+=end
   end
 
   context "when I change the general toc setting to 1" do
@@ -94,15 +96,15 @@ describe Card do
 
     describe "renders with/without toc" do
       it "should not render toc for 'Onne Heading'" do
-        Card::Format.new(@c1).render_open_content.should match /Table of Contents/
+        @c1.format.render_open_content.should match /Table of Contents/
       end
       it "should render toc for 'Twwo Heading'" do
-        Card::Format.new(@c2).render_open_content.should match /Table of Contents/
+        @c2.format.render_open_content.should match /Table of Contents/
       end
       it "should not render for 'Twwo Heading' when changed to 3" do
         @rule_card.content = "3"
         @c2.rule(:table_of_contents).should == "3"
-        Card::Format.new(@c2).render_open_content.should_not match /Table of Contents/
+        @c2.format.render_open_content.should_not match /Table of Contents/
       end
     end
 
@@ -111,7 +113,7 @@ describe Card do
   context 'when I use CardtypeE cards' do
 
     before do
-      Account.as_bot do
+      Card::Auth.as_bot do
         @c1 = Card.create :name=>'toc1', :type=>"CardtypeE",
           :content=>Card['Onne Heading'].content
         @c2 = Card.create :name=>'toc2', :type=>"CardtypeE",
@@ -137,13 +139,13 @@ describe Card do
 
     describe "renders without toc" do
       it "should not render for 'Onne Heading'" do
-        Card::Format.new(@c1).render_open_content.should_not match /Table of Contents/
+        @c1.format.render_open_content.should_not match /Table of Contents/
       end
       it "should render for 'Twwo Heading'" do
-        Card::Format.new(@c2).render_open_content.should_not match /Table of Contents/
+        @c2.format.render_open_content.should_not match /Table of Contents/
       end
       it "should render for 'Three Heading'" do
-        Card::Format.new(@c3).render_open_content.should_not match /Table of Contents/
+        @c3.format.render_open_content.should_not match /Table of Contents/
       end
     end
 
@@ -158,25 +160,23 @@ describe Card do
       end
     end
 
+=begin
     # class methods
     describe ".default_rule" do
       it 'should have default rule' do
         Card.default_rule(:table_of_contents).should == '0'
       end
     end
-
+=end
   end
 
   context "when I create a new rule" do
     before do
-      Account.as_bot do
-        @c1 = Card.create :name=>'toc1', :type=>"CardtypeE",
-          :content=>Card['Onne Heading'].content
-        # FIXME: CardtypeE should inherit from *default => Basic
-        @c2 = Card.create :name=>'toc2', #:type=>"CardtypeE",
-          :content=>Card['Twwo Heading'].content
-        @c3 = Card.create :name=>'toc3', #:type=>"CardtypeE",
-          :content=>Card['Three Heading'].content
+      Card::Auth.as_bot do
+        Card.create! :name=>'Basic+*type+*table of contents', :content=>'2'
+        @c1 = Card.create! :name=>'toc1', :type=>"CardtypeE", :content=>Card['Onne Heading'].content
+        @c2 = Card.create! :name=>'toc2', :content=>Card['Twwo Heading'].content
+        @c3 = Card.create! :name=>'toc3', :content=>Card['Three Heading'].content
         @c1.type_name.should == 'Cardtype E'
         @rule_card = @c1.rule_card(:table_of_contents)
 
@@ -200,14 +200,14 @@ describe Card do
 
     describe "renders with/without toc" do
       it "should not render for 'Onne Heading'" do
-        Card::Format.new(@c1).render_open_content.should_not match /Table of Contents/
+        @c1.format.render_open_content.should_not match /Table of Contents/
       end
       it "should render for 'Twwo Heading'" do
         @c2.rule(:table_of_contents).should == "2"
-        Card::Format.new(@c2).render_open_content.should match /Table of Contents/
+        @c2.format.render_open_content.should match /Table of Contents/
       end
       it "should render for 'Three Heading'" do
-        Card::Format.new(@c3).render_open_content.should match /Table of Contents/
+        @c3.format.render_open_content.should match /Table of Contents/
       end
     end
   end
@@ -234,14 +234,14 @@ describe Card do
 
     describe "renders with/without toc" do
       it "should not render toc for 'Onne Heading'" do
-        Card::Format.new(@c1).render_open_content.should match /Table of Contents/
+        @c1.format.render_open_content.should match /Table of Contents/
       end
       it "should render toc for 'Twwo Heading'" do
-        Card::Format.new(@c2).render_open_content.should match /Table of Contents/
+        @c2.format.render_open_content.should match /Table of Contents/
       end
       it "should not render for 'Twwo Heading' when changed to 3" do
         @rule_card.content = "3"
-        Card::Format.new(@c2).render_open_content.should_not match /Table of Contents/
+        @c2.format.render_open_content.should_not match /Table of Contents/
       end
     end