wagn 1.13.0 → 1.14.0.pre1

data/{spec/mod/standard → mod/05_standard/spec}/set/all/account_spec.rb

@@ -4,7 +4,7 @@ describe Card::Set::All::Account do
   describe 'accountable?' do
     
     it 'should be false for cards with *accountable rule off' do
-      Card['A'].accountable?.should == false
+      expect(Card['A'].accountable?).to eq(false)
     end
 
     it 'should be true for cards with *accountable rule on' do
@@ -12,7 +12,7 @@ describe Card::Set::All::Account do
         Card.create :name=>'A+*self+*accountable', :content=>'1'
         Card.create :name=>'*account+*right+*create', :content=>'[[Anyone Signed In]]'
       end
-      Card['A'].accountable?.should == true
+      expect(Card['A'].accountable?).to eq(true)
     end
     
   end
@@ -21,12 +21,12 @@ describe Card::Set::All::Account do
   
     it "for Wagn Bot" do
       Card::Auth.current_id = Card::WagnBotID
-      Card::Auth.current.parties.sort.should == [Card::WagnBotID, Card::AnyoneSignedInID, Card::AdministratorID]
+      expect(Card::Auth.current.parties.sort).to eq([Card::WagnBotID, Card::AnyoneSignedInID, Card::AdministratorID])
     end
     
     it "for Anonymous" do
       Card::Auth.current_id = Card::AnonymousID
-      Card::Auth.current.parties.sort.should == [Card::AnonymousID]
+      expect(Card::Auth.current.parties.sort).to eq([Card::AnonymousID])
     end
 
     context 'for Joe User' do
@@ -36,7 +36,7 @@ describe Card::Set::All::Account do
       end
 
       it "should initially have only auth and self " do
-        @parties.should == [Card::AnyoneSignedInID, @joe_user_card.id]
+        expect(@parties).to eq([Card::AnyoneSignedInID, @joe_user_card.id])
       end
       
       it 'should update when new roles are set' do
@@ -44,14 +44,14 @@ describe Card::Set::All::Account do
         r1 = Card['r1']
 
         Card::Auth.as_bot { roles_card.items = [ r1.id ] }        
-        Card['Joe User'].parties.should == @parties            # local cache still has old parties (permission does not change mid-request)        
+        expect(Card['Joe User'].parties).to eq(@parties)            # local cache still has old parties (permission does not change mid-request)        
                                                                
         Wagn::Cache.restore                                    # simulate new request -- clears local cache, where, eg, @parties would still be cached on card
         Card::Auth.current_id = Card::Auth.current_id                # simulate new request -- current_id assignment clears several class variables
         
         new_parties = [ Card::AnyoneSignedInID, r1.id, @joe_user_card.id ]
-        Card['Joe User'].parties.should == new_parties         # @parties regenerated, now with correct values
-        Card::Auth.current. parties.should == new_parties
+        expect(Card['Joe User'].parties).to eq(new_parties)         # @parties regenerated, now with correct values
+        expect(Card::Auth.current. parties).to eq(new_parties)
         
         # @joe_user_card.refresh(force=true).parties.should == new_parties   # should work, but now superfluous?
       end
@@ -61,7 +61,7 @@ describe Card::Set::All::Account do
   
   describe 'among?' do
     it 'should be true for self' do
-      Card::Auth.current.among?([Card::Auth.current_id]).should be_true
+      expect(Card::Auth.current.among?([Card::Auth.current_id])).to be_truthy
     end
   end
   
@@ -78,8 +78,8 @@ describe Card::Set::All::Account do
       c = Card['Joe New']
       u = Card::Auth[ 'joe@new.com' ]
       
-      c.should == u
-      c.type_id.should == Card::UserID
+      expect(c).to eq(u)
+      expect(c.type_id).to eq(Card::UserID)
 =begin      
       email = ActionMailer::Base.deliveries.last
       email.to.should == ['joe@new.com']
@@ -95,13 +95,13 @@ describe Card::Set::All::Account do
     end
     it "should handle email updates" do
       @card.update_attributes! '+*account'=>{ '+*email'=>'joe@user.co.uk' }
-      @card.account.email.should == 'joe@user.co.uk'
+      expect(@card.account.email).to eq('joe@user.co.uk')
     end
   
     it "should let Wagn Bot block accounts" do
       Card::Auth.as_bot do
         @card.account.status_card.update_attributes! :content => 'blocked'
-        @card.account.blocked?.should be_true
+        expect(@card.account.blocked?).to be_truthy
       end
     end
     
@@ -110,7 +110,7 @@ describe Card::Set::All::Account do
       expect do
         @card.account.status_card.update_attributes! :content => 'blocked'
       end.to raise_error
-      @card.account.blocked?.should be_false
+      expect(@card.account.blocked?).to be_falsey
     end
   end
   
@@ -121,14 +121,14 @@ describe Card::Set::All::Account do
 
 
     it "*all+*read should apply to Joe User" do
-      @read_rules.member?(Card.fetch('*all+*read').id).should be_true
+      expect(@read_rules.member?(Card.fetch('*all+*read').id)).to be_truthy
     end
 
     it "9 more should apply to Joe Admin" do
       # includes lots of account rules...
       Card::Auth.as(:joe_admin) do
         ids = Card::Auth.as_card.read_rules
-        ids.length.should == @read_rules.size + 9
+        expect(ids.length).to eq(@read_rules.size + 9)
       end
     end
 

data/{spec/mod/standard → mod/05_standard/spec}/set/all/all_css_spec.rb

@@ -5,6 +5,6 @@ describe Card::Set::All::AllCss do
     content = '#box { display: block }'
     rendered = render_card :content, { :content=>content }, :format=>:css
 #    rendered.should =~ /Style Card\:/
-    rendered.should =~ /#{ Regexp.escape content }/
+    expect(rendered).to match(/#{ Regexp.escape content }/)
   end
 end

data/{spec/mod/standard → mod/05_standard/spec}/set/all/all_csv_spec.rb

@@ -3,7 +3,7 @@
 describe Card::Set::All::AllCsv, "CSV mod" do
   context "csv_row view" do
     it "should handle inclusions" do
-      render_card( :csv_row, { :content=>'{{A+B}} {{T}}' }, :format => :csv ).should == "AlphaBeta,Theta"
+      expect(render_card( :csv_row, { :content=>'{{A+B}} {{T}}' }, :format => :csv )).to eq("AlphaBeta,Theta")
     end
   end
 end

data/{spec/mod/standard → mod/05_standard/spec}/set/all/attach_spec.rb

@@ -4,6 +4,6 @@ describe Card::Set::All::Attach do
   it 'should be triggered by image card creation' do
     file = File.new("#{ Wagn.gem_root }/test/fixtures/mao2.jpg")
     card = Card.create :name => "Bananamaster", :type=>'Image', :attach=>file
-    card.attach.url.should =~ /^\/files\/Bananamaster-original-\d+/
+    expect(card.attach.url).to match(/^\/files\/Bananamaster-original-\d+/)
   end
 end

data/{spec/mod/standard → mod/05_standard/spec}/set/all/base_spec.rb

@@ -4,27 +4,27 @@ describe Card::Set::All::Base do
 
   describe 'handles view' do
   
-    it("name"    ) { render_card(:name).should      == 'Tempo Rary' }
-    it("key"     ) { render_card(:key).should       == 'tempo_rary' }
-    it("linkname") { render_card(:linkname).should  == 'Tempo_Rary' }
+    it("name"    ) { expect(render_card(:name)).to      eq('Tempo Rary') }
+    it("key"     ) { expect(render_card(:key)).to       eq('tempo_rary') }
+    it("linkname") { expect(render_card(:linkname)).to  eq('Tempo_Rary') }
 
     it "url" do
       Card::Env[:protocol] = 'http://'
       Card::Env[:host]     = 'eric.skippy.com'
-      render_card(:url).should == 'http://eric.skippy.com/Tempo_Rary'
+      expect(render_card(:url)).to eq('http://eric.skippy.com/Tempo_Rary')
     end
 
     it :raw do
       @a = Card.new :content=>"{{A}}"
-      @a.format._render(:raw).should == "{{A}}"
+      expect(@a.format._render(:raw)).to eq("{{A}}")
     end
 
     it "core" do
-      render_card(:core, :name=>'A+B').should == "AlphaBeta"
+      expect(render_card(:core, :name=>'A+B')).to eq("AlphaBeta")
     end
     
     it 'core for new card' do
-      Card.new.format._render_core.should == ''
+      expect(Card.new.format._render_core).to eq('')
     end
   
     describe 'array' do
@@ -33,7 +33,7 @@ describe Card::Set::All::Base do
         Card.create! :name => "n+b", :type=>"Phrase", :content=>"say:\"what\""
         Card.create! :name => "n+c", :type=>"Number", :content=>"30"
         c = Card.new :name => 'nplusarray', :content => "{{n+*children+by create|array}}"
-        c.format._render( :core ).should == %{["10", "say:\\"what\\"", "30"]}
+        expect(c.format._render( :core )).to eq(%{["10", "say:\\"what\\"", "30"]})
       end
 
       it "of pointer items" do
@@ -42,11 +42,11 @@ describe Card::Set::All::Base do
         Card.create! :name => "n+c", :type=>"Number", :content=>"30"
         Card.create! :name => "npoint", :type=>"Pointer", :content => "[[n+a]]\n[[n+b]]\n[[n+c]]"
         c = Card.new :name => 'npointArray', :content => "{{npoint|array}}"
-        c.format._render( :core ).should == %q{["10", "20", "30"]}
+        expect(c.format._render( :core )).to eq(%q{["10", "20", "30"]})
       end
       
       it "of basic items" do
-        render_card(:array, :content=>'yoing').should==%{["yoing"]}
+        expect(render_card(:array, :content=>'yoing')).to eq(%{["yoing"]})
       end
     end
  

data/mod/05_standard/spec/set/all/email_html_spec.rb

@@ -0,0 +1,15 @@
+# -*- encoding : utf-8 -*-
+
+describe Card::EmailHtmlFormat do
+  it "renders full urls" do
+    Card::Env[:protocol] = 'http://'
+    Card::Env[:host] = 'www.fake.com'
+    expect(render_content('[[B]]', :format=>'email_html')).to eq('<a class="known-card" href="http://www.fake.com/B">B</a>')
+  end
+  
+  describe "raw view" do
+    it "renders missing included cards as blank" do
+      expect(render_content('{{strombooby}}', :format=>'email_html')).to eq('')
+    end
+  end
+end

data/{spec/mod/standard → mod/05_standard/spec}/set/all/event_viz_spec.rb

@@ -3,7 +3,7 @@
 describe Card::Set::All::EventViz do
   describe '#events' do
     it "should have at least twenty events" do
-      Card['A'].events( :update ).split("\n").length.should > 20
+      expect(Card['A'].events( :update ).split("\n").length).to be > 20
     end
   end
 end

data/mod/05_standard/spec/set/all/follow_spec.rb

@@ -0,0 +1,83 @@
+# -*- encoding : utf-8 -*-
+
+describe Card do
+  before do
+    Timecop.travel(Wagn.future_stamp)  # make sure we're ahead of all the test data
+    @just_s = [Card["Sara"].id]
+    @s_and_j= [Card["Sara"].id, Card["John"].id].sort
+  end
+end
+
+
+describe "Card::Set::All::Follow" do
+ 
+  def expect_user user_name
+    expect(Card.fetch(user_name).account)
+  end
+
+  def be_notified_of card_name
+    receive(:send_change_notice).with(kind_of(Card::Act), card_name)
+  end
+
+  context "when following cards" do
+    before do
+      Card::Auth.current_id = Card['john'].id
+      Timecop.travel(Wagn.future_stamp)  # make sure we're ahead of all the test data
+    end
+  
+    def expect_notice_for card_name
+      expect_any_instance_of(Card::Set::Right::Account).to receive(:send_change_notice).with(kind_of(Card::Act), card_name)
+    end
+    
+    it "sends notifications of edits" do
+      expect_user("Sara").to be_notified_of "Sara Following"
+      Card::Auth.current_id = Card['john'].id
+      Card["Sara Following"].update_attributes :content => "A new change"
+    end
+  
+    it "does not send notification to author of change" do
+      expect_user("John").not_to receive(:send_change_notice)
+      Card["All Eyes On Me"].update_attributes :content => "edit by John"
+    end
+  end
+  
+  context "when following cardtypes" do
+    before do
+      Card::Auth.current_id = Card['joe admin'].id
+    end
+    it "sends notifications of additions" do
+      new_card = Card.new :name => "Microscope", :type => "Optic"
+      expect_user("Sara").to be_notified_of "Optic"
+      new_card.save!
+    end
+
+    it "sends notification of updates" do
+      expect_user("Sara").to be_notified_of "Optic"
+      Card["Sunglasses"].update_attributes :content => 'updated content'
+    end
+    
+    it "sends only one notification per user"  do
+      expect_user("Sara").to receive(:send_change_notice).exactly(1)
+      Card["Google glass"].update_attributes :content => 'updated content'
+    end
+  end
+
+
+  context "when following trunk" do
+    before do
+      Timecop.travel(Wagn.future_stamp)  # make sure we're ahead of all the test data
+      Card::Auth.current_id = Card['joe user'].id
+      Card.create :type=>'Book', :name=>'Ulysses'
+      expect(Card['Ulysses']).to be
+      Card.create :name=> 'joe camel+*following', :content=>'[[Ulysses]]'
+      Card.create :name=> 'joe admin+*following', :content=>'[[Book]]'
+    end
+
+    it "sends notification to Joe Camel" do
+      name = "Ulysses+author"
+      expect_user("joe admin").to be_notified_of "Book"
+      expect_user("joe camel").to be_notified_of "Ulysses"
+      Card.create :name=>name, :content => "James Joyce"
+    end
+  end
+end

data/mod/05_standard/spec/set/all/history_spec.rb

@@ -0,0 +1,161 @@
+# -*- encoding : utf-8 -*-
+describe Card::Set::All::History do
+  context "history view" do
+    # before do
+    #   Card.create! :name=>"my histoer card"
+    # end
+    it 'should have a frame' do
+      history = render_card :history, :name=>"A"
+      assert_view_select history, 'div[class~="card-frame"]'
+    end
+  end
+  
+  
+  describe '#create_act_and_action' do
+    let!(:act_start_cnt) {Card::Act.count}
+    let(:content)        {"Nobody expects the Spanish inquisition"}
+    let(:act)            {@card.acts.last}
+    let(:action)         {act.actions.last}
+    
+    context 'for single card' do
+      before do
+        @card = Card::Auth.as_bot do
+          Card.create :name=>"single card", :content=>content
+        end
+      end
+        
+      context 'when created' do
+        it 'adds new act' do
+          expect(Card::Act.count).to eq(act_start_cnt+1)
+          expect(act.card_id).to eq(@card.id)
+        end
+        it 'adds create action' do
+          expect(action.action_type).to eq(:create)
+        end
+      end
+      
+      context 'when updated' do
+        it 'adds no act if nothing changed' do
+          @card.update_attributes  :name=>"single card", :content=>content
+          expect(Card::Act.count).to eq(act_start_cnt+1)
+        end
+        it 'adds new act' do
+          @card.update_attributes :content=>"new content"
+          expect(Card::Act.count).to eq(act_start_cnt+2)
+        end
+      end
+      
+      context 'when deleted' do
+        before do
+          Card::Auth.as_bot do
+            @card.delete
+          end
+        end
+        it 'adds act' do
+          expect(Card::Act.count).to eq(act_start_cnt+2)
+        end
+        it 'adds delete action' do
+          expect(action.action_type).to eq(:delete)
+        end  
+        it 'adds trash change' do  
+          expect(action.changes.last.field).to eq('trash')
+          expect(action.changes.last.value).to eq('1')
+        end
+      end
+    end
+
+    context 'for subcard' do
+      before do
+        Card::Auth.as_bot do
+          @card = Card.create :name=>"left", :subcards=>{"+right" =>{ :content=>content}}
+          @left_action = act.actions[0]
+          @right_action = act.actions[2]
+          @plus_action = act.actions[1]
+        end
+      end
+    
+      context 'when created' do
+        it 'adds only a act for left card' do
+          expect(Card::Act.count).to eq(act_start_cnt+1)
+          expect(act.card).to eq(@card)
+        end
+    
+        it 'adds three actions' do
+          expect(act.actions.size).to eq(3)
+        end
+        it 'adds action for left part of type create' do
+          expect(@left_action.card.name).to eq("left")
+          expect(@left_action.action_type).to eq(:create)
+        end
+        it 'adds action for right part of type create' do
+          expect(@right_action.card.name).to eq("right")
+          expect(@right_action.action_type).to eq(:create)
+        end
+        it 'adds action for plus card of type create' do
+          expect(@plus_action.card.name).to eq("left+right")
+          expect(@plus_action.action_type).to eq(:create)
+        end
+        it 'adds content change' do
+          expect(@plus_action.changes.find_by_field(:db_content).value).to eq(content)
+        end
+        it 'adds superaction for plus card' do
+          expect(@plus_action.super_action_id).to eq(@left_action.id)
+        end
+      end
+      
+      context 'when updated' do
+        it 'adds act for left card' do
+          @card.update_attributes :subcards=>{"+right"=>{:content=>"New content", :db_content=>"New Content"}}
+          expect(Card::Act.count).to eq(act_start_cnt+2)
+          expect(act.card).to eq(@card)
+        end
+        it 'adds action for subcard' do
+          @card.update_attributes :subcards=>{"+right"=>{:content=>"New content", :content=>"New Content"}}
+          act = @card.acts.last
+          expect(act.actions.count).to eq(1)
+          expect(act.actions.last.action_type).to eq(:update)
+          expect(act.actions.last.card.name).to eq("left+right")
+        end
+      end
+    end
+    
+    context 'for plus card' do
+      before do
+        Card::Auth.as_bot do
+          @card = Card.create :name=>'left+right', :content=>content
+          @left_action = act.actions[1]
+          @plus_action = act.actions[0]
+          @right_action = act.actions[2]
+        end
+      end
+      
+      context 'adds' do
+        it 'only a act for plus card' do
+          expect(Card::Act.count).to eq(act_start_cnt+1)
+          expect(act.card_id).to eq(@card.id)
+        end
+        it 'three actions' do
+          expect(act.actions.size).to eq(3)
+        end            
+        it 'action for left part of type create' do
+          expect(@left_action.card.name).to eq("left")
+          expect(@left_action.action_type).to eq(:create)
+        end
+        it 'superaction for left part' do
+          expect(@left_action.super_action_id).to eq(@plus_action.id)
+        end
+        it 'action for right part of type create' do
+          expect(@right_action.card.name).to eq("right")
+          expect(@right_action.action_type).to eq(:create)
+        end
+        it 'action for plus card of type create' do
+          expect(@plus_action.card.name).to eq("left+right")
+          expect(@plus_action.action_type).to eq(:create)
+        end   
+        it 'content change' do
+          expect(@plus_action.changes.find_by_field(:db_content).value).to eq(content)
+        end
+      end
+    end
+  end
+end