card 1.101.3 → 1.101.4

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

@@ -1,100 +0,0 @@
-# -*- encoding : utf-8 -*-
-
-RSpec.describe Card::Set::All::Rules do
-  before do
-    Card::Auth.signin Card::WagnBotID
-  end
-
-  describe "setting data setup" do
-    it "makes Set of +*type" do
-      Card.create! name: "SpeciForm", type: "Cardtype"
-      expect(Card.create!(name: "SpeciForm+*type").type_code).to eq(:set)
-    end
-  end
-
-  describe "#rule" do
-    it "retrieves Set based value" do
-      Card.create name: "Book+*type+*help", content: "authorize"
-      help_rule = Card.new(type: "Book").rule(:help)
-      expect(help_rule).to eq("authorize")
-    end
-
-    it "retrieves single values" do
-      Card.create! name: "banana+*self+*help", content: "pebbles"
-      expect(Card["banana"].rule(:help)).to eq("pebbles")
-    end
-  end
-
-  describe "#setting_codenames_by_group" do
-    before do
-      @pointer_settings = %i[options options_label input]
-    end
-    it "doesn't fail on nonexistent trunks" do
-      codenames = Card.new(name: "foob+*right").setting_codenames_by_group
-      expect(codenames.class).to eq(Hash)
-    end
-
-    it "returns universal setting names for non-pointer set" do
-      skip "Different api, we should just put the tests in a new spec for that"
-      snbg = Card.fetch("*star").setting_codenames_by_group
-      # warn "snbg #{snbg.class} #{snbg.inspect}"
-      expect(snbg.keys.length).to eq(4)
-      expect(snbg.keys.first).to be_a Symbol
-      expect(snbg.keys.member?(:pointer)).not_to be_truthy
-    end
-  end
-
-  describe "user specific rules" do
-    before do
-      Card::Auth.signin "Joe User"
-    end
-
-    it "user rule is recognized as rule" do
-      Card::Auth.as_bot do
-        card = Card.create name: "Book+*type+Joe User+*follow",
-                           content: "[[*always]]"
-        expect(card.is_rule?).to be_truthy
-      end
-    end
-
-    it "retrieves Set based value" do
-      Card::Auth.as_bot do
-        Card.create name: "Book+*type+Joe User+*follow", content: "[[*always]]"
-      end
-      expect(Card.new(type: "Book").preference(:follow)).to eq("[[*always]]")
-    end
-
-    it "retrieves user independent Set based value" do
-      Card::Auth.as_bot do
-        Card.create name: "Book+*type+*all+*follow", content: "[[Home]]"
-      end
-      expect(Card.new(type: "Book").preference(:follow)).to eq("[[Home]]")
-    end
-
-    it "uses *all user rule when no super.s"
-
-    it "user-specific value overwrites user-independent value" do
-      Card::Auth.as_bot do
-        Card.create name: "Book+*type+Joe User+*follow", content: "[[*never]]"
-        Card.create name: "Book+*type+*all+*follow", content: "[[*always]]"
-      end
-      expect(Card.new(type: "Book").preference(:follow)).to eq("[[*never]]")
-    end
-
-    describe "#all_user_ids_with_rule_for" do
-      it "returns all user with values for the given Set and rule" do
-        Card::Auth.as_bot do
-          Card.create(name: "Book+*type+Joe User+*follow", content: "[[Home]]")
-          Card::Auth.signin "Joe Admin"
-          Card.create(name: "Book+*type+Joe Admin+*follow", content: "[[Home]]")
-          user_ids = Card::Rule.all_user_ids_with_rule_for(
-            Card.fetch("Book+*type"), :follow
-          )
-          expect(user_ids.sort).to eq(
-            [Card["Joe User"].id, Card["Joe Admin"].id].sort
-          )
-        end
-      end
-    end
-  end
-end

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

@@ -1,102 +0,0 @@
-RSpec.describe Card::Set::All::Subcards 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
-
-  class Card
-    def __current_trans
-      @current_trans = ActiveRecord::Base.connection.current_transaction
-    end
-
-    def __record_names reset=false
-      trans = @current_trans && !reset ? @current_trans : __current_trans
-      trans.records&.map { |r| r.try :name }&.compact
-    end
-  end
-
-  describe "add subcards" do
-    context "when in integrate stage" do
-      context "with default subcard handling" do
-        it "processes all cards in one transaction" do
-          with_test_events do
-            test_event :validate, on: :create, for: "main card" do
-              add_subcard("sub card")
-            end
-
-            test_event :finalize, on: :create, for: "main card" do
-              expect(__record_names).to eq ["main card", "sub card"]
-            end
-
-            create_card
-          end
-        end
-      end
-
-      context "with delayed jobs" do
-        before { Cardio.delaying! }
-        after { Cardio.delaying! :off }
-
-        context "with serial subcard handling" do
-          it "director.delay! processes subcards in separate transaction" do
-            with_test_events do
-              test_event :validate, on: :create, for: "main card" do
-                sc = add_subcard("sub card")
-                sc.director.delay!
-              end
-
-              test_event :finalize, on: :create, for: "main card" do
-                expect(__record_names(true)).to eq ["main card"]
-                expect(subcard("sub card").director.stage).to eq nil
-              end
-
-              test_event :integrate, on: :create, for: "main card" do
-                expect(__record_names(true)).to eq(nil)
-                expect(subcard("sub card").director.stage).to eq nil
-              end
-
-              test_event :finalize, on: :create, for: "sub card" do
-                expect(__record_names(true)).to eq ["sub card"]
-              end
-
-              test_event :integrate_with_delay, on: :create do
-                expect(__record_names(true)).to eq(nil)
-              end
-              create_card
-              expect(Delayed::Worker.new.work_off).to eq [2, 0]
-              expect(Card["sub card"]).to be_instance_of(Card)
-            end
-          end
-        end
-      end
-
-      describe "in integrate_with_delay stage" do
-        it "processes cards not in the same transaction" do
-          with_test_events do
-            test_event :integrate_with_delay, on: :create, for: "main card" do
-              Card.create! name: "sub create card"
-              add_subcard("sub card")
-            end
-
-            test_event :finalize, on: :create, for: "main card" do
-              __current_trans
-            end
-
-            main_card = create_card
-            Delayed::Worker.new.work_off
-
-            expect(main_card.__record_names).to eq ["main card"]
-            expect(Card["sub card"]).to exist
-            expect(Card["sub create card"]).to exist
-
-            act_of_main = main_card.acts.last
-            expect(act_of_main).to eq Card["sub create card"].actions.last.act
-            expect(act_of_main).to eq Card["sub card"].actions.last.act
-          end
-        end
-      end
-    end
-  end
-end