card 1.91 → 1.92

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

@@ -54,172 +54,7 @@ end
 include PermissionSpecHelper
 
 describe Card::Set::All::Permissions do
-  # FIXME: lots of good tests here, butmysql generally disorganized.
-
-  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
+  # FIXME: lots of good tests here, but generally disorganized.
 
   context "??" do
     before do
@@ -527,10 +362,29 @@ describe Card::Set::All::Permissions do
         .to eq(rule_id)
     end
   end
-end
 
-# FIXME-perm
 
-# need test for
-# changing cardtypes gives you correct permissions
-# (changing cardtype in general...)
+  describe "cardtypes and permissions" do
+    specify "cardtype b has create role r1" do
+      expect(Card["Cardtype B+*type+*create"]).to have_content("[[r3]]")
+                                                    .and have_type :pointer
+    end
+
+    example "changing cardtype needs new cardtype's create permission", with_user: "u2" do
+      # u3 can update but not create cardtype b
+      c = Card["basicname"]
+      c.update_attributes type: "cardtype_b"
+
+      expect(c.errors[:permission_denied])
+        .to include(/You don't have permission to change to this type/)
+      expect(Card["basicname"]).to have_type :basic
+    end
+
+    # example "changing cardtype needs new cardtype's create permission", with: "u1" do
+    #   update! "basicname", type: "cardtype_b"
+    #   expect { update! "basicname", content: "new content" }
+    #     .to raise_error(/You don't have permission to change to this type/)
+    # end
+  end
+end
+

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

@@ -0,0 +1,171 @@
+# -*- encoding : utf-8 -*-
+
+module RenameMethods
+  def name_invariant_attributes card
+    {
+      content: card.content,
+      # updater_id:  card.updater_id,
+      # revisions:   card.actions.count,
+      referers: card.referers.map(&:name).sort,
+      referees: card.referees.map(&:name).sort,
+      descendants: card.descendants.map(&:id).sort
+    }
+  end
+
+  def assert_rename card, new_name
+    if card.is_a? String
+      card = Card[card].refresh || raise("Couldn't find card named #{card}")
+    end
+    attrs_before = name_invariant_attributes(card)
+    actions_count_before = card.actions.count
+    update card.name, name: new_name, update_referers: true
+    expect(card.actions.count).to eq(actions_count_before + 1)
+    assert_equal attrs_before, name_invariant_attributes(card)
+    assert_equal new_name, card.name
+    assert Card[new_name]
+  end
+end
+
+RSpec.describe Card::Set::All::Rename do
+  include RenameMethods
+  include CardExpectations
+
+  it "renaming plus card to its own child" do
+    assert_rename "A+B", "A+B+T"
+  end
+
+  it "clears cache for old name" do
+    assert_rename "Menu", "manure"
+    expect(Card["Menu"]).to be_nil
+  end
+
+  it "wipes old references by default" do
+    update "Menu", name: "manure"
+    expect(Card["manure"].references_in.size).to eq(0)
+  end
+
+  it "picks up new references" do
+    expect(Card["Z"].references_in.size).to eq(2)
+    assert_rename "Z", "Mister X"
+    expect(Card["Mister X"].references_in.size).to eq(3)
+  end
+
+  it "handles name variants" do
+    assert_rename "B", "b"
+  end
+
+  it "handles plus cards renamed to simple" do
+    assert_rename "A+B", "K"
+  end
+
+  it "handles flipped parts" do
+    assert_rename "A+B", "B+A"
+  end
+
+  it "fails if card exists" do
+    expect { update "T", name: "A+B" }.to raise_error(/Name must be unique/)
+  end
+
+  it "fails if used as tag" do
+    expect { update "B", name: "A+D" }.to raise_error(/Name must be unique/)
+  end
+
+  it "updates descendants" do
+    old_names = %w[One+Two One+Two+Three Four+One Four+One+Five]
+    new_names = %w[Uno+Two Uno+Two+Three Four+Uno Four+Uno+Five]
+    card_list = old_names.map {|name| Card[name]}
+
+    expect(card_list.map(&:name)).to eq old_names
+    update "One", name: "Uno"
+    expect(card_list.map(&:reload).map(&:name)).to eq new_names
+  end
+
+  it "fails if name is invalid" do
+    expect { update "T", name: "YT/Yo" }
+      .to raise_error(/Validation failed: Name may not contain/)
+  end
+
+  example "simple to simple" do
+    assert_rename "A", "Alephant"
+  end
+
+  example "simple to junction with create" do
+    assert_rename "T", "C+J"
+  end
+
+  example "reset key" do
+    c = Card["basicname"]
+    update "basicname", name: "banana card"
+    expect(c.key).to eq("banana_card")
+    expect(Card["Banana Card"]).not_to be_nil
+  end
+
+  it "does not fail when updating inaccessible referer" do
+    Card.create! name: "Joe Card", content: "Whattup"
+    Card::Auth.as "joe_admin" do
+      Card.create! name: "Admin Card", content: "[[Joe Card]]"
+    end
+
+    c = Card["Joe Card"]
+    c.update_attributes! name: "Card of Joe", update_referers: true
+    assert_equal "[[Card of Joe]]", Card["Admin Card"].content
+  end
+
+  it "test_rename_should_update_structured_referer" do
+    Card::Auth.as_bot do
+      c = Card.create! name: "Pit"
+      Card.create! name: "Orange", type: "Fruit", content: "[[Pit]]"
+      Card.create! name: "Fruit+*type+*structure", content: "this [[Pit]]"
+
+      assert_equal "this [[Pit]]", Card["Orange"].raw_content
+      c.update_attributes! name: "Seed", update_referers: true
+      assert_equal "this [[Seed]]", Card["Orange"].raw_content
+    end
+  end
+
+  it "handles plus cards that have children" do
+    assert_rename Card["a+b"], "e+f"
+  end
+
+  context "self references" do
+    example "renaming card with self link should nothang" do
+      update "self aware", name: "buttah", update_referers: true
+      expect_content_of("Buttah").to eq "[[/new/{{_self|name}}|new]]"
+    end
+
+    it "renames card without updating references" do
+      update "self aware", name: "Newt", update_referers: false
+      expect_content_of("Newt").to eq "[[/new/{{_self|name}}|new]]"
+    end
+  end
+
+  context "references" do
+    it "updates nests" do
+      update "Blue", name: "Red", update_referers: true
+      expect_content_of("blue includer 1").to eq "{{Red}}"
+      expect_content_of("blue includer 2").to eq "{{Red|closed;other:stuff}}"
+    end
+
+    it "tupdates nests when renaming to plus" do
+      update "Blue", name: "blue includer 1+color", update_referers: true
+      expect_content_of("blue includer 1").to eq "{{blue includer 1+color}}"
+    end
+
+    it "reference updates on case variants" do
+      update "Blue", name: "Red", update_referers: true
+      expect_content_of("blue linker 1").to eq "[[Red]]"
+      expect_content_of("blue linker 2").to eq "[[Red]]"
+    end
+
+    example "reference updates plus to simple" do
+      assert_rename Card["A+B"], "schmuck"
+      expect_content_of("X").to eq "[[A]] [[schmuck]] [[T]]"
+    end
+
+    it "substitutes name part" do
+      c1 = Card["A+B"]
+      assert_rename Card["B"], "buck"
+      expect(Card.find(c1.id).name).to eq "A+buck"
+    end
+  end
+end

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

@@ -5,40 +5,45 @@
 # a quarter of its current length
 
 describe Card do
+  RSpec::Matchers.define :have_toc do
+    match do |card|
+      values_match?(/Table of Contents/, card.format.render_open_content)
+    end
+  end
+
+  let(:c1) { described_class["Onne Heading"] }
+  let(:c2) { described_class["Twwo Heading"] }
+  let(:c3) { described_class["Three Heading"] }
+  let(:rule_card) { c1.rule_card(:table_of_contents) }
+
   context "when there is a general toc rule of 2" do
     before do
       Card::Auth.as_bot do
         described_class.create! name: "Basic+*type+*table of contents", content: "2"
       end
-      expect(@c1 = described_class["Onne Heading"]).to be
-      expect(@c2 = described_class["Twwo Heading"]).to be
-      expect(@c3 = described_class["Three Heading"]).to be
-      expect(@c1.type_id).to eq(Card::BasicID)
-      expect(@rule_card = @c1.rule_card(:table_of_contents)).to be
+    end
+
+    specify do
+      expect(c1.type_id).to eq(Card::BasicID)
+      expect(rule_card).to be_a Card
     end
 
     describe ".rule" do
       it "has a value of 2" do
-        expect(@rule_card.content).to eq("2")
-        expect(@c1.rule(:table_of_contents)).to eq("2")
+        expect(rule_card.content).to eq("2")
+        expect(c1.rule(:table_of_contents)).to eq("2")
       end
     end
 
     describe "renders with/without toc" do
       it "does not render for 'Onne Heading'" do
-        expect(@c1.format.render_open_content).not_to match(/Table of Contents/)
+        expect(c1).not_to have_toc
       end
       it "renders for 'Twwo Heading'" do
-        expect(@c2.format.render_open_content).to match(/Table of Contents/)
+        expect(c2).to have_toc
       end
       it "renders for 'Three Heading'" do
-        expect(@c3.format.render_open_content).to match(/Table of Contents/)
-      end
-    end
-
-    describe ".rule_card" do
-      it "get the same card without the * and singular" do
-        expect(@c1.rule_card(:table_of_contents)).to eq(@rule_card)
+        expect(c3).to have_toc
       end
     end
 
@@ -81,31 +86,26 @@ describe Card do
 
   context "when I change the general toc setting to 1" do
     before do
-      expect(@c1 = described_class["Onne Heading"]).to be
-      expect(@c2 = described_class["Twwo Heading"]).to be
-      expect(@c1.type_id).to eq(Card::BasicID)
-      expect(@rule_card = @c1.rule_card(:table_of_contents)).to be
-      @rule_card.content = "1"
+      rule_card.content = "1"
     end
 
     describe ".rule" do
       it "has a value of 1" do
-        expect(@rule_card.content).to eq("1")
-        expect(@c1.rule(:table_of_contents)).to eq("1")
+        expect(c1.rule(:table_of_contents)).to eq("1")
       end
     end
 
     describe "renders with/without toc" do
       it "does not render toc for 'Onne Heading'" do
-        expect(@c1.format.render_open_content).to match(/Table of Contents/)
+        expect(c1).to have_toc
       end
       it "renders toc for 'Twwo Heading'" do
-        expect(@c2.format.render_open_content).to match(/Table of Contents/)
+        expect(c2).to have_toc
       end
       it "does not render for 'Twwo Heading' when changed to 3" do
-        @rule_card.content = "3"
-        expect(@c2.rule(:table_of_contents)).to eq("3")
-        expect(@c2.format.render_open_content).not_to match(/Table of Contents/)
+        rule_card.content = "3"
+        expect(c2.rule(:table_of_contents)).to eq("3")
+        expect(c2).not_to have_toc
       end
     end
   end
@@ -138,13 +138,13 @@ describe Card do
 
     describe "renders without toc" do
       it "does not render for 'Onne Heading'" do
-        expect(@c1.format.render_open_content).not_to match(/Table of Contents/)
+        expect(@c1).not_to have_toc
       end
       it "renders for 'Twwo Heading'" do
-        expect(@c2.format.render_open_content).not_to match(/Table of Contents/)
+        expect(@c2).not_to have_toc
       end
       it "renders for 'Three Heading'" do
-        expect(@c3.format.render_open_content).not_to match(/Table of Contents/)
+        expect(@c3).not_to have_toc
       end
     end
 
@@ -199,48 +199,44 @@ describe Card do
 
     describe "renders with/without toc" do
       it "does not render for 'Onne Heading'" do
-        expect(@c1.format.render_open_content).not_to match(/Table of Contents/)
+        expect(@c1).not_to have_toc
       end
       it "renders for 'Twwo Heading'" do
         expect(@c2.rule(:table_of_contents)).to eq("2")
-        expect(@c2.format.render_open_content).to match(/Table of Contents/)
+        expect(@c2).to have_toc
       end
       it "renders for 'Three Heading'" do
-        expect(@c3.format.render_open_content).to match(/Table of Contents/)
+        expect(@c3).to have_toc
       end
     end
   end
-  # end
 
   context "when I change the general toc setting to 1" do
+    let(:c1) { described_class["Onne Heading"] }
+    let(:c2) { described_class["Twwo Heading"] }
+    let(:rule_card) { c1.rule_card(:table_of_contents) }
+
     before do
-      expect(@c1 = described_class["Onne Heading"]).to be
-      # FIXME: CardtypeE should inherit from *default => Basic
-      # @c2 = Card.create name: 'toc2', type: "CardtypeE",
-      #                   content: Card['Twwo Heading'].content
-      expect(@c2 = described_class["Twwo Heading"]).to be
-      expect(@c1.type_id).to eq(Card::BasicID)
-      expect(@rule_card = @c1.rule_card(:table_of_contents)).to be
-      @rule_card.content = "1"
+      rule_card.content = "1"
     end
 
     describe ".rule" do
       it "has a value of 1" do
-        expect(@rule_card.content).to eq("1")
-        expect(@c1.rule(:table_of_contents)).to eq("1")
+        expect(rule_card.content).to eq("1")
+        expect(c1.rule(:table_of_contents)).to eq("1")
       end
     end
 
     describe "renders with/without toc" do
       it "does not render toc for 'Onne Heading'" do
-        expect(@c1.format.render_open_content).to match(/Table of Contents/)
+        expect(c1).to have_toc
       end
       it "renders toc for 'Twwo Heading'" do
-        expect(@c2.format.render_open_content).to match(/Table of Contents/)
+        expect(c2).to have_toc
       end
       it "does not render for 'Twwo Heading' when changed to 3" do
-        @rule_card.content = "3"
-        expect(@c2.format.render_open_content).not_to match(/Table of Contents/)
+        rule_card.content = "3"
+        expect(c2).not_to have_toc
       end
     end
   end