card 1.93.3 → 1.93.4

data/spec/lib/card/reference_spec.rb

@@ -1,212 +0,0 @@
-# -*- 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
-    end
-
-    it "on template creation" do
-      Card.create! name: "SpecialForm", type: "Cardtype"
-      Card.create! name: "Form1", type: "SpecialForm", content: "foo"
-      Card.create! name: "SpecialForm+*type+*structure", content: "{{+bar}}"
-      Card["Form1"].format.render!(:core)
-      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!
-      Card["JoeForm"].format.render!(:core)
-      expect(Card["JoeForm"].includees.map(&:key)).to contain_exactly("joe_form+banana", "joe_form+fruit", "joe_form+monkey")
-    end
-  end
-
-  it "in references should survive cardtype change" do
-    create! "Banana", "[[Yellow]]"
-    create! "Submarine", "[[Yellow]]"
-    create! "Sun", "[[Yellow]]"
-    create! "Yellow"
-    yellow_refs = Card["Yellow"].referers.map(&:name).sort
-    expect(yellow_refs).to eq(%w(Banana Submarine Sun))
-
-    y = Card["Yellow"]
-    y.type_id = Card.fetch_id "UserForm"
-    y.save!
-
-    yellow_refs = Card["Yellow"].referers.map(&:name).sort
-    expect(yellow_refs).to eq(%w(Banana Submarine Sun))
-  end
-
-  it "container nest" 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 = create!("L", "[[Ethan]]")  # no Ethan card yet...
-    @e = create!("Earthman")
-    @e.update_attributes! name: "Ethan" # NOW there is an Ethan card
-    #  do we need the links to be caught before reloading the card?
-    expect(Card["Ethan"].referers.map(&:name).include?("L")).not_to eq(nil)
-  end
-
-  it "updates references on rename when requested" do
-    create! "watermelon", "mmmm"
-    create! "watermelon+seeds", "black"
-    lew = create!("Lew", "likes [[watermelon]] and [[watermelon+seeds|seeds]]")
-
-    watermelon = Card["watermelon"]
-    watermelon.update_referers = true
-    watermelon.name = "grapefruit"
-    watermelon.save!
-    result = "likes [[grapefruit]] and [[grapefruit+seeds|seeds]]"
-    expect(lew.reload.content).to eq(result)
-  end
-
-  it "updates referers on rename when requested (case 2)" do
-    card = Card["Administrator Menu+*self+*read"]
-    old_refs = Card::Reference.where(referee_id: Card::AdministratorID)
-
-    card.update_referers = true
-    card.name = "Administrator Menu+*type+*read"
-    card.save
-
-    new_refs = Card::Reference.where(referee_id: Card::AdministratorID)
-    expect(old_refs).to eq(new_refs)
-  end
-
-  it "does not update references when not requested" do
-    watermelon = create "watermelon", "mmmm"
-    watermelon_seeds = create "watermelon+seeds", "black"
-    lew = create("Lew", "likes [[watermelon]] and [[watermelon+seeds|seeds]]")
-
-    assert_equal [watermelon.id, watermelon_seeds.id],
-                 lew.references_out.order(:id).map(&:referee_id),
-                 "stores referee ids"
-
-    watermelon = Card["watermelon"]
-    watermelon.update_referers = false
-    watermelon.name = "grapefruit"
-    watermelon.save!
-
-    correct_content = "likes [[watermelon]] and [[watermelon+seeds|seeds]]"
-    expect(lew.reload.content).to eq(correct_content)
-
-    ref_types = lew.references_out.order(:id).map(&:ref_type)
-    expect(ref_types).to eq(%w(L L P)), "need partial references!"
-    actual_referee_ids = lew.references_out.order(:id).map(&:referee_id)
-    assert_equal actual_referee_ids, [nil, nil, Card.fetch_id("seed")],
-                 'only partial reference to "seeds" should have referee_id'
-  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_referers: 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_referers: false
-    @x = Card["X"]
-    expect(@x.content).to eq("[[A]] [[A+B]] [[T]]")
-  end
-
-  it "template nest" do
-    Card.create! name: "ColorType", type: "Cardtype", content: ""
-    Card.create! name: "ColorType+*type+*structure", content: "{{+rgb}}"
-    green = Card.create! name: "green", type: "ColorType"
-    create! "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
-    Card.create name: "alpha"
-    Card.create name: "beta", content: "I link to [[alpha]]"
-    expect(Card["alpha"].referers.map(&:name)).to eq(["beta"])
-    expect(Card["beta"].referees.map(&:name)).to eq(["alpha"])
-  end
-
-  it "link with spaces" do
-    Card.create! name: "alpha card"
-    Card.create! name: "beta card", content: "I link to [[alpha_card]]"
-    expect(Card["beta card"].referees.map(&:name)).to eq(["alpha card"])
-    expect(Card["alpha card"].referers.map(&:name)).to eq(["beta card"])
-  end
-
-  it "simple nest" do
-    Card.create name: "alpha"
-    Card.create name: "beta", content: "I nest {{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
-    Card.create name: "alpha"
-    Card.create name: "beta", content: "I link to [[alpha|ALPHA]]"
-    expect(Card["beta"].referees.map(&:name)).to eq(["alpha"])
-    expect(Card["alpha"].referers.map(&:name)).to eq(["beta"])
-  end
-
-  it "query" do
-    Card.create(
-      type: "Search",
-      name: "search with references",
-      content: '{"name":"X", "right_plus":["Y",{"content":["in","A","B"]}]}'
-    )
-    y_referers = Card["Y"].referers.map(&:name)
-    expect(y_referers).to include("search with references")
-
-    search_referees = Card["search with references"].referees.map(&:name).sort
-    expect(search_referees).to eq(%w(A B X Y))
-  end
-
-  it "handles contextual names in Basic cards" do
-    Card.create type: "Basic", name: "basic w refs", content: "{{_+A}}"
-    Card["A"].update_attributes! name: "AAA", update_referers: true
-    expect(Card["basic w refs"].content).to eq "{{_+AAA}}"
-  end
-
-  it "handles contextual names in Search cards" do
-    Card.create type: "Search", name: "search w refs", content: '{"name":"_+A"}'
-    Card["A"].update_attributes! name: "AAA", update_referers: true
-    expect(Card["search w refs"].content).to eq '{"name":"_+AAA"}'
-  end
-
-  it "handles commented nest" do
-    c = Card.create name: "nest comment test", content: "{{## hi mom }}"
-    expect(c.errors.any?).to be_falsey
-  end
-
-  it "pickup new links on create" do
-    @l = create!("woof", "[[Lewdog]]")  # no Lewdog card yet...
-    @e = create!("Lewdog")              # now there is
-    # NOTE @e.referers does not work, you have to reload
-    expect(@e.reload.referers.map(&:name).include?("woof")).not_to eq(nil)
-  end
-
-  it "pickup new nests on create" do
-    @l = Card.create! name: "woof", content: "{{Lewdog}}"
-    # no Lewdog card yet...
-    @e = Card.new name: "Lewdog", content: "grrr"
-    # now it's inititated
-    expect(@e.name_referers.map(&:name).include?("woof")).not_to eq(nil)
-  end
-end

data/spec/lib/card/set/event_spec.rb

@@ -1,22 +0,0 @@
-describe Card::Set::Event do
-  it "params are deserialized in intergrate_with_delay events" do
-    @called = false
-    def event_called
-      @called = true
-    end
-
-
-    with_test_events do
-      test_event :integrate_with_delay, on: :update, for: "A" do
-        event_called
-        expect(Card::Env.params)
-          .to include(level1: ActionController::Parameters.new(level2: :a_symbol))
-      end
-
-      Card::Env.params[:level1] = ActionController::Parameters.new level2: :a_symbol
-      Card["A"].update_attributes! content: "new content"
-
-      expect(@called).to eq true
-    end
-  end
-end

data/spec/lib/card/set/trait_spec.rb

@@ -1,80 +0,0 @@
-# -*- encoding : utf-8 -*-
-
-
-describe Card::Set::Trait do
-  class Card
-    module Set
-      class Type
-        module Phrase
-          extend Card::Set
-          card_accessor :write, type: :phrase
-          card_accessor :read, type_id: Card::PhraseID
-        end
-      end
-
-      class TypePlusRight
-        module Phrase
-          module Write
-            extend Card::Set
-            def type_plus_right_module_loaded
-              true
-            end
-          end
-        end
-      end
-
-      class TypePlusRight
-        module Phrase
-          module Read
-            extend Card::Set
-            def type_plus_right_module_loaded
-              true
-            end
-          end
-        end
-      end
-    end
-  end
-
-  subject do
-    Card::Auth.as_bot do
-      Card.create! name: "joke",
-                   type_id: Card::PhraseID,
-                   "+*write" => "some content",
-                   "+*read" => "some content"
-    end
-  end
-
-  # FIXME: The expectations that are commented out fail which is worrying.
-  # But the tests are new not the behaviour. I removed them so that we can use
-  # CI again
-  context "if accessor type is defined by a symbol" do
-    it "trait card is created correctly" do
-      in_stage :prepare_to_validate, on: :create,
-                                     trigger: -> { subject } do
-        # test API doesn't support sets for event
-        # so we check the name
-        return unless name == "joke"
-        aggregate_failures do
-          expect(write_card.type_id).to eq(Card::PhraseID)
-          # expect(write_card.left).to be_instance_of(Card)
-          # expect(write_card).to respond_to(:type_plus_right_module_loaded)
-        end
-      end
-    end
-  end
-
-  context "if accessor type is defined by an id" do
-    it "trait card is created correctly" do
-      in_stage :prepare_to_validate, on: :create,
-                                     trigger: -> { subject } do
-        return unless name == "joke"
-        aggregate_failures do
-          # expect(read_card.type_id).to eq(Card::PhraseID)
-          expect(read_card.left).to be_instance_of(Card)
-          expect(read_card).to respond_to(:type_plus_right_module_loaded)
-        end
-      end
-    end
-  end
-end

data/spec/lib/card/set_pattern_spec.rb

@@ -1,59 +0,0 @@
-# -*- encoding : utf-8 -*-
-
-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
-
-describe Card::Set::Pattern do
-  specify ".in_load_order" do
-    expect(Card::Set::Pattern.in_load_order)
-      .to eq(%i[abstract all all_plus type star rstar right type_plus_right self])
-  end
-end
-
-# FIXME: - these should probably be in pattern-specific specs,
-# though that may not leave much to test in the base class :)
-
-describe Card::Set::Right 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::Set::Type do
-  it_generates name: "Book+*type", from: Card.new(type: "Book")
-
-  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::Format::HtmlFormat))
-      .to include(Card::Set::Type::Pointer::HtmlFormat)
-    expect(@mylist_card.set_format_modules(Card::Format::CssFormat))
-      .to include(Card::Set::Type::Pointer::CssFormat)
-    expect(@mylist_card.set_format_modules(Card::Format::JsFormat))
-      .to include(Card::Set::Type::Pointer::JsFormat)
-    expect(@mylist_card.set_modules).to include(Card::Set::Type::Pointer)
-  end
-end
-
-describe Card::Set::AllPlus do
-  it_generates name: "*all plus", from: Card.new(name: "Book+author")
-end
-
-describe Card::Set::All do
-  it_generates name: "*all", from: Card.new(type: "Book")
-end
-
-describe Card::Set::TypePlusRight do
-  author_card = Card.new(name: "Iliad+author")
-  it_generates name: "Book+author+*type plus right", from: author_card
-end

data/spec/lib/card/set_spec.rb

@@ -1,89 +0,0 @@
-# -*- 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 "does not 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 "does not 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::Format::HtmlFormat }
-#   let(:html_format_double) { double("Card::Format::HtmlFormat") }
-#
-#   it "defines 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 "calls 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 "defines 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 "defines 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