wagn 1.13.0 → 1.14.0.pre1

data/mod/01_core/spec/set/all/notify_spec.rb

@@ -0,0 +1,199 @@
+shared_examples_for 'notifications' do
+  # describe '#change_notice' do
+  #   context 'for new card with subcards' do
+  #     name = "another card with subcards"
+  #     content = "main content {{+s1}}  {{+s2}}"
+  #     sub1_content = 'new content of subcard 1'
+  #     sub2_content = 'new content of subcard 2'
+  #     before do
+  #       Card::Auth.as_bot do
+  #         @card = Card.create!(:name=>name, :content=>content,
+  #                              :subcards=>{ '+s1'=>{:content=>sub1_content},
+  #                                           '+s2'=>{:content=>sub2_content} })
+  #       end
+  #     end
+  #     subject { @card.format(:format=>format).render_change_notice }
+  #     it { is_expected.to include content }
+  #     it { is_expected.to include sub1_content }
+  #     it { is_expected.to include sub2_content }
+  #
+  #     context 'and missing permissions' do
+  #       subject { Card.fetch(@card.name).format(:format=>format).render_change_notice }
+  #       context 'for subcard' do
+  #         before do
+  #           Card.create_or_update! "#{name}+s1+*self+*read",:type=>'Pointer',:content=>'[[Administrator]]'
+  #         end
+  #         it "excludes subcard content" do
+  #           Card::Auth.as(:joe_user) do
+  #             is_expected.not_to include sub1_content
+  #             is_expected.to include sub2_content
+  #           end
+  #         end
+  #       end
+  #       context 'for main card' do
+  #         before do
+  #           Card.create_or_update! "#{name}+*self+*read",:type=>'Pointer',:content=>'[[Administrator]]'
+  #           Card.create_or_update! "#{name}+s1+*self+*read",:type=>'Pointer',:content=>'[[Anyone]]'
+  #         end
+  #         it 'includes subcard content' do
+  #           Card::Auth.as(:joe_user) do
+  #             is_expected.to include sub1_content
+  #          end
+  #        end
+  #         it "excludes maincard content" do
+  #           Card::Auth.as(:joe_user) do
+  #             is_expected.not_to include content
+  #             is_expected.not_to be_empty
+  #           end
+  #         end
+  #       end
+  #       context 'for all parts' do
+  #         before do
+  #           #Card.create_or_update! "#{name}+s1+*self+*read",:type=>'Pointer',:content=>'[[Administrator]]'
+  #           #Card.create_or_update! "#{name}+s2+*self+*read",:type=>'Pointer',:content=>'[[Administrator]]'
+  #           Card.create_or_update! "s1+*self+*read",:type=>'Pointer',:content=>'[[Administrator]]'
+  #           Card.create_or_update! "s2+*self+*read",:type=>'Pointer',:content=>'[[Administrator]]'
+  #           Card.create_or_update! "#{name}+*self+*read",:type=>'Pointer',:content=>'[[Administrator]]'
+  #         end
+  #         it { is_expected.to be_empty }
+  #       end
+  #     end
+  #   end
+  # end
+
+  describe '#list_of_changes' do
+    name = 'subedit notice'
+    content = 'new content'
+    
+    before do
+      @card = Card.create!(:name=>name, :content=>content)
+    end
+    subject { @card.format(:format=>format).render_list_of_changes }
+    
+    context 'for a new card' do
+      it { is_expected.to include "content: #{content}" }
+      it { is_expected.to include 'cardtype: Basic' }
+    end
+    context 'for a updated card' do
+      before { @card.update_attributes!(:name=>'bnn card', :type=>:pointer, :content=>'changed content') }
+      it { is_expected.to include 'new content: [[changed content]]' }
+      it { is_expected.to include 'new cardtype: Pointer' }
+      it { is_expected.to include 'new name: bnn card' }
+    end
+    context 'for a deleted card' do
+      before { @card.delete }
+      it { is_expected.to be_empty }
+    end
+    
+    context 'for a given action' do
+      subject do
+        action = @card.last_action
+        @card.update_attributes!(:name=>'bnn card', :type=>:pointer, :content=>'changed content')
+        @card.format(:format=>format).render_list_of_changes(:action=>action)
+      end
+      it { is_expected.to include "content: #{content}" }
+    end
+    context 'for a given action id' do
+      subject do
+        action_id = @card.last_action.id
+        @card.update_attributes!(:name=>'bnn card', :type=>:pointer, :content=>'changed content')
+        @card.format(:format=>format).render_list_of_changes(:action_id=>action_id)
+      end
+      it { is_expected.to include "content: #{content}" }
+    end
+  end
+  
+  describe 'subedit_notice' do
+    def list_of_changes_for card
+      card.db_content
+    end
+    name = 'subedit notice card'
+    content = 'new content'
+    before do
+      @card = Card.create!(:name=>name, :content=>content)
+    end
+    subject { @card.format(:format=>format).render_subedit_notice }
+    
+    context 'for a new card' do
+      it { is_expected.to include name }
+      it { is_expected.to include 'created' }
+      it { is_expected.to include list_of_changes_for @card }
+    end
+    
+    context 'for a updated card' do
+      changed_name = 'changed subedit notice'
+      changed_content = 'changed content'
+      before { @card.update_attributes!(:name=>changed_name, :content=>changed_content) }
+      it { is_expected.to include changed_name }
+      it { is_expected.to include 'updated' }
+      it { is_expected.to include list_of_changes_for @card }
+    end
+    
+    context 'for a deleted card' do
+      before { @card.delete } 
+      it { is_expected.to include name }
+      it { is_expected.to include 'deleted' }
+    end
+  end
+end
+
+
+describe Card::Set::All::Notify do
+  describe 'html format' do
+    include_examples 'notifications' do
+      let(:format) { 'email_html' }
+    end
+
+    # it 'contains html' do
+ #      card = Card.create! :name=>'new card'
+ #      expect(card.format(:format=>:email_html).render_change_notice).to include '<p>'
+ #    end
+  end
+
+  describe 'text format' do
+    include_examples 'notifications' do
+      let(:format) { 'email_text' }
+    end
+
+#     it 'does not contain html' do
+#       card = Card.create! :name=>'new card'
+#       expect(card.format(:format=>:email_text).render_change_notice).not_to match /<\w+>/
+#     end
+#     it 'creates well formatted text message' do
+#       name = "another card with subcards"
+#       content = "main content {{+s1}}  {{+s2}}"
+#       sub1_content = 'new content of subcard 1'
+#       sub2_content = 'new content of subcard 2'
+#       Card::Auth.as_bot do
+#         @card = Card.create!(:name=>name, :content=>content,
+#                              :subcards=>{ '+s1'=>{:content=>sub1_content},
+#                                           '+s2'=>{:content=>sub2_content} })
+#       end
+#       result =  @card.format(:format=>:email_text).render_change_notice
+#       expect(result).to eq(%{Dear My Wagn user
+#
+# "another card with subcards"
+# was just created by Joe User
+#    cardtype: Basic
+#    content: main content {{+s1}}  {{+s2}}
+#
+# This update included the following changes:
+#
+# another card with subcards+s1 created
+#    cardtype: Basic
+#    content: new content of subcard 1
+#
+#
+# another card with subcards+s2 created
+#    cardtype: Basic
+#    content: new content of subcard 2
+#
+#
+# See the card: /another_card_with_subcards
+#
+# You received this email because you're following "".
+# Visit /update/+*following?drop_item= to stop receiving these emails.})
+#     end
+
+  end
+end

data/{spec/mod/core → mod/01_core/spec}/set/all/pattern_spec.rb

@@ -6,40 +6,40 @@ describe Card::Set::All::Pattern do
     it "returns self, type, all for simple cards" do
       Card::Auth.as_bot do
         card = Card.new( :name => "AnewCard" )
-        card.set_names.should == [ "Basic+*type","*all"]
+        expect(card.set_names).to eq([ "Basic+*type","*all"])
         card.save!
         card = Card.fetch("AnewCard")
-        card.set_names.should == [ "AnewCard+*self","Basic+*type","*all"]
+        expect(card.set_names).to eq([ "AnewCard+*self","Basic+*type","*all"])
       end
     end
 
     it "returns set names for simple star cards" do
       Card::Auth.as_bot do
-        Card.fetch('*update').set_names.should == [
+        expect(Card.fetch('*update').set_names).to eq([
           "*update+*self","*star","Setting+*type","*all"
-        ]
+        ])
       end
     end
 
     it "returns set names for junction cards" do
       Card::Auth.as_bot do
-        Card.new( :name=>"Iliad+author" ).set_names.should == [
+        expect(Card.new( :name=>"Iliad+author" ).set_names).to eq([
           "Book+author+*type plus right","author+*right","Basic+*type","*all plus","*all"
-        ]
+        ])
       end
     end
 
     it "returns set names for compound star cards" do
       Card::Auth.as_bot do
-        Card.new( :name=>"Iliad+*to" ).set_names.should == [
-          "Book+*to+*type plus right","*to+*right","*rstar","Phrase+*type","*all plus","*all"
-        ]
+        expect(Card.new( :name=>"Iliad+*to" ).set_names).to eq([
+          "Book+*to+*type plus right","*to+*right","*rstar","Pointer+*type","*all plus","*all"
+        ])
       end
     end
     
     it "handles type plus right prototypes properly" do #right place for this?  really need more prototype tests...
       Card::Auth.as_bot do
-        Card.fetch('Fruit+flavor+*type plus right').prototype.set_names.include?('Fruit+flavor+*type plus right').should be_true
+        expect(Card.fetch('Fruit+flavor+*type plus right').prototype.set_names.include?('Fruit+flavor+*type plus right')).to be_truthy
       end
     end
   end
@@ -48,7 +48,7 @@ describe Card::Set::All::Pattern do
   describe :rule_set_keys do
     it "returns correct set names for new cards" do
       card = Card.new :name => "AnewCard"
-      card.rule_set_keys.should == [ "#{Card::BasicID}+type", "all"]
+      expect(card.rule_set_keys).to eq([ "#{Card::BasicID}+type", "all"])
     end
     
   end
@@ -57,25 +57,25 @@ describe Card::Set::All::Pattern do
     it "returns css names for simple star cards" do
       Card::Auth.as_bot do
         card = Card.new( :name => "*AnewCard")
-        card.safe_set_keys.should == "ALL TYPE-basic STAR"
+        expect(card.safe_set_keys).to eq("ALL TYPE-basic STAR")
         card.save!
         card = Card.fetch("*AnewCard")
-        card.safe_set_keys.should == "ALL TYPE-basic STAR SELF-Xanew_card"
+        expect(card.safe_set_keys).to eq("ALL TYPE-basic STAR SELF-Xanew_card")
       end
     end
 
     it "returns set names for junction cards" do
       card=Card.new( :name=>"Iliad+author" )
-      card.safe_set_keys.should == "ALL ALL_PLUS TYPE-basic RIGHT-author TYPE_PLUS_RIGHT-book-author"
+      expect(card.safe_set_keys).to eq("ALL ALL_PLUS TYPE-basic RIGHT-author TYPE_PLUS_RIGHT-book-author")
       card.save!
       card = Card.fetch("Iliad+author")
-      card.safe_set_keys.should == "ALL ALL_PLUS TYPE-basic RIGHT-author TYPE_PLUS_RIGHT-book-author SELF-iliad-author"
+      expect(card.safe_set_keys).to eq("ALL ALL_PLUS TYPE-basic RIGHT-author TYPE_PLUS_RIGHT-book-author SELF-iliad-author")
     end
   end
 
   describe :label do
     it "returns label for name" do
-      Card.new(:name=>'address+*right').label.should== %{All "+address" cards}
+      expect(Card.new(:name=>'address+*right').label).to eq(%{All "+address" cards})
     end
   end
 end

data/{spec/mod/core → mod/01_core/spec}/set/all/permissions_spec.rb

@@ -66,9 +66,9 @@ describe Card::Set::All::Permissions do
 
     it "should be *all+*read by default" do
       card = Card.fetch('Home')
-      card.read_rule_id.should == Card.fetch('*all+*read').id
-      card.who_can(:read).should ==  [Card::AnyoneID]
-      Card::Auth.as(:anonymous){ card.ok?(:read).should be_true }
+      expect(card.read_rule_id).to eq(Card.fetch('*all+*read').id)
+      expect(card.who_can(:read)).to eq([Card::AnyoneID])
+      Card::Auth.as(:anonymous){ expect(card.ok?(:read)).to be_truthy }
     end
 
     it "should update to role ('Anyone Signed In')" do
@@ -78,10 +78,10 @@ describe Card::Set::All::Permissions do
       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::AnyoneSignedInID]
-      Card::Auth.as(:anonymous){ card.ok?(:read).should be_false }
+      expect(pc).to be
+      expect(card.read_rule_id).to eq(pc.id)
+      expect(card.who_can(:read)).to eq([Card::AnyoneSignedInID])
+      Card::Auth.as(:anonymous){ expect(card.ok?(:read)).to be_falsey }
     end
 
     it "should update to user ('Joe Admin')" do
@@ -89,12 +89,12 @@ describe Card::Set::All::Permissions do
       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]
-      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  }
+      expect(card.read_rule_id).to eq(@perm_card.id)
+      expect(card.who_can(:read)).to eq([Card['joe_admin'].id])
+      Card::Auth.as(:anonymous) { expect(card.ok?(:read)).to be_falsey }
+      Card::Auth.as(:joe_user)  { expect(card.ok?(:read)).to be_falsey }
+      Card::Auth.as(:joe_admin) { expect(card.ok?(:read)).to be_truthy  }
+      Card::Auth.as_bot         { expect(card.ok?(:read)).to be_truthy  }
     end
 
     it "should revert to more general rule when more specific (self) rule is deleted" do
@@ -103,7 +103,7 @@ describe Card::Set::All::Permissions do
         @perm_card.delete!
       end
       card = Card.fetch('Home')
-      card.read_rule_id.should == Card.fetch('*all+*read').id
+      expect(card.read_rule_id).to eq(Card.fetch('*all+*read').id)
     end
 
     it "should revert to more general rule when more specific (right) rule is deleted" do
@@ -111,13 +111,13 @@ describe Card::Set::All::Permissions do
       Card::Auth.as_bot do
         pc=Card.create(:name=>'B+*right+*read', :type=>'Pointer', :content=>'[[Anyone Signed In]]')
       end
-      pc.should be
+      expect(pc).to be
       card = Card.fetch('A+B')
-      card.read_rule_id.should == pc.id
+      expect(card.read_rule_id).to eq(pc.id)
       pc = Card.fetch(pc.name) #important to re-fetch to catch issues with detecting change in trash status.
       Card::Auth.as_bot { pc.delete }
       card = Card.fetch('A+B')
-      card.read_rule_id.should == Card.fetch('*all+*read').id
+      expect(card.read_rule_id).to eq(Card.fetch('*all+*read').id)
     end
 
     it "should revert to more general rule when more specific rule is renamed" do
@@ -130,7 +130,7 @@ describe Card::Set::All::Permissions do
       end
 
       card = Card.fetch('Home')
-      card.read_rule_id.should == Card.fetch('*all+*read').id
+      expect(card.read_rule_id).to eq(Card.fetch('*all+*read').id)
     end
 
     it "should not be overruled by a more general rule added later" do
@@ -143,17 +143,17 @@ describe Card::Set::All::Permissions do
       end
 
       card = Card.fetch('Home')
-      card.read_rule_id.should == @perm_card.id
+      expect(card.read_rule_id).to eq(@perm_card.id)
     end
 
     it "should get updated when trunk type change makes type-plus-right apply / unapply" do
       @perm_card.name = "Phrase+B+*type plus right+*read"
       Card::Auth.as_bot { @perm_card.save! }
-      Card.fetch('A+B').read_rule_id.should == Card.fetch('*all+*read').id
+      expect(Card.fetch('A+B').read_rule_id).to eq(Card.fetch('*all+*read').id)
       c = Card.fetch('A')
       c.type_id = Card::PhraseID
       c.save!
-      Card.fetch('A+B').read_rule_id.should == @perm_card.id
+      expect(Card.fetch('A+B').read_rule_id).to eq(@perm_card.id)
     end
 
     it "should work with relative settings" do
@@ -163,10 +163,10 @@ describe Card::Set::All::Permissions do
         all_plus.save
       end
       c = Card.new(:name=>'Home+Heart')
-      c.who_can(:read).should == [Card::AnyoneSignedInID]
-      c.permission_rule_card(:read).first.id.should == @perm_card.id
+      expect(c.who_can(:read)).to eq([Card::AnyoneSignedInID])
+      expect(c.permission_rule_card(:read).first.id).to eq(@perm_card.id)
       c.save
-      c.read_rule_id.should == @perm_card.id
+      expect(c.read_rule_id).to eq(@perm_card.id)
     end
 
     it "should get updated when relative settings change" do
@@ -175,18 +175,18 @@ describe Card::Set::All::Permissions do
         all_plus.save
       end
       c = Card.new(:name=>'Home+Heart')
-      c.who_can(:read).should == [Card::AnyoneID]
-      c.permission_rule_card(:read).first.id.should == Card.fetch('*all+*read').id
+      expect(c.who_can(:read)).to eq([Card::AnyoneID])
+      expect(c.permission_rule_card(:read).first.id).to eq(Card.fetch('*all+*read').id)
       c.save
-      c.read_rule_id.should == Card.fetch('*all+*read').id
+      expect(c.read_rule_id).to eq(Card.fetch('*all+*read').id)
       Card::Auth.as_bot { @perm_card.save! }
       c2 = Card.fetch('Home+Heart')
-      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
+      expect(c2.who_can(:read)).to eq([Card::AnyoneSignedInID])
+      expect(c2.read_rule_id).to eq(@perm_card.id)
+      expect(Card.fetch('Home+Heart').read_rule_id).to eq(@perm_card.id)
       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
+      expect(Card.fetch('Home').read_rule_id).to eq(Card.fetch('*all+*read').id)
+      expect(Card.fetch('Home+Heart').read_rule_id).to eq(Card.fetch('*all+*read').id)
     end
 
     it "should insure that class overrides work with relative settings" do
@@ -195,15 +195,15 @@ describe Card::Set::All::Permissions do
         all_plus.save
         Card::Auth.as_bot { @perm_card.save! }
         c = Card.create(:name=>'Home+Heart')
-        c.read_rule_id.should == @perm_card.id
+        expect(c.read_rule_id).to eq(@perm_card.id)
         r = Card.create(:name=>'Heart+*right+*read', :type=>'Pointer', :content=>'[[Administrator]]')
-        Card.fetch('Home+Heart').read_rule_id.should == r.id
+        expect(Card.fetch('Home+Heart').read_rule_id).to eq(r.id)
       end
     end
 
     it "should work on virtual+virtual cards" do
       c = Card.fetch('Number+*type+by name')
-      c.ok?(:read).should be_true
+      expect(c.ok?(:read)).to be_truthy
     end
 
   end
@@ -222,21 +222,21 @@ describe Card::Set::All::Permissions do
 
     it "checking ok read should not add to errors" do
       Card::Auth.as_bot do
-        Card::Auth.always_ok?.should == true
+        expect(Card::Auth.always_ok?).to eq(true)
       end
       Card::Auth.as(:joe_user) do
-        Card::Auth.always_ok?.should == false
+        expect(Card::Auth.always_ok?).to eq(false)
       end
       Card::Auth.as(:joe_admin) do
-        Card::Auth.always_ok?.should == true
+        expect(Card::Auth.always_ok?).to eq(true)
         Card.create! :name=>"Hidden"
         Card.create(:name=>'Hidden+*self+*read', :type=>'Pointer', :content=>'[[Anyone Signed In]]')
       end
 
       Card::Auth.as(:anonymous) do
         h = Card.fetch('Hidden')
-        h.ok?(:read).should == false
-        h.errors.empty?.should_not == nil
+        expect(h.ok?(:read)).to eq(false)
+        expect(h.errors.empty?).not_to eq(nil)
       end
     end
 
@@ -244,8 +244,8 @@ describe Card::Set::All::Permissions 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]
-        c1.ok?(:comment).should be_true
+        expect(c1.who_can( :comment )).to eq([Card['r1'].id])
+        expect(c1.ok?(:comment)).to be_truthy
       end
     end
 
@@ -253,8 +253,8 @@ describe Card::Set::All::Permissions do
       Card.where(:trash=>false).each do |c|
         prc = c.permission_rule_card(:read)
         #warn "C #{c.inspect}, #{c.read_rule_id}, #{prc.first.id}, #{c.read_rule_class}, #{prc.second}, #{prc.first.inspect}" unless prc.last == c.read_rule_class && prc.first.id == c.read_rule_id
-        prc.last.should == c.read_rule_class
-        prc.first.id.should == c.read_rule_id
+        expect(prc.last).to eq(c.read_rule_class)
+        expect(prc.first.id).to eq(c.read_rule_id)
       end
     end
 
@@ -358,11 +358,11 @@ describe Card::Set::All::Permissions do
       
       it "should inherit" 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   
+          expect(Card.fetch( 'A+*self' ).ok?(:create)).to be_truthy #explicitly granted above
+          expect(Card.fetch( 'A+*right').ok?(:create)).to be_falsey #by default restricted   
           
-          Card.fetch( 'A+*self+*structure',  :new=>{} ).ok?(:create).should be_true # +*structure granted;
-          Card.fetch( 'A+*right+*structure', :new=>{} ).ok?(:create).should be_false # can't create A+B, therefore can't create A+B+C
+          expect(Card.fetch( 'A+*self+*structure',  :new=>{} ).ok?(:create)).to be_truthy # +*structure granted;
+          expect(Card.fetch( 'A+*right+*structure', :new=>{} ).ok?(:create)).to be_falsey # can't create A+B, therefore can't create A+B+C
         end
       end
       
@@ -379,10 +379,10 @@ describe Card::Set::All::Permissions do
        end
 
        Card::Auth.as(@u1) do
-         Card.search(:content=>'WeirdWord').map(&:name).sort.should == %w( c1 c2 c3 )
+         expect(Card.search(:content=>'WeirdWord').map(&:name).sort).to eq(%w( c1 c2 c3 ))
        end
        Card::Auth.as(@u2) do
-         Card.search(:content=>'WeirdWord').map(&:name).sort.should == %w( c2 c3 )
+         expect(Card.search(:content=>'WeirdWord').map(&:name).sort).to eq(%w( c2 c3 ))
        end
     end
 
@@ -398,11 +398,11 @@ describe Card::Set::All::Permissions do
       end
 
       Card::Auth.as(@u1) do
-        Card.search(:content=>'WeirdWord').map(&:name).sort.should == %w( c1 c2 c3 )
+        expect(Card.search(:content=>'WeirdWord').map(&:name).sort).to eq(%w( c1 c2 c3 ))
       end
       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 )
+        expect(Card.search(:content=>'WeirdWord').map(&:name).sort).to eq(%w( c2 c3 ))
       end
     end
 
@@ -432,7 +432,7 @@ describe Card::Set::All::Permissions do
 
 
   it "should let joe view new cards" do
-    Card.new.ok?(:read).should be_true
+    expect(Card.new.ok?(:read)).to be_truthy
   end
 
 
@@ -443,24 +443,24 @@ describe Card::Set::All::Permissions do
 
     it "should let anonymous users view basic cards" do
       Card::Auth.as :anonymous do
-        @c.ok?(:read).should be_true
+        expect(@c.ok?(:read)).to be_truthy
       end
     end
 
     it "should let joe user basic cards" do
       Card::Auth.as :joe_user do
-        @c.ok?(:read).should be_true
+        expect(@c.ok?(:read)).to be_truthy
       end
     end
   end
 
   it "should allow anyone signed in to create Basic Cards" do
-    Card.new.ok?(:create).should be_true
+    expect(Card.new.ok?(:create)).to be_truthy
   end
 
   it "should not allow someone not signed in to create Basic Cards" do
     Card::Auth.as :anonymous do
-      Card.new.ok?(:create).should_not be_true
+      expect(Card.new.ok?(:create)).not_to be_truthy
     end
   end
 
@@ -478,18 +478,18 @@ 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]
+      expect(c.who_can(:delete)).to eq([Card['joe_user'].id])
       Card::Auth.as(:joe_user) do
-        c.ok?(:delete).should == true
+        expect(c.ok?(:delete)).to eq(true)
       end
       Card::Auth.as(:u1) do
-        c.ok?(:delete).should == false
+        expect(c.ok?(:delete)).to eq(false)
       end
       Card::Auth.as(:anonymous) do
-        c.ok?(:delete).should == false
+        expect(c.ok?(:delete)).to eq(false)
       end
       Card::Auth.as_bot do
-        c.ok?(:delete).should == true #because administrator
+        expect(c.ok?(:delete)).to eq(true) #because administrator
       end
     end
   end