card 1.91 → 1.92

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

@@ -145,9 +145,9 @@ describe Card::Set::All::Collection do
       tabs = render_card :tabs, name: "tab_test", type_id: Card::PlainTextID,
                                 content: "{{A|type;title:my tab title}}"
       assert_view_select tabs, "div[role=tabpanel]" do
-        assert_select 'li > a[data-toggle=tab][href="#tab_test-my_tab_title"]',
+        assert_select 'li > a[data-toggle=tab][href="#tab_test-a"]',
                       "my tab title"
-        assert_select "div.tab-pane#tab_test-my_tab_title", "Basic"
+        assert_select "div.tab-pane#tab_test-a", "Basic"
       end
     end
 

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

@@ -0,0 +1,54 @@
+# -*- encoding : utf-8 -*-
+
+describe Card::Set::All::EventConditions, "event" 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_attributes! 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"].content] * STAGES.size
+        change_content
+        expect(@log).to contain_exactly(*content_before_change)
+      end
+    end
+  end
+end

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

@@ -34,8 +34,7 @@ describe Card::Set::All::Fetch do
     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_instance_of(Card)
-        expect(card.name).to eq("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.raw_content.should == 'joe@user.com'
@@ -152,9 +151,8 @@ describe Card::Set::All::Fetch do
                      content: "Formatted Content"
         Card.create! name: "a+y", content: "DB Content"
         card = Card.fetch("a+y")
-        expect(card.virtual?).to be_falsey
+        expect(card).to be_not_virtual.and have_content "DB Content"
         expect(card.rule(:structure)).to eq("Formatted Content")
-        expect(card.content).to eq("DB Content")
       end
 
       it "prefers a pattern virtual card to trash cards" do
@@ -163,29 +161,25 @@ describe Card::Set::All::Fetch do
         Card.fetch("a+y").delete!
 
         card = Card.fetch("a+y")
-        expect(card.virtual?).to be
-        expect(card.raw_content).to eq("Formatted Content")
+        expect(card).to be_virtual.and have_raw_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.virtual?).to be
-        expect(card.raw_content).to eq("Right Content")
+        expect(card).to be_virtual.and have_raw_content "Right Content"
 
         #        warn 'creating template'
         tpr = Card.create! name: "Basic+y+*type plus right+*structure",
                            content: "Type Plus Right Content"
         card = Card.fetch("a+y")
-        expect(card.virtual?).to be
-        expect(card.raw_content).to eq("Type Plus Right Content")
+        expect(card).to be_virtual.and have_raw_content "Type Plus Right Content"
 
         # ~~~ delete type plus right rule
         tpr.delete!
         card = Card.fetch("a+y")
-        expect(card.virtual?).to be
-        expect(card.raw_content).to eq("Right Content")
+        expect(card).to be_virtual.and have_raw_content "Right Content"
       end
 
       it "does not hit the database for every fetch_virtual lookup" do
@@ -208,7 +202,7 @@ describe Card::Set::All::Fetch do
         it "initializes card with default content" do
           card = Card.fetch "non-existent",
                             new: { default_content: "default content" }
-          expect(card.content).to eq "default content"
+          expect(card).to have_content "default content"
         end
       end
       context "when new card exist" do
@@ -217,7 +211,7 @@ describe Card::Set::All::Fetch do
                    "+sub" => { content: "some content" }
           card = Card.fetch "new card+sub",
                             new: { default_content: "new content" }
-          expect(card.content).to eq "some content"
+          expect(card).to have_content "some content"
         end
       end
     end
@@ -226,22 +220,21 @@ describe Card::Set::All::Fetch do
   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_instance_of(Card)
-      expect(new_card.new_record?).to be_truthy
+      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_instance_of(Card)
-      expect(new_card.new_record?).to be_falsey
+      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_instance_of(Card)
-      expect(new_card.type_code).to eq(:image)
-      expect(new_card.new_record?).to be_truthy
-      expect(Card.fetch("Never Before", new: {}).type_id).to eq(Card::BasicID)
+      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
 
@@ -253,10 +246,9 @@ describe Card::Set::All::Fetch do
       end
     end
     it "finds cards with *right+*structure specified" do
-      c = Card.fetch("A+testsearch".to_name)
-      assert c.virtual?
-      expect(c.type_code).to eq(:search_type)
-      expect(c.raw_content).to eq('{"plus":"_self"}')
+      expect(Card.fetch("A+testsearch".to_name))
+        .to be_virtual.and have_type(:search_type)
+                              .and have_raw_content '{"plus":"_self"}'
     end
     context "fetched virtual card with new args" do
       it "fetchs the virtual card with type set in patterns" do
@@ -264,9 +256,9 @@ describe Card::Set::All::Fetch do
                                          supercard: Card["home"] }
 
         c = Card.fetch("Home+testsearch".to_name)
-        assert c.virtual?
-        expect(c.type_code).to eq(:search_type)
-        expect(c.raw_content).to eq('{"plus":"_self"}')
+        expect(c).to be_virtual.and have_type(:search_type)
+                                       .and have_raw_content('{"plus":"_self"}')
+
         patterns = c.instance_variable_get("@patterns").map(&:to_s)
         expect(patterns).to include("Search+*type")
       end

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

@@ -0,0 +1,17 @@
+#require '#benchmark/ips'
+#
+#RSpec.describe Card::Set::All::I18n do
+#  it "can access scope" do
+#    expect(Card["A"].format.t(:key))
+#      .to eq "translation missing: en.mod.spec.set.all.i18n_spec.key"
+#  end
+#
+#  it "gets correct text" do
+#    x.report('with auto_scope') do
+#      Card[:admin_info].format(:html).render_warning_list_with_auto_scope([])
+#    end
+#    x.report('with explicit scope') do
+#      Card[:admin_info].format(:html).render_warning_list([])
+#    end
+#  end
+#end

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

@@ -1,7 +1,37 @@
 # -*- encoding : utf-8 -*-
 
 describe Card::Set::All::Name do
-  describe "autoname" do
+  describe "event: set_name" do
+    it "handles case variants" do
+      @c = Card.create! name: "chump"
+      expect(@c.name).to eq("chump")
+      @c.name = "Chump"
+      @c.save!
+      expect(@c.name).to eq("Chump")
+    end
+
+    it "handles changing from plus card to simple" do
+      c = Card.create! name: "four+five"
+      c.name = "nine"
+      c.save!
+      expect(c.name).to eq("nine")
+      expect(c.left_id).to eq(nil)
+      expect(c.right_id).to eq(nil)
+    end
+  end
+
+  describe "event: set_left_and_right" do
+    example "create junction" do
+      expect do
+        Card.create! name: "Peach+Pear", content: "juicy"
+      end.to increase_card_count.by(3)
+      expect(Card["Peach"]).to be_a(Card)
+      expect(Card["Pear"]).to be_a(Card)
+      expect(Card["Peach+Pear"]).to have_content "juicy"
+    end
+  end
+
+  describe "event: autoname" do
     before do
       Card::Auth.as_bot do
         @b1 = Card.create! name: "Book+*type+*autoname", content: "b1"
@@ -21,7 +51,7 @@ describe Card::Set::All::Name do
 
     it "handles trashed names" do
       b1 = Card.create! type: "Book"
-      Card::Auth.as_bot { b1.delete }
+      Card::Auth.as_bot {b1.delete}
       b1 = Card.create! type: "Book"
       expect(b1.name).to eq("b1")
     end
@@ -45,7 +75,7 @@ describe Card::Set::All::Name do
     end
   end
 
-  describe "repair_key" do
+  describe "#repair_key" do
     it "fixes broken keys" do
       a = Card["a"]
       a.update_column "key", "broken_a"
@@ -57,4 +87,10 @@ describe Card::Set::All::Name do
       expect(a.key).to eq("a")
     end
   end
+
+  describe "#descendants" do
+    it "finds descendants" do
+      expect(Card["A"].descendants.length).to be > 0
+    end
+  end
 end

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

@@ -0,0 +1,21 @@
+describe Card::Set::All::NameValidations, "validate name" do
+  it "errors on name with /" do
+    expect { create "testname/" }
+      .to raise_error /Name may not contain/
+  end
+
+  it "errors on junction name  with /" do
+    expect { create "jasmin+ri/ce" }
+      .to raise_error /Name may not contain/
+  end
+
+  it "does not allow empty name" do
+    expect { create "" }
+      .to raise_error /Name can't be blank/
+  end
+
+  it "does not allow mismatched name and key" do
+    expect { create "Test", key: "foo" }
+      .to raise_error /wrong key/
+  end
+end

data/mod/core/spec/set/all/permissions/reader_rules_spec.rb

@@ -0,0 +1,166 @@
+describe Card::Set::All::Permissions do
+  describe "reader rules" do
+    before do
+      @perm_card = Card.new name: "Home+*self+*read", type: "Pointer",
+                            content: "[[Anyone Signed In]]"
+    end
+
+    it "is *all+*read by default" do
+      card = Card.fetch("Home")
+      expect(card.read_rule_id).to eq(Card.fetch("*all+*read").id)
+      expect(card.who_can(:read)).to eq([Card::AnyoneID])
+      Card::Auth.as(:anonymous) { expect(card.ok?(:read)).to be_truthy }
+    end
+
+    it "updates to role ('Anyone Signed In')" do
+      name = @perm_card.name
+      Card::Auth.as_bot { @perm_card.save! }
+      pc = Card[name]
+      card = Card["Home"]
+      # warn "card #{name}, #{card.inspect}, #{pc.inspect}"
+      expect(pc).to be
+      expect(card.read_rule_id).to eq(pc.id)
+      expect(card.who_can(:read)).to eq([Card::AnyoneSignedInID])
+      Card::Auth.as(:anonymous) { expect(card.ok?(:read)).to be_falsey }
+    end
+
+    it "updates to user ('Joe Admin')" do
+      @perm_card.content = "[[Joe Admin]]"
+      Card::Auth.as_bot { @perm_card.save! }
+
+      card = Card.fetch("Home")
+      expect(card.read_rule_id).to eq(@perm_card.id)
+      expect(card.who_can(:read)).to eq([Card["joe_admin"].id])
+      Card::Auth.as(:anonymous) { expect(card.ok?(:read)).to be_falsey }
+      Card::Auth.as("joe_user")  { expect(card.ok?(:read)).to be_falsey }
+      Card::Auth.as("joe_admin") { expect(card.ok?(:read)).to be_truthy  }
+      Card::Auth.as_bot         { expect(card.ok?(:read)).to be_truthy  }
+    end
+
+    context "when more specific (self) rule is deleted" do
+      it "reverts to more general rule"  do
+        Card::Auth.as_bot do
+          @perm_card.save!
+          @perm_card.delete!
+        end
+        card = Card.fetch("Home")
+        expect(card.read_rule_id).to eq(Card.fetch("*all+*read").id)
+      end
+    end
+
+    context "when more specific (right) rule is deleted" do
+      it "reverts to more general rule" do
+        pc = nil
+        Card::Auth.as_bot do
+          pc = Card.create name: "B+*right+*read", type: "Pointer",
+                           content: "[[Anyone Signed In]]"
+        end
+        expect(pc).to be
+        card = Card.fetch("A+B")
+        expect(card.read_rule_id).to eq(pc.id)
+        # important to re-fetch to catch issues
+        # with detecting change in trash status.
+        pc = Card.fetch(pc.name)
+        Card::Auth.as_bot { pc.delete }
+        card = Card.fetch("A+B")
+        expect(card.read_rule_id).to eq(Card.fetch("*all+*read").id)
+      end
+    end
+
+    context "when more specific rule is renamed" do
+      it "reverts to more general rule" do
+        Card::Auth.as_bot do
+          @perm_card.save!
+          @perm_card = Card[@perm_card.name]
+          @perm_card.name = "Something else+*self+*read"
+          @perm_card.save!
+        end
+
+        card = Card.fetch("Home")
+        expect(card.read_rule_id).to eq(Card.fetch("*all+*read").id)
+      end
+    end
+
+    it "gets not overruled by a more general rule added later" do
+      Card::Auth.as_bot do
+        @perm_card.save!
+        c = Card.fetch("Home")
+        c.type_id = Card::PhraseID
+        c.save!
+        Card.create name: "Phrase+*type+*read", type: "Pointer",
+                    content: "[[Joe User]]"
+      end
+
+      card = Card.fetch("Home")
+      expect(card.read_rule_id).to eq(@perm_card.id)
+    end
+
+    it "gets updated when trunk type change makes " \
+       "type-plus-right apply / unapply" do
+      @perm_card.name = "Phrase+B+*type plus right+*read"
+      Card::Auth.as_bot { @perm_card.save! }
+      expect(Card.fetch("A+B").read_rule_id).to eq(Card.fetch("*all+*read").id)
+      c = Card.fetch("A")
+      c.type_id = Card::PhraseID
+      c.save!
+      expect(Card.fetch("A+B").read_rule_id).to eq(@perm_card.id)
+    end
+
+    it "works with relative settings" do
+      Card::Auth.as_bot do
+        @perm_card.save!
+        all_plus = Card.fetch "*all plus+*read", new: { content: "_left" }
+        all_plus.save
+      end
+      c = Card.new(name: "Home+Heart")
+      expect(c.who_can(:read)).to eq([Card::AnyoneSignedInID])
+      expect(c.permission_rule_id(:read)).to eq(@perm_card.id)
+      c.save
+      expect(c.read_rule_id).to eq(@perm_card.id)
+    end
+
+    it "gets updated when relative settings change" do
+      Card::Auth.as_bot do
+        all_plus = Card.fetch "*all plus+*read", new: { content: "_left" }
+        all_plus.save
+      end
+      c = Card.new(name: "Home+Heart")
+      expect(c.who_can(:read)).to eq([Card::AnyoneID])
+      expect(c.permission_rule_id(:read)).to(
+        eq(Card.fetch("*all+*read").id)
+      )
+      c.save
+      expect(c.read_rule_id).to eq(Card.fetch("*all+*read").id)
+      Card::Auth.as_bot { @perm_card.save! }
+      c2 = Card.fetch("Home+Heart")
+      expect(c2.who_can(:read)).to eq([Card::AnyoneSignedInID])
+      expect(c2.read_rule_id).to eq(@perm_card.id)
+      expect(Card.fetch("Home+Heart").read_rule_id).to(
+        eq(@perm_card.id)
+      )
+      Card::Auth.as_bot { @perm_card.delete }
+      expect(Card.fetch("Home").read_rule_id).to eq(Card.fetch("*all+*read").id)
+      expect(Card.fetch("Home+Heart").read_rule_id).to(
+        eq(Card.fetch("*all+*read").id)
+      )
+    end
+
+    it "insures that class overrides work with relative settings" do
+      Card::Auth.as_bot do
+        all_plus = Card.fetch "*all plus+*read", new: { content: "_left" }
+        all_plus.save
+        Card::Auth.as_bot { @perm_card.save! }
+        c = Card.create(name: "Home+Heart")
+        expect(c.read_rule_id).to eq(@perm_card.id)
+        r = Card.create name: "Heart+*right+*read", type: "Pointer",
+                        content: "[[Administrator]]"
+        expect(Card.fetch("Home+Heart").read_rule_id).to eq(r.id)
+      end
+    end
+
+    it "works on virtual+virtual cards" do
+      c = Card.fetch("Number+*type+by name")
+      expect(c.ok?(:read)).to be_truthy
+    end
+  end
+end