wagn 1.13.0 → 1.14.0.pre1

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

@@ -5,9 +5,9 @@ describe Card::Set::All::Json, "JSON mod" do
     it "should handle real and virtual cards" do
       jf = Card::JsonFormat
       real_json = jf.new(Card['T']).show :status, {}
-      JSON[real_json].should == {"key"=>"t","status"=>"real","id"=>Card['T'].id, 'url_key'=>'T'}
+      expect(JSON[real_json]).to eq({"key"=>"t","status"=>"real","id"=>Card['T'].id, 'url_key'=>'T'})
       virtual_json = jf.new(Card.fetch('T+*self')).show :status, {}
-      JSON[virtual_json].should == {"key"=>"t+*self","status"=>"virtual",'url_key'=>'T+*self'}
+      expect(JSON[virtual_json]).to eq({"key"=>"t+*self","status"=>"virtual",'url_key'=>'T+*self'})
     end
     
     it "should treat both unknown and unreadable cards as unknown" do
@@ -17,9 +17,9 @@ describe Card::Set::All::Json, "JSON mod" do
         unknown = Card.new :name=>'sump'
         unreadable = Card.new :name=>'kumq', :type=>'Fruit'
         unknown_json = jf.new(unknown).show :status, {}
-        JSON[unknown_json].should == {"key"=>"sump","status"=>"unknown", 'url_key'=>'sump'}
+        expect(JSON[unknown_json]).to eq({"key"=>"sump","status"=>"unknown", 'url_key'=>'sump'})
         unreadable_json = jf.new(unreadable).show :status, {}
-        JSON[unreadable_json].should == {"key"=>"kumq","status"=>"unknown", 'url_key'=>'kumq'}
+        expect(JSON[unreadable_json]).to eq({"key"=>"kumq","status"=>"unknown", 'url_key'=>'kumq'})
       end
     end
   end

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

@@ -0,0 +1,74 @@
+describe Card::Set::Type::EmailTemplate do
+  before :each do
+    Card::Auth.as_bot do
+      Card.create! :name=>"mail template",  :type_code=>'email_template', :subcards=>{'+*html message'=>{content: 'Hi Joe! My name is {{_self|name}}'},
+                                                                                      '+*to'=>{content: 'joe@user.com'},
+                                                                                      '+*from'=>{content: 'from@user.com'} }
+    end
+  end
+  it 'sends email on update' do
+    Card::Auth.as_bot do
+      Card.create! :name=>"mail test+*self+*on update", type_code: :pointer, content: "[[mail template]]"
+    end
+    card = Card.fetch "mail test"
+    expect { Card::Auth.as_bot { card.update_attributes(content: "test") } }.to change { Mail::TestMailer.deliveries.count }.by(1)
+  end
+  
+  it 'sends email on delete' do
+    Card::Auth.as_bot do
+      Card.create! :name=>"mail test+*self+*on delete", type_code: :pointer, content: "[[mail template]]"
+    end
+    card = Card.fetch "mail test"
+    expect { Card::Auth.as_bot { card.delete } }.to change { Mail::TestMailer.deliveries.count }.by(1)
+  end
+  
+  it 'sends email on create' do
+    Card::Auth.as_bot do
+      Card.create! :name=>"Cardtype A+*type+*on create", type_code: :pointer, content: "[[mail template]]"
+    end
+    expect { Card::Auth.as_bot { Card.create! :name=>"mail test", type_code: :cardtype_a} }.to change { ActionMailer::Base.deliveries.count }.by(1)
+  end
+  
+  describe '#send_action_mails' do
+    before do
+      Card::Auth.as_bot do
+        Card.create! :name=>"another mail template",  :type_code=>'email_template', :subcards=>{'+*html message'=>{content: 'Hi Joe! My name is {{_self|name}}'},
+                                                                                        '+*to'=>{content: 'joe@user.com'},
+                                                                                        '+*from'=>{content: 'from@user.com'} }
+        Card.create! :name=>"mail test+*self+*on update", type_code: :pointer, content: "[[mail template]]\n[[another mail template]]"
+        Card.create! :name=>"mail test+*self+*on delete", type_code: :pointer, content: "[[mail template]]\n[[another mail template]]"
+      end
+      card = Card.fetch "mail test"      
+      ActionMailer::Base.deliveries = []
+      card.send_action_mails :on=>:update
+    end
+    
+    it 'delivers all emails for given action' do
+      expect(ActionMailer::Base.deliveries.size).to eq(2)
+    end
+    it 'uses correct context' do
+      expect(ActionMailer::Base.deliveries.last.body.raw_source).to include('My name is mail test')
+    end
+  end
+  
+  # describe '#send_timer_mails' do
+ #    before do
+ #      ActionMailer::Base.deliveries = []
+ #      Card::Auth.as_bot do
+ #        Card.create! :name=>"A+*hourly", :type_code=>'email_template',  :subcards=>{'+*message'=>{content: 'hourly update name:{{_self|name}}'},
+ #                                                                                      '+*to'=>{content: 'joe@user.com'},
+ #                                                                                      '+*from'=>{content: 'from@user.com'}}
+ #      end
+ #      Card::Set::All::Observer.send_timer_mails :hourly
+ #      @mail = ActionMailer::Base.deliveries.last
+ #    end
+ #
+ #    it 'delivers hourly mails' do
+ #      expect(@mail.body.raw_source).to include('hourly update')
+ #    end
+ #    it 'uses correct context' do
+ #      expect(@mail.body.raw_source).to include('name:A')
+ #    end
+ #  end
+end
+

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

@@ -3,7 +3,7 @@
 describe Card::Set::All::RichHtml do
   describe 'missing view' do
     it "should prompt to add" do
-      render_content('{{+cardipoo|open}}').match(/Add \<span/ ).should_not be_nil
+      expect(render_content('{{+cardipoo|open}}').match(/Add \<span/ )).not_to be_nil
     end
   end
   
@@ -13,23 +13,23 @@ describe Card::Set::All::RichHtml do
     end
     
     it "should get type options from type_field renderer method" do
-      @card.format.type_field.should match(/<option [^>]*selected/)
+      expect(@card.format.type_field).to match(/<option [^>]*selected/)
       tf=@card.format.type_field(:no_current_type=>true)
-      tf.should_not match(/<option [^>]*selected/)
-      tf.scan(/<option /).length.should == 23
+      expect(tf).not_to match(/<option [^>]*selected/)
+      expect(tf.scan(/<option /).length).to eq(24)
       tf=@card.format.type_field
-      tf.should match(/<option [^>]*selected/)
-      tf.scan(/<option /).length.should == 23
+      expect(tf).to match(/<option [^>]*selected/)
+      expect(tf.scan(/<option /).length).to eq(24)
     end
     
     it "should get type list" do
       Card::Auth.as :anonymous do
         tf=@card.format.type_field(:no_current_type=>true)
-        tf.should_not match(/<option [^>]*selected/)
-        tf.scan(/<option /).length.should == 1
+        expect(tf).not_to match(/<option [^>]*selected/)
+        expect(tf.scan(/<option /).length).to eq(1)
         tf=@card.format.type_field
-        tf.should match(/<option [^>]*selected/)
-        tf.scan(/<option /).length.should == 2
+        expect(tf).to match(/<option [^>]*selected/)
+        expect(tf.scan(/<option /).length).to eq(2)
       end
     end
   end
@@ -37,13 +37,13 @@ describe Card::Set::All::RichHtml do
   context "type and header" do
     it "should render type without no-edit class when no cards of type" do
       card = Card['UserForm']  # no cards with this type
-      card.format.render_type.should match(/<a [^>]* class="([^"]* )?cardtype[^"]*"/)
-      card.format.render_type.should_not match(/<a [^>]* class="([^"]* )?no-edit[^"]*"/)
+      expect(card.format.render_type).to match(/<a [^>]* class="([^"]* )?cardtype[^"]*"/)
+      expect(card.format.render_type).not_to match(/<a [^>]* class="([^"]* )?no-edit[^"]*"/)
     end
     it "should render type header with no-edit class when cards of type exist" do
       no_edit_card = Card['cardtype a']
-      no_edit_card.format.render_type.should match(/<a [^>]* class="([^"]* )?cardtype[^"]*"/)
-      no_edit_card.format.render_type.should match(/<a [^>]* class="([^"]* )?no-edit[^"]*"/)
+      expect(no_edit_card.format.render_type).to match(/<a [^>]* class="([^"]* )?cardtype[^"]*"/)
+      expect(no_edit_card.format.render_type).to match(/<a [^>]* class="([^"]* )?no-edit[^"]*"/)
     end
   end
 end

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

@@ -3,6 +3,6 @@
 describe Card::Set::All::Rss do
   it 'should render recent.rss' do
     rendered = Card[:recent].format(:format=>:rss).show( nil, {} )
-    rendered.should =~ /xml/
+    expect(rendered).to match(/xml/)
   end
 end

data/mod/05_standard/spec/set/right/account_spec.rb

@@ -0,0 +1,162 @@
+# -*- encoding : utf-8 -*-
+
+describe Card::Set::Right::Account do
+  
+  describe '#create' do
+    context "valid user" do
+      #note - much of this is tested in account_request_spec
+      before do
+        Card::Auth.as_bot do
+          @user_card = Card.create! :name=>'TmpUser', :type_id=>Card::UserID, '+*account'=>{ 
+            '+*email'=>'tmpuser@wagn.org', '+*password'=>'tmp_pass'
+          }
+        end
+      
+      end
+      
+      it 'should create an authenticable password' do
+        expect(Card::Auth.password_authenticated?( @user_card.account, 'tmp_pass')).to be_truthy
+      end
+    end
+    
+    it "should check accountability of 'accounted' card" do
+      @unaccountable = Card.create :name=>'BasicUnaccountable', '+*account'=>{ '+*email'=>'tmpuser@wagn.org', '+*password'=>'tmp_pass' }
+      expect(@unaccountable.errors['+*account'].first).to eq('not allowed on this card')
+    end
+    
+    it "should require email" do
+      @no_email = Card.create :name=>'TmpUser', :type_id=>Card::UserID, '+*account'=>{ '+*password'=>'tmp_pass' }
+      expect(@no_email.errors['+*account'].first).to match(/email required/)
+    end
+  end
+  
+  describe '#send_account_verification_email' do
+    before do
+      @email = 'joe@user.com'
+      @account = Card::Auth[@email].account
+      Mail::TestMailer.deliveries.clear
+      @account.send_account_verification_email
+      @mail = Mail::TestMailer.deliveries.last
+    end
+
+    it 'has correct address' do
+      expect( @mail.to ).to eq([@email])
+    end
+
+    it 'contains deck title' do
+      expect( @mail.parts[0].body.raw_source ).to match(Card.setting( :title ))
+    end
+
+    it 'contains link to verify account' do
+      expect( @mail.parts[0].body.raw_source ).to include("/update/#{@account.left.cardname.url_key}?token=#{@account.token}")
+    end
+
+    it 'contains expiry days' do
+      expect(@mail.parts[0].body.raw_source).to include("valid for #{Wagn.config.token_expiry / 1.day } days")
+    end
+  end
+
+  describe '#send_reset_password_token' do
+    before do
+      @email = 'joe@user.com'
+      @account = Card::Auth[@email].account
+      Mail::TestMailer.deliveries = []
+      @account.send_reset_password_token
+      @mail = Mail::TestMailer.deliveries.last
+    end
+
+    it 'contains deck title' do
+      expect( @mail.parts[0].body.raw_source ).to match(Card.setting( :title ))
+    end
+
+    it 'contains password resset link' do
+      expect( @mail.parts[0].body.raw_source ).to include("/update/#{@account.cardname.url_key}?reset_token=#{@account.token_card.refresh(true).content}")
+    end
+
+    it 'contains expiry days' do
+      expect(@mail.parts[0].body.raw_source).to include("valid for #{Wagn.config.token_expiry / 1.day } days")
+    end
+  end
+  
+  
+  
+  
+  describe '#update_attributes' do
+    before :each do
+      @user_card = Card::Auth[ 'joe@user.com' ]
+    end
+
+    it 'should reset password' do
+      @user_card.account.password_card.update_attributes!(:content => 'new password')
+      assert_equal @user_card.id, Card::Auth.authenticate('joe@user.com', 'new password')
+    end
+  
+    it 'should not rehash password when updating email' do
+      @user_card.account.email_card.update_attributes!(:content => 'joe2@user.com')
+      assert_equal @user_card.id, Card::Auth.authenticate('joe2@user.com', 'joe_pass')
+    end
+  end
+  
+  
+  describe '#reset_password' do
+    before :each do
+      @email = 'joe@user.com'
+      @account = Card::Auth[@email].account
+      @account.send_reset_password_token
+      @token = @account.token
+      Card::Env.params[:reset_token] = @token
+      Card::Auth.current_id = Card::AnonymousID
+    end
+
+    it 'should authenticate with correct token and delete token card' do
+      expect(Card::Auth.current_id).to eq(Card::AnonymousID)
+      expect(@account.save).to eq(true)
+      expect(Card::Auth.current_id).to eq(@account.left_id)
+      @account = @account.refresh force=true
+      expect(@account.fetch(:trait => :token)).to be_nil
+      expect(@account.save).to be_falsey
+    end
+  
+    it 'should not work if token is expired' do
+      @account.token_card.update_column :updated_at, 3.days.ago.strftime("%F %T")
+      @account.token_card.expire
+      
+      result = @account.save
+      expect(result).to eq(true)                 # successfully completes save
+      expect(@account.token).not_to eq(@token)   # token gets updated
+      success = Card::Env.params[:success]
+      expect(success[:message]).to match(/expired/) # user notified of expired token
+    end
+    
+    it 'should not work if token is wrong' do
+      Card::Env.params[:reset_token] = @token + 'xxx'
+      @account.save
+      expect(@account.errors[:abort].first).to match(/incorrect_token/)
+    end  
+    
+  end
+  
+  
+  describe '#send_change_notice' do
+    it 'send multipart email' do
+      skip
+#      pending
+    end
+    
+    context 'denied access' do
+      it 'excludes protected subcards' do
+        skip
+        Card.create(:name=>"A+B+*self+*read", :type=>'Pointer', :content=>"[[u1]]")
+        u2 = Card.fetch 'u2+*following', :new=>{:type=>'Pointer'}
+        u2.add_item "A"
+        a = Card.fetch "A"
+        a.update_attributes( :content=> "new content", :subcards=>{'+B'=>{:content=>'hidden content'}})
+      end
+      
+      it 'sends no email if changes not visible' do
+        skip
+      end
+    end
+  end
+end
+

data/{spec/mod/standard → mod/05_standard/spec}/set/right/email_spec.rb

@@ -10,19 +10,19 @@ describe Card::Set::Right::Email do
 
     it 'should allow Wagn Bot to read' do
       Card::Auth.as_bot do
-        @format.render_raw.should == 'u1@user.com'
+        expect(@format.render_raw).to eq('u1@user.com')
       end
     end
 
     it 'should allow self to read' do
       Card::Auth.as Card['u1'] do
-        @format.render_raw.should == 'u1@user.com'
+        expect(@format.render_raw).to eq('u1@user.com')
       end
     end
 
     it 'should hide from other users' do
-      @card.ok?(:read).should be_false
-      @format.render_raw.should =~ /denied/
+      expect(@card.ok?(:read)).to be_falsey
+      expect(@format.render_raw).to match(/denied/)
     end
   end
   
@@ -35,18 +35,18 @@ describe Card::Set::Right::Email do
       it 'should downcase email' do
         Card::Auth.as_bot do
           @email_card.update_attributes! :content=>'QuIrE@example.com'
-          @email_card.content.should == 'quire@example.com'
+          expect(@email_card.content).to eq('quire@example.com')
         end
       end
 
       it 'should require valid email' do
         @email_card.update_attributes :content=>'boop'
-        @email_card.errors[:content].first.should =~ /must be valid address/
+        expect(@email_card.errors[:content].first).to match(/must be valid address/)
       end
       
       it 'should require unique email' do
         @email_card.update_attributes :content=>'joe@user.com'
-        @email_card.errors[:content].first.should =~ /must be unique/
+        expect(@email_card.errors[:content].first).to match(/must be unique/)
       end
       
     end

data/{spec/mod/standard → mod/05_standard/spec}/set/right/password_spec.rb

@@ -10,14 +10,14 @@ describe Card::Set::Right::Password do
 
     it 'should encrypt password' do
       @user_card.account.password_card.update_attributes! :content => 'new password'
-      @user_card.account.password.should_not == 'new password'
+      expect(@user_card.account.password).not_to eq('new password')
       assert_equal @user_card.id, Card::Auth.authenticate('joe@user.com', 'new password')
     end
 
     it 'should validate password' do
       password_card = @user_card.account.password_card
       password_card.update_attributes :content => '2b'
-      password_card.errors[:password].should_not be_empty
+      expect(password_card.errors[:password]).not_to be_empty
       
     end
     
@@ -25,17 +25,17 @@ describe Card::Set::Right::Password do
       it "shouldn't change the password" do
         acct = @user_card.account
         original_pw = acct.password
-        original_pw.size.should > 10
+        expect(original_pw.size).to be > 10
         pw_card = acct.password_card
         pw_card.content = ''
         pw_card.save
-        original_pw.should == pw_card.refresh(force=true).content
+        expect(original_pw).to eq(pw_card.refresh(force=true).content)
       end
       
       it "shouldn't break email editing" do
-        @user_card.account.update_attributes! '+*password'=>'', '+*email'=>'joe2@user.com'
-#        @user_card.account.update_attributes! '+*email'=>'joe2@user.com'
-        @user_card.account.email.should == 'joe2@user.com'
+        @user_card.account.update_attributes! :subcards=>{'+*password'=>'', '+*email'=>'joe2@user.com'}
+        expect(@user_card.account.email).to eq('joe2@user.com')
+        expect(@user_card.account.password).not_to be_empty
       end
     end
   end

data/{spec/mod/standard → mod/05_standard/spec}/set/right/when_created_spec.rb

@@ -2,6 +2,6 @@
 
 describe Card::Set::Right::WhenCreated do
   it 'should produce a text date' do
-    render_card( :core, :name=>'A+*when created' ).should =~ /\w+ \d+/
+    expect(render_card( :core, :name=>'A+*when created' )).to match(/\w+ \d+/)
   end
 end

data/{spec/mod/standard → mod/05_standard/spec}/set/right/when_last_edited_spec.rb

@@ -2,6 +2,6 @@
 
 describe Card::Set::Right::WhenLastEdited do
   it 'should produce a text date' do
-    render_card( :core, :name=>'A+*when last edited' ).should =~ /\w+ \d+/
+    expect(render_card( :core, :name=>'A+*when last edited' )).to match(/\w+ \d+/)
   end
 end

data/{spec/mod/standard → mod/05_standard/spec}/set/rstar/rules_spec.rb

@@ -3,8 +3,8 @@
 describe Card::Set::Rstar::Rules do
   it "should render setting view for a right set" do
      r = Card['*read+*right'].format.render_open
-     r.should_not match(/error/i)
-     r.should_not match('No Card!')
+     expect(r).not_to match(/error/i)
+     expect(r).not_to match('No Card!')
      #warn "r = #{r}"
      assert_view_select r, 'table[class="set-rules"]' do
        assert_select 'a[href~="/*read+*right+*input?view=open_rule"]', :text => 'input'
@@ -14,8 +14,8 @@ describe Card::Set::Rstar::Rules do
   it "should render setting view for a *input rule" do
     Card::Auth.as_bot do
       r = Card.fetch('*read+*right+*input',:new=>{}).format.render_open_rule
-      r.should_not match(/error/i)
-      r.should_not match('No Card!')
+      expect(r).not_to match(/error/i)
+      expect(r).not_to match('No Card!')
       #warn "r = #{r}"
       assert_view_select r, 'tr[class="card-slot open-rule edit-rule"]' do
         assert_select 'input[id="success_id"][name=?][type="hidden"][value="*read+*right+*input"]', 'success[id]'