pg_trunk 0.1.0

data/spec/operations/domains/change_domain_spec.rb

@@ -0,0 +1,287 @@
+# frozen_string_literal: true
+
+describe ActiveRecord::Migration, "#change_domain" do
+  before_all { run_migration "create_schema :dict" }
+  before { run_migration(old_snippet) }
+
+  let(:old_snippet) do
+    <<~RUBY
+      create_domain "dict.us_postal_code", as: "text" do |d|
+        d.collation "en_US"
+        d.default_sql "'00000'::text"
+        d.null false
+        d.constraint %q(VALUE ~ '^\\d{5}(-\\d{4})?$'::text), name: "valid_code"
+        d.comment "US postal code"
+      end
+    RUBY
+  end
+
+  context "when not null constraint is changed" do
+    let(:migration) do
+      <<~RUBY
+        change_domain "dict.us_postal_code" do |d|
+          d.null true
+        end
+      RUBY
+    end
+    let(:new_snippet) do
+      <<~RUBY
+        create_domain "dict.us_postal_code", as: "text" do |d|
+          d.collation "en_US"
+          d.default_sql "'00000'::text"
+          d.constraint %q(VALUE ~ '^\\d{5}(-\\d{4})?$'::text), name: "valid_code"
+          d.comment "US postal code"
+        end
+      RUBY
+    end
+    let(:query) { "SELECT NULL::dict.us_postal_code;" }
+
+    its(:execution) { is_expected.to enable_sql_request(query) }
+    its(:execution) { is_expected.to remove(old_snippet).from_schema }
+    its(:execution) { is_expected.to insert(new_snippet).into_schema }
+
+    its(:inversion) { is_expected.to disable_sql_request(query) }
+    its(:inversion) { is_expected.not_to change_schema }
+  end
+
+  context "when new constraint is added" do
+    let(:migration) do
+      <<~RUBY
+        change_domain "dict.us_postal_code" do |d|
+          d.add_constraint %q(VALUE ~ '^\\d{5}$'::text), name: "new_check"
+        end
+      RUBY
+    end
+    let(:new_snippet) do
+      <<~RUBY
+        create_domain "dict.us_postal_code", as: "text" do |d|
+          d.collation "en_US"
+          d.default_sql "'00000'::text"
+          d.null false
+          d.constraint %q(VALUE ~ '^\\d{5}$'::text), name: "new_check"
+          d.constraint %q(VALUE ~ '^\\d{5}(-\\d{4})?$'::text), name: "valid_code"
+          d.comment "US postal code"
+        end
+      RUBY
+    end
+    let(:query) { "SELECT '00000-0000'::dict.us_postal_code;" }
+
+    its(:execution) { is_expected.to disable_sql_request(query) }
+    its(:execution) { is_expected.to remove(old_snippet).from_schema }
+    its(:execution) { is_expected.to insert(new_snippet).into_schema }
+
+    its(:inversion) { is_expected.to enable_sql_request(query) }
+    its(:inversion) { is_expected.not_to change_schema }
+  end
+
+  context "when existing constraint is dropped with :check option" do
+    let(:migration) do
+      <<~RUBY
+        change_domain "dict.us_postal_code" do |d|
+          d.drop_constraint "valid_code", check: %q(VALUE ~ '^\\d{5}(-\\d{4})?$'::text)
+        end
+      RUBY
+    end
+    let(:new_snippet) do
+      <<~RUBY
+        create_domain "dict.us_postal_code", as: "text" do |d|
+          d.collation "en_US"
+          d.default_sql "'00000'::text"
+          d.null false
+          d.comment "US postal code"
+        end
+      RUBY
+    end
+    let(:query) { "SELECT 'foobar'::dict.us_postal_code;" }
+
+    its(:execution) { is_expected.to enable_sql_request(query) }
+    its(:execution) { is_expected.to remove(old_snippet).from_schema }
+    its(:execution) { is_expected.to insert(new_snippet).into_schema }
+
+    its(:inversion) { is_expected.to disable_sql_request(query) }
+    its(:inversion) { is_expected.not_to change_schema }
+  end
+
+  context "with `force: :cascade` option" do
+    let(:migration) do
+      <<~RUBY
+        change_domain "dict.us_postal_code", force: :cascade do |d|
+          d.drop_constraint "valid_code", check: %q(VALUE ~ '^\\d{5}(-\\d{4})?$'::text)
+        end
+      RUBY
+    end
+    let(:new_snippet) do
+      <<~RUBY
+        create_domain "dict.us_postal_code", as: "text" do |d|
+          d.collation "en_US"
+          d.default_sql "'00000'::text"
+          d.null false
+          d.comment "US postal code"
+        end
+      RUBY
+    end
+    let(:query) { "SELECT '00000-0000'::dict.us_postal_code;" }
+
+    its(:execution) { is_expected.to enable_sql_request(query) }
+    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(/force: :cascade/i) }
+  end
+
+  context "when existing constraint is dropped without :check option" do
+    let(:migration) do
+      <<~RUBY
+        change_domain "dict.us_postal_code" do |d|
+          d.drop_constraint "valid_code"
+        end
+      RUBY
+    end
+    let(:new_snippet) do
+      <<~RUBY
+        create_domain "dict.us_postal_code", as: "text" do |d|
+          d.collation "en_US"
+          d.default_sql "'00000'::text"
+          d.null false
+          d.comment "US postal code"
+        end
+      RUBY
+    end
+    let(:query) { "SELECT '00000-0000'::us_postal_code;" }
+
+    its(:execution) { is_expected.to disable_sql_request(query) }
+    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(/check/i) }
+  end
+
+  context "when absent constraint is dropped without :if_exists option" do
+    let(:migration) do
+      <<~RUBY
+        change_domain "dict.us_postal_code" do |d|
+          d.drop_constraint "foo"
+        end
+      RUBY
+    end
+
+    its(:execution) { is_expected.to raise_error(StandardError) }
+  end
+
+  context "when absent constraint is dropped with `if_exists: true` option" do
+    let(:migration) do
+      <<~RUBY
+        change_domain "dict.us_postal_code" do |d|
+          d.drop_constraint "foo", if_exists: true
+        end
+      RUBY
+    end
+
+    its(:execution) { is_expected.not_to change_schema }
+    it { is_expected.to be_irreversible.because_of(/if_exists: true/i) }
+  end
+
+  context "when default_sql value is changed with :from option" do
+    let(:migration) do
+      <<~RUBY
+        change_domain "dict.us_postal_code" do |d|
+          d.default_sql "'11111-0000'", from: "'00000'"
+        end
+      RUBY
+    end
+    let(:new_snippet) do
+      <<~RUBY
+        create_domain "dict.us_postal_code", as: "text" do |d|
+          d.collation "en_US"
+          d.default_sql "'11111-0000'::text"
+          d.null false
+          d.constraint %q(VALUE ~ '^\\d{5}(-\\d{4})?$'::text), name: "valid_code"
+          d.comment "US postal code"
+        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 default_sql value is changed without :from option" do
+    let(:migration) do
+      <<~RUBY
+        change_domain "dict.us_postal_code" do |d|
+          d.default_sql "'11111-0000'"
+        end
+      RUBY
+    end
+    let(:new_snippet) do
+      <<~RUBY
+        create_domain "dict.us_postal_code", as: "text" do |d|
+          d.collation "en_US"
+          d.default_sql "'11111-0000'::text"
+          d.null false
+          d.constraint %q(VALUE ~ '^\\d{5}(-\\d{4})?$'::text), name: "valid_code"
+          d.comment "US postal code"
+        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(/default_sql/i) }
+  end
+
+  context "when comment is changed with :from option" do
+    let(:migration) do
+      <<~RUBY
+        change_domain "dict.us_postal_code" do |d|
+          d.comment "US postal code (zip)", from: "US postal code"
+        end
+      RUBY
+    end
+    let(:new_snippet) do
+      <<~RUBY
+        create_domain "dict.us_postal_code", as: "text" do |d|
+          d.collation "en_US"
+          d.default_sql "'00000'::text"
+          d.null false
+          d.constraint %q(VALUE ~ '^\\d{5}(-\\d{4})?$'::text), name: "valid_code"
+          d.comment "US postal code (zip)"
+        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 comment is changed without :from option" do
+    let(:migration) do
+      <<~RUBY
+        change_domain "dict.us_postal_code" do |d|
+          d.comment "US postal code (zip)"
+        end
+      RUBY
+    end
+    let(:new_snippet) do
+      <<~RUBY
+        create_domain "dict.us_postal_code", as: "text" do |d|
+          d.collation "en_US"
+          d.default_sql "'00000'::text"
+          d.null false
+          d.constraint %q(VALUE ~ '^\\d{5}(-\\d{4})?$'::text), name: "valid_code"
+          d.comment "US postal code (zip)"
+        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(/comment/i) }
+  end
+
+  context "without changes" do
+    let(:migration) { 'change_domain "dict.us_postal_code"' }
+
+    it { is_expected.to fail_validation.because(/there are no changes/i) }
+  end
+end

data/spec/operations/domains/create_domain_spec.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+describe ActiveRecord::Migration, "#create_domain" do
+  before_all { run_migration "create_schema :dict" }
+
+  context "with a full definition" do
+    let(:migration) do
+      <<~RUBY
+        create_domain "dict.us_postal_code", as: "text" do |d|
+          d.collation "en_US"
+          d.default_sql "'00000'::text"
+          d.null false
+          d.constraint %q(VALUE ~ '^\\d{5}(-\\d{4})?$'::text), name: "valid_code"
+          d.comment "US postal code"
+        end
+      RUBY
+    end
+    let(:query) { "SELECT '12345'::dict.us_postal_code;" }
+
+    its(:execution) { is_expected.to enable_sql_request(query) }
+    its(:execution) { is_expected.to insert(migration).into_schema }
+    its(:inversion) { is_expected.to disable_sql_request(query) }
+    its(:inversion) { is_expected.not_to change_schema }
+  end
+
+  context "without type" do
+    let(:migration) do
+      <<~RUBY
+        create_domain "dict.us_postal_code" do |d|
+          d.collation "en_US"
+          d.default_sql <<~Q
+            '00000'::text
+          Q
+          d.null false
+          d.constraint <<~Q, name: "valid_code"
+            VALUE ~ '^\d{5}$'::text OR VALUE ~ '^\d{5}-\d{4}$'::text
+          Q
+          d.comment <<~COMMENT
+            US postal code
+          COMMENT
+        end
+      RUBY
+    end
+
+    it { is_expected.to fail_validation.because(/type can't be blank/i) }
+  end
+
+  context "without name" do
+    let(:migration) do
+      <<~RUBY
+        create_domain as: "text" do |d|
+          d.collation "en_US"
+          d.default_sql <<~Q
+            '00000'::text
+          Q
+          d.null false
+          d.constraint <<~Q, name: "valid_code"
+            VALUE ~ '^\d{5}$'::text OR VALUE ~ '^\d{5}-\d{4}$'::text
+          Q
+          d.comment <<~COMMENT
+            US postal code
+          COMMENT
+        end
+      RUBY
+    end
+
+    it { is_expected.to fail_validation.because(/name can't be blank/i) }
+  end
+end

data/spec/operations/domains/drop_domain_spec.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+describe ActiveRecord::Migration, "#drop_domain" do
+  before_all { run_migration "create_schema :dict" }
+  before { run_migration(snippet) }
+
+  let(:snippet) do
+    <<~RUBY
+      create_domain "dict.us_postal_code", as: "text" do |d|
+        d.collation "en_US"
+        d.default_sql "'00000'::text"
+        d.null false
+        d.constraint %q(VALUE ~ '^\\d{5}(-\\d{4})?$'::text), name: "valid_code"
+        d.comment "US postal code"
+      end
+    RUBY
+  end
+  let(:query) { "SELECT '00000-0000'::dict.us_postal_code;" }
+
+  context "with a full definition" do
+    let(:migration) do
+      <<~RUBY
+        drop_domain "dict.us_postal_code", as: "text" do |d|
+          d.collation "en_US"
+          d.default_sql "'00000'::text"
+          d.constraint %q(VALUE ~ '^\\d{5}(-\\d{4})?$'::text), name: "valid_code"
+          d.null false
+          d.comment "US postal code"
+        end
+      RUBY
+    end
+
+    its(:execution) { is_expected.to disable_sql_request(query) }
+    its(:execution) { is_expected.to remove(snippet).from_schema }
+    its(:inversion) { is_expected.to enable_sql_request(query) }
+    its(:inversion) { is_expected.not_to change_schema }
+  end
+
+  context "with a qualified name only" do
+    let(:migration) do
+      <<~RUBY
+        drop_domain "dict.us_postal_code"
+      RUBY
+    end
+
+    its(:execution) { is_expected.to disable_sql_request(query) }
+    its(:execution) { is_expected.to remove(snippet).from_schema }
+    it { is_expected.to be_irreversible.because(/type can't be blank/i) }
+  end
+
+  context "when domain is used" do
+    before do
+      run_migration <<~RUBY
+        execute <<~Q
+          CREATE TABLE sums (value integer, zip dict.us_postal_code);
+        Q
+      RUBY
+    end
+
+    context "without the `force` option" do
+      let(:migration) do
+        <<~RUBY
+          drop_domain "dict.us_postal_code"
+        RUBY
+      end
+
+      its(:execution) { is_expected.to raise_error(StandardError) }
+    end
+
+    context "with the `force: :cascade` option" do
+      let(:migration) do
+        <<~RUBY
+          drop_domain "dict.us_postal_code", force: :cascade
+        RUBY
+      end
+
+      its(:execution) { is_expected.to disable_sql_request(query) }
+      its(:execution) { is_expected.to remove(snippet).from_schema }
+      it { is_expected.to be_irreversible.because_of(/force: :cascade/i) }
+    end
+  end
+
+  context "when domain is absent without `if_exists` option" do
+    let(:migration) do
+      <<~RUBY
+        drop_domain "foo"
+      RUBY
+    end
+
+    its(:execution) { is_expected.to raise_error(StandardError) }
+  end
+
+  context "when domain is absent with `if_exists: true` option" do
+    let(:migration) do
+      <<~RUBY
+        drop_domain "foo", 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
+
+  context "without a name" do
+    let(:migration) do
+      <<~RUBY
+        drop_domain as: "text" do |d|
+          d.collation "en_US"
+          d.default_sql "'00000'::text"
+          d.constraint %q(VALUE ~ '^\d{5}$' OR VALUE ~ '^\d{5}-\d{4}$'), name: "valid_code"
+          d.null false
+          d.comment "US postal code"
+        end
+      RUBY
+    end
+
+    it { is_expected.to fail_validation.because(/name can't be blank/i) }
+  end
+end

data/spec/operations/domains/rename_domain_spec.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+describe ActiveRecord::Migration, "#rename_domain" do
+  before_all { run_migration "create_schema :dict" }
+  before { run_migration(old_snippet) }
+
+  let(:old_snippet) do
+    <<~RUBY
+      create_domain "existing_string", as: "text" do |d|
+        d.null false
+      end
+    RUBY
+  end
+  let(:old_query) { "SELECT 'foo'::existing_string;" }
+
+  context "with new name and schema" do
+    let(:migration) do
+      <<~RUBY
+        rename_domain "existing_string", to: "dict.present_string"
+      RUBY
+    end
+    let(:new_snippet) do
+      <<~RUBY
+        create_domain "dict.present_string", as: "text" do |d|
+          d.null false
+        end
+      RUBY
+    end
+    let(:new_query) { "SELECT 'USD'::dict.present_string;" }
+
+    its(:execution) { is_expected.to enable_sql_request(new_query) }
+    its(:execution) { is_expected.to disable_sql_request(old_query) }
+    its(:execution) { is_expected.to remove(old_snippet).from_schema }
+    its(:execution) { is_expected.to insert(new_snippet).into_schema }
+
+    its(:inversion) { is_expected.to disable_sql_request(new_query) }
+    its(:inversion) { is_expected.to enable_sql_request(old_query) }
+    its(:inversion) { is_expected.not_to change_schema }
+  end
+
+  context "with the same name and schema" do
+    let(:migration) do
+      <<~RUBY
+        rename_domain "existing_string", to: "public.existing_string"
+      RUBY
+    end
+
+    it { is_expected.to fail_validation.because(/new name must be different/i) }
+  end
+
+  context "without new schema/name" do
+    let(:migration) do
+      <<~RUBY
+        rename_domain "existing_string"
+      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_domain to: "dict.present_string"
+      RUBY
+    end
+
+    it { is_expected.to fail_validation.because(/name can't be blank/i) }
+  end
+end

data/spec/operations/enums/change_enum_spec.rb

@@ -0,0 +1,157 @@
+# frozen_string_literal: true
+
+describe ActiveRecord::Migration, "#change_enum" do
+  before_all { run_migration "create_schema :finances" }
+  before { run_migration(old_snippet) }
+
+  let(:old_snippet) do
+    <<~RUBY
+      create_enum "currency" do |e|
+        e.values "eur", "usd"
+        e.comment "Supported currencies"
+      end
+    RUBY
+  end
+
+  context "when values are renamed" do
+    let(:migration) do
+      <<~RUBY
+        change_enum :currency do |e|
+          e.rename_value "usd", to: "USD"
+          e.rename_value "eur", to: "EUR"
+        end
+      RUBY
+    end
+    let(:new_snippet) do
+      <<~RUBY
+        create_enum "currency" do |e|
+          e.values "EUR", "USD"
+          e.comment "Supported currencies"
+        end
+      RUBY
+    end
+    let(:old_query) { "SELECT 'eur'::currency;" }
+    let(:new_query) { "SELECT 'EUR'::currency;" }
+
+    its(:execution) { is_expected.to disable_sql_request(old_query) }
+    its(:execution) { is_expected.to enable_sql_request(new_query) }
+    its(:execution) { is_expected.to remove(old_snippet).from_schema }
+    its(:execution) { is_expected.to insert(new_snippet).into_schema }
+
+    its(:inversion) { is_expected.to enable_sql_request(old_query) }
+    its(:inversion) { is_expected.to disable_sql_request(new_query) }
+    its(:inversion) { is_expected.not_to change_schema }
+  end
+
+  context "when values are added" do
+    let(:migration) do
+      <<~RUBY
+        change_enum :currency do |e|
+          e.add_value "jpy"
+          e.add_value "cfr", before: "eur"
+          e.add_value "gbp", after: "eur"
+          e.add_value "btc", before: "cfr"
+        end
+      RUBY
+    end
+    let(:new_snippet) do
+      <<~RUBY
+        create_enum "currency" do |e|
+          e.values "btc", "cfr", "eur", "gbp", "usd", "jpy"
+          e.comment "Supported currencies"
+        end
+      RUBY
+    end
+
+    context "in PostgreSQL v11 and below", before_version: 12 do
+      its(:execution) { is_expected.to raise_error(/supported in PostgreSQL v12+/i) }
+    end
+
+    context "in PostgreSQL v12+", since_version: 12 do
+      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(/adding new values/i) }
+    end
+  end
+
+  context "when values both added and renamed", since_version: 12 do
+    let(:migration) do
+      <<~RUBY
+        change_enum :currency do |e|
+          e.rename_value "eur", to: "EUR"
+          e.add_value "CFR", before: "eur"
+          e.rename_value "usd", to: "USD"
+        end
+      RUBY
+    end
+    let(:new_snippet) do
+      <<~RUBY
+        create_enum "currency" do |e|
+          e.values "CFR", "EUR", "USD"
+          e.comment "Supported currencies"
+        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(/adding new values/i) }
+  end
+
+  context "when the comment is changed" do
+    let(:new_snippet) do
+      <<~RUBY
+        create_enum "currency" do |e|
+          e.values "eur", "usd"
+          e.comment "Supported currency values"
+        end
+      RUBY
+    end
+
+    context "without the `from` option" do
+      let(:migration) do
+        <<~RUBY
+          change_enum "currency" do |e|
+            e.comment "Supported currency values"
+          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(/comment/i) }
+    end
+
+    context "with the `from` option" do
+      let(:migration) do
+        <<~RUBY
+          change_enum "currency" do |e|
+            e.comment "Supported currency values", from: "Supported currencies"
+          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
+  end
+
+  context "without any change" do
+    let(:migration) { "change_enum :currencies" }
+
+    it { is_expected.to fail_validation.because(/there are no changes/i) }
+  end
+
+  context "without a name" do
+    let(:migration) do
+      <<~RUBY
+        change_enum do |e|
+          e.rename_value "eur", to: "EUR"
+        end
+      RUBY
+    end
+
+    it { is_expected.to fail_validation.because(/name can't be blank/i) }
+  end
+end