wagn 1.12.7

data/spec/models/card/type_transition_spec.rb

@@ -0,0 +1,162 @@
+# -*- encoding : utf-8 -*-
+require 'wagn/spec_helper'
+
+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
+    Account.as_bot do
+      @role = Card.search(:type=>'Role')[0]
+    end
+  end
+
+  it "should have a role type" do
+    @role.type_id.should== Card::RoleID
+  end
+end
+
+
+
+describe Card, "with account" do
+  before do
+    Account.as_bot do
+      @joe = change_card_to_type('Joe User', :basic)
+    end
+  end
+
+  it "should not have errors" do
+    @joe.errors.empty?.should == true
+  end
+
+  it "should allow type changes" do
+    @joe.type_code.should == :basic
+  end
+
+end
+
+describe Card, "type transition approve create" do
+  it 'should have cardtype b create role r1' do
+    (c=Card.fetch('Cardtype B+*type+*create')).content.should == '[[r1]]'
+    c.type_code.should == :pointer
+  end
+
+  it "should have errors" do
+    c = change_card_to_type("basicname", "cardtype_b")
+    c.errors[:permission_denied].should_not be_empty
+  end
+
+  it "should be the original type" do
+    lambda { change_card_to_type("basicname", "cardtype_b") }
+    Card["basicname"].type_code.should == :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"
+    @c.errors[:type].first.match(/card d always has errors/).should be_true
+  end
+
+  it "should retain original type" do
+    pending "CardtypeD does not have a codename, so this is an invalid test"
+    Card["basicname"].type_code.should == :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"
+    Card.count.should == 1
+  end
+
+  it "should change type of the card" do
+    Card["type-e-card"].type_code.should == :basic
+  end
+end
+
+describe Card, "type transition create callback" do
+  before do
+    Account.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"
+    Card.count.should == 3
+  end
+
+  it "should change type of card" do
+    Card["basicname"].type_code.should == :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
+
+
+

data/spec/models/card/validation_spec.rb

@@ -0,0 +1,37 @@
+# -*- encoding : utf-8 -*-
+require 'wagn/spec_helper'
+
+describe Card, "validate name" do
+
+  it "should error on name with /" do
+    @c = Card.create :name=>"testname/"
+    @c.errors[:name].should_not be_blank
+  end
+
+  it "should error on junction name  with /" do
+    @c = Card.create :name=>"jasmin+ri/ce"
+    @c.errors[:name].should_not be_blank
+  end
+
+  it "shouldn't create any new cards when name invalid" do
+    original_card_count = Card.count
+    @c = Card.create :name=>"jasmin+ri/ce"
+    Card.count.should == original_card_count
+  end
+
+  it "should not allow empty name" do
+    @c = Card.new :name=>""
+    @c.valid?.should == false
+    @c.errors[:name].should_not be_blank
+  end
+
+  # maybe the @c.key= should just throw an error, but now it doesn't take anyway
+  it "should not allow mismatched name and key" do
+    @c = Card.new :name=>"Test"
+    @c.key="foo"
+    #@c.key.should == 'test'
+    @c.valid?.should == false
+    #@c.errors[:key].should_not be_blank
+  end
+
+end

data/spec/models/card_spec.rb

@@ -0,0 +1,177 @@
+# -*- encoding : utf-8 -*-
+require 'wagn/spec_helper'
+
+describe Card do
+
+  describe "test data" do
+    it "should be findable by name" do
+      Card["Wagn Bot"].class.should == Card
+    end
+  end
+
+  describe "creation" 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 "content change should create new revision" do
+    before do
+      Account.as_bot do
+        @c = Card['basicname']
+        @c.update_attributes! :content=>'foo'
+      end
+    end
+
+    it "should have 2 revisions"  do
+      @c.revisions.length.should == 2
+    end
+
+    it "should have original revision" do
+      @c.revisions[0].content.should == 'basiccontent'
+    end
+  end
+
+
+
+  describe "created a virtual card when missing and has a template" do
+    it "should be flagged as virtual" do
+      Card.new(:name=>'A+*last edited').virtual?.should be_true
+    end
+  end
+end
+
+describe "basic card tests" do
+
+
+  def assert_simple_card card
+    card.name.should be, "name not null"
+    card.name.empty?.should be_false, "name not empty"
+    rev = card.current_revision
+    rev.should be_instance_of Card::Revision
+    rev.creator.should be_instance_of Card
+  end
+
+  def assert_samecard card1, card2
+    assert_equal card1.current_revision, card2.current_revision
+  end
+
+  def assert_stable card1
+    card2 = Card[card1.name]
+    assert_simple_card card1
+    assert_simple_card card2
+    assert_samecard card1, card2
+    assert_equal card1.right, card2.right
+  end
+
+  it 'should remove cards' do
+    forba = Card.create! :name=>"Forba"
+    torga = Card.create! :name=>"TorgA"
+    torgb = Card.create! :name=>"TorgB"
+    torgc = Card.create! :name=>"TorgC"
+
+    forba_torga = Card.create! :name=>"Forba+TorgA";
+    torgb_forba = Card.create! :name=>"TorgB+Forba";
+    forba_torga_torgc = Card.create! :name=>"Forba+TorgA+TorgC";
+
+    Card['Forba'].delete!
+
+    Card["Forba"].should be_nil
+    Card["Forba+TorgA"].should be_nil
+    Card["TorgB+Forba"].should be_nil
+    Card["Forba+TorgA+TorgC"].should be_nil
+
+    # FIXME: this is a pretty dumb test and it takes a loooooooong time
+    #while card = Card.find(:first,:conditions=>["type not in (?,?,?) and trash=?", 'AccountRequest','User','Cardtype',false] )
+    #  card.delete!
+    #end
+    #assert_equal 0, Card.find_all_by_trash(false).size
+  end
+
+  #test test_attribute_card
+  #  alpha, beta = Card.create(:name=>'alpha'), Card.create(:name=>'beta')
+  #  assert_nil alpha.attribute_card('beta')
+  #  Card.create :name=>'alpha+beta'
+  #   alpha.attribute_card('beta').should be_instance_of(Card)
+  #end
+
+  it 'should create cards' do
+    alpha = Card.new :name=>'alpha', :content=>'alpha'
+    alpha.content.should == 'alpha'
+    alpha.save
+    alpha.name.should == 'alpha'
+    assert_stable alpha
+  end
+
+
+  it 'should not find nonexistent' do
+    Card['no such card+no such tag'].should be_nil
+    Card['HomeCard+no such tag'].should be_nil
+  end
+
+
+  it 'update_should_create_subcards' do
+    banana = Card.create! :name=>'Banana'
+    Card.update banana.id, :cards=>{ "+peel" => { :content => "yellow" }}
+
+    peel = Card['Banana+peel']
+    peel.content.       should == "yellow"
+    Card['joe_user'].id.should == peel.creator_id
+  end
+
+  it 'update_should_create_subcards_as_wagn_bot_if_missing_subcard_permissions' do
+    Card.create :name=>'peel'
+    Account.current_id = Card::AnonID
+    Card['Banana'].should_not be
+    Card['Basic'].ok?(:create).should be_false, "anon can't creat"
+
+    Card.create! :type=>"Fruit", :name=>'Banana', :cards=>{ "+peel" => { :content => "yellow" }}
+    Card['Banana'].should be
+    peel = Card["Banana+peel"]
+
+    peel.current_revision.content.should == "yellow"
+    peel.creator_id.should == Card::AnonID
+  end
+
+  it 'update_should_not_create_subcards_if_missing_main_card_permissions' do
+    b = Card.create!( :name=>'Banana' )
+    Account.as Card::AnonID do
+      b.update_attributes :cards=>{ "+peel" => { :content => "yellow" }}
+      b.errors[:permission_denied].should_not be_empty
+      
+      
+      c = Card.update(b.id, :cards=>{ "+peel" => { :content => "yellow" }})
+      c.errors[:permission_denied].should_not be_empty
+      Card['Banana+peel'].should be_nil
+    end
+  end
+
+
+  it 'create_without_read_permission' do
+    c = Card.create!({:name=>"Banana", :type=>"Fruit", :content=>"mush"})
+    Account.as Card::AnonID do
+      assert_raises Card::PermissionDenied do
+        c.ok! :read
+      end
+    end
+  end
+
+end

data/spec/models/user_spec.rb

@@ -0,0 +1,95 @@
+# -*- encoding : utf-8 -*-
+require 'wagn/spec_helper'
+
+describe User do
+  
+  describe 'update' do
+    it 'should not rehash password' do
+      Account[ 'joe@user.com' ].update_attributes!(:email => 'joe2@user.com')
+      assert_equal Account[ 'joe2@user.com' ].card_id, Account.authenticate('joe2@user.com', 'joe_pass')
+    end
+  end
+  
+  describe "#read_rules" do
+    before(:all) do
+      @read_rules = Card['joe_user'].read_rules
+    end
+
+
+    it "*all+*read should apply to Joe User" do
+      @read_rules.member?(Card.fetch('*all+*read').id).should be_true
+    end
+
+    it "3 more should apply to Joe Admin" do
+      Account.as(:joe_admin) do
+        ids = Account.as_card.read_rules
+        #warn "rules = #{ids.map(&Card.method(:find)).map(&:name) * ', '}"
+        ids.length.should == @read_rules.size + 4
+      end
+    end
+
+  end
+  
+  
+  it 'should reset password' do
+    Account[ 'joe@user.com' ].update_attributes(:password => 'new password', :password_confirmation => 'new password')
+    assert_equal Account[ 'joe@user.com' ].card_id, Account.authenticate('joe@user.com', 'new password')
+  end
+
+  it 'should create user' do
+    assert_difference User, :count do
+      assert create_user.valid?
+    end
+  end
+
+  it 'should require valid password' do
+    assert_no_difference User, :count do
+      u = create_user(:password => 'AB', :password_confirmation => 'AB')
+      assert u.errors[:password]
+    end
+  end
+
+  it 'should require password confirmation' do
+    assert_no_difference User, :count do
+      u = create_user(:password_confirmation => nil)
+      assert u.errors[:password_confirmation]
+    end
+  end
+
+  it 'should require email' do
+    assert_no_difference User, :count do
+      u = create_user(:email => nil)
+      assert u.errors[:email]
+    end
+  end
+
+  it 'should downcase email' do
+    u=create_user(:email=>'QuIrE@example.com')
+    assert_equal 'quire@example.com', u.email
+  end
+
+
+
+#  def test_should_authenticate_user with same email as wagn bot
+#    u1 = Account.admin
+#  end
+
+  protected
+  
+  def assert_difference(object, method = nil, difference = 1)
+    initial_value = object.send(method)
+    yield
+    assert_equal initial_value + difference, object.send(method), "#{object}##{method}"
+  end
+
+  def assert_no_difference(object, method, &block)
+    assert_difference object, method, 0, &block
+  end
+  
+  def create_user(options = {})
+    User.create({ :login => 'quire', :email => 'quire@example.com',
+      :password => 'quire', :password_confirmation => 'quire',
+      :card_id=>0, :account_id=>0
+    }.merge(options))
+  end
+end