wagn 1.12.7

data/spec/lib/card/set_pattern_spec.rb

@@ -0,0 +1,40 @@
+# -*- encoding : utf-8 -*-
+require 'wagn/spec_helper'
+
+module SetPatternSpecHelper
+  def it_generates( opts )
+    name = opts[:name]
+    card = opts[:from]
+    it "generates name '#{name}' for card '#{card.name}'" do
+      described_class.new(card).to_s.should == 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::SetPattern::RightPattern 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::SetPattern::TypePattern do
+  it_generates :name => "Book+*type", :from => Card.new( :type => "Book" )
+end
+
+describe Card::SetPattern::AllPlusPattern do
+  it_generates :name => "*all plus", :from => Card.new( :name => "Book+author" )
+end
+
+describe Card::SetPattern::AllPattern do
+  it_generates :name => "*all", :from => Card.new( :type => "Book" )
+end
+
+describe Card::SetPattern::TypePlusRightPattern 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,84 @@
+# -*- encoding : utf-8 -*-
+require 'wagn/spec_helper'
+
+module Card::Set::Right::Account # won't this conflict with a real set (and fail to provide controlled test?)
+  extend Card::Set
+
+  card_accessor :status, :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
+      @account_card.status.should == 'request'
+    end
+
+    it "shouldn't have a reader method for card_writer" do
+      @account_card.respond_to?( :write).should be_false
+      @account_card.method( :write= ).should be
+    end
+
+    it "shouldn't have a reader method for card_reader" do
+      @account_card.method( :read).should be
+      @account_card.respond_to?( :read= ).should be_false
+    end
+
+    it "sets and saves attribute" do
+      @account_card.write= 'test_value'
+      @account_card.status= 'pending'
+      @account_card.status.should == 'pending'
+      Account.as_bot { @account_card.save }
+      Card.cache.reset
+      (tcard = Card['sara'].fetch(:trait=>:account)).should be
+      tcard.status.should == 'pending'
+      tcard.fetch(:trait=>:write).content.should == 'test_value'
+    end
+  end
+
+  let(:card) { proxy Card.new(:name=>'simple') }
+  let(:card_self) { proxy Card.new(:name=>'*navbox') }
+  let(:card_right) { proxy Card.new(:name=>'card+*right') }
+  let(:card_type_search) { proxy Card.new(:name=>'search_me', :type=>Card::SearchID) }
+  let(:card_double) { proxy Card }
+  let(:format_double) { proxy Card::Format }
+  let(:html_format_double) { proxy Card::HtmlFormat }
+
+  it "should define Formatter methods from modules" do
+    format_double.method(:render_navbox_self_core).should be
+    format_double.method(:_render_right_right_raw).should be
+    format_double.method(:render_type_search_core).should be
+    format_double.method(:_final_type_search_raw).should be
+  end
+  it "should call set render methods" do
+    card_self.should_receive(:_final_self_navbox_core)
+    card_self.render_core
+    card_right.method(:_render_right_right_raw).should be
+    card_right.render_core
+    card_type_search.method(:render_type_search_core).should be
+    card_type_search.render_core
+    card.method(:_final_type_search_raw).should be
+    card.render_core
+  end
+  it "should define Formatter methods from modules" do
+    html_format_double.method(:render_self_navbox_core).should be
+    html_format_double.method(:_render_right_right_raw).should be
+    html_format_double.method(:render_type_search_core).should be
+    html_format_double.method(:_final_type_search_raw).should be
+  end
+  it "should define Formatter methods from modules" do
+    card_self.should_receive(:_final_self_navbox_titled)
+    card_self.render_titled
+    card_right.method(:_render_right_right_edit).should be
+    card_right.render_edit
+    card_type_search.method(:render_type_search_menu).should be
+    card_type_search.render_menu
+    card.method(:_final_type_search_content).should be
+    card.render_content
+  end
+end

data/spec/lib/wagn/cache_spec.rb

@@ -0,0 +1,120 @@
+# -*- encoding : utf-8 -*-
+require 'wagn/spec_helper'
+
+describe Wagn::Cache do
+  describe "with nil store" do
+    before do
+      mock(Wagn::Cache).generate_cache_id.times(2).returns("cache_id")
+      @cache = Wagn::Cache.new :prefix=>"prefix"
+    end
+
+    describe "#basic operations" do
+      it "should work" do
+        @cache.write("a", "foo")
+        @cache.read("a").should == "foo"
+        @cache.fetch("b") { "bar" }
+        @cache.read("b").should == "bar"
+        @cache.reset
+      end
+    end
+  end
+
+  describe "with same cache_id" do
+    before :each do
+      @store = ActiveSupport::Cache::MemoryStore.new
+      mock(Wagn::Cache).generate_cache_id().returns("cache_id")
+      @cache = Wagn::Cache.new :store=>@store, :prefix=>"prefix"
+    end
+
+    it "#read" do
+      mock(@store).read("prefix/cache_id/foo")
+      @cache.read("foo")
+    end
+
+    it "#write" do
+      mock(@store).write("prefix/cache_id/foo", "val")
+      @cache.write("foo", "val")
+      @cache.read('foo').should == "val"
+    end
+
+    it "#fetch" do
+      block = Proc.new { "hi" }
+      mock(@store).fetch("prefix/cache_id/foo", &block)
+      @cache.fetch("foo", &block)
+    end
+
+    it "#delete" do
+      mock(@store).delete("prefix/cache_id/foo")
+      @cache.delete "foo"
+    end
+
+    it "#write_local" do
+      @cache.write_local('a', 'foo')
+      @cache.read("a").should == 'foo'
+      mock.dont_allow(@store).write
+      @cache.store.read("a").should == nil
+    end
+  end
+
+  it "#reset" do
+    mock(Wagn::Cache).generate_cache_id.returns("cache_id1")
+    @store = ActiveSupport::Cache::MemoryStore.new
+    @cache = Wagn::Cache.new :store=>@store, :prefix=>"prefix"
+    @cache.prefix.should == "prefix/cache_id1/"
+    @cache.write("foo","bar")
+    @cache.read("foo").should == "bar"
+
+    # reset
+    mock(Wagn::Cache).generate_cache_id.returns("cache_id2")
+    @cache.reset
+    @cache.prefix.should == "prefix/cache_id2/"
+    @cache.store.read("prefix/cache_id").should == "cache_id2"
+    @cache.read("foo").should be_nil
+
+    cache2 = Wagn::Cache.new :store=>@store, :prefix=>"prefix"
+    cache2.prefix.should == "prefix/cache_id2/"
+  end
+
+  describe "with file store" do
+    before do
+      cache_path = "#{Wagn.root}/tmp/cache"
+      @store = ActiveSupport::Cache::FileStore.new cache_path
+
+      @store.clear
+      #cache_path = cache_path + "/prefix"
+      #p = Pathname.new(cache_path)
+      #p.mkdir if !p.exist?
+      #
+      #root_dirs = Dir.entries(cache_path).reject{|f| ['.', '..'].include?(f)}
+      #files_to_remove = root_dirs.collect{|f| File.join(cache_path, f)}
+      #FileUtils.rm_r(files_to_remove)
+
+      mock(Wagn::Cache).generate_cache_id.times(2).returns("cache_id1")
+      @cache = Wagn::Cache.new :store=>@store, :prefix=>"prefix"
+    end
+
+    describe "#basic operations with special symbols" do
+      it "should work" do
+        @cache.write('%\\/*:?"<>|', "foo")
+        cache2 = Wagn::Cache.new :store=>@store, :prefix=>"prefix"
+        cache2.read('%\\/*:?"<>|').should == "foo"
+        @cache.reset
+      end
+    end
+
+    describe "#basic operations with non-latin symbols" do
+      it "should work" do
+        @cache.write('(汉语漢語 Hànyǔ; 华语華語 Huáyǔ; 中文 Zhōngwén', "foo")
+        @cache.write('русский', "foo")
+        cache3 = Wagn::Cache.new :store=>@store, :prefix=>"prefix"
+        cache3.read('(汉语漢語 Hànyǔ; 华语華語 Huáyǔ; 中文 Zhōngwén').should == "foo"
+        cache3.read('русский').should == "foo"
+        @cache.reset
+      end
+    end
+
+    describe "#tempfile" do
+      # TODO
+    end
+  end
+end

data/spec/lib/wagn/loader_spec.rb

@@ -0,0 +1,33 @@
+require "wagn/spec_helper"
+
+describe Wagn::Loader do
+  let(:card_double) { proxy Card }
+  let(:pat_all_double) { proxy Card::SetPattern::AllPattern }
+  let(:format_double) { proxy Card::Format }
+  let(:html_format_double) { proxy Card::HtmlFormat }
+  it "should auto-load Card class methods from lib/wagn and mods" do
+    card_double.should_receive(:load_set_modules)
+    card_double.should_receive(:load_formats)
+    card_double.should_receive(:load_sets)
+    card_double.should_receive(:tracks).with(:any_args) # so Card still loads without core in failure testing
+    card_double.method(:version).should be
+    card_double.method(:method_key).should be
+    card_double.method(:type_card).should be
+    card_double.method(:file_path).should be
+  end
+  it "should define Card methods from modules" do
+    pat_all_double.method(:set_modules).should be
+  end
+  it "should define Formatter methods from modules" do
+    format_double.method(:render_core).should be
+    format_double.method(:_render_raw).should be
+    format_double.method(:render_core).should be
+    format_double.method(:_render_raw).should be
+  end
+  it "should define Formatter methods from modules" do
+    html_format_double.method(:render_core).should be
+    html_format_double.method(:_render_raw).should be
+    html_format_double.method(:render_core).should be
+    html_format_double.method(:_render_raw).should be
+  end
+end

data/spec/mailers/account_spec.rb

@@ -0,0 +1,66 @@
+# -*- encoding : utf-8 -*-
+require 'wagn/spec_helper'
+include EmailSpec::Helpers
+include EmailSpec::Matchers
+
+describe Mailer do
+  CHARSET = "utf-8"
+  #include ActionMailer::Quoting
+
+  before do
+    #FIXME: from addresses are really Account.user, not Account.as_user based, but
+    # these tests are pretty much all using the Account.as, not logging in.
+    Account.current_id =nil # this is needed to clear logins from other test run before
+    ActionMailer::Base.delivery_method = :test
+    ActionMailer::Base.perform_deliveries = true
+    ActionMailer::Base.deliveries = []
+  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 "account info, new password" do # forgot password
+    before do
+      user_id =  Card['sara'].id
+      Account.as_bot do
+        @user = Account[ user_id ]
+        @email = @user.send_account_info(:subject => "New password subject", :message => "Forgot my password")
+      end
+    end
+
+    context "new password message" do
+      it "is addressed to users email" do
+        @email.should deliver_to(@user.email)
+      end
+
+      it "is from Wagn Bot email" do
+        #warn "test from #{Account.admin.inspect}, #{Account.admin.email}"
+        @email.should deliver_from("Wagn Bot <no-reply@wagn.org>")
+      end
+
+      it "has subject" do
+        @email.should have_subject( /^New password subject$/ )
+      end
+
+      it "sends the right email" do
+        #@email.should have_body_text /Account Details\b.*\bPassword: *[0-9A-Za-z]{9}$/m
+        @email.should have_body_text( /Account Details.*\bPassword: *[0-9A-Za-z]{9}$/m )
+      end
+    end
+  end
+
+  describe "flexmail" do
+    # FIXME: at least two tests should be here, with & w/o attachment.
+  end
+
+  private
+    def read_fixture(action)
+      IO.readlines("#{FIXTURES_PATH}/user_notifier/#{action}")
+    end
+
+    def encode(subject)
+      quoted_printable(subject, CHARSET)
+    end
+
+end

data/spec/mailers/mailer_spec.rb

@@ -0,0 +1,57 @@
+# -*- encoding : utf-8 -*-
+require 'wagn/spec_helper'
+
+describe Mailer do
+  #include ActionMailer::Quoting
+
+  before do
+    ActionMailer::Base.delivery_method = :test
+    ActionMailer::Base.perform_deliveries = true
+    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"
+      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 [Account.admin.email], @mail.from
+      end
+    end
+  end
+
+  describe "flexmail" do
+    # FIXME: at least two tests should be here, with & w/o attachment.
+  end
+
+  private
+    def read_fixture(action)
+      IO.readlines("#{FIXTURES_PATH}/user_notifier/#{action}")
+    end
+
+    def encode(subject)
+      quoted_printable(subject, Mailer::CHARSET)
+    end
+
+end

data/spec/models/account_spec.rb

@@ -0,0 +1,19 @@
+# -*- encoding : utf-8 -*-
+require 'wagn/spec_helper'
+
+describe Account do
+
+
+  it 'should authenticate user' do
+    assert_equal Account[ 'joe@user.com' ].card_id, Account.authenticate('joe@user.com', 'joe_pass')
+  end
+
+  it 'should authenticate user despite whitespace' do
+    assert_equal Account[ 'joe@user.com' ].card_id, Account.authenticate(' joe@user.com ', ' joe_pass ')
+  end
+
+  it 'should authenticate user with weird email capitalization' do
+    assert Account.authenticate('JOE@user.com', 'joe_pass')
+  end
+  
+end

data/spec/models/card/cardtype_spec.rb

@@ -0,0 +1,218 @@
+# -*- encoding : utf-8 -*-
+require 'wagn/spec_helper'
+
+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
+    Card['City'].should_not 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')
+      @card.type_name.should == 'Cardtype'
+    end
+
+    it "creates cardtype model and permission" do
+      @card.type_id = Card.fetch_id('cookie')
+      @card.save!
+      @card.type_name.should == 'Cookie'
+      @card=Card['Cookie']
+      assert_instance_of Card, @card
+      @card.type_code.should == 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
+    Account.current_id = Card::AnonID
+  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
+    lambda {
+      Card.new( :name=>'foo', :type=>'Cardtype')
+    }.should_not 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
+    @a.dependents.length.should > 0
+  end
+  it "should successfully have its type changed" do
+    Account.as_bot do
+      @a.type_id = Card::PhraseID;
+      @a.save!
+      Card['A'].type_code.should== :phrase
+    end
+  end
+  it "should still have its dependents after changing type" do
+    Account.as_bot do
+      assert type_id = Card.fetch_id('cardtype_e')
+      @a.type_id = type_id; @a.save!
+      Card['A'].dependents.length.should > 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
+    Account.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
+    Account.as_bot do
+      @ct = Card.create! :name=>'Animal', :type=>'Cardtype'
+    end
+  end
+
+  it "should have create permissions" do
+    @ct.who_can(:create).should_not be_nil
+  end
+
+  it "its create permissions should be based on Basic" do
+    @ct.who_can(:create).should == Card['Basic'].who_can(:create)
+  end
+end
+
+describe Card, "Wannabe Cardtype Card" do
+  before do
+    Account.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
+    Card['convertible'].type_code.should==:cardtype
+  end
+end
+
+describe User, "Joe User" do
+  before do
+    Account.as_bot do
+      @r3 = Card['r3']
+      Card.create :name=>'Cardtype F+*type+*create', :type=>'Pointer', :content=>'[[r3]]'
+    end
+
+    @user = Account.user
+    @ucard = Card[@user.card_id]
+    @type_names = Account.createable_types
+  end
+
+  it "should not have r3 permissions" do
+    @ucard.fetch(:new=>{}, :trait=>:roles).item_names.member?(@r3.name).should be_false
+  end
+  it "should ponder creating a card of Cardtype F, but find that he lacks create permissions" do
+    Card.new(:type=>'Cardtype F').ok?(:create).should be_false
+  end
+  it "should not find Cardtype F on its list of createable cardtypes" do
+    @type_names.member?('Cardtype F').should be_false
+  end
+  it "should find Basic on its list of createable cardtypes" do
+    @type_names.member?('Basic').should be_true
+  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
+    Card.search(:type=>@ct.name).should_not be_empty
+  end
+
+  it "should raise an error when you try to delete it" do
+    Account.as_bot do
+      @ct.delete
+      @ct.errors[:cardtype].should_not be_empty
+    end
+  end
+end
+
+
+describe Card::Set::Type::Cardtype do
+
+  it "should handle changing away from Cardtype" do
+    Account.as_bot do
+      ctg = Card.create! :name=>"CardtypeG", :type=>"Cardtype"
+      ctg.type_id = Card::BasicID
+      ctg.save!
+      ctg = Card["CardtypeG"]
+      ctg.type_code.should == :basic
+      #ctg.extension.should == nil
+    end
+  end
+end
+
+