pg_trunk 0.1.0 → 0.2.0

data/spec/operations/rules/rename_rule_spec.rb

@@ -0,0 +1,148 @@
+# frozen_string_literal: true
+
+describe ActiveRecord::Migration, "#rename_rule" do
+  before_all do
+    run_migration <<~RUBY
+      create_table :users do |t|
+        t.string :name
+      end
+    RUBY
+  end
+  before { run_migration(old_snippet) }
+
+  context "when a rule was named" do
+    let(:old_snippet) do
+      <<~RUBY
+        create_rule "users", "prevent_insertion" do |r|
+          r.event :insert
+          r.kind :instead
+          r.comment "Prevent insertion to users"
+        end
+      RUBY
+    end
+
+    context "with a new name" do
+      let(:migration) do
+        <<~RUBY
+          rename_rule "users", "prevent_insertion", to: "do_nothing"
+        RUBY
+      end
+      let(:new_snippet) do
+        <<~RUBY
+          create_rule "users", "do_nothing" do |r|
+            r.event :insert
+            r.kind :instead
+            r.comment "Prevent insertion to users"
+          end
+        RUBY
+      end
+
+      its(:execution) { is_expected.to remove(old_snippet).from_schema }
+      its(:execution) { is_expected.to insert(new_snippet).into_schema }
+      its(:inversion) { is_expected.not_to change_schema }
+    end
+
+    context "with the same name" do
+      let(:migration) do
+        <<~RUBY
+          rename_rule "users", "prevent_insertion", to: "prevent_insertion"
+        RUBY
+      end
+
+      it { is_expected.to fail_validation.because(/new name must be different/i) }
+    end
+
+    context "without new name" do
+      let(:migration) do
+        <<~RUBY
+          rename_rule "users", "prevent_insertion" do |r|
+            r.event :insert
+            r.kind :instead
+          end
+        RUBY
+      end
+      let(:new_snippet) do
+        <<~RUBY
+          create_rule "users" do |r|
+            r.event :insert
+            r.kind :instead
+            r.comment "Prevent insertion to users"
+          end
+        RUBY
+      end
+
+      its(:execution) { is_expected.to remove(old_snippet).from_schema }
+      its(:execution) { is_expected.to insert(new_snippet).into_schema }
+      its(:inversion) { is_expected.not_to change_schema }
+    end
+
+    context "when absent name can't be generated from kind/event" do
+      let(:migration) do
+        <<~RUBY
+          rename_rule "users", "prevent_insertion"
+        RUBY
+      end
+
+      it { is_expected.to fail_validation.because(/new name can't be blank/i) }
+    end
+  end
+
+  context "when a rule was anonymous" do
+    let(:old_snippet) do
+      <<~RUBY
+        create_rule "users" do |r|
+          r.event :insert
+          r.kind :instead
+          r.comment "Prevent insertion to users"
+        end
+      RUBY
+    end
+
+    context "with a new name" do
+      let(:migration) do
+        <<~RUBY
+          rename_rule "users", to: "do_nothing" do |r|
+            r.event :insert
+            r.kind :instead
+          end
+        RUBY
+      end
+      let(:new_snippet) do
+        <<~RUBY
+          create_rule "users", "do_nothing" do |r|
+            r.event :insert
+            r.kind :instead
+            r.comment "Prevent insertion to users"
+          end
+        RUBY
+      end
+
+      its(:execution) { is_expected.to remove(old_snippet).from_schema }
+      its(:execution) { is_expected.to insert(new_snippet).into_schema }
+      its(:inversion) { is_expected.not_to change_schema }
+    end
+
+    context "without new name" do
+      let(:migration) do
+        <<~RUBY
+          rename_rule "users" do |r|
+            r.event :insert
+            r.kind :instead
+          end
+        RUBY
+      end
+
+      it { is_expected.to fail_validation.because(/new name must be different/i) }
+    end
+
+    context "when absent name can't be generated" do
+      let(:migration) do
+        <<~RUBY
+          rename_rule "users", to: "do_nothing"
+        RUBY
+      end
+
+      it { is_expected.to fail_validation.because(/name can't be blank/i) }
+    end
+  end
+end

data/spec/operations/sequences/change_sequence_spec.rb

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+describe ActiveRecord::Migration, "#change_sequence" do
+  before { run_migration(old_snippet) }
+
+  let(:old_snippet) do
+    <<~RUBY
+      create_sequence "global_num", as: "integer" do |s|
+        s.increment_by 2
+        s.min_value 0
+        s.max_value 2000
+        s.start_with 1
+        s.cache 10
+        s.cycle true
+        s.comment "Sequence for global numbers (odds then evens)"
+      end
+    RUBY
+  end
+
+  context "with reversible changes" do
+    let(:migration) do
+      <<~RUBY
+        change_sequence "global_num" do |s|
+          s.type "bigint", from: "integer"
+          s.increment_by 3, from: 2
+          s.min_value 1, from: 0
+          s.max_value 3000, from: 2000
+          s.start_with 2, from: 1
+          s.cache 20, from: 10
+          s.cycle false
+          s.comment "Global numbers", from: "Sequence for global numbers (odds then evens)"
+        end
+      RUBY
+    end
+    let(:new_snippet) do
+      <<~RUBY
+        create_sequence "global_num" do |s|
+          s.increment_by 3
+          s.max_value 3000
+          s.start_with 2
+          s.cache 20
+          s.comment "Global numbers"
+        end
+      RUBY
+    end
+
+    its(:execution) { is_expected.to remove(old_snippet).from_schema }
+    its(:execution) { is_expected.to insert(new_snippet).into_schema }
+    its(:inversion) { is_expected.not_to change_schema }
+  end
+
+  context "with irreversible changes" do
+    let(:migration) do
+      <<~RUBY
+        change_sequence "global_num" do |s|
+          s.type "bigint"
+          s.increment_by 3
+          s.min_value 1
+          s.max_value 3000
+          s.start_with 2
+          s.cache 20
+          s.cycle false
+          s.comment "Global numbers"
+        end
+      RUBY
+    end
+    let(:new_snippet) do
+      <<~RUBY
+        create_sequence "global_num" do |s|
+          s.increment_by 3
+          s.max_value 3000
+          s.start_with 2
+          s.cache 20
+          s.comment "Global numbers"
+        end
+      RUBY
+    end
+
+    its(:execution) { is_expected.to remove(old_snippet).from_schema }
+    its(:execution) { is_expected.to insert(new_snippet).into_schema }
+    it { is_expected.to be_irreversible.because_of(/undefined values to revert/i) }
+  end
+
+  context "when sequence was absent" do
+    let(:old_snippet) { "" }
+
+    context "without the `:if_exists` option" do
+      let(:migration) do
+        <<~RUBY
+          change_sequence "global_num" do |s|
+            s.comment "Global numbers"
+          end
+        RUBY
+      end
+
+      its(:execution) { is_expected.to raise_error(StandardError) }
+    end
+
+    context "with the `if_exists: true` option" do
+      let(:migration) do
+        <<~RUBY
+          change_sequence "global_num", if_exists: true do |s|
+            s.comment "Global numbers"
+          end
+        RUBY
+      end
+
+      its(:execution) { is_expected.not_to change_schema }
+      it { is_expected.to be_irreversible.because_of(/if_exists: true/i) }
+    end
+  end
+
+  context "without changes" do
+    let(:migration) do
+      <<~RUBY
+        change_sequence "global_num"
+      RUBY
+    end
+
+    it { is_expected.to fail_validation.because(/changes can't be blank/i) }
+  end
+
+  context "without a name" do
+    let(:migration) do
+      <<~RUBY
+        change_sequence do |s|
+          s.comment "Global numbers"
+        end
+      RUBY
+    end
+
+    it { is_expected.to fail_validation.because(/name can't be blank/i) }
+  end
+end

data/spec/operations/sequences/create_sequence_spec.rb

@@ -0,0 +1,156 @@
+# frozen_string_literal: true
+
+describe ActiveRecord::Migration, "#create_sequence" do
+  before_all do
+    run_migration <<~RUBY
+      create_schema :app
+
+      create_table :customers do |t|
+        t.bigint :global_num
+      end
+    RUBY
+  end
+
+  context "with a minimal definition" do
+    let(:migration) do
+      <<~RUBY
+        create_sequence "app.global_num"
+      RUBY
+    end
+
+    its(:execution) { is_expected.to insert(migration).into_schema }
+    its(:inversion) { is_expected.not_to change_schema }
+  end
+
+  context "with a table-agnostic definition" do
+    let(:migration) do
+      <<~RUBY
+        create_sequence "app.global_num", as: "integer" do |s|
+          s.increment_by 2
+          s.min_value 0
+          s.max_value 2000
+          s.start_with 1
+          s.cache 10
+          s.cycle true
+          s.comment "Sequence for global numbers (odds then evens)"
+        end
+      RUBY
+    end
+
+    its(:execution) { is_expected.to insert(migration).into_schema }
+    its(:inversion) { is_expected.not_to change_schema }
+  end
+
+  context "with a column-specific definition" do
+    let(:migration) do
+      <<~RUBY
+        create_sequence "global_num" do |s|
+          s.owned_by "customers", "global_num"
+          s.increment_by 2
+          s.min_value 0
+          s.max_value 2000
+          s.start_with 1
+          s.cache 10
+          s.cycle true
+          s.comment "Sequence for customers global_num"
+        end
+      RUBY
+    end
+
+    its(:execution) { is_expected.to insert(migration).into_schema }
+    its(:inversion) { is_expected.not_to change_schema }
+  end
+
+  context "when the sequence existed" do
+    before { run_migration(migration) }
+
+    context "without the `:if_not_exists` option" do
+      let(:migration) do
+        <<~RUBY
+          create_sequence "app.global_num"
+        RUBY
+      end
+
+      its(:execution) { is_expected.to raise_error(StandardError) }
+    end
+
+    context "with the `if_not_exists: true` option" do
+      let(:migration) do
+        <<~RUBY
+          create_sequence "app.global_num", if_not_exists: true
+        RUBY
+      end
+      let(:snippet) do
+        <<~RUBY
+          create_sequence "app.global_num"
+        RUBY
+      end
+
+      its(:execution) { is_expected.not_to change_schema }
+      it { is_expected.to be_irreversible.because_of(/if_not_exists: true/i) }
+    end
+  end
+
+  context "with a zero increment" do
+    let(:migration) do
+      <<~RUBY
+        create_sequence "app.global_number", increment_by: 0
+      RUBY
+    end
+
+    it { is_expected.to fail_validation.because(/increment must not be zero/i) }
+  end
+
+  context "with invalid min..max range" do
+    let(:migration) do
+      <<~RUBY
+        create_sequence "app.global_number", min_value: 2, max_value: 1
+      RUBY
+    end
+
+    it { is_expected.to fail_validation.because(/min value must not exceed max value/i) }
+  end
+
+  context "with start value out of min..max range" do
+    let(:migration) do
+      <<~RUBY
+        create_sequence "app.global_number",
+                        min_value: 0,
+                        max_value: 10,
+                        start_with: -1
+      RUBY
+    end
+
+    it { is_expected.to fail_validation.because(/start value cannot be less than min value/i) }
+  end
+
+  context "with a zero cache" do
+    let(:migration) do
+      <<~RUBY
+        create_sequence "app.global_number", cache: 0
+      RUBY
+    end
+
+    it { is_expected.to fail_validation.because(/cache must be greater than or equal to 1/i) }
+  end
+
+  context "with a wrong type" do
+    let(:migration) do
+      <<~RUBY
+        create_sequence "app.global_number", as: "text"
+      RUBY
+    end
+
+    its(:execution) { is_expected.to raise_error(StandardError) }
+  end
+
+  context "without a name" do
+    let(:migration) do
+      <<~RUBY
+        create_sequence
+      RUBY
+    end
+
+    it { is_expected.to fail_validation.because(/name can't be blank/i) }
+  end
+end

data/spec/operations/sequences/drop_sequence_spec.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+describe ActiveRecord::Migration, "#drop_sequence" do
+  before_all { run_migration("create_schema :app") }
+  before { run_migration(old_snippet) }
+
+  let(:old_snippet) do
+    <<~RUBY
+      create_sequence "app.global_num", as: "integer" do |s|
+        s.increment_by 2
+        s.min_value 0
+        s.max_value 2000
+        s.start_with 1
+        s.cache 10
+        s.cycle true
+        s.comment "Sequence for global numbers (odds then evens)"
+      end
+    RUBY
+  end
+
+  context "with a full definition" do
+    let(:migration) do
+      <<~RUBY
+        drop_sequence "app.global_num", as: "integer" do |s|
+          s.increment_by 2
+          s.min_value 0
+          s.max_value 2000
+          s.start_with 1
+          s.cache 10
+          s.cycle true
+          s.comment "Sequence for global numbers (odds then evens)"
+        end
+      RUBY
+    end
+
+    its(:execution) { is_expected.to remove(old_snippet).from_schema }
+    its(:inversion) { is_expected.not_to change_schema }
+  end
+
+  context "with a minimal definition" do
+    let(:migration) do
+      <<~RUBY
+        drop_sequence "app.global_num"
+      RUBY
+    end
+    let(:new_snippet) do
+      <<~RUBY
+        create_sequence "app.global_num"
+      RUBY
+    end
+
+    its(:execution) { is_expected.to remove(old_snippet).from_schema }
+    its(:inversion) { is_expected.to remove(old_snippet).from_schema }
+    its(:inversion) { is_expected.to insert(new_snippet).into_schema }
+  end
+
+  context "when the sequence was absent" do
+    before { run_migration(migration) }
+
+    context "without the `:if_exists` option" do
+      let(:migration) do
+        <<~RUBY
+          drop_sequence "app.global_num"
+        RUBY
+      end
+
+      its(:execution) { is_expected.to raise_error(StandardError) }
+    end
+
+    context "with the `if_exists: true` option" do
+      let(:migration) do
+        <<~RUBY
+          drop_sequence "app.global_num", if_exists: true
+        RUBY
+      end
+
+      its(:execution) { is_expected.not_to change_schema }
+      it { is_expected.to be_irreversible.because_of(/if_exists: true/i) }
+    end
+  end
+
+  context "with the force: :cascade option" do
+    let(:migration) do
+      <<~RUBY
+        drop_sequence "app.global_num", force: :cascade
+      RUBY
+    end
+
+    its(:execution) { is_expected.to remove(old_snippet).from_schema }
+    it { is_expected.to be_irreversible.because_of(/force: :cascade/i) }
+  end
+
+  context "without a name" do
+    let(:migration) do
+      <<~RUBY
+        drop_sequence
+      RUBY
+    end
+
+    it { is_expected.to fail_validation.because(/name can't be blank/i) }
+  end
+end

data/spec/operations/sequences/rename_sequence_spec.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+describe ActiveRecord::Migration, "#rename_sequence" do
+  before_all { run_migration "create_schema :seq" }
+  before { run_migration(old_snippet) }
+
+  let(:old_snippet) do
+    <<~RUBY
+      create_sequence "global_num" do |s|
+        s.increment_by 2
+        s.min_value 0
+        s.max_value 2000
+        s.start_with 1
+        s.cache 10
+        s.cycle true
+        s.comment "Sequence for global numbers (odds then evens)"
+      end
+    RUBY
+  end
+
+  context "with a new name" do
+    let(:migration) do
+      <<~RUBY
+        rename_sequence "global_num", to: "seq.global_number"
+      RUBY
+    end
+    let(:new_snippet) do
+      <<~RUBY
+        create_sequence "seq.global_number" do |s|
+          s.increment_by 2
+          s.min_value 0
+          s.max_value 2000
+          s.start_with 1
+          s.cache 10
+          s.cycle true
+          s.comment "Sequence for global numbers (odds then evens)"
+        end
+      RUBY
+    end
+
+    its(:execution) { is_expected.to remove(old_snippet).from_schema }
+    its(:execution) { is_expected.to insert(new_snippet).into_schema }
+    its(:inversion) { is_expected.not_to change_schema }
+  end
+
+  context "when sequence was absent" do
+    let(:old_snippet) { "" }
+
+    context "without the `:if_exists` option" do
+      let(:migration) do
+        <<~RUBY
+          rename_sequence "global_num", to: "global_number"
+        RUBY
+      end
+
+      its(:execution) { is_expected.to raise_error(StandardError) }
+    end
+
+    context "with the `if_exists: true` option" do
+      let(:migration) do
+        <<~RUBY
+          rename_sequence "global_num", to: "global_number", if_exists: true
+        RUBY
+      end
+
+      its(:execution) { is_expected.not_to change_schema }
+      it { is_expected.to be_irreversible.because_of(/if_exists: true/i) }
+    end
+  end
+
+  context "with the same name" do
+    let(:migration) do
+      <<~RUBY
+        rename_sequence "global_num", to: "global_num"
+      RUBY
+    end
+
+    it { is_expected.to fail_validation.because(/new name must be different/i) }
+  end
+
+  context "without new name" do
+    let(:migration) do
+      <<~RUBY
+        rename_sequence "global_num"
+      RUBY
+    end
+
+    it { is_expected.to fail_validation.because(/new name can't be blank/i) }
+  end
+
+  context "without current name" do
+    let(:migration) do
+      <<~RUBY
+        rename_sequence to: "seq.global_number"
+      RUBY
+    end
+
+    it { is_expected.to fail_validation.because(/name can't be blank/i) }
+  end
+end