wagn 1.13.0 → 1.14.0.pre1

data/spec/mod/core/set/all/rules_spec.rb

@@ -1,98 +0,0 @@
-# -*- encoding : utf-8 -*-
-
-describe Card::Set::All::Rules do
-  before do
-    Card::Auth.current_id = Card::WagnBotID
-  end
-
-  describe "setting data setup" do
-    it "should make Set of +*type" do
-      Card.create! :name=>"SpeciForm", :type=>'Cardtype'
-      Card.create!( :name=>"SpeciForm+*type" ).type_code.should == :set
-    end
-  end
-
-  describe "#rule" do
-    it "retrieves Set based value" do
-      Card.create :name => "Book+*type+*add help", :content => "authorize"
-      Card.new( :type => "Book" ).rule(:add_help, :fallback=>:help).should == "authorize"
-    end
-
-    it "retrieves default values" do
-      #Card.create :name => "all Basic cards", :type => "Set", :content => "{\"type\": \"Basic\"}"  #defaults should work when other Sets are present
-      assert c=Card.create(:name => "*all+*add help", :content => "lobotomize")
-#      Card.default_rule(:add_help, :fallback=>:help).should == "lobotomize"
-      Card.new( :type => "Basic" ).rule(:add_help, :fallback=>:help).should == "lobotomize"
-    end
-
-    it "retrieves single values" do
-      Card.create! :name => "banana+*self+*help", :content => "pebbles"
-      Card["banana"].rule(:help).should == "pebbles"
-    end
-    
-    context 'with fallback' do
-      before do
-        Card.create :name => "*all+*help", :content => "edit any kind of card"
-      end
-
-      it "retrieves default setting" do
-        Card.new( :type => "Book" ).rule(:add_help, :fallback=>:help).should == "edit any kind of card"
-      end
-
-      it "retrieves primary setting" do
-        Card.create :name => "*all+*add help", :content => "add any kind of card"
-        Card.new( :type => "Book" ).rule(:add_help, :fallback=>:help).should == "add any kind of card"
-      end
-
-      it "retrieves more specific default setting" do
-        Card.create :name => "*all+*add help", :content => "add any kind of card"
-        Card.create :name => "*Book+*type+*help", :content => "edit a Book"
-        Card.new( :type => "Book" ).rule(:add_help, :fallback=>:help).should == "add any kind of card"
-      end
-    end
-  end
-
-
-  describe "#setting_codes_by_group" do
-    before do
-      @pointer_key = Card::Set::Type::Setting::POINTER_KEY
-      @pointer_settings =  [ :options, :options_label, :input ]
-    end
-    it "doesn't fail on nonexistent trunks" do
-      Card.new(:name=>'foob+*right').setting_codes_by_group.class.should == Hash
-    end
-    
-    it "returns universal setting names for non-pointer set" do
-      pending "Different api, we should just put the tests in a new spec for that"
-      snbg = Card.fetch('*star').setting_codes_by_group
-      #warn "snbg #{snbg.class} #{snbg.inspect}"
-      snbg.keys.length.should == 4
-      snbg.keys.first.should be_a Symbol
-      snbg.keys.member?( @pointer_key ).should_not be_true
-    end
-
-    it "returns pointer-specific setting names for pointer card (*type)" do
-      pending "Different api, we should just put the tests in a new spec for that"
-      # was this test wrong before?  What made Fruit a pointer without this?
-      Card::Auth.as_bot do
-        c1=Card.create! :name=>'Fruit+*type+*default', :type=>'Pointer'
-        Card.create! :name=>'Pointer+*type'
-      end
-      c2 = Card.fetch('Fruit+*type')
-      snbg = c2.setting_codes_by_group
-      #warn "snbg #{snbg.class}, #{snbg.inspect}"
-      snbg[@pointer_key].should == @pointer_settings
-      c3 = Card.fetch('Pointer+*type')
-      snbg = c3.setting_codes_by_group
-      snbg[@pointer_key].should == @pointer_settings
-    end
-
-    it "returns pointer-specific setting names for pointer card (*self)" do
-      c = Card.fetch '*star+*create+*self', :new=>{}
-      snbg = c.setting_codes_by_group
-      #warn "result #{snbg.inspect}"
-      snbg[@pointer_key].should == @pointer_settings
-    end
-
-  end
-end

data/spec/mod/standard/chunk/link_spec.rb

@@ -1,59 +0,0 @@
-# -*- encoding : utf-8 -*-
-
-describe Card::Chunk::Link do
-
-  it "should handle unknown cards" do
-    render_content('[[Nixon]]').should == '<a class="wanted-card" href="/Nixon">Nixon</a>'
-  end
-
-  it 'should handle known cards' do
-    render_content("[[A]]").should=='<a class="known-card" href="/A">A</a>'
-  end
-  
-  it 'should handle custom text' do
-    render_content('[[Baines|Lyndon]]').should == '<a class="wanted-card" href="/Baines">Lyndon</a>'
-  end
-
-  it "should handle relative names" do
-    @card = Card.new :name=>'Kennedy'
-    render_content('[[+Monroe]]'     ).should == '<a class="wanted-card" href="/Kennedy+Monroe">Kennedy+Monroe</a>'
-    render_content('[[_self+Exner]]' ).should == '<a class="wanted-card" href="/Kennedy+Exner">Kennedy+Exner</a>'
-    render_content('[[Onassis+]]'    ).should == '<a class="wanted-card" href="/Onassis+Kennedy">Onassis+Kennedy</a>'
-  end
-
-  it "should handle relative names in context" do
-    @card = Card.new :name=>'Kennedy'
-    format_args = { :context_names => [ 'Kennedy'.to_name ] }
-    render_content('[[+Monroe]]'    , format_args ).should == '<a class="wanted-card" href="/Kennedy+Monroe">+Monroe</a>'
-    render_content('[[_self+Exner]]', format_args ).should == '<a class="wanted-card" href="/Kennedy+Exner">+Exner</a>'
-    render_content('[[Onassis+]]'   , format_args ).should == '<a class="wanted-card" href="/Onassis+Kennedy">Onassis</a>'
-  end
-
-  it "should handle relative urls" do
-    render_content('[[/recent]]').should == '<a class="internal-link" href="/recent">/recent</a>'
-  end
-
-  it "should handle absolute urls" do
-    render_content('[[http://google.com]]').should == '<a class="external-link" href="http://google.com">http://google.com</a>'
-  end
-
-  it "should escape spaces in cardnames with %20 (not +)" do
-    render_content('[[Marie "Mad Dog" Deatherage|Marie]]').should ==
-      '<a class="wanted-card" href="/Marie_Mad_Dog_Deatherage?card%5Bname%5D=Marie+%22Mad+Dog%22+Deatherage">Marie</a>'
-  end
-
-  it "should not escape content outside of link" do
-    render_content('wgw&nbsp; [[http://www.google.com|google]] &nbsp;  <br>').should == 
-      "wgw&nbsp; <a class=\"external-link\" href=\"http://www.google.com\">google</a> &nbsp;  <br>"
-  end
-  
-  it "should handle inclusions in link text" do
-    render_content('[[linkies|{{namies|name}}]]').should == '<a class="wanted-card" href="/linkies">namies</a>'
-  end
-  
-  it "should handle dot (.) in missing cardlink" do
-    render_content("[[Wagn 1.10.12]]").should=='<a class="wanted-card" href="/Wagn_1_10_12?card%5Bname%5D=Wagn+1.10.12">Wagn 1.10.12</a>'
-  end
-
-end
-

data/spec/mod/standard/set/all/email_html_spec.rb

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

data/spec/mod/standard/set/all/flexmail_spec.rb

@@ -1,5 +0,0 @@
-# -*- encoding : utf-8 -*-
-
-describe Card::Set::All::Flexmail do
-  # set just has simple event. tests are in features/flexmail.feature and spec/lib/card/flexmail_spec.rb
-end

data/spec/mod/standard/set/all/follow_spec.rb

@@ -1,95 +0,0 @@
-# -*- 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
-
-  describe "#watchers" do
-    it "returns users watching this card specifically" do
-      Card["All Eyes On Me"].watchers.sort.should == @s_and_j
-    end
-
-    it "returns users watching cards of this type" do
-      Card["Sunglasses"].watchers.should == @just_s
-    end
-  end
-
-  describe "#card_watchers" do
-    it "returns users watching this card specifically" do
-      Card["All Eyes On Me"].watcher_pairs(false).sort.should == @s_and_j
-    end
-  end
-
-  describe "#type_watchers" do
-    it "returns users watching cards of this type" do
-      Card["Sunglasses"].watcher_pairs(false, :type).should == @just_s
-    end
-  end
-end
-
-describe "On Card Changes" 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
-
-  it "sends notifications of edits" do
-    mock(Card::Mailer).change_notice( Card['Sara'].id, Card["Sara Watching"], "updated", "Sara Watching", nil )
-    Card["Sara Watching"].update_attributes :content => "A new change"
-  end
-
-  it "sends notifications of additions" do
-    new_card = Card.new :name => "Microscope", :type => "Optic"
-    mock(Card::Mailer).change_notice( Card['Sara'].id, new_card,"created", "Optic", nil  )
-    new_card.save!
-  end
-
-  it "sends notification of updates" do
-    mock(Card::Mailer).change_notice( is_a(Integer), Card["Sunglasses"], "updated", "Optic", nil)
-    Card["Sunglasses"].update_attributes :content => 'updated content'
-  end
-
-  it "does not send notification to author of change" do
-    mock(Card::Mailer).change_notice.with_any_args.times(any_times) do
-      |*a| a[0].should_not == Card::Auth.current_id
-    end
-
-    Card["All Eyes On Me"].update_attributes :content => "edit by John"
-  end
-
-  it "does include author in wathers" do
-     Card["All Eyes On Me"].watchers.member?(Card::Auth.current_id).should be_true
-  end
-end
-
-
-describe "Trunk watcher notificatione" do
-  before do
-    Timecop.travel(Wagn.future_stamp)  # make sure we're ahead of all the test data
-
-    Card.create :type=>'Book', :name=>'Ulysses'
-    (@ulyss =Card['Ulysses']).should be
-    watchers_card = Card.fetch "Ulysses+*watchers", :new=>{}
-    c = Card['joe camel']
-    watchers_card << c
-    @jc_id = c.id
-    watchers_card.save
- 
-    watchers_card = Card.fetch "Book+*watchers", :new=>{}
-    c = Card['joe admin']
-    watchers_card << c
-    @ja_id = c.id
-    watchers_card.save
-  end
-
-  it "sends notification to Joe Camel" do
-    name = "Ulysses+author"
-    mock(Card::Mailer).change_notice( @ja_id, @ulyss, "updated", 'Book' , [[name, "created"]], is_a(Card))
-    mock(Card::Mailer).change_notice( @jc_id, @ulyss, "updated", @ulyss.name , [[name, "created"]], is_a(Card))
-    c=Card.create :name=>name, :content => "James Joyce"
-  end
-
-end

data/spec/mod/standard/set/all/history_spec.rb

@@ -1,10 +0,0 @@
-# -*- encoding : utf-8 -*-
-
-describe Card::Set::All::History do
-  context "history view" do
-    it 'should have a frame' do
-      history = render_card :history, :name=>"A"
-      assert_view_select history, 'div[class~="card-frame"]'
-    end
-  end
-end

data/spec/mod/standard/set/right/account_spec.rb

@@ -1,90 +0,0 @@
-# -*- 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
-        Card::Auth.password_authenticated?( @user_card.account, 'tmp_pass').should be_true
-      end
-    end
-    
-    it "should check accountability of 'accounted' card" do
-      @unaccountable = Card.create :name=>'BasicUnaccountable', '+*account'=>{ '+*email'=>'tmpuser@wagn.org', '+*password'=>'tmp_pass' }
-      @unaccountable.errors['+*account'].first.should == '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' }
-      @no_email.errors['+*account'].first.should =~ /email required/
-    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
-      Card::Auth.current_id.should == Card::AnonymousID
-      @account.save.should == true
-      Card::Auth.current_id.should == @account.left_id
-      @account = @account.refresh force=true
-      @account.fetch(:trait => :token).should be_nil
-      @account.save.should == false
-    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
-      result.should == true                 # successfully completes save
-      @account.token.should_not == @token   # token gets updated
-      success = Card::Env.params[:success]
-      success[:message].should =~ /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
-      @account.errors[:abort].first.should =~ /incorrect_token/
-    end  
-    
-  end
-  
-end
-

data/spec/mod/standard/set/type/search_type_spec.rb

@@ -1,27 +0,0 @@
-# -*- 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}}")
-    c.should match('search-result-item item-name')
-    render_content("{{Asearch|core}}"          ).scan('search-result-item item-closed').size.should == 10
-    render_content("{{Asearch|core;item:open}}").scan('search-result-item item-open'  ).size.should == 10
-    render_content("{{Asearch|core|titled}}"   ).scan('search-result-item item-titled').size.should == 10
-  end
-
-  it "should handle returning 'count'" do
-    render_card(:core, :type=>'Search', :content=>%{{ "type":"User", "return":"count"}}).should == '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}}"
-    r.scan('"view":"link"').size.should == 0
-    r.scan('item-closed').size.should == 2 #there are two of each
-  end
-end

data/spec/mod/standard/set/type/set_spec.rb

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

data/spec/mod/standard/set/type/signup_spec.rb

@@ -1,169 +0,0 @@
-# -*- encoding : utf-8 -*-
-
-
-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
-        @form.match( /Sign up/ ).should be_true
-      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]]'
-        Card.create! :name=>'*request+*to', :content=>'signups@wagn.org'
-      end
-      @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
-      @signup.type_id.should == Card::SignupID
-      @account.email.should == 'wolf@wagn.org'
-      @account.status.should == 'pending'
-      @account.salt.should_not == ''
-      @account.password.length.should > 10 #encrypted
-      @account.token.should be_present
-    end
-  
-    it 'should send email with an appropriate link' do
-    end
-    
-    it 'should create an authenticable token' do
-      @account.token.should == @token
-      @account.authenticate_by_token(@token).should == @signup.id
-      @account.fetch(:trait=> :token).should_not be_present
-    end
-    
-    it 'should notify someone' do
-      ActionMailer::Base.deliveries.last.to.should == ['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"
-      @signup.errors.should be_empty
-      @signup.type_id.should == Card::UserID
-      @account.status.should == 'active'
-      Card[ @account.name ].active?.should be_true
-    end
-    
-    it 'should reject expired token and create new token' do
-      @account.token_card.update_column :updated_at, 3.days.ago.strftime("%F %T")
-      @account.token_card.expire
-      Card::Env.params[:token] = @token
-      
-      result = @signup.update_attributes!({})
-      result.should == true                 # successfully completes save
-      @account.token.should_not == @token   # token gets updated
-      success = Card::Env.params[:success]
-      success[:message].should =~ /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.
-      Card::Auth.as_bot do
-        Card.create! :name=>'*request+*to', :content=>'signups@wagn.org'
-      end
-      @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
-      @signup.type_id.should == Card::SignupID
-      @account.email.should == 'wolf@wagn.org'
-      @account.status.should == 'pending'
-      @account.salt.should_not == ''
-      @account.password.length.should > 10 #encrypted
-    end
-    
-    it 'should not create a token' do
-      @account.token.should_not be_present
-    end
-    
-    it 'should notify someone' do
-      ActionMailer::Base.deliveries.last.to.should == ['signups@wagn.org']
-    end
-    
-    
-    context 'approval with token' do
-      
-      it 'should create token' do
-        Card::Env.params[:approve_token] = true
-        Card::Auth.as :joe_admin
-        
-        @signup = Card.fetch @signup.id
-        @signup.save!
-        @signup.account.token.should 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!
-        @signup.account.token.should_not be_present
-        @signup.type_id.should == Card::UserID
-        @signup.account.status.should == 'active'
-      end
-    end
-
-  end
-  
-  
-  context 'invitation' do
-    before do
-      # NOTE: by default Anonymous does not have permission to create User cards.
-      Card::Auth.as_bot do
-        Card.create! :name=>'*request+*to', :content=>'signups@wagn.org'
-        @signup = Card.create! :name=>'Big Bad Wolf', :type_id=>Card::SignupID, '+*account'=>{ '+*email'=>'wolf@wagn.org'}
-      end
-      @account = @signup.account
-    end
-    
-    it 'should create all the necessary cards, but no password' do
-      @signup.type_id.should == Card::SignupID
-      @account.email.should == 'wolf@wagn.org'
-      @account.status.should == 'pending'
-      @account.salt.should_not == ''
-      @account.token.should be_present
-      @account.password.should_not be_present
-    end
-    
-  end
-
-end