card 1.93.3 → 1.93.4

data/spec/lib/card/subcards_spec.rb

@@ -1,177 +0,0 @@
-# -*- encoding : utf-8 -*-
-
-describe Card::Subcards do
-  describe "creating card with subcards" do
-    it "works with subcard hash" do
-      Card::Auth.as_bot do
-        @card = Card.create!(
-          name: "card with subs",
-          subcards: { "+sub1" => { content: "this is sub1" } }
-        )
-      end
-      expect(Card["card with subs+sub1"].content).to eq "this is sub1"
-    end
-
-    it "check name-key bug" do
-      Card::Auth.as_bot do
-        Card.create! name: "Matthias", subcards: {"+name" => "test"}
-        expect(Card.exists? "Matthias+name").to be_truthy
-      end
-    end
-
-    it "works with content string" do
-      Card::Auth.as_bot do
-        @card = Card.create!(
-          name: "card with subs", subcards: { "+sub1" => "this is sub1" }
-        )
-      end
-      expect(Card["card with subs+sub1"].content).to eq "this is sub1"
-    end
-
-    it "check unstable key bug" do
-      Card::Auth.as_bot do
-        Card.create! name: "Matthias", subcards: {"+name" => "test"}
-        expect(Card.exists? "Matthias+name").to be_truthy
-      end
-    end
-
-    it "works with +name key in args" do
-      Card::Auth.as_bot do
-        @card = Card.create!(
-          name: "card with subs", "+sub1" => { content: "this is sub1" }
-        )
-      end
-      expect(Card["card with subs+sub1"].content).to eq "this is sub1"
-    end
-
-    it "handles more than one level" do
-      Card::Auth.as_bot do
-        @card = Card.create!(
-          name: "card with subs", "+sub1" => { "+sub2" => "this is sub2" }
-        )
-      end
-      expect(Card["card with subs+sub1+sub2"].content).to eq "this is sub2"
-    end
-
-    it "handles compound names" do
-      Card::Auth.as_bot do
-        @card = Card.create! name: "superman", "+sub1+sub2" => "this is sub2"
-      end
-      expect(Card["superman+sub1"]).to be_truthy
-      expect(Card["superman+sub1+sub2"].content).to eq "this is sub2"
-    end
-
-    it "keeps plural of left part" do
-      Card::Auth.as_bot do
-        @card = Card.create!(
-          name: "supermen", content: "something",
-          subcards: { "+pseudonym" => "clark" }
-        )
-      end
-      expect(Card["supermen+pseudonym"].name).to eq "supermen+pseudonym"
-    end
-
-    it "cleans the cache for autonaming case" do
-      Card::Auth.as_bot do
-        Card.create!(
-          name: "Book+*type+*autoname", content: "Book_1",
-          type_id: Card::PhraseID
-        )
-        card = Card.create!(
-          type: "Book",
-          subcards: { "+editable" => "yes" }
-        )
-        expect(card.errors).to be_empty
-        expect(Card["#{card.name}+editable"]).to be_truthy
-        @card = Card.create!(
-          type: "Book",
-          subcards: { "+editable" => "sure" }
-        )
-      end
-
-      expect(@card.errors).to be_empty
-      expect(Card["#{@card.name}+editable"]).to be_truthy
-    end
-  end
-
-  describe "#add_subfield" do
-    before do
-      @card = Card["A"]
-    end
-    subject do
-      Card.fetch("#{@card.name}+sub", new: {}, local_only: true).content
-    end
-    it "works with string" do
-      @card.add_subfield "sub", content: "this is a sub"
-      is_expected.to eq "this is a sub"
-    end
-    it "works with codename" do
-      @card.add_subfield :phrase, content: "this is a sub"
-      subcard = Card.fetch("A+phrase", new: {}, local_only: true)
-      expect(subcard.content).to eq "this is a sub"
-    end
-  end
-
-  describe "#subfield" do
-    before do
-      @card = Card["A"]
-    end
-    subject do
-      Card.fetch("#{@card.name}+sub", new: {}, local_only: true).content
-    end
-    it "works with string" do
-      @card.add_subfield "sub", content: "this is a sub"
-      expect(@card.subfield("sub").content).to eq "this is a sub"
-    end
-
-    it "works with codename" do
-      @card.add_subfield :phrase, content: "this is a sub"
-      expect(@card.subfield(":phrase").content).to eq "this is a sub"
-    end
-
-    it "works together with type change" do
-      Card::Auth.as_bot do
-        @card = Card.create!(
-          name: "card with subs", "+sub1" => "first"
-        )
-        @card.update_attributes! type_id: Card::PhraseID, "+sub1" => "second"
-      end
-      expect(Card["card with subs+sub1"].content).to eq "second"
-    end
-  end
-
-  describe "#add" do
-    before do
-      @card = Card["A"]
-    end
-    it "adds a subcard" do
-      @card.add_subcard "sub", content: "sub content"
-      @card.save!
-      expect(Card["sub"].content).to eq "sub content"
-    end
-  end
-  describe "two levels of subcards" do
-    it "creates cards with subcards with subcards" do
-      Card::Auth.as_bot do
-        in_stage :validate, trigger: -> { Card.create!(name: "test") } do
-          if name == "test"
-            add_subfield("first-level")
-            subfield("first-level").add_subfield "second-level", content: "yeah"
-          end
-        end
-      end
-      expect(Card.fetch("test+first-level+second-level").content).to eq "yeah"
-    end
-    it "creates cards with subcards with subcards using codenames" do
-      Card::Auth.as_bot do
-        in_stage :validate, trigger: -> { Card.create!(name: "test") } do
-          if name == "test"
-            add_subfield :children
-            subfield(:children).add_subfield :title, content: "yeah"
-          end
-        end
-      end
-      expect(Card.fetch("test+*child+*title").content).to eq "yeah"
-    end
-  end
-end

data/spec/lib/card/success_spec.rb

@@ -1,148 +0,0 @@
-# -*- encoding : utf-8 -*-
-
-describe Card::Env::Success do
-  let(:context) { Card["A"].name }
-  let(:previous) { "/B" }
-  let(:home)     { Card["Home"] }
-  def success_params params
-    Card::Env.save_location Card["B"]
-    @success = Card::Env::Success.new context, params
-  end
-  describe "#target" do
-    subject { @success.target }
-
-    context "initialized with nil" do
-      before do
-        success_params nil
-      end
-      it { is_expected.to eq Card["A"] }
-    end
-
-    context "initialized with hash" do
-      before do
-        success_params id: home.id, view: "closed"
-      end
-      it { is_expected.to eq home }
-    end
-
-    context "initialized with REDIRECT string" do
-      before do
-        success_params "REDIRECT: Home"
-      end
-      it { is_expected.to eq home }
-    end
-
-    context "initialized with TEXT string" do
-      before do
-        success_params "TEXT: Hi"
-      end
-      it { is_expected.to eq "Hi" }
-    end
-
-    context "initialized with card object" do
-      before do
-        success_params home
-      end
-      it { is_expected.to eq home }
-    end
-
-    context "initialized with url" do
-      before do
-        success_params "http://wagn.org"
-      end
-      it  { is_expected.to eq "http://wagn.org" }
-    end
-  end
-
-  describe "#to_url" do
-    subject { @success.to_url }
-    context "with params" do
-      context "using initilization" do
-        before do
-          success_params id: home.id, view: "closed", layout: "my_layout"
-        end
-        it { is_expected.to eq "/Home?layout=my_layout&view=closed" }
-      end
-      context "using array assignment" do
-        before do
-          success_params nil
-          @success[:view] = "closed"
-        end
-        it { is_expected.to eq "/A?view=closed" }
-      end
-      context "using assignment" do
-        before do
-          success_params nil
-          @success.view = "closed"
-        end
-        it { is_expected.to eq "/A?view=closed" }
-      end
-      context "using <<" do
-        before do
-          success_params nil
-          @success << { card: home, view: "closed" }
-        end
-        it { is_expected.to eq "/Home?view=closed" }
-      end
-    end
-    context "redirect string" do
-      before do
-        success_params "REDIRECT: *previous"
-      end
-      it { is_expected.to eq previous }
-    end
-  end
-
-  describe "#soft_redirect?" do
-    it "returns true if soft_redirect parameter is true" do
-      success_params soft_redirect: true
-      expect(@success.soft_redirect?).to be_truthy
-    end
-  end
-
-  describe "#hard_redirect?" do
-    it 'true for "REDIRECT: anywhere"' do
-      success_params "REDIRECT: anywhere"
-      expect(@success.hard_redirect?).to be_truthy
-    end
-  end
-
-  describe "#mark=" do
-    subject { @success.target }
-    before do
-      success_params nil
-    end
-    it "works with id" do
-      @success.mark = home.id
-      is_expected.to eq home
-    end
-    it "works with name" do
-      @success.mark = home.name
-      is_expected.to eq home
-    end
-    it "works with card object" do
-      @success.mark = home
-      is_expected.to eq home
-    end
-  end
-
-  describe "params" do
-    it "returns params hash" do
-      success_params name: "Home", view: "View"
-      @success.layout = "Layout"
-      @success.apply script: "Script"
-      @success << { structure: "Structure" }
-      expect(@success.params.keys.sort).to eq [:layout, :script, :structure, :view]
-    end
-    it 'ignores "id", "name", "mark", "card"", target", and "redirect"' do
-      success_params(id: 5,
-                     name: "Home",
-                     card: Card["Home"],
-                     mark: "Home",
-                     target: "Home",
-                     redirect: false,
-                     view: "View")
-      expect(@success.params.keys).to eq [:view]
-    end
-  end
-end

data/spec/lib/card/view_cache_spec.rb

@@ -1,27 +0,0 @@
-# -*- encoding : utf-8 -*-
-
-describe Card::View do
-  it "cache gets cleared by Card::Cache.reset_all" do
-    Card::View.cache.write "testkey", 1
-    expect(Card::View.cache.exist? "testkey").to be_truthy
-    Card::Cache.reset_all
-    expect(Card::View.cache.exist? "testkey").to be_falsey
-  end
-
-  def html_message_for user
-    Card["follower notification email"].format(:email_html)
-      .render_mail(context: Card["All Eyes On Me"],
-                   to: "#{user}@user.com",
-                   follower: user,
-                   followed_set: "All Eyes On Me+*self",
-                   follow_option: "*always")
-      .html_part.body.raw_source
-  end
-
-  example "email templates" do
-    html_message_for "John"
-    msg = html_message_for "Sara"
-    expect(msg).to include("update/Sara+*follow")
-               .and not_include "John"
-  end
-end

data/spec/mailers/mailer_spec.rb

@@ -1,62 +0,0 @@
-# -*- 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/create_spec.rb

@@ -1,119 +0,0 @@
-# -*- encoding : utf-8 -*-
-
-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 "does not create a new card until saved" do
-    expect do
-      Card.new(name: "foo", type: "Cardtype")
-    end.not_to increase_card_count
-  end
-
-  it "does not override explicit content with default content", as_bot: true do
-    create "blue+*right+*default", content: "joe", type: "Pointer"
-    c = Card.new name: "Lady+blue", content: "[[Jimmy]]"
-    expect(c.content).to eq("[[Jimmy]]")
-  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 "does not have errors" do
-    expect(@b.errors.size).to eq(0)
-  end
-  it "has the right class" do
-    expect(@c.class).to eq(Card)
-  end
-  it "has the right key" do
-    expect(@c.key).to eq("new_card")
-  end
-  it "has the right name" do
-    expect(@c.name).to eq("New Card")
-  end
-  it "has the right content" do
-    expect(@c.content).to eq("Great Content")
-  end
-
-  it "has the right content" do
-    expect(@c.db_content).to eq "Great Content"
-  end
-
-  it "is findable by name" do
-    expect(Card["New Card"]).to be_a Card
-  end
-end
-
-describe Card, "create junction two parts" do
-  before(:each) do
-    @c = Card.create! name: "Peach+Pear", content: "juicy"
-  end
-
-  it "doesn't have errors" do
-    expect(@c.errors.size).to eq(0)
-  end
-
-  it "creates junction card" do
-    expect(Card["Peach+Pear"]).to be_a(Card)
-  end
-
-  it "creates trunk card" do
-    expect(Card["Peach"]).to be_a(Card)
-  end
-
-  it "creates tag card" do
-    expect(Card["Pear"]).to be_a(Card)
-  end
-end
-
-describe Card, "create junction three parts" do
-  it "creates very left card" do
-    Card.create! name: "Apple+Peach+Pear", content: "juicy"
-    expect(Card["Apple"].class).to eq(Card)
-  end
-
-  it "sets left and right ids" do
-    Card.create! name: "Sugar+Milk+Flour", content: "tasty"
-    sugar_milk = Card["Sugar+Milk"]
-    sugar_milk_flour = Card["Sugar+Milk+Flour"]
-    expect(sugar_milk_flour.left_id).to eq(sugar_milk.id)
-    expect(sugar_milk_flour.right_id).to eq(Card.fetch_id("Flour"))
-    expect(sugar_milk.left_id).to eq(Card.fetch_id("Sugar"))
-    expect(sugar_milk.right_id).to eq(Card.fetch_id("Milk"))
-  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 "does not have r3 permissions" do
-    expect(@ucard.fetch(new: {}, trait: :roles).item_names.member?(@r3.name)).to be_falsey
-  end
-  it "ponders 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 "does not find Cardtype F on its list of createable cardtypes" do
-    expect(@type_names.member?("Cardtype F")).to be_falsey
-  end
-  it "finds Basic on its list of createable cardtypes" do
-    expect(@type_names.member?("Basic")).to be_truthy
-  end
-end