wagn 1.12.7

data/spec/models/card/comment_spec.rb

@@ -0,0 +1,38 @@
+# -*- encoding : utf-8 -*-
+require 'wagn/spec_helper'
+
+
+# FIXME: this test is breaking; I can cut and paste the code into console and it works great. wtf?
+describe Card, "record appender" do
+  before do
+    @r = Card.where(:type_id=>Card::RoleID).first
+    @rule = Card.new :name=>'A+*self+*comment', :type_id=>Card::PointerID, :content=>"[[#{@r.name}]]"
+  end
+
+  it "should have appender immediately" do
+    Card['a'].ok?(:comment).should_not be_true
+    Account.as_bot do
+      @rule.save!
+    end
+    Card['a'].ok?(:comment).should be_true
+  end
+
+  it "should have appender immediately" do
+    Account.as(Card::WagnBotID) do Card['a'].ok?(:comment).should_not be_true end
+    Account.as_bot do @rule.save! end
+    Account.as(Card::WagnBotID) do Card['a'].ok?(:comment).should be_true end
+  end
+end
+
+
+describe Card, "comment addition" do
+  it "should combine content after save" do
+    Account.as_bot do
+      Card.create :name => 'basicname+*self+*comment', :content=>'[[Anyone Signed In]]'
+      @c = Card.fetch "basicname"
+      @c.comment = " and more\n  \nsome lines\n\n"
+      @c.save!
+    end
+    Card["basicname"].content.should =~ /\<p\>some lines\<\/p\>/
+  end
+end

data/spec/models/card/create_spec.rb

@@ -0,0 +1,83 @@
+# -*- encoding : utf-8 -*-
+require 'wagn/spec_helper'
+
+# FIXME this shouldn't be here
+describe Card::Set::Type::Cardtype, ".create with :codename" do
+  it "should work" do
+    Card.create!(:name=>"Foo Type", :codename=>"foo", :type=>'Cardtype').type_code.should==:cardtype
+  end
+end
+
+
+
+
+describe Card, "created by Card.new " do
+  before(:each) do
+    Account.as_bot do
+      @c = Card.new :name=>"New Card", :content=>"Great Content"
+    end
+  end
+
+  it "should not override explicit content with default content" do
+    Account.as_bot do
+      Card.create! :name => "blue+*right+*default", :content => "joe", :type=>"Pointer"
+      c = Card.new :name => "Lady+blue", :content => "[[Jimmy]]"
+      c.content.should == "[[Jimmy]]"
+    end
+  end
+end
+
+
+
+describe Card, "created by Card.create with valid attributes" do
+  before(:each) do
+    Account.as_bot do
+      @b = Card.create :name=>"New Card", :content=>"Great Content"
+      @c = Card.find(@b.id)
+    end
+  end
+
+  it "should not have errors"        do @b.errors.size.should == 0        end
+  it "should have the right class"   do @c.class.should    == Card end
+  it "should have the right key"     do @c.key.should      == "new_card"  end
+  it "should have the right name"    do @c.name.should     == "New Card"  end
+  it "should have the right content" do @c.content.should  == "Great Content" end
+
+  it "should have a revision with the right content" do
+    @c.current_revision.content == "Great Content"
+  end
+
+  it "should be findable by name" do
+    Card["New Card"].class.should == Card
+  end
+end
+
+
+describe Card, "create junction" do
+  before(:each) do
+    @c = Card.create! :name=>"Peach+Pear", :content=>"juicy"
+  end
+
+  it "should not have errors" do
+    @c.errors.size.should == 0
+  end
+
+  it "should create junction card" do
+    Card["Peach+Pear"].class.should == Card
+  end
+
+  it "should create trunk card" do
+    Card["Peach"].class.should == Card
+  end
+
+  it "should create tag card" do
+    Card["Pear"].class.should == Card
+  end
+end
+
+
+
+describe Card, "types" do
+
+end
+

data/spec/models/card/reference_spec.rb

@@ -0,0 +1,214 @@
+# -*- encoding : utf-8 -*-
+require 'wagn/spec_helper'
+
+describe Card::Reference do
+
+  before do
+    Account.current_id = Card::WagnBotID
+  end
+
+  describe "references on hard templated cards should get updated" do
+    it "on structuree creation" do
+      Card.create! :name=>"JoeForm", :type=>'UserForm'
+      Card::Format.new(Card["JoeForm"]).render(:core)
+      assert_equal ["joe_form+age", "joe_form+description", "joe_form+name"],
+        Card["JoeForm"].includees.map(&:key).sort
+      Card["JoeForm"].references_expired.should_not == true
+    end
+
+    it "on template creation" do
+      Card.create! :name=>"SpecialForm", :type=>'Cardtype'
+      Card.create! :name=>"Form1", :type=>'SpecialForm', :content=>"foo"
+      c = Card["Form1"]
+      c.references_expired.should be_nil
+      Card.create! :name=>"SpecialForm+*type+*structure", :content=>"{{+bar}}"
+      c = Card["Form1"]
+      c.references_expired.should be_true
+      Card::Format.new(Card["Form1"]).render(:core)
+      c = Card["Form1"]
+      c.references_expired.should be_nil
+      Card["Form1"].includees.map(&:key).should == ["form1+bar"]
+    end
+
+    it "on template update" do
+      Card.create! :name=>"JoeForm", :type=>'UserForm'
+      tmpl = Card["UserForm+*type+*structure"]
+      tmpl.content = "{{+monkey}} {{+banana}} {{+fruit}}";
+      tmpl.save!
+      Card["JoeForm"].references_expired.should be_true
+      Card::Format.new(Card["JoeForm"]).render(:core)
+      assert_equal ["joe_form+banana", "joe_form+fruit", "joe_form+monkey"],
+        Card["JoeForm"].includees.map(&:key).sort
+      Card["JoeForm"].references_expired.should_not == true
+    end
+  end
+
+  it "in references should survive cardtype change" do
+    newcard("Banana","[[Yellow]]")
+    newcard("Submarine","[[Yellow]]")
+    newcard("Sun","[[Yellow]]")
+    newcard("Yellow")
+    Card["Yellow"].referencers.map(&:name).sort.should == %w{ Banana Submarine Sun }
+    y=Card["Yellow"];
+    y.type_id= Card.fetch_id "UserForm";
+    y.save!
+    Card["Yellow"].referencers.map(&:name).sort.should == %w{ Banana Submarine Sun }
+  end
+
+  it "container inclusion" do
+    Card.create :name=>'bob+city'
+    Card.create :name=>'address+*right+*default',:content=>"{{_L+city}}"
+    Card.create :name=>'bob+address'
+    Card.fetch('bob+address').includees.map(&:name).should == ["bob+city"]
+    Card.fetch('bob+city').includers.map(&:name).should == ["bob+address"]
+  end
+
+  it "pickup new links on rename" do
+    @l = newcard("L", "[[Ethan]]")  # no Ethan card yet...
+    @e = newcard("Earthman")
+    @e.update_attributes! :name => "Ethan"  # NOW there is an Ethan card
+    # @e.referencers.map(&:name).include("L")  as the test was originally written, fails
+    #  do we need the links to be caught before reloading the card?
+    Card["Ethan"].referencers.map(&:name).include?("L").should_not == nil
+  end
+
+  it "should update references on rename when requested" do
+    watermelon = newcard('watermelon', 'mmmm')
+    watermelon_seeds = newcard('watermelon+seeds', 'black')
+    lew = newcard('Lew', "likes [[watermelon]] and [[watermelon+seeds|seeds]]")
+
+    watermelon = Card['watermelon']
+    watermelon.update_referencers = true
+    watermelon.name="grapefruit"
+    watermelon.save!
+    lew.reload.content.should == "likes [[grapefruit]] and [[grapefruit+seeds|seeds]]"
+  end
+
+  it "should update referencers on rename when requested (case 2)" do
+    card = Card['Administrator Menu+*self+*read']
+    refs = Card::Reference.where(:referee_id => Card::AdminID).map(&:referer_id).sort
+    card.update_referencers = true
+    card.name='Administrator Menu+*type+*read'
+    card.save
+    Card::Reference.where(:referee_id => Card::AdminID).map(&:referer_id).sort.should == refs
+  end
+
+  it "should not update references when not requested" do
+
+    watermelon = newcard('watermelon', 'mmmm')
+    watermelon_seeds = newcard('watermelon+seeds', 'black')
+    lew = newcard('Lew', "likes [[watermelon]] and [[watermelon+seeds|seeds]]")
+
+    assert_equal [1,1], lew.references_to.map(&:present), "links should not be Wanted before"
+    watermelon = Card['watermelon']
+    watermelon.update_referencers = false
+    watermelon.name="grapefruit"
+    watermelon.save!
+    lew.reload.content.should == "likes [[watermelon]] and [[watermelon+seeds|seeds]]"
+    assert_equal [ 'L', 'L' ], lew.references_to.map(&:ref_type), "links should be a LINK"
+    assert_equal [ 0, 0 ], lew.references_to.map(&:present), "links should not be present"
+  end
+
+  it "update referencing content on rename junction card" do
+    @ab = Card["A+B"] #linked to from X, included by Y
+    @ab.update_attributes! :name=>'Peanut+Butter', :update_referencers => true
+    @x = Card['X']
+    @x.content.should == "[[A]] [[Peanut+Butter]] [[T]]"
+  end
+
+  it "update referencing content on rename junction card" do
+    @ab = Card["A+B"] #linked to from X, included by Y
+    @ab.update_attributes! :name=>'Peanut+Butter', :update_referencers=>false
+    @x = Card['X']
+    @x.content.should == "[[A]] [[A+B]] [[T]]"
+  end
+
+  it "template inclusion" do
+    cardtype = Card.create! :name=>"ColorType", :type=>'Cardtype', :content=>""
+    Card.create! :name=>"ColorType+*type+*structure", :content=>"{{+rgb}}"
+    green = Card.create! :name=>"green", :type=>'ColorType'
+    rgb = newcard 'rgb'
+    green_rgb = Card.create! :name => "green+rgb", :content=>"#00ff00"
+
+    green.reload.includees.map(&:name).should == ["green+rgb"]
+    green_rgb.reload.includers.map(&:name).should == ['green']
+  end
+
+  it "simple link" do
+    alpha = Card.create :name=>'alpha'
+    beta = Card.create :name=>'beta', :content=>"I link to [[alpha]]"
+    Card['alpha'].referencers.map(&:name).should == ['beta']
+    Card['beta'].referees.map(&:name).should == ['alpha']
+  end
+
+  it "link with spaces" do
+    alpha = Card.create! :name=>'alpha card'
+    beta =  Card.create! :name=>'beta card', :content=>"I link to [[alpha_card|ALPHA CARD]]"
+    Card['beta card'].referees.map(&:name).should == ['alpha card']
+    Card['alpha card'].referencers.map(&:name).should == ['beta card']
+  end
+
+
+  it "simple inclusion" do
+    alpha = Card.create :name=>'alpha'
+    beta = Card.create :name=>'beta', :content=>"I include to {{alpha}}"
+    Card['beta'].includees.map(&:name).should == ['alpha']
+    Card['alpha'].includers.map(&:name).should == ['beta']
+  end
+
+  it "non simple link" do
+    alpha = Card.create :name=>'alpha'
+    beta = Card.create :name=>'beta', :content=>"I link to [[alpha|ALPHA]]"
+    Card['beta'].referees.map(&:name).should == ['alpha']
+    Card['alpha'].referencers.map(&:name).should == ['beta']
+  end
+  
+  it "should handle commented inclusion" do
+    c = Card.create :name=>'inclusion comment test', :content=>'{{## hi mom }}'
+    c.errors.any?.should be_false
+  end
+
+
+  it "pickup new links on create" do
+    @l = newcard("woof", "[[Lewdog]]")  # no Lewdog card yet...
+    @e = newcard("Lewdog")              # now there is
+    # NOTE @e.referencers does not work, you have to reload
+    @e.reload.referencers.map(&:name).include?("woof").should_not == nil
+  end
+
+  it "pickup new inclusions on create" do
+    @l = Card.create! :name=>"woof", :content=>"{{Lewdog}}"  # no Lewdog card yet...
+    @e = Card.new(:name=>"Lewdog", :content=>"grrr")              # now there is
+    @e.name_referencers.map(&:name).include?("woof").should_not == nil
+  end
+
+=begin
+
+  # This test doesn't make much sense to me... LWH
+  it "revise changes references from wanted to linked for new cards" do
+    new_card = Card.create(:name=>'NewCard')
+    new_card.revise('Reference to [[WantedCard]], and to [[WantedCard2]]', Time.now, Card['quentin'].account),
+        new_format)
+
+    references = new_card.card_references(true)
+    references.size.should == 2
+    references[0].referee_key.should == 'WantedCard'
+    references[0].ref_type.should == Card::Reference::WANTED_PAGE
+    references[1].referee_key.should == 'WantedCard2'
+    references[1].ref_type.should == Card::Reference::WANTED_PAGE
+
+    wanted_card = Card.create(:name=>'WantedCard')
+    wanted_card.revise('And here it is!', Time.now, Card['quentin'].account), new_format)
+
+    # link type stored for NewCard -> WantedCard reference should change from WANTED to LINKED
+    # reference NewCard -> WantedCard2 should remain the same
+    references = new_card.card_references(true)
+    references.size.should == 2
+    references[0].referee_key.should == 'WantedCard'
+    references[0].ref_type.should == Card::Reference::LINKED_PAGE
+    references[1].referee_key.should == 'WantedCard2'
+    references[1].ref_type.should == Card::Reference::WANTED_PAGE
+  end
+=end
+
+end

data/spec/models/card/revision_spec.rb

@@ -0,0 +1,58 @@
+# -*- encoding : utf-8 -*-
+require 'wagn/spec_helper'
+
+describe Card::Revision do
+
+  it 'should be created whenever content is updated' do
+    author1 = Account[ 'joe@user.com' ]
+    author2 = Account[ 'sara@user.com' ]
+    author_cd1 = Card[author1.card_id]
+    author_cd2 = Card[author2.card_id]
+    Account.current_id = Card::WagnBotID
+    rc1=author_cd1.fetch(:new=>{}, :trait=>:roles)
+    rc1 << Card::AdminID
+    rc2 = author_cd2.fetch(:new=>{}, :trait=>:roles)
+    rc2 << Card::AdminID
+    author_cd1.save
+    author_cd2.save
+    Account.current_id = author_cd1.id
+    card = Card.create! :name=>'alpha', :content=>'stuff'
+    Account.current_id = author_cd2.id
+    card.content = 'boogy'
+    card.save
+    card.reload
+
+    assert_equal 2, card.revisions.count, 'Should have two revisions'
+    assert_equal author_cd2.name, card.current_revision.creator.name, 'current author'
+    assert_equal author_cd1.name, card.revisions.first.creator.name,  'first author'
+  end
+
+=begin
+  # FIXME- should revisit what we want to have happen here; for now keep saving unchanged revisions..
+  def test_revise_content_unchanged
+    @card = newcard('alpha', 'banana')
+    last_revision_before = @card.current_revision
+    revisions_number_before = @card.revisions.size
+
+    @card.content = (@card.current_revision.content)
+    @card.save
+
+    assert_equal last_revision_before, @card.current_revision(true)
+    assert_equal revisions_number_before, @card.revisions.size
+  end
+=end
+
+=begin #FIXME - don't think this is used by any controller. we'll see what breaks
+  def test_rollback
+    @card = newcard("alhpa", "some test content")
+    @user = Account[ Card['quentin'].id ]
+    @card.content = "spot two"; @card.save
+    @card.content = "spot three"; @card.save
+    assert_equal 3, @card.revisions(true).length, "Should have three revisions"
+    @card.current_revision(true)
+    @card.rollback(0)
+    assert_equal "some test content", @card.current_revision(true).content
+  end
+=end
+
+end

data/spec/models/card/trash_spec.rb

@@ -0,0 +1,258 @@
+# -*- encoding : utf-8 -*-
+require 'wagn/spec_helper'
+
+
+describe Card, "deleting card" do
+  it "should require permission" do
+    a = Card['a']
+    Account.as :anonymous do
+      a.ok?(:delete).should == false
+      a.delete.should == false
+      a.errors[:permission_denied].should_not be_empty
+      Card['a'].trash.should == false
+    end
+    
+  end
+end
+
+describe Card, "deleted card" do
+  before do
+    Account.as_bot do
+      @c = Card['A']
+      @c.delete!
+    end
+  end
+  it "should be in the trash" do
+    @c.trash.should be_true
+  end
+  it "should come out of the trash when a plus card is created" do
+    Account.as_bot do
+      Card.create(:name=>'A+*acct')
+      c = Card[ 'A' ]
+      c.trash.should be_false
+    end
+  end
+end
+
+describe Card, "in trash" do
+  it "should be retrieved by fetch with new" do
+    Card.create(:name=>"Betty").delete
+    c=Card.fetch "Betty", :new=>{}
+    c.save
+    Card["Betty"].should be_instance_of(Card)
+  end
+end
+
+
+describe Card, "plus cards" do
+  it "should be deleted when root is" do
+    Account.as :joe_admin do
+      c = Card.create! :name=>'zz+top'
+      root = Card['zz']
+      root.delete
+#      Rails.logger.info "ERRORS = #{root.errors.full_messages*''}"
+      Card.find(c.id).trash.should be_true
+      Card['zz'].should be_nil
+    end
+  end
+end
+
+# FIXME: these user tests should probably be in a set of cardtype specific tests somewhere..
+describe User, "with revisions" do
+  before do Account.as_bot { @c = Card["Wagn Bot"] } end
+  it "should not be removable" do
+    @c.delete.should_not be_true
+  end
+end
+
+describe User, "without revisions" do
+  before do
+    Account.as_bot do
+      @c = Card.create! :name=>'User Must Die', :type=>'User'
+    end
+  end
+  it "should be removable" do
+    @c.delete!.should be_true
+  end
+end
+
+
+
+
+#NOT WORKING, BUT IT SHOULD
+#describe Card, "a part of an unremovable card" do
+#  before do
+#     Account.as(Card::WagnBotID)
+#     # this ugly setup makes it so A+Admin is the actual user with edits..
+#     Card["Wagn Bot"].update_attributes! :name=>"A+Wagn Bot"
+#  end
+#  it "should not be removable" do
+#    @a = Card['A']
+#    @a.delete.should_not be_true
+#  end
+#end
+
+describe Card, "dependent removal" do
+  before do
+    @a = Card['A']
+    @a.delete!
+    @c = Card.find_by_key "A+B+C".to_name.key
+  end
+
+  it "should be trash" do
+    @c.trash.should be_true
+  end
+
+  it "should not be findable by name" do
+    Card["A+B+C"].should == nil
+  end
+end
+
+describe Card, "rename to trashed name" do
+  before do
+    Account.as_bot do
+      @a = Card["A"]
+      @b = Card["B"]
+      @a.delete!  #trash
+      Rails.logger.info "\n\n~~~~~~~deleted~~~~~~~~\n\n\n"
+      
+      @b.update_attributes! :name=>"A", :update_referencers=>true
+    end
+  end
+
+  it "should rename b to a" do
+    @b.name.should == 'A'
+  end
+
+  it "should rename a to a*trash" do
+    (c = Card.find(@a.id)).cardname.to_s.should == 'A*trash'
+    c.name.should == 'A*trash'
+    c.key.should == 'a*trash'
+  end
+end
+
+
+describe Card, "sent to trash" do
+  before do
+    Account.as_bot do
+      @c = Card["basicname"]
+      @c.delete!
+    end
+  end
+
+  it "should be trash" do
+    @c.trash.should == true
+  end
+
+  it "should not be findable by name" do
+    Card["basicname"].should == nil
+  end
+
+  it "should still have revision" do
+    @c.revisions.length.should == 1
+    @c.current_revision.content.should == 'basiccontent'
+  end
+end
+
+describe Card, "revived from trash" do
+  before do
+    Account.as_bot do
+      Card["basicname"].delete!
+      
+      @c = Card.create! :name=>'basicname', :content=>'revived content'
+    end
+  end
+
+  it "should not be trash" do
+    @c.trash.should == false
+  end
+
+  it "should have 2 revisions" do
+    @c.revisions.length.should == 2
+  end
+
+  it "should still have old revisions" do
+    @c.revisions[0].content.should == 'basiccontent'
+  end
+
+  it "should have a new revision" do
+    @c.content.should == 'revived content'
+#    Card.fetch(@c.name).content.should == 'revived content'
+  end
+end
+
+describe Card, "recreate trashed card via new" do
+#  before do
+#    Account.as(Card::WagnBotID)
+#    @c = Card.create! :type=>'Basic', :name=>"BasicMe"
+#  end
+
+#  this test is known to be broken; we've worked around it for now
+#  it "should delete and recreate with a different cardtype" do
+#    @c.delete!
+#    @re_c = Card.new :type=>"Phrase", :name=>"BasicMe", :content=>"Banana"
+#    @re_c.save!
+#  end
+
+end
+
+describe Card, "junction revival" do
+  before do
+    Account.as_bot do
+      @c = Card.create! :name=>"basicname+woot", :content=>"basiccontent"
+      @c.delete!
+      @c = Card.create! :name=>"basicname+woot", :content=>"revived content"
+    end
+  end
+
+  it "should not be trash" do
+    @c.trash.should == false
+  end
+
+  it "should have 2 revisions" do
+    @c.revisions.length.should == 2
+  end
+
+  it "should still have old revisions" do
+    @c.revisions[0].content.should == 'basiccontent'
+  end
+
+  it "should have a new revision" do
+    @c.content.should == 'revived content'
+  end
+end
+
+describe "remove tests" do
+
+  before do
+    @a = Card["A"]
+  end
+
+  # I believe this is here to test a bug where cards with certain kinds of references
+  # would fail to delete.  probably less of an issue now that delete is done through
+  # trash.
+  it "test_remove" do
+    assert @a.delete!, "card should be deleteable"
+    assert_nil Card["A"]
+  end
+
+  it "test_recreate_plus_card_name_variant" do
+    Card.create( :name => "rta+rtb" ).delete
+    Card["rta"].update_attributes :name=> "rta!"
+    c = Card.create! :name=>"rta!+rtb"
+    assert Card["rta!+rtb"]
+    assert !Card["rta!+rtb"].trash
+    assert Card.find_by_key('rtb*trash').nil?
+  end
+
+  it "test_multiple_trash_collision" do
+    Card.create( :name => "alpha" ).delete
+    3.times do
+      b = Card.create( :name => "beta" )
+      b.name = "alpha"
+      assert b.save!
+      b.delete
+    end
+  end
+end
+