card 0.0.1 → 1.15.pre

data/spec/models/card/create_spec.rb

@@ -0,0 +1,82 @@
+# -*- encoding : utf-8 -*-
+
+# FIXME this shouldn't be here
+describe Card::Set::Type::Cardtype, ".create with :codename" do
+  it "should work" do
+    expect(Card.create!(:name=>"Foo Type", :codename=>"foo", :type=>'Cardtype').type_code).to eq(:cardtype)
+  end
+end
+
+
+
+
+describe Card, "created by Card.new " do
+  before(:each) do
+    Card::Auth.as_bot do
+      @c = Card.new :name=>"New Card", :content=>"Great Content"
+    end
+  end
+
+  it "should not override explicit content with default content" do
+    Card::Auth.as_bot do
+      Card.create! :name => "blue+*right+*default", :content => "joe", :type=>"Pointer"
+      c = Card.new :name => "Lady+blue", :content => "[[Jimmy]]"
+      expect(c.content).to eq("[[Jimmy]]")
+    end
+  end
+end
+
+
+
+describe Card, "created by Card.create with valid attributes" do
+  before(:each) do
+    Card::Auth.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 expect(@b.errors.size).to eq(0)        end
+  it "should have the right class"   do expect(@c.class).to    eq(Card) end
+  it "should have the right key"     do expect(@c.key).to      eq("new_card")  end
+  it "should have the right name"    do expect(@c.name).to     eq("New Card")  end
+  it "should have the right content" do expect(@c.content).to  eq("Great Content") end
+
+  it "should have the right content" do
+    @c.db_content == "Great Content"
+  end
+
+  it "should be findable by name" do
+    expect(Card["New Card"].class).to eq(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
+    expect(@c.errors.size).to eq(0)
+  end
+
+  it "should create junction card" do
+    expect(Card["Peach+Pear"].class).to eq(Card)
+  end
+
+  it "should create trunk card" do
+    expect(Card["Peach"].class).to eq(Card)
+  end
+
+  it "should create tag card" do
+    expect(Card["Pear"].class).to eq(Card)
+  end
+end
+
+
+
+describe Card, "types" do
+
+end
+

data/spec/models/card/trash_spec.rb

@@ -0,0 +1,260 @@
+# -*- encoding : utf-8 -*-
+
+require 'card/action'
+
+describe Card, "deleting card" do
+  it "should require permission" do
+    a = Card['a']
+    Card::Auth.as :anonymous do
+      expect(a.ok?(:delete)).to eq(false)
+      expect(a.delete).to eq(false)
+      expect(a.errors[:permission_denied]).not_to be_empty
+      expect(Card['a'].trash).to eq(false)
+    end
+    
+  end
+end
+
+describe Card, "deleted card" do
+  before do
+    Card::Auth.as_bot do
+      @c = Card['A']
+      @c.delete!
+    end
+  end
+  it "should be in the trash" do
+    expect(@c.trash).to be_truthy
+  end
+  it "should come out of the trash when a plus card is created" do
+    Card::Auth.as_bot do
+      Card.create(:name=>'A+*acct')
+      c = Card[ 'A' ]
+      expect(c.trash).to be_falsey
+    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
+    expect(Card["Betty"]).to be_instance_of(Card)
+  end
+end
+
+
+describe Card, "plus cards" do
+  it "should be deleted when root is" do
+    Card::Auth.as :joe_admin do
+      c = Card.create! :name=>'zz+top'
+      root = Card['zz']
+      root.delete
+#      Rails.logger.info "ERRORS = #{root.errors.full_messages*''}"
+      expect(Card.find(c.id).trash).to be_truthy
+      expect(Card['zz']).to be_nil
+    end
+  end
+end
+
+# FIXME: these user tests should probably be in a set of cardtype specific tests somewhere..
+describe Card do
+  context "with revisions" do
+    before do Card::Auth.as_bot { @c = Card["Wagn Bot"] } end
+    it "should not be removable" do
+      expect(@c.delete).not_to be_truthy
+    end
+  end
+
+  context "without revisions" do
+    before do
+      Card::Auth.as_bot do
+        @c = Card.create! :name=>'User Must Die', :type=>'User'
+      end
+    end
+    it "should be removable" do
+      expect(@c.delete!).to be_truthy
+    end
+  end
+end
+
+
+
+
+#NOT WORKING, BUT IT SHOULD
+#describe Card, "a part of an unremovable card" do
+#  before do
+#     Card::Auth.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
+    expect(@c.trash).to be_truthy
+  end
+
+  it "should not be findable by name" do
+    expect(Card["A+B+C"]).to eq(nil)
+  end
+end
+
+describe Card, "rename to trashed name" do
+  before do
+    Card::Auth.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
+    expect(@b.name).to eq('A')
+  end
+
+  it "should rename a to a*trash" do
+    expect((c = Card.find(@a.id)).cardname.to_s).to eq('A*trash')
+    expect(c.name).to eq('A*trash')
+    expect(c.key).to eq('a*trash')
+  end
+end
+
+
+describe Card, "sent to trash" do
+  before do
+    Card::Auth.as_bot do
+      @c = Card["basicname"]
+      @c.delete!
+    end
+  end
+
+  it "should be trash" do
+    expect(@c.trash).to eq(true)
+  end
+
+  it "should not be findable by name" do
+    expect(Card["basicname"]).to eq(nil)
+  end
+
+  it "should still have actions" do
+    expect(@c.actions.count).to eq(2)
+    expect(@c.last_change_on(:db_content).value).to eq('basiccontent')
+  end
+end
+
+describe Card, "revived from trash" do
+  before do
+    Card::Auth.as_bot do
+      Card["basicname"].delete!
+      
+      @c = Card.create! :name=>'basicname', :content=>'revived content'
+    end
+  end
+
+  it "should not be trash" do
+    expect(@c.trash).to eq(false)
+  end
+
+  it "should have 3 actions" do
+    expect(@c.actions.count).to eq(3)
+  end
+
+  it "should still have old content" do
+    expect(@c.nth_action(1).change_for(2).first.value).to eq('basiccontent')
+  end
+
+  it "should have the same content" do
+    expect(@c.content).to eq('revived content')
+#    Card.fetch(@c.name).content.should == 'revived content'
+  end
+end
+
+describe Card, "recreate trashed card via new" do
+#  before do
+#    Card::Auth.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
+    Card::Auth.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
+    expect(@c.trash).to eq(false)
+  end
+
+  it "should have 3 actions" do
+    expect(@c.actions.count).to eq(3)
+  end
+
+  it "should still have old action" do
+    expect(@c.nth_action(1).change_for(2).first.value).to eq('basiccontent')
+  end
+
+  it "should have old content" do
+    expect(@c.db_content).to eq('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
+

data/spec/models/card/type_transition_spec.rb

@@ -0,0 +1,161 @@
+# -*- encoding : utf-8 -*-
+
+class Card
+  cattr_accessor :count
+
+  module Set::Type
+  
+    module CardtypeA
+      extend Card::Set
+
+      def ok_to_delete
+        deny_because("not allowed to delete card a")
+      end
+    end
+
+#    module CardtypeC
+#      extend Card::Set
+#    end
+
+    module CardtypeD
+      def valid?
+        errors.add :create_error, "card d always has errors"
+        errors.empty?
+      end
+    end
+
+    module CardtypeE
+      def self.included(base) Card.count = 2   end
+      def on_type_change()    decrement_count  end
+      def decrement_count()   Card.count -= 1  end
+    end
+
+    module CardtypeF
+      def self.included(base) Card.count = 2   end
+      # FIXME: create_extension doesn't exist anymore, need another hook
+      def create_extension()  increment_count  end
+      def increment_count()   Card.count += 1  end
+    end
+  end
+end
+
+describe Card, "with role" do
+  before do
+    Card::Auth.as_bot do
+      @role = Card.search(:type=>'Role')[0]
+    end
+  end
+
+  it "should have a role type" do
+    expect(@role.type_id).to eq(Card::RoleID)
+  end
+end
+
+
+
+describe Card, "with account" do
+  before do
+    Card::Auth.as_bot do
+      @joe = change_card_to_type('Joe User', :basic)
+    end
+  end
+
+  it "should not have errors" do
+    expect(@joe.errors.empty?).to eq(true)
+  end
+
+  it "should allow type changes" do
+    expect(@joe.type_code).to eq(:basic)
+  end
+
+end
+
+describe Card, "type transition approve create" do
+  it 'should have cardtype b create role r1' do
+    expect((c=Card.fetch('Cardtype B+*type+*create')).content).to eq('[[r1]]')
+    expect(c.type_code).to eq(:pointer)
+  end
+
+  it "should have errors" do
+    c = change_card_to_type("basicname", "cardtype_b")
+    expect(c.errors[:permission_denied]).not_to be_empty
+  end
+
+  it "should be the original type" do
+    lambda { change_card_to_type("basicname", "cardtype_b") }
+    expect(Card["basicname"].type_code).to eq(:basic)
+  end
+end
+
+
+#describe Card, "type transition validate_delete" do
+#  before do @c = change_card_to_type("type-c-card", :basic) end
+#
+#  it "should have errors" do
+#    @c.errors[:delete_error].first.should == "card c is indestructible"
+#  end
+#
+#  it "should retain original type" do
+#    Card["type_c_card"].type_code.should == :cardtype_c
+#  end
+#end
+
+describe Card, "type transition validate_create" do
+  before do @c = change_card_to_type("basicname", "cardtype_d") end
+
+  it "should have errors" do
+    pending "CardtypeD does not have a codename, so this is an invalid test"
+    expect(@c.errors[:type].first.match(/card d always has errors/)).to be_truthy
+  end
+
+  it "should retain original type" do
+    pending "CardtypeD does not have a codename, so this is an invalid test"
+    expect(Card["basicname"].type_code).to eq(:basic)
+  end
+end
+
+describe Card, "type transition delete callback" do
+  before do
+    @c = change_card_to_type("type-e-card", :basic)
+  end
+
+  it "should decrement counter in before delete" do
+    pending "no trigger for this test anymore"
+    expect(Card.count).to eq(1)
+  end
+
+  it "should change type of the card" do
+    expect(Card["type-e-card"].type_code).to eq(:basic)
+  end
+end
+
+describe Card, "type transition create callback" do
+  before do
+    Card::Auth.as_bot do
+      Card.create(:name=>'Basic+*type+*delete', :type=>'Pointer', :content=>"[[Anyone Signed in]]")
+    end
+    @c = change_card_to_type("basicname", :cardtype_f)
+  end
+
+  it "should increment counter"  do
+    pending "No extensions, so no hooks for this now"
+    expect(Card.count).to eq(3)
+  end
+
+  it "should change type of card" do
+    expect(Card["basicname"].type_code).to eq(:cardtype_f)
+  end
+end
+
+
+def change_card_to_type name, type
+  card = Card.fetch(name)
+  tid=card.type_id = Symbol===type ? Card::Codename[type] : Card.fetch_id(type)
+  #warn "card[#{name.inspect}, T:#{type.inspect}] is #{card.inspect}, TID:#{tid}"
+  r=card.save
+  #warn "saved #{card.inspect} R#{r}"
+  card
+end
+
+
+