card 1.101.1 → 1.101.6

data/mod/core/spec/set/all/content_spec.rb

@@ -1,15 +0,0 @@
-# -*- encoding : utf-8 -*-
-
-describe Card::Set::All::Content do
-  describe "save_content_draft" do
-    it "stores a draft revision" do
-      @card = Card.create! name: "mango", content: "foo"
-      @card.save_content_draft("bar")
-      expect(@card.drafts.length).to eq 1
-      @card.save_content_draft("booboo")
-      @card.reload
-      expect(@card.drafts.length).to eq 1
-      expect(@card.drafts[0].value(:db_content)).to eq "booboo"
-    end
-  end
-end

data/mod/core/spec/set/all/event_conditions_spec.rb

@@ -1,217 +0,0 @@
-# -*- encoding : utf-8 -*-
-
-RSpec.describe Card::Set::All::EventConditions do
-  let(:create_card) {Card.create!(name: "main card")}
-  let(:create_card_with_subcards) do
-    Card.create name: "main card",
-                subcards: {
-                  "11" => { subcards: { "111" => "A" } },
-                  "12" => { subcards: { "121" => "A" } }
-                }
-  end
-
-  context "restricted to changed content:" do
-    STAGES = [:validate, :store, :finalize, :integrate]
-
-    def add_to_log entry
-      @log << entry
-    end
-
-    def change_content
-      Card["A"].update! content: "changed content"
-    end
-
-    before do
-      @log = []
-    end
-
-    it "is executed when content changed" do
-      with_test_events do
-        STAGES.each do |stage|
-          test_event stage, on: :update, changed: :content, for: "A" do
-            # can't access instance variables here but methods are fine
-            add_to_log stage
-          end
-        end
-        change_content
-        expect(@log).to contain_exactly(*STAGES)
-      end
-    end
-
-    specify "content change is accessible in all stages" do
-      with_test_events do
-        STAGES.each do |stage|
-          test_event stage, on: :update, changed: :content, for: "A" do
-            add_to_log db_content_before_act
-          end
-        end
-        content_before_change = [Card["A"].db_content] * STAGES.size
-        change_content
-        expect(@log).to contain_exactly(*content_before_change)
-      end
-    end
-
-    context "when changing type" do
-      def update_type
-        Card::Auth.as_bot do
-          Card["Sample Pointer"].update! type: "Search"
-        end
-      end
-
-      it "does NOT run update events from sets that no longer apply after change" do
-        with_test_events do
-          test_event :validate, on: :update, set: Card::Set::Type::Pointer do
-            add_to_log "NO to run"
-          end
-          update_type
-          expect(@log).to be_empty
-        end
-      end
-
-      it "does run update events from old sets when `changing` value present" do
-        with_test_events do
-          test_event :validate,
-                     on: :update, set: Card::Set::Type::Pointer, changing: :type do
-            add_to_log "YES to run"
-          end
-          update_type
-          expect(@log).to contain_exactly("YES to run")
-        end
-      end
-
-      it "does run update events from sets that apply after change" do
-        with_test_events do
-          test_event :validate, on: :update, set: Card::Set::Type::SearchType do
-            add_to_log "YES to run"
-          end
-          update_type
-          expect(@log).to contain_exactly("YES to run")
-        end
-      end
-
-      # following does not yet work, because old card has both old sets and new sets
-      # when conditions are tested.
-      xit "does NOT run update events from new sets when `changing` value present" do
-        with_test_events do
-          test_event :validate,
-                     on: :update, set: Card::Set::Type::SearchType, changing: :type do
-            add_to_log "NO to run"
-          end
-          update_type
-          expect(@log).to be_empty
-        end
-      end
-    end
-
-    context "when changing name" do
-      def update_name
-        Card::Auth.as_bot do
-          Card["Cardtype B+*type+*create"].update! name: "B+*update"
-        end
-      end
-
-      it "does NOT run update events from sets that no longer apply after change" do
-        with_test_events do
-          test_event :validate, on: :update, set: Card::Set::Right::Create do
-            add_to_log "NO to run"
-          end
-          update_name
-          expect(@log).to be_empty
-        end
-      end
-
-      it "does run update events from old sets when `changing` value present" do
-        with_test_events do
-          test_event :validate,
-                     on: :update, set: Card::Set::Right::Create, changing: :name do
-            add_to_log "YES to run"
-          end
-          update_name
-          expect(@log).to contain_exactly("YES to run")
-        end
-      end
-
-      it "does run update events from sets that apply after change" do
-        with_test_events do
-          test_event :validate, on: :update, set: Card::Set::Right::Update do
-            add_to_log "YES to run"
-          end
-          update_name
-          expect(@log).to contain_exactly("YES to run")
-        end
-      end
-    end
-
-    describe "trigger option" do
-      specify "trigger for whole act" do
-        with_test_events do
-          test_event :validate, on: :update, trigger: :required, for: "A" do
-            add_to_log "triggered"
-          end
-          Card["A"].update! content: "changed content"
-
-          aggregate_failures do
-            expect(@log).to be_empty
-            Card["A"].update! content: "changed content", trigger: :test_event_0
-            expect(@log).to contain_exactly "triggered"
-          end
-        end
-      end
-    end
-
-    describe "skip option" do
-      def expect_skipping changes, log1, log2,
-                          for_name: nil, skip_key: :skip, allowed: :allowed, force: false
-        with_test_events do
-          add_logging_test_event allowed, for_name
-          update_with_skip force, changes, skip_key
-
-          aggregate_failures do
-            expect(@log).to eq(log1)                              # logging with skip
-            Card["A"].update! changes                             # update without skip
-            expect(@log).to contain_exactly(*log2)                # logging without skip
-          end
-        end
-      end
-
-      def add_logging_test_event allowed, for_name
-        event_args = { on: :update, skip: allowed }
-        event_args[:for] = for_name if for_name
-        test_event(:validate, event_args) do
-          add_to_log "#{name} executed"
-        end
-      end
-
-      def update_with_skip force, changes, skip_key
-        skip_card = Card["A"]
-        if force
-          skip_card.skip_event! :test_event_0
-          skip_card.update! changes
-        else
-          skip_card.update! changes.merge(skip_key => :test_event_0)
-        end
-      end
-
-      specify "skip condition" do
-        expect_skipping({ content: "changed" }, [], "A executed", for_name: "A")
-      end
-
-      specify "skip condition in subcard" do
-        expect_skipping({ content: "changed", subcards: { "+B" => "changed +B" } },
-                        [], "A+B executed", for_name: "A+B")
-      end
-
-      specify "skip_in_action condition" do
-        expect_skipping({ content: "changed", subcards: { "+B" => "changed +B" } },
-                        ["A+B executed"],
-                        ["A executed", "A+B executed", "A+B executed"],
-                        skip_key: :skip_in_action)
-      end
-
-      specify "force skip" do
-        expect_skipping({ content: "changed" }, [], "A executed",
-                        force: true, for_name: "A")
-      end
-    end
-  end
-end

data/mod/core/spec/set/all/fetch_helper_spec.rb

@@ -1,65 +0,0 @@
-# -*- encoding : utf-8 -*-
-
-RSpec.describe Card::Set::All::FetchHelper do
-  let(:retrieve) { test_retrieve_existing }
-  let(:retrieve_from_trash) { test_retrieve_existing look_in_trash: true }
-
-  def fetch_object opts={}
-    if @fetch_object
-      @fetch_object.opts.merge! opts
-      @fetch_object
-    else
-      @fetch_object = Card::Fetch.new("A".to_name, opts)
-    end
-  end
-
-  def test_retrieve_existing opts={}
-    fetch_object(opts)&.retrieve_existing
-  end
-
-  describe "#controller fetch" do
-    it "removes underscores from new card names" do
-      expect(Card.controller_fetch(mark: "no_un_der_score").name).to eq("no un der score")
-    end
-  end
-
-  describe "retrieve_existing" do
-    it "looks for non-cached card in database" do
-      # expect_db_retrieval_with(:key, "a", nil) { retrieve }
-      expect_db_retrieval { retrieve }
-    end
-
-    it "doesn't look in db for cached cards(real)" do
-      Card.cache.write "a", Card["B"]
-      expect_no_db_retrieval { retrieve }
-    end
-
-    it "doesn't look in db for cached cards (new)" do
-      Card.cache.write "a", Card.new
-      expect_no_db_retrieval { retrieve }
-    end
-
-    it "doesn't look in db for cached cards (real) if 'look_in_trash' option used" do
-      Card.cache.write "a", Card["B"]
-      expect_no_db_retrieval { retrieve_from_trash }
-    end
-
-    it "looks in db for cached cards (new) if 'look_in_trash' option used" do
-      Card.cache.write "a", Card.new
-      # expect_db_retrieval_with(:key, "a", true) { retrieve_from_trash }
-      expect_db_retrieval { retrieve_from_trash }
-    end
-
-    def expect_no_db_retrieval
-      allow(fetch_object).to receive(:retrieve_from_db)
-      yield
-      expect(fetch_object).not_to have_received(:retrieve_from_db)
-    end
-
-    def expect_db_retrieval
-      allow(fetch_object).to receive(:retrieve_from_db)
-      yield
-      expect(fetch_object).to have_received(:retrieve_from_db) # .with(*args)
-    end
-  end
-end

data/mod/core/spec/set/all/fetch_spec.rb

@@ -1,338 +0,0 @@
-# -*- encoding : utf-8 -*-
-
-RSpec.describe Card::Set::All::Fetch do
-  describe "#fetch" do
-    it "returns and caches existing cards" do
-      card_double = class_double("Card")
-      expect(Card.fetch("A")).to be_instance_of(Card)
-      expect(Card.cache.read("a")).to be_instance_of(Card)
-      expect(card_double).not_to receive(:find_by_key)
-      expect(Card.fetch("A")).to be_instance_of(Card)
-    end
-
-    it "returns nil and caches missing cards" do
-      expect(Card.fetch("Zork")).to be_nil
-      expect(Card.cache.read("zork").new_card?).to be_truthy
-      expect(Card.fetch("Zork")).to be_nil
-    end
-
-    it "returns nil and caches trash cards" do
-      Card::Auth.as_bot do
-        card_double = class_double("Card")
-        Card.fetch("A").delete!
-        expect(Card.fetch("A")).to be_nil
-        expect(card_double).not_to receive(:find_by_key_and_trash)
-        expect(Card.fetch("A")).to be_nil
-      end
-    end
-
-    it "returns and caches builtin cards" do
-      expect(Card.fetch("*head")).to be_instance_of(Card)
-      expect(Card.cache.read("*head")).not_to be_nil
-    end
-
-    it "returns virtual cards and caches them as missing" do
-      Card::Auth.as_bot do
-        card = Card.fetch("Joe User+*email")
-        expect(card).to be_a(Card).and have_name "Joe User+*email"
-        expect(card.format.render_raw).to eq("joe@user.com")
-      end
-      # card.content.should == 'joe@user.com'
-      # cached_card = Card.cache.read('joe_user+*email')
-      # cached_card.missing?.should be_true
-      # cached_card.virtual?.should be_true
-    end
-
-    it "fetches virtual cards after skipping them" do
-      expect(Card["A+*self"]).to be_nil
-      expect(Card.fetch("A+*self")).not_to be_nil
-    end
-
-    it "fetches newly virtual cards", as_bot: true do
-      expect(Card.fetch("A+virtual")).to be_nil
-      create "virtual+*right+*structure"
-      expect(Card.fetch("A+virtual")).not_to be_nil
-    end
-
-    it "fetches virtual set cards" do
-      aself = Card.fetch("A+*self")
-      Card::Cache.reset_all
-      Card.fetch "A+*self"
-
-      expect(aself.set_names).to include("Set+*type")
-    end
-
-    it "fetches structured cards" do
-      Card::Auth.as_bot do
-        Card.create! name: "y+*right+*structure", content: "Formatted Content"
-        Card.create! name: "a+y", content: "DB Content"
-      end
-      card = Card.fetch("a+y")
-      expect(card).to be_real.and have_content("Formatted Content").and have_db_content("DB Content")
-    end
-
-    it "handles name variants of cached cards" do
-      expect(Card.fetch("yomama+*self").name).to eq("yomama+*self")
-      expect(Card.fetch("YOMAMA+*self").name).to eq("YOMAMA+*self")
-      expect(Card.fetch("yomama", new: {}).name).to eq("yomama")
-      expect(Card.fetch("YOMAMA", new: {}).name).to eq("YOMAMA")
-      expect(Card.fetch("yomama!", new: { name: "Yomama" }).name)
-        .to eq("Yomama")
-    end
-
-    it "fetches junction of names" do
-      card = Card.fetch "A", "B"
-      expect(card).to be_instance_of(Card)
-      expect(card.name).to eq "A+B"
-    end
-
-    it "fetches junction of string, id, and codename" do
-      card = Card.fetch "Book", Card.fetch_id(:type), :structure
-      expect(card).to be_instance_of(Card)
-      expect(card.name).to eq "Book+*type+*structure"
-    end
-
-    it "fetches junction of name, card object, and codename" do
-      card = Card.fetch "Book".to_name, Card.fetch(:type), :structure
-      expect(card).to be_instance_of(Card)
-      expect(card.name).to eq "Book+*type+*structure"
-    end
-
-    it "does not recurse infinitely on template templates" do
-      expect(Card.fetch("*structure+*right+*structure")).to be_nil
-    end
-
-    it "expires card and dependencies on save" do
-      # Card.cache.dump # should be empty
-      Card.cache.soft.reset
-      expect(Card.cache.soft.store.keys).to eq([])
-
-      Card::Auth.as_bot do
-        a = Card.fetch("A")
-        expect(a).to be_instance_of(Card)
-
-        # expires the saved card
-        expect(a).to receive(:expire).and_call_original
-        # expect().to receive(:delete).with('a#SUBCARDS#').and_call_original
-        # expires plus cards
-        # expect(Card.cache).to receive(:delete).with('c+a')
-        # expect(Card.cache).to receive(:delete).with('d+a')
-        # expect(Card.cache).to receive(:delete).with('f+a')
-        # expect(Card.cache).to receive(:delete).with('a+b')
-        # expect(Card.cache).to receive(:delete).with('a+c')
-        # expect(Card.cache).to receive(:delete).with('a+d')
-        # expect(Card.cache).to receive(:delete).with('a+e')
-        # expect(Card.cache).to receive(:delete).with('a+b+c')
-
-        # expired including? cards
-        # expect(Card.cache).to receive(:delete).with('x').exactly(2).times
-        # expect(Card.cache).to receive(:delete).with('y').exactly(2).times
-        a.save!
-      end
-    end
-
-    describe "default option" do
-      context "when card doesn't exist" do
-        it "initializes new cards" do
-          card = Card.fetch "non-existent",
-                            new: { default_content: "default content" }
-          expect(card.db_content).to eq "default content"
-        end
-      end
-      context "when new card exist" do
-        it "doesn't change anything" do
-          Card.new name: "new card",
-                   "+sub" => { content: "some content" }
-          card = Card.fetch "new card+sub",
-                            new: { default_content: "new content" }
-          expect(card.db_content).to eq "some content"
-        end
-      end
-    end
-
-    describe "preferences" do
-      before do
-        Card::Auth.signin Card::WagnBotID
-      end
-
-      it "prefers db cards to pattern virtual cards" do
-        Card.create! name: "y+*right+*structure",
-                     content: "Formatted Content"
-        Card.create! name: "a+y", content: "DB Content"
-        card = Card.fetch("a+y")
-        expect(card).to be_not_virtual.and have_db_content "DB Content"
-        expect(card.rule(:structure)).to eq("Formatted Content")
-      end
-
-      it "prefers a pattern virtual card to trash cards" do
-        Card.create!(name: "y+*right+*structure", content: "Formatted Content")
-        Card.create!(name: "a+y", content: "DB Content")
-        Card.fetch("a+y").delete!
-
-        card = Card.fetch("a+y")
-        expect(card).to be_virtual.and have_content "Formatted Content"
-      end
-
-      it "recognizes pattern overrides" do
-        # ~~~ create right rule
-        Card.create!(name: "y+*right+*structure", content: "Right Content")
-        card = Card.fetch("a+y")
-        expect(card).to be_virtual.and have_content "Right Content"
-
-        #        warn 'creating template'
-        tpr = Card.create! name: "RichText+y+*type plus right+*structure",
-                           content: "Type Plus Right Content"
-        card = Card.fetch("a+y")
-        expect(card).to be_virtual.and have_content "Type Plus Right Content"
-
-        # ~~~ delete type plus right rule
-        tpr.delete!
-        card = Card.fetch("a+y")
-        expect(card).to be_virtual.and have_content "Right Content"
-      end
-
-      it "does not hit the database for every fetch_virtual lookup" do
-        card_double = class_double("Card")
-        Card.create!(name: "y+*right+*structure", content: "Formatted Content")
-        Card.fetch("a+y")
-        expect(card_double).not_to receive(:find_by_key)
-        Card.fetch("a+y")
-      end
-
-      it "does not be a new_record after being saved" do
-        Card.create!(name: "growing up")
-        card = Card.fetch("growing up")
-        expect(card.new_record?).to be_falsey
-      end
-    end
-
-    describe "default_content option" do
-      context "when card doesn't exist" do
-        it "initializes card with default content" do
-          card = Card.fetch "non-existent",
-                            new: { default_content: "default content" }
-          expect(card).to have_db_content "default content"
-        end
-      end
-      context "when new card exist" do
-        it "doesn't change content" do
-          Card.new name: "new card", "+sub" => { content: "some content" }
-          card = Card.fetch "new card+sub", new: { default_content: "new content" }
-          expect(card).to have_db_content "some content"
-        end
-      end
-    end
-  end
-
-  describe "#fetch new: { ... }" do
-    it "returns a new card if it doesn't find one" do
-      new_card = Card.fetch "Never Seen Me Before", new: {}
-      expect(new_card).to be_a(Card).and be_a_new_record
-      expect { new_card.save! }.to increase_card_count.by(1)
-    end
-
-    it "returns a card if it finds one" do
-      new_card = Card.fetch "A+B", new: {}
-      expect(new_card).to be_a(Card).and be_real
-      expect { new_card.save! }.not_to increase_card_count
-    end
-
-    it "takes a second hash of options as new card options" do
-      new_card = Card.fetch "Never Before", new: { type: "Image" }
-      expect(new_card).to be_a(Card).and be_a_new_record
-                                            .and have_type(:image)
-      expect(Card.fetch("Never Before", new: {})).to have_type(:basic)
-    end
-  end
-
-  describe "#fetch_virtual" do
-    before do
-      Card::Auth.as_bot do
-        Card.create! name: "testsearch+*right+*structure",
-                     content: '{"plus":"_self"}', type: "Search"
-      end
-    end
-    it "finds cards with *right+*structure specified" do
-      expect(Card.fetch("A+testsearch".to_name))
-        .to be_virtual.and have_type(:search_type)
-                              .and have_content '{"plus":"_self"}'
-    end
-    context "fetched virtual card with new args" do
-      it "fetchs the virtual card with type set in patterns" do
-        Card.fetch "+testsearch", new: { name: "+testsearch",
-                                         supercard: Card["home"] }
-
-        c = Card.fetch("Home+testsearch".to_name)
-        expect(c).to be_virtual.and have_type(:search_type)
-                                       .and have_content('{"plus":"_self"}')
-
-        patterns = c.instance_variable_get("@patterns").map(&:to_s)
-        expect(patterns).to include("Search+*type")
-      end
-    end
-  end
-
-  describe "#id" do
-    it "handles integer args" do
-      expect(Card.id(1234)).to eq(1234)
-    end
-
-    it "handles card args" do
-      a = Card["A"]
-      expect(Card.id(a)).to eq(a.id)
-    end
-
-    it "handles symbols" do
-      expect(Card.id(:structure)).to eq(Card::StructureID)
-    end
-  end
-
-  describe "#exists?" do
-    it "is true for cards that are there" do
-      expect(Card.exists?("A")).to eq(true)
-    end
-
-    it "is false for cards that aren't" do
-      expect(Card.exists?("Mumblefunk is gone")).to eq(false)
-    end
-  end
-
-  describe "#fetch_name" do
-    example "symbol" do
-      expect(Card.fetch_name(:all)).to eq "*all"
-    end
-
-    example "string" do
-      expect(Card.fetch_name("home")).to eq "Home"
-    end
-
-    example "id" do
-      expect(Card.fetch_name(Card::BasicID)).to eq "RichText"
-    end
-
-    example "invalid id" do
-      expect(Card.fetch_name("~1836/[[/assets/fonts")).to be_nil
-    end
-
-    example "array" do
-      expect(Card.fetch_name(%w[a b])).to eq "A+B"
-    end
-
-    example "param list" do
-      expect(Card.fetch_name("fruit", :type, "*create")).to eq "Fruit+*type+*create"
-    end
-
-    example "name doesn't exist" do
-      expect(Card.fetch_name("unknown_name")).to eq nil
-    end
-
-    example "fallback policy" do
-      name = Card.fetch_name("unknown_name") { "Unknown Name" }
-      expect(name).to eq "Unknown Name"
-    end
-
-    it "doesn't fetch virtual names" do
-      expect(Card.fetch_name(:all, :self, :create)).to eq nil
-    end
-  end
-end