card 0.0.1 → 1.15.pre

data/spec/lib/card/reference_spec.rb

@@ -0,0 +1,213 @@
+# -*- encoding : utf-8 -*-
+
+describe Card::Reference do
+
+  before do
+    Card::Auth.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["JoeForm"].format.render(:core)
+      assert_equal ["joe_form+age", "joe_form+description", "joe_form+name"],
+        Card["JoeForm"].includees.map(&:key).sort
+      expect(Card["JoeForm"].references_expired).not_to eq(true)
+    end
+
+    it "on template creation" do
+      Card.create! :name=>"SpecialForm", :type=>'Cardtype'
+      Card.create! :name=>"Form1", :type=>'SpecialForm', :content=>"foo"
+      c = Card["Form1"]
+      expect(c.references_expired).to be_nil
+      Card.create! :name=>"SpecialForm+*type+*structure", :content=>"{{+bar}}"
+      c = Card["Form1"]
+      expect(c.references_expired).to be_truthy
+      Card["Form1"].format.render(:core)
+      c = Card["Form1"]
+      expect(c.references_expired).to be_nil
+      expect(Card["Form1"].includees.map(&:key)).to eq(["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!
+      expect(Card["JoeForm"].references_expired).to be_truthy
+      Card["JoeForm"].format.render(:core)
+      assert_equal ["joe_form+banana", "joe_form+fruit", "joe_form+monkey"],
+        Card["JoeForm"].includees.map(&:key).sort
+      expect(Card["JoeForm"].references_expired).not_to eq(true)
+    end
+  end
+
+  it "in references should survive cardtype change" do
+    newcard("Banana","[[Yellow]]")
+    newcard("Submarine","[[Yellow]]")
+    newcard("Sun","[[Yellow]]")
+    newcard("Yellow")
+    expect(Card["Yellow"].referencers.map(&:name).sort).to eq(%w{ Banana Submarine Sun })
+    y=Card["Yellow"];
+    y.type_id= Card.fetch_id "UserForm";
+    y.save!
+    expect(Card["Yellow"].referencers.map(&:name).sort).to eq(%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'
+    expect(Card.fetch('bob+address').includees.map(&:name)).to eq(["bob+city"])
+    expect(Card.fetch('bob+city').includers.map(&:name)).to eq(["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?
+    expect(Card["Ethan"].referencers.map(&:name).include?("L")).not_to eq(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!
+    expect(lew.reload.content).to eq("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::AdministratorID).map(&:referer_id).sort
+    card.update_referencers = true
+    card.name='Administrator Menu+*type+*read'
+    card.save
+    expect(Card::Reference.where(:referee_id => Card::AdministratorID).map(&:referer_id).sort).to eq(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,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!
+    expect(lew.reload.content).to eq("likes [[watermelon]] and [[watermelon+seeds|seeds]]")
+    assert_equal lew.references_to.order(:id).map(&:ref_type), ['L','P','P','L'], "links should be a LINK"
+    assert_equal lew.references_to.order(:id).map(&:present), [ 0, 0, 1, 0 ],  "only reference to +seeds should 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']
+    expect(@x.content).to eq("[[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']
+    expect(@x.content).to eq("[[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"
+
+    expect(green.reload.includees.map(&:name)).to eq(["green+rgb"])
+    expect(green_rgb.reload.includers.map(&:name)).to eq(['green'])
+  end
+
+  it "simple link" do
+    alpha = Card.create :name=>'alpha'
+    beta = Card.create :name=>'beta', :content=>"I link to [[alpha]]"
+    expect(Card['alpha'].referencers.map(&:name)).to eq(['beta'])
+    expect(Card['beta'].referees.map(&:name)).to eq(['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]]"
+    expect(Card['beta card'].referees.map(&:name)).to eq(['alpha card'])
+    expect(Card['alpha card'].referencers.map(&:name)).to eq(['beta card'])
+  end
+
+
+  it "simple inclusion" do
+    alpha = Card.create :name=>'alpha'
+    beta = Card.create :name=>'beta', :content=>"I include to {{alpha}}"
+    expect(Card['beta'].includees.map(&:name)).to eq(['alpha'])
+    expect(Card['alpha'].includers.map(&:name)).to eq(['beta'])
+  end
+
+  it "non simple link" do
+    alpha = Card.create :name=>'alpha'
+    beta = Card.create :name=>'beta', :content=>"I link to [[alpha|ALPHA]]"
+    expect(Card['beta'].referees.map(&:name)).to eq(['alpha'])
+    expect(Card['alpha'].referencers.map(&:name)).to eq(['beta'])
+  end
+  
+  it "should handle commented inclusion" do
+    c = Card.create :name=>'inclusion comment test', :content=>'{{## hi mom }}'
+    expect(c.errors.any?).to be_falsey
+  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
+    expect(@e.reload.referencers.map(&:name).include?("woof")).not_to eq(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
+    expect(@e.name_referencers.map(&:name).include?("woof")).not_to eq(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/lib/card/set_pattern_spec.rb

@@ -0,0 +1,56 @@
+# -*- encoding : utf-8 -*-
+
+module SetPatternSpecHelper
+  def it_generates( opts )
+    name = opts[:name]
+    card = opts[:from]
+    it "generates name '#{name}' for card '#{card.name}'" do
+      expect(described_class.new(card).to_s).to eq(name)
+    end
+  end
+end
+
+include SetPatternSpecHelper
+
+describe Card::SetPattern do
+end
+
+#FIXME - these should probably be in pattern-specific specs, though that may not leave much to test in the base class :)
+
+describe Card::RightSet do
+  it_generates :name => "author+*right", :from => Card.new( :name => "Iliad+author" )
+  it_generates :name => "author+*right", :from => Card.new( :name => "+author" )
+end
+
+describe Card::TypeSet do
+  it_generates :name => "Book+*type", :from => Card.new( :type => "Book" )
+end
+
+describe Card::TypeSet do
+  before :each do
+    Card::Auth.as_bot do
+      @mylist = Card.create! :name=>'MyList', :type_id=>Card::CardtypeID
+      Card.create :name=>'MyList+*type+*default', :type_id=>Card::PointerID
+    end
+    @mylist_card = Card.create :name=>'ip', :type_id=>@mylist.id
+  end
+  # similar tests for an inherited type of Pointer
+  it 'has inherited set module' do
+    expect(@mylist_card.set_format_modules(Card::HtmlFormat)).to include(Card::Set::Type::Pointer::HtmlFormat)
+    expect(@mylist_card.set_format_modules(Card::CssFormat)).to include(Card::Set::Type::Pointer::CssFormat)
+    expect(@mylist_card.set_format_modules(Card::JsFormat)).to include(Card::Set::Type::Pointer::JsFormat)
+    expect(@mylist_card.set_modules).to include(Card::Set::Type::Pointer)
+  end
+end
+
+describe Card::AllPlusSet do
+  it_generates :name => "*all plus", :from => Card.new( :name => "Book+author" )
+end
+
+describe Card::AllSet do
+  it_generates :name => "*all", :from => Card.new( :type => "Book" )
+end
+
+describe Card::TypePlusRightSet do
+  it_generates :name => "Book+author+*type plus right", :from => Card.new( :name=>"Iliad+author" )
+end

data/spec/lib/card/set_spec.rb

@@ -0,0 +1,88 @@
+# -*- encoding : utf-8 -*-
+
+# module Card::Set::Right::Account # won't this conflict with a real set (and fail to provide controlled test?)
+#   extend Card::Set
+#
+#   card_accessor :role,   :default => "request", :type=>:phrase
+#   card_writer   :write,  :default => "request", :type=>:phrase
+#   card_reader   :read,   :default => "request", :type=>:phrase
+# end
+#
+# describe Card do
+#   before do
+#     @account_card = Card['sara'].fetch :trait=>:account
+#   end
+#
+#   describe "Read and write card attribute" do
+#     it "gets email attribute" do
+#       expect(@account_card.role).to eq('request')
+#     end
+#
+#     it "shouldn't have a reader method for card_writer" do
+#       expect(@account_card.respond_to?( :write)).to be_falsey
+#       expect(@account_card.method( :write= )).to be
+#     end
+#
+#     it "shouldn't have a reader method for card_reader" do
+#       expect(@account_card.method( :read)).to be
+#       expect(@account_card.respond_to?( :read= )).to be_falsey
+#     end
+#
+#     it "sets and saves attribute" do
+#       @account_card.write= 'test_value'
+#       @account_card.status= 'pending'
+# #      @account_card.status.should == 'pending'
+#       Card::Auth.as_bot { @account_card.save }
+# #      Card.cache.reset
+#       expect(tcard = Card['sara'].fetch(:trait=>:account)).to be
+#       expect(tcard.status).to eq('pending')
+#       expect(tcard.fetch(:trait=>:write).content).to eq('test_value')
+#     end
+#
+#   end
+#
+#   let(:card) { Card.new(:name=>'simple') }
+#   let(:card_self) { Card.new(:name=>'*navbox') }
+#   let(:card_right) { Card.new(:name=>'card+*right') }
+#   let(:card_type_search) { Card.new(:name=>'search_me', :type=>Card::SearchID) }
+#   let(:card_double) { Card }
+#   let(:format_double) { object_double(Card.new(:name=>'card+*right').format) }
+#
+#   #let(:html_format_double) { Card::HtmlFormat }
+#   let(:html_format_double) { double("Card::HtmlFormat") }
+#
+#   it "should define Formatter methods from modules" do
+#     expect(format_double).to respond_to(:render_navbox_self_core)
+#     expect(format_double.method(:render_navbox_self_core)).to be
+#     expect(format_double.method(:_render_right_right_raw)).to be
+#     expect(format_double.method(:render_type_search_core)).to be
+#     expect(format_double.method(:_final_type_search_raw)).to be
+#   end
+#   it "should call set render methods" do
+#     expect(card_self).to receive(:_final_self_navbox_core)
+#     card_self.format.render_core
+#     #expect(card_right.format.method(:_render_right_right_raw)).to be
+#     #expect(card_right.format).to respond_to(:_render_right_right_raw)
+#     card_right.format.render_core
+#     expect(card_type_search.method(:render_type_search_core)).to be
+#     card_type_search.format.render_core
+#     expect(card.method(:_final_type_search_raw)).to be
+#     card.format.render_core
+#   end
+#   it "should define Formatter methods from modules" do
+#     expect(html_format_double.method(:render_self_navbox_core)).to be
+#     expect(html_format_double.method(:_render_right_right_raw)).to be
+#     expect(html_format_double.method(:render_type_search_core)).to be
+#     expect(html_format_double.method(:_final_type_search_raw)).to be
+#   end
+#   it "should define Formatter methods from modules" do
+#     expect(card_self).to receive(:_final_self_navbox_titled)
+#     card_self.render_titled
+#     expect(card_right.method(:_render_right_right_edit)).to be
+#     card_right.render_edit
+#     expect(card_type_search.method(:render_type_search_menu)).to be
+#     card_type_search.render_menu
+#     expect(card.method(:_final_type_search_content)).to be
+#     card.render_content
+#   end
+# end

data/spec/mailers/mailer_spec.rb

@@ -0,0 +1,64 @@
+# -*- encoding : utf-8 -*-
+require 'card/mailer'
+
+describe Card::Mailer do
+  #include ActionMailer::Quoting
+
+  before do
+    ActionMailer::Base.deliveries = []
+
+    @expected = Mail.new
+  end
+
+  #
+  ## see notifier test for data used in these tests
+  # FIXME: the cache is not cleared properly between tests.  if the order changes
+  #  (ie try renamed change notice below to change_notice) then *notify+*from gets stuck on.
+  # context "change notice" do
+  #   before do
+  #     user =  Card['sara'].id
+  #     card =  Card["Sunglasses"]
+  #     action = "edited"
+  #     Card::Mailer.change_notice( user, card, action, card.name ).deliver
+  #   end
+  #
+  #   it "deliver a message" do
+  #     assert_equal 1, ActionMailer::Base.deliveries.size
+  #   end
+  #
+  #   context "change notice message" do
+  #     before do
+  #       @mail = ActionMailer::Base.deliveries[0]
+  #     end
+  #     it "is addressed to users email" do
+  #       assert_equal ["sara@user.com"],  @mail.to
+  #     end
+  #     it "is from Wag bot email" do
+  #       assert_equal [Card[Card::WagnBotID].account.email], @mail.from
+  #     end
+  #   end
+  # end
+  #
+  # describe "flexmail" do
+  #   # FIXME: at least two tests should be here, with & w/o attachment.
+  # end
+  
+  
+  
+  # describe "cardmail" do
+  #   before do
+  #     Card.gimme "mailtest", :content => "test"
+  #   end
+  #   it "renders email text" do
+  #     Card::Mailer.cardmail(:to => "sara@user.com").deliver
+  #     @mail = ActionMailer::Base.deliveries.last
+  #     expect(@mail.body).to eq("test")
+  #   end
+  # end
+
+  private
+    def encode(subject)
+      quoted_printable(subject, Card::Mailer::CHARSET)
+    end
+
+end

data/spec/models/card/cardtype_spec.rb

@@ -0,0 +1,216 @@
+# -*- encoding : utf-8 -*-
+
+class Card
+  # REVIEW: hooks api will do this differently, probably should remove and add new tests elsewhere
+  # this is used by some type based modules on CardtypeE from type_transition
+  cattr_accessor :count
+end
+
+describe "Card (Cardtype)" do
+
+  it "should not allow cardtype remove when instances present" do
+    Card.create :name=>'City', :type=>'Cardtype'
+    city = Card.fetch('City')
+    c1=Card.create :name=>'Sparta', :type=>'City'
+    c2=Card.create :name=>'Eugene', :type=>'City'
+    assert_equal ['Eugene','Sparta'], Card.search(:type=>'City').map(&:name).sort
+    assert_raises ActiveRecord::RecordInvalid do
+      city.delete!
+    end
+    # make sure it wasn't deleted / trashed
+    expect(Card['City']).not_to be_nil
+  end
+
+  it "remove cardtype" do
+    Card.create! :name=>'County', :type=>'Cardtype'
+    c = Card['County']
+    c.delete
+  end
+
+  it "cardtype creation and dynamic cardtype" do
+
+    assert Card.create( :name=>'BananaPudding', :type=>'Cardtype' ).type_id == Card::Codename[:cardtype]
+    assert_instance_of Card, c=Card.fetch("BananaPudding")
+
+    # you have to have a module to include or it's just a Basic (type_code fielde excepted)
+    cd = Card.create(:type=>'banana_pudding',:name=>"figgy" )
+    assert cd.type_name == 'BananaPudding'
+    assert Card.find_by_type_id(c.id)
+  end
+
+  describe "conversion to cardtype" do
+    before do
+      @card = Card.create!(:type=>'Cardtype', :name=>'Cookie')
+      expect(@card.type_name).to eq('Cardtype')
+    end
+
+    it "creates cardtype model and permission" do
+      @card.type_id = Card.fetch_id('cookie')
+      @card.save!
+      expect(@card.type_name).to eq('Cookie')
+      @card=Card['Cookie']
+      assert_instance_of Card, @card
+      expect(@card.type_code).to eq(nil) # :cookie
+      assert_equal 'Cookie', Card.create!( :name=>'Oreo', :type=>'Cookie' ).type_name
+    end
+  end
+
+  it "cardtype" do
+    Card.find(:all).each do |card|
+      assert !card.type_card.nil?
+    end
+  end
+
+end
+
+
+describe Card, "created without permission" do
+  before do
+    Card::Auth.current_id = Card::AnonymousID
+  end
+
+  # FIXME:  this one should pass.  unfortunately when I tried to fix it it started looking like the clean solution
+  #  was to rewrite most of the permissions section as simple validations and i decided not to go down that rabbit hole.
+  #
+  #it "should not be valid" do
+  #  Card.new( :name=>'foo', :type=>'Cardtype').valid?.should_not be_true
+  #end
+
+  it "should not create a new cardtype until saved" do
+    expect {
+      Card.new( :name=>'foo', :type=>'Cardtype')
+    }.not_to change(Card, :count)
+  end
+end
+
+
+describe Card, "Normal card with dependents" do
+  before do
+    @a = Card['A']
+  end
+  it "should confirm that it has dependents" do
+    expect(@a.dependents.length).to be > 0
+  end
+  it "should successfully have its type changed" do
+    Card::Auth.as_bot do
+      @a.type_id = Card::PhraseID;
+      @a.save!
+      expect(Card['A'].type_code).to eq(:phrase)
+    end
+  end
+  it "should still have its dependents after changing type" do
+    Card::Auth.as_bot do
+      assert type_id = Card.fetch_id('cardtype_e')
+      @a.type_id = type_id; @a.save!
+      expect(Card['A'].dependents.length).to be > 0
+    end
+  end
+end
+
+
+=begin No extension any more, is there a modified version of this we need?
+describe Card, "Recreated Card" do
+  before do
+    Card::Auth.as_bot do
+    @ct = Card.create! :name=>'Species', :type=>'Cardtype'
+    @ct.delete!
+    @ct = Card.create! :name=>'Species', :type=>'Cardtype'
+    end
+  end
+
+  it "should have a cardtype extension" do
+    @ct.extension.should_not be_nil
+  end
+
+end
+=end
+
+describe Card, "New Cardtype" do
+  before do
+    Card::Auth.as_bot do
+      @ct = Card.create! :name=>'Animal', :type=>'Cardtype'
+    end
+  end
+
+  it "should have create permissions" do
+    expect(@ct.who_can(:create)).not_to be_nil
+  end
+
+  it "its create permissions should be based on Basic" do
+    expect(@ct.who_can(:create)).to eq(Card['Basic'].who_can(:create))
+  end
+end
+
+describe Card, "Wannabe Cardtype Card" do
+  before do
+    Card::Auth.as_bot do
+      @card = Card.create! :name=> 'convertible'
+      @card.type_id=Card::CardtypeID
+      @card.save!
+    end
+
+  end
+  it "should successfully change its type to a Cardtype" do
+    expect(Card['convertible'].type_code).to eq(:cardtype)
+  end
+end
+
+describe Card, "Joe User" do
+  before do
+    Card::Auth.as_bot do
+      @r3 = Card['r3']
+      Card.create :name=>'Cardtype F+*type+*create', :type=>'Pointer', :content=>'[[r3]]'
+    end
+
+    @ucard = Card::Auth.current
+    @type_names = Card::Auth.createable_types
+  end
+
+  it "should not have r3 permissions" do
+    expect(@ucard.fetch(:new=>{}, :trait=>:roles).item_names.member?(@r3.name)).to be_falsey
+  end
+  it "should ponder creating a card of Cardtype F, but find that he lacks create permissions" do
+    expect(Card.new(:type=>'Cardtype F').ok?(:create)).to be_falsey
+  end
+  it "should not find Cardtype F on its list of createable cardtypes" do
+    expect(@type_names.member?('Cardtype F')).to be_falsey
+  end
+  it "should find Basic on its list of createable cardtypes" do
+    expect(@type_names.member?('Basic')).to be_truthy
+  end
+
+end
+
+
+describe Card, "Cardtype with Existing Cards" do
+  before do
+    @ct = Card['Cardtype F']
+  end
+  it "should have existing cards of that type" do
+    expect(Card.search(:type=>@ct.name)).not_to be_empty
+  end
+
+  it "should raise an error when you try to delete it" do
+    Card::Auth.as_bot do
+      @ct.delete
+      expect(@ct.errors[:cardtype]).not_to be_empty
+    end
+  end
+end
+
+
+describe Card::Set::Type::Cardtype do
+
+  it "should handle changing away from Cardtype" do
+    Card::Auth.as_bot do
+      ctg = Card.create! :name=>"CardtypeG", :type=>"Cardtype"
+      ctg.type_id = Card::BasicID
+      ctg.save!
+      ctg = Card["CardtypeG"]
+      expect(ctg.type_code).to eq(:basic)
+      #ctg.extension.should == nil
+    end
+  end
+end
+
+