wagn 1.13.0 → 1.14.0.pre1

data/{spec/mod/standard → mod/05_standard/spec}/set/self/all_spec.rb

@@ -8,24 +8,25 @@ describe Card::Set::Self::All do
   end
   
   context '#update' do
-    it 'should be trigger empty trash (with right params)' do
+    it 'should trigger empty trash (with right params)' do
       Card::Auth.as_bot do
         Card['A'].delete!
-        Card.where( :trash=>true ).should_not be_empty
+        expect(Card.where( :trash=>true )).not_to be_empty
         Card::Env.params[:task] = :empty_trash
         @all.update_attributes({})
-        Card.where( :trash=>true ).should be_empty
+        expect(Card.where( :trash=>true )).to be_empty
       end
     end
 
-    it 'should be trigger deleting old revisions (with right params)' do
+    it 'should trigger deleting old revisions (with right params)' do
       Card::Auth.as_bot do
         a = Card['A']
         a.update_attributes! :content=>'a new day'
-        a.revisions.count.should == 2
+        a.update_attributes! :content=>'another day'
+        expect(a.actions.count).to eq(3)
         Card::Env.params[:task] = :delete_old_revisions
         @all.update_attributes({})
-        a.revisions.count.should == 1        
+        expect(a.actions.count).to eq(1)        
       end
     end
 

data/{spec/mod/standard → mod/05_standard/spec}/set/self/now_spec.rb

@@ -2,6 +2,6 @@
 
 describe Card::Set::Self::Now do
   it "should have a date" do
-    render_card(:raw, :name=>'*now').match(/\w+day, \w+ \d+, \d{4}/ ).should_not be_nil
+    expect(render_card(:raw, :name=>'*now').match(/\w+day, \w+ \d+, \d{4}/ )).not_to be_nil
   end
 end

data/{spec/mod/standard → mod/05_standard/spec}/set/self/signin_spec.rb

@@ -10,43 +10,43 @@ describe Card::Set::Self::Signin do
   
   it 'open view should have email and password fields' do
     open_view = @card.format.render_open
-    open_view.should =~ /email/
-    open_view.should =~ /password/
+    expect(open_view).to match(/email/)
+    expect(open_view).to match(/password/)
     
   end
   
   it 'edit view should prompt for forgot password' do
     edit_view = @card.format.render_edit
-    edit_view.should =~ /email/
-    edit_view.should =~ /reset_password/
+    expect(edit_view).to match(/email/)
+    expect(edit_view).to match(/reset_password/)
   end
   
   it 'password reset success view should prompt to check email' do
     rps_view = @card.format.render_reset_password_success
-    rps_view.should =~ /Check your email/
+    expect(rps_view).to match(/Check your email/)
   end
   
   it 'delete action should sign out account' do
-    Card::Auth.current_id.should == Card['joe_user'].id
+    expect(Card::Auth.current_id).to eq(Card['joe_user'].id)
     @card.delete
-    Card::Auth.current_id.should == Card::AnonymousID
+    expect(Card::Auth.current_id).to eq(Card::AnonymousID)
   end
   
   context "#update" do
     it 'should trigger signin with valid credentials' do
       @card.update_attributes! '+*email'=>'joe@admin.com', '+*password'=>'joe_pass'
-      Card::Auth.current.should == Card['joe admin']
+      expect(Card::Auth.current).to eq(Card['joe admin'])
     end
 
 
     it 'should not trigger signin with bad email' do
       @card.update_attributes! '+*email'=>'schmoe@admin.com', '+*password'=>'joe_pass'
-      @card.errors[:signin].first.should =~ /Unrecognized email/
+      expect(@card.errors[:signin].first).to match(/Unrecognized email/)
     end
     
     it 'should not trigger signin with bad password' do
       @card.update_attributes! '+*email'=>'joe@admin.com', '+*password'=>'joe_fail'
-      @card.errors[:signin].first.should =~ /Wrong password/
+      expect(@card.errors[:signin].first).to match(/Wrong password/)
     end
     
     
@@ -60,12 +60,12 @@ describe Card::Set::Self::Signin do
     it 'should be triggered by an update' do
       #Card['joe admin'].account.token.should be_nil FIXME - this should be t
       @card.update_attributes! '+*email'=>'joe@admin.com'
-      Card['joe admin'].account.token.should_not be_nil
+      expect(Card['joe admin'].account.token).not_to be_nil
     end
     
     it 'should return an error if email is not found' do
       @card.update_attributes '+*email'=>'schmoe@admin.com'
-      @card.errors[:email].first.should =~ /not recognized/
+      expect(@card.errors[:email].first).to match(/not recognized/)
     end
   end
   

data/{spec/mod/standard → mod/05_standard/spec}/set/self/version_spec.rb

@@ -2,6 +2,6 @@
 
 describe Card::Set::Self::Version do
   it "should have an X.X.X version" do
-    (render_card(:raw, :name=>'*version') =~ (/\d\.\d+\.\w+/ )).should be_true
+    expect(render_card(:raw, :name=>'*version') =~ (/\d\.\d+\.\w+/ )).to be_truthy
   end
 end

data/mod/05_standard/spec/set/type/email_template_spec.rb

@@ -0,0 +1,130 @@
+describe Card::Set::Type::EmailTemplate do
+  def mailconfig args={}
+    Card['a mail template'].email_config(args)
+  end
+  
+  before do
+    Card::Auth.current_id = Card::WagnBotID
+    Card.create! :name => "a mail template", :type=>:email_template, :subcards=>{
+      "+*to" => { :content => "joe@user.com" },
+      "+*from" => { :content => "from@user.com" },
+      "+*subject" => { :content => "Subject of the mail" },
+      "+*html_message" => { :content => "[[B]]" }
+    }
+  end
+  
+  describe "mail view" do
+    let(:rendered_mail) { Card.fetch("a mail template").format.render_mail }
+   
+    
+    it "renders absolute urls" do
+      Card::Env[:protocol] = 'http://'
+      Card::Env[:host] = 'www.fake.com'
+      expect(rendered_mail.body).to include('<a class="known-card" href="http://www.fake.com/B">B</a>')
+    end
+    
+    # it "renders multipart mails" do
+    # end
+    
+    it 'renders broken config' do
+      Card.fetch("a mail template+*to").update_attributes(:content=>"invalid mail address")
+    end
+  end
+  
+  describe "#email_config" do
+    it "returns correct hash with email configuration" do
+      Card['a mail template+*html_message'].update_attributes! :content => "Nobody expects the Spanish Inquisition"
+      expect(mailconfig).to eq({
+        :to => "joe@user.com",
+        :from => "from@user.com",
+        :subject => "Subject of the mail",
+        :html_message => Card::Mailer.layout("Nobody expects the Spanish Inquisition"),
+      })
+    end
+    
+    it "uses context card for email config" do
+      Card['a mail template+*html_message'].update_attributes! :content => "Nobody expects {{_left+surprise|core}}"
+      c = Card.create :name=>'Banana+surprise', :content=>"the Spanish Inquisition"
+      c = Card.create :name => "Banana+emailtest", :content => "data content"
+      expect( mailconfig( context: c ) ).to eq({
+        :to => "joe@user.com",
+        :from => "from@user.com",
+        :subject => "Subject of the mail",
+        :html_message => Card::Mailer.layout("Nobody expects the Spanish Inquisition"),
+      })
+    end
+    
+    it "takes Pointer value for address fields" do
+       Card.create! :name => "a mail template+*cc", :content => "[[joe@user.com]]", :type=>'Pointer'
+       expect(mailconfig[:cc]).to eq('joe@user.com')
+     end
+     
+     it "handles +*email cards" do
+       Card::Auth.as_bot do
+         Card.create! :name => "a mail template+*cc", :content => "[[Joe User+*email]]", :type=>'Pointer'
+         Card.create! :name => "a mail template+*bcc", :content => '{"name":"Joe Admin","append":"*email"}', :type=>'Search'
+       end
+       conf = mailconfig
+       expect(conf[:cc]).to eq('joe@user.com')
+       expect(conf[:bcc]).to eq('joe@admin.com')
+     end
+     
+     it 'creates multipart email if text and html given' do
+       Card.create! :name => "a mail template+*text_message", :content => "Nobody expects the Spanish Inquisition"
+       email = render_card :mail, {:name=>"a mail template"}, {}
+       expect(email[:content_type].value).to include('multipart/alternative')
+     end
+  end
+
+  describe "complex config view" do
+    before do
+      class ActionView::Base
+        def params
+          @controller ? @controller.params : {}
+        end
+      end
+
+      Card::Auth.as_bot do
+        Card.create!  :name => 'Bobs addy', :content=>'bob@bob.com', :type=>'Phrase'
+        Card.create!  :name => 'default subject', :content=>'a very nutty thang', :type=>'Phrase'
+        Card.create!  :name => "mailconfig+*to", :content => %{ {"key":"bob_addy"} }, :type=>'Search'
+        Card.create!  :name => "mailconfig+*from", :content => %{ {"left":"_left", "right":"email"} }, :type=>'Search'
+        Card.create!  :name => "subject search+*right+*structure", :content => %{{"referred_to_by":"_self+subject"}}, :type=>'Search'
+        Card.create!  :name => "mailconfig+*subject", :content => "{{+subject search|core;item:core}}"
+        Card.create! :name => "mailconfig+*html message", :content => "Triggered by {{_self|name}} and its wonderful content: {{_self|core}}"
+        Card.create! :name => "mailconfig+*attach", :type=>"Pointer", :content => "[[_self+attachment]]"
+        Card.create! :name=>'Trigger', :type=>'Cardtype'
+        Card.create! :name=>'Trigger+*type+*create', :type=>'Pointer', :content=>'[[Anonymous]]'
+       # Card.create! :name => "Trigger+*type+*send", :content => "[[mailconfig]]", :type=>'Pointer'
+      end
+    end
+
+    it "returns correct hash with email configuration" do
+      Card::Auth.as_bot do
+        Card::Env[:protocol] = 'http://'
+        Card::Env[:host]     = 'a.com'
+
+        c = Card.create(
+          :name    => "Banana Trigger",
+          :content => "data content [[A]]",
+          :type    => 'Trigger',
+          :subcards=> {
+            '+email'      => {:content=>'gary@gary.com'},
+            '+subject'    => {:type=>'Pointer', :content=>'[[default subject]]'},
+#            '+attachment' => {:type=>'File', :content=>"notreally.txt" }
+          }
+        )
+        conf = mailconfig( context: c )
+
+        expect(conf[:to     ]).to eq("bob@bob.com")
+        expect(conf[:from   ]).to eq("gary@gary.com")
+        expect(conf[:bcc    ]).to eq(nil)
+        expect(conf[:cc     ]).to eq(nil)
+        expect(conf[:subject]).to eq("a very nutty thang")
+#        conf[:attach ].should == ['Banana Trigger+attachment']
+        expect(conf[:html_message]).to  include("Triggered by Banana Trigger and its wonderful content: data content " +
+          '<a class="known-card" href="http://a.com/A">A</a>')
+      end
+    end
+  end
+end

data/{spec/mod/standard → mod/05_standard/spec}/set/type/html_spec.rb

@@ -10,14 +10,14 @@ describe Card::Set::Type::Html do
   end
 
   it "should not render any content in closed view" do
-    render_card(:closed_content, :type=>'Html', :content=>"<strong>Lions and Tigers</strong>").should == ''
+    expect(render_card(:closed_content, :type=>'Html', :content=>"<strong>Lions and Tigers</strong>")).to eq('')
   end
 
   it "should render inclusions" do
-    render_card( :core, :type=>'HTML', :content=>'{{a}}' ).should =~ /slot/
+    expect(render_card( :core, :type=>'HTML', :content=>'{{a}}' )).to match(/slot/)
   end
 
   it 'should not render uris' do
-    render_card( :core, :type=>'HTML', :content=>'http://google.com' ).should_not =~ /\<a/
+    expect(render_card( :core, :type=>'HTML', :content=>'http://google.com' )).not_to match(/\<a/)
   end
 end

data/{spec/mod/standard → mod/05_standard/spec}/set/type/image_spec.rb

@@ -11,6 +11,6 @@ describe Card::Set::Type::Image do
     image_card = Card.create! :name => "TestImage", :type=>"Image", :content => %{TestImage.jpg\nimage/jpeg\n12345}
     including_card = Card.new :name => 'Image1', :content => "{{TestImage | core; size:small }}"
     rendered = including_card.format._render :core
-    assert_view_select rendered, 'img[src=?]', "/files/TestImage-small-#{image_card.current_revision_id}.jpg"
+    assert_view_select rendered, 'img[src=?]', "/files/TestImage-small-#{image_card.last_content_action_id}.jpg"
   end
 end

data/{spec/mod/standard → mod/05_standard/spec}/set/type/layout_type_spec.rb

@@ -2,6 +2,6 @@
 
 describe Card::Set::Type::LayoutType do
   it "should include Html card methods" do
-    Card.new( :type=>'Layout' ).clean_html?.should be_false
+    expect(Card.new( :type=>'Layout' ).clean_html?).to be_falsey
   end
 end

data/mod/05_standard/spec/set/type/search_type_spec.rb

@@ -0,0 +1,27 @@
+# -*- encoding : utf-8 -*-
+
+describe Card::Set::Type::SearchType do
+  it "should wrap search items with correct view class" do
+    Card.create :type=>'Search', :name=>'Asearch', :content=>%{{"type":"User"}}
+    c=render_content("{{Asearch|core;item:name}}")
+    expect(c).to match('search-result-item item-name')
+    expect(render_content("{{Asearch|core}}"          ).scan('search-result-item item-closed').size).to eq(10)
+    expect(render_content("{{Asearch|core;item:open}}").scan('search-result-item item-open'  ).size).to eq(10)
+    expect(render_content("{{Asearch|core|titled}}"   ).scan('search-result-item item-titled').size).to eq(10)
+  end
+
+  it "should handle returning 'count'" do
+    expect(render_card(:core, :type=>'Search', :content=>%{{ "type":"User", "return":"count"}})).to eq('10')
+  end
+  
+  it "should pass item args correctly" do
+    Card.create!(
+      :name=>'Pointer2Searches', 
+      :type_id=>Card::PointerID, 
+      :content=>"[[Layout+*type+by name]]\n[[PlainText+*type+by name]]"
+    )
+    r = render_content "{{Pointer2Searches|core|closed|hide:menu}}"
+    expect(r.scan('"view":"link"').size).to eq(0)
+    expect(r.scan('item-closed').size).to eq(2) #there are two of each
+  end
+end

data/mod/05_standard/spec/set/type/set_spec.rb

@@ -0,0 +1,26 @@
+# -*- encoding : utf-8 -*-
+
+describe Card::Set::Type::Set do
+  
+  describe :junction_only? do
+    it "should identify sets that only apply to plus cards" do
+      expect(Card.fetch("*all").junction_only?).to be_falsey
+      expect(Card.fetch("*all plus").junction_only?).to be_truthy
+      expect(Card.fetch("Book+*type").junction_only?).to be_falsey
+      expect(Card.fetch("*to+*right").junction_only?).to be_truthy
+      expect(Card.fetch("Book+*to+*type plus right").junction_only?).to be_truthy
+    end
+  end
+  
+  describe :inheritable? do
+    it "should identify sets that can inherit rules" do
+      expect(Card.fetch("A+*self").inheritable?).to be_falsey
+      expect(Card.fetch("A+B+*self").inheritable?).to be_truthy
+      expect(Card.fetch("Book+*to+*type plus right").inheritable?).to be_truthy
+      expect(Card.fetch("Book+*type").inheritable?).to be_falsey
+      expect(Card.fetch("*to+*right").inheritable?).to be_truthy
+      expect(Card.fetch("*all plus").inheritable?).to be_truthy
+      expect(Card.fetch("*all").inheritable?).to be_falsey
+    end
+  end
+end

data/mod/05_standard/spec/set/type/signup_spec.rb

@@ -0,0 +1,209 @@
+# -*- encoding : utf-8 -*-
+
+include Wagn::Location
+describe Card::Set::Type::Signup do
+  
+  before do
+    Card::Auth.current_id = Card::AnonymousID
+  end
+  
+  
+  context 'signup form form' do
+    before do
+      card = Card.new :type_id=>Card::SignupID
+      @form = card.format.render_new
+    end
+    
+    it 'should prompt to signup' do
+      Card::Auth.as :anonymous do
+        expect(@form.match( /Sign up/ )).to be_truthy
+      end
+    end
+  end
+  
+
+   
+  context 'signup (without approval)' do
+    before do
+      ActionMailer::Base.deliveries = [] #needed?
+
+      Card::Auth.as_bot do
+        Card.create! :name=>'User+*type+*create', :content=>'[[Anyone]]'
+      end
+      
+      Card::Auth.current_id = Card::AnonymousID
+      @signup = Card.create! :name=>'Big Bad Wolf', :type_id=>Card::SignupID, 
+        '+*account'=>{'+*email'=>'wolf@wagn.org', '+*password'=>'wolf'}     
+        
+      @account = @signup.account
+      @token = @account.token
+    end
+    
+    it 'should create all the necessary cards' do
+      expect(@signup.type_id).to eq(Card::SignupID)
+      expect(@account.email).to eq('wolf@wagn.org')
+      expect(@account.status).to eq('pending')
+      expect(@account.salt).not_to eq('')
+      expect(@account.password.length).to be > 10 #encrypted
+      expect(@account.token).to be_present
+    end
+  
+    it 'should send email with an appropriate link' do
+      @mail = ActionMailer::Base.deliveries.last
+      expect( @mail.parts[0].body.raw_source ).to match(Card.setting( :title ))
+    end
+    
+    it 'should create an authenticable token' do
+      expect(@account.token).to eq(@token)
+      expect(@account.authenticate_by_token(@token)).to eq(@signup.id)
+      expect(@account.fetch(:trait=> :token)).not_to be_present
+    end
+    
+    it 'should notify someone' do
+      expect(ActionMailer::Base.deliveries.last.to).to eq(['signups@wagn.org'])
+    end
+    
+    it 'should be activated by an update' do
+      Card::Env.params[:token] = @token
+      @signup.update_attributes({})
+      #puts @signup.errors.full_messages * "\n"
+      expect(@signup.errors).to be_empty
+      expect(@signup.type_id).to eq(Card::UserID)
+      expect(@account.status).to eq('active')
+      expect(Card[ @account.name ].active?).to be_truthy
+    end
+    
+    it 'should reject expired token and create new token' do
+      @account.token_card.update_column :updated_at, 8.days.ago.strftime("%F %T")
+      @account.token_card.expire
+      Card::Env.params[:token] = @token
+      
+      result = @signup.update_attributes!({})
+      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
+  
+  end
+
+
+  context 'signup (with approval)' do
+    before do
+      # NOTE: by default Anonymous does not have permission to create User cards.
+      Mail::TestMailer.deliveries.clear
+      Card::Auth.current_id = Card::AnonymousID
+      @signup = Card.create! :name=>'Big Bad Wolf', :type_id=>Card::SignupID,
+        '+*account'=>{ '+*email'=>'wolf@wagn.org', '+*password'=>'wolf' }
+      @account = @signup.account
+    end
+    
+    
+    it 'should create all the necessary cards, but no token' do
+      expect(@signup.type_id).to eq(Card::SignupID)
+      expect(@account.email).to eq('wolf@wagn.org')
+      expect(@account.status).to eq('pending')
+      expect(@account.salt).not_to eq('')
+      expect(@account.password.length).to be > 10 #encrypted
+    end
+    
+    it 'should not create a token' do
+      expect(@account.token).not_to be_present
+    end
+        
+    it 'sends signup alert email' do
+      signup_alert = ActionMailer::Base.deliveries.last
+      expect(signup_alert.to).to eq(['signups@wagn.org'])
+      [0, 1].each do |part|
+        body = signup_alert.body.parts[part].body.raw_source
+        expect(body).to include(@signup.name)
+        expect(body).to include('wolf@wagn.org')
+      end
+      
+    end
+    
+    it 'deos not send verification email' do
+      expect(Mail::TestMailer.deliveries[-2]).to be_nil
+    end
+    
+    
+    context 'approval with token' do
+      
+      it 'should create token' do
+        Card::Env.params[:approve_with_token] = true
+        Card::Auth.as :joe_admin
+        
+        @signup = Card.fetch @signup.id
+        @signup.save!
+        expect(@signup.account.token).to be_present
+      end
+      
+    end
+    
+    context 'approval without token' do
+      
+      it 'should create token' do
+        Card::Env.params[:approve_without_token] = true
+        Card::Auth.as :joe_admin
+        
+        @signup = Card.fetch @signup.id
+        @signup.save!
+        expect(@signup.account.token).not_to be_present
+        expect(@signup.type_id).to eq(Card::UserID)
+        expect(@signup.account.status).to eq('active')
+      end
+    end
+
+  end
+  
+  
+  context 'invitation' do
+    before do
+      # NOTE: by default Anonymous does not have permission to create User cards.
+      Card::Auth.current_id = Card::WagnBotID 
+      @signup = Card.create! :name=>'Big Bad Wolf', :type_id=>Card::SignupID, '+*account'=>{ '+*email'=>'wolf@wagn.org'}
+      @account = @signup.account
+    end
+    
+    it 'should create all the necessary cards, but no password' do
+      expect(@signup.type_id).to eq(Card::SignupID)
+      expect(@account.email).to eq('wolf@wagn.org')
+      expect(@account.status).to eq('pending')
+      expect(@account.salt).not_to eq('')
+      expect(@account.token).to be_present
+      expect(@account.password).not_to be_present
+    end
+    
+  end
+
+  # describe '#signup_notifications' do
+  #   before do
+  #     Card::Auth.as_bot do
+  #       Card.create! :name=>'*request+*to', :content=>'signups@wagn.org'
+  #     end
+  #     @user_name = 'Big Bad Wolf'
+  #     @user_email = 'wolf@wagn.org'
+  #     @signup = Card.create! :name=>@user_name, :type_id=>Card::SignupID, '+*account'=>{
+  #       '+*email'=>@user_email, '+*password'=>'wolf'}
+  #     ActionMailer::Base.deliveries = []
+  #     @signup.signup_notifications
+  #     @mail = ActionMailer::Base.deliveries.last
+  #   end
+  #
+  #   it 'send to correct address' do
+  #     expect(@mail.to).to eq(['signups@wagn.org'])
+  #   end
+  #
+  #   it 'contains request url' do
+  #      expect(@mail.body.raw_source).to include(wagn_url(@signup))
+  #   end
+  #
+  #   it 'contains user name' do
+  #     expect(@mail.body.raw_source).to include(@user_name)
+  #   end
+  #
+  #   it 'contains user email' do
+  #     expect(@mail.body.raw_source).to include(@user_email)
+  #   end
+  # end
+end