pg_trunk 0.1.0

data/spec/operations/enums/create_enum_spec.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+describe ActiveRecord::Migration, "#create_enum" do
+  before_all { run_migration "create_schema :finances" }
+
+  context "with a full definition" do
+    let(:migration) do
+      <<~RUBY
+        create_enum "finances.currency" do |e|
+          e.values "EUR", "USD"
+          e.comment "Supported currency values"
+        end
+      RUBY
+    end
+    let(:query) { "SELECT 'EUR'::finances.currency;" }
+
+    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 values" do
+    let(:migration) { "create_enum :currency" }
+
+    it { is_expected.to fail_validation.because(/values can't be blank/i) }
+  end
+
+  context "without name" do
+    let(:migration) do
+      <<~RUBY
+        create_enum do |e|
+          e.values "EUR", "USD"
+        end
+      RUBY
+    end
+
+    it { is_expected.to fail_validation.because(/name can't be blank/i) }
+  end
+end

data/spec/operations/enums/drop_enum_spec.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+describe ActiveRecord::Migration, "#drop_enum" do
+  before_all { run_migration "create_schema :finances" }
+  before { run_migration(snippet) }
+
+  let(:snippet) do
+    <<~RUBY
+      create_enum "currency" do |e|
+        e.values "CHF", "EUR", "GBP", "USD", "JPY"
+        e.comment "Supported currencies"
+      end
+    RUBY
+  end
+  let(:query) { "SELECT 'USD'::currency;" }
+
+  context "with a full definition" do
+    let(:migration) do
+      <<~RUBY
+        drop_enum "currency" do |e|
+          e.values "CHF", "EUR", "GBP", "USD"
+          e.value "JPY"
+          e.comment "Supported currencies"
+        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_enum "currency"
+      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(/values can't be blank/i) }
+  end
+
+  context "when enum is used" do
+    before do
+      run_migration <<~RUBY
+        execute "CREATE TABLE sums (value integer, label currency);"
+      RUBY
+    end
+
+    context "without the `force` option" do
+      let(:migration) do
+        <<~RUBY
+          drop_enum "currency" do |e|
+            e.values "CHF", "EUR", "GBP", "USD"
+            e.value "JPY"
+            e.comment "Supported currencies"
+          end
+        RUBY
+      end
+
+      its(:execution) { is_expected.to raise_error(StandardError) }
+    end
+
+    context "with the `force: :cascade` option" do
+      let(:migration) do
+        <<~RUBY
+          drop_enum "currency", force: :cascade do |e|
+            e.values "CHF", "EUR", "GBP", "USD", "JPY"
+            e.comment "Supported currencies"
+          end
+        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 enum is absent" do
+    context "without the `force` option" do
+      let(:migration) do
+        <<~RUBY
+          drop_enum "foo"
+        RUBY
+      end
+
+      its(:execution) { is_expected.to raise_error(StandardError) }
+    end
+
+    context "with the `if_exists: true` option" do
+      let(:migration) do
+        <<~RUBY
+          drop_enum "foo", if_exists: true
+        RUBY
+      end
+
+      its(:execution) { is_expected.to enable_sql_request(query) }
+      its(:execution) { is_expected.not_to change_schema }
+      it { is_expected.to be_irreversible.because_of(/if_exists: true/i) }
+    end
+  end
+
+  context "without a name" do
+    let(:migration) do
+      <<~RUBY
+        drop_enum do |e|
+          e.values "CHF", "EUR", "GBP", "USD"
+          e.value "JPY"
+          e.comment "Supported currencies"
+        end
+      RUBY
+    end
+
+    it { is_expected.to fail_validation.because(/name can't be blank/i) }
+  end
+end

data/spec/operations/enums/rename_enum_spec.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+describe ActiveRecord::Migration, "#rename_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 "CHF", "EUR", "GBP", "USD", "JPY"
+        e.comment "Supported currencies"
+      end
+    RUBY
+  end
+  let(:old_query) { "SELECT 'USD'::currency;" }
+
+  context "with new name and schema" do
+    let(:migration) do
+      <<~RUBY
+        rename_enum "currency", to: "finances.currency_value"
+      RUBY
+    end
+    let(:new_snippet) do
+      <<~RUBY
+        create_enum "finances.currency_value" do |e|
+          e.values "CHF", "EUR", "GBP", "USD", "JPY"
+          e.comment "Supported currencies"
+        end
+      RUBY
+    end
+    let(:new_query) { "SELECT 'USD'::finances.currency_value;" }
+
+    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_enum "currency", to: "public.currency"
+      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_enum "currency"
+      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_enum to: "finances.currency_value"
+      RUBY
+    end
+
+    it { is_expected.to fail_validation.because(/name can't be blank/i) }
+  end
+end

data/spec/operations/foreign_keys/add_foreign_key_spec.rb

@@ -0,0 +1,208 @@
+# frozen_string_literal: true
+
+describe ActiveRecord::Migration, "#add_foreign_key" do
+  before_all do
+    run_migration <<~RUBY
+      create_table :roles do |t|
+        t.string :name, index: { unique: true }
+        t.index %i[name id], unique: true
+      end
+
+      create_table :users do |t|
+        t.integer :role_id
+        t.string  :role_name
+        t.string  :role
+      end
+    RUBY
+  end
+
+  context "without options" do
+    let(:migration) do
+      <<~RUBY.squish
+        add_foreign_key "users", "roles"
+      RUBY
+    end
+    let(:invalid_query) do
+      <<~Q
+        -- breaks fk constraint
+        INSERT INTO users (role_id) VALUES (1);
+      Q
+    end
+    let(:valid_query) do
+      <<~Q
+        INSERT INTO roles (id) VALUES (1);
+        INSERT INTO users (role_id) VALUES (1);
+      Q
+    end
+
+    its(:execution) { is_expected.to enable_sql_request(valid_query) }
+    its(:execution) { is_expected.to disable_sql_request(invalid_query) }
+    its(:execution) { is_expected.to insert(migration).into_schema }
+
+    its(:inversion) { is_expected.not_to change_schema }
+    its(:inversion) { is_expected.to reenable_sql_request(invalid_query) }
+  end
+
+  context "with a custom primary key" do
+    let(:migration) do
+      <<~RUBY.squish
+        add_foreign_key "users", "roles", primary_key: "name"
+      RUBY
+    end
+    let(:invalid_query) do
+      <<~Q
+        -- breaks fk constraint
+        INSERT INTO users (role_name) VALUES ('admin');
+      Q
+    end
+    let(:valid_query) do
+      <<~Q
+        INSERT INTO roles (name) VALUES ('admin');
+        INSERT INTO users (role_name) VALUES ('admin');
+      Q
+    end
+
+    its(:execution) { is_expected.to enable_sql_request(valid_query) }
+    its(:execution) { is_expected.to disable_sql_request(invalid_query) }
+    its(:execution) { is_expected.to insert(migration).into_schema }
+
+    its(:inversion) { is_expected.to reenable_sql_request(invalid_query) }
+    its(:inversion) { is_expected.not_to change_schema }
+  end
+
+  context "with a custom name" do
+    let(:migration) do
+      <<~RUBY.squish
+        add_foreign_key "users", "roles", name: "user_role_fk"
+      RUBY
+    end
+
+    its(:execution) { is_expected.to insert(migration).into_schema }
+    its(:inversion) { is_expected.not_to change_schema }
+  end
+
+  context "with cascades" do
+    let(:migration) do
+      <<~RUBY.squish
+        add_foreign_key "users", "roles",
+                        on_update: :cascade,
+                        on_delete: :restrict
+      RUBY
+    end
+
+    its(:execution) { is_expected.to insert(migration).into_schema }
+    its(:inversion) { is_expected.not_to change_schema }
+  end
+
+  context "with a multi-key constraint" do
+    let(:migration) do
+      <<~RUBY.squish
+        add_foreign_key "users", "roles",
+                        primary_key: %w[name id],
+                        match: :full
+      RUBY
+    end
+    let(:invalid_query) do
+      <<~Q
+        -- breaks fk constraint
+        INSERT INTO roles (id, name) VALUES (1, 'admin'), (2, 'developer');
+        INSERT INTO users (role_id, role_name) VALUES (1, 'developer');
+      Q
+    end
+    let(:valid_query) do
+      <<~Q
+        INSERT INTO roles (id, name) VALUES (1, 'developer');
+        INSERT INTO users (role_id, role_name) VALUES (1, 'developer');
+      Q
+    end
+
+    its(:execution) { is_expected.to enable_sql_request(valid_query) }
+    its(:execution) { is_expected.to disable_sql_request(invalid_query) }
+    its(:execution) { is_expected.to insert(migration).into_schema }
+
+    its(:inversion) { is_expected.to reenable_sql_request(invalid_query) }
+    its(:inversion) { is_expected.not_to change_schema }
+  end
+
+  context "with a custom multi-key constraint" do
+    let(:migration) do
+      <<~RUBY.squish
+        add_foreign_key "users", "roles",
+                        columns: %w[role role_id],
+                        primary_key: %w[name id],
+                        match: :full
+      RUBY
+    end
+
+    its(:execution) { is_expected.to insert(migration).into_schema }
+    its(:inversion) { is_expected.not_to change_schema }
+  end
+
+  context "with a comment" do
+    let(:migration) do
+      <<~RUBY
+        add_foreign_key "users", "roles", comment: "The user's role"
+      RUBY
+    end
+
+    its(:execution) { is_expected.to insert(migration).into_schema }
+    its(:inversion) { is_expected.not_to change_schema }
+  end
+
+  context "when foreign key already existed" do
+    before do
+      run_migration <<~RUBY
+        add_foreign_key "users", "roles"
+      RUBY
+    end
+
+    context "without the `if_not_exists` option" do
+      let(:migration) do
+        <<~RUBY
+          add_foreign_key "users", "roles"
+        RUBY
+      end
+
+      its(:execution) { is_expected.to raise_error(StandardError) }
+    end
+
+    context "with the `if_not_exists: true` option" do
+      let(:migration) do
+        <<~RUBY
+          add_foreign_key "users", "roles", if_not_exists: true
+        RUBY
+      end
+
+      its(:execution) { is_expected.not_to raise_error }
+      it { is_expected.to be_irreversible.because_of(/if_not_exists: true/i) }
+    end
+  end
+
+  context "without a reference" do
+    let(:migration) do
+      <<~RUBY.squish
+        add_foreign_key "users"
+      RUBY
+    end
+
+    it { is_expected.to fail_validation.because(/reference can't be blank/i) }
+  end
+
+  context "inside table definition" do
+    let(:migration) do
+      <<~RUBY
+        change_table :users do |t|
+          t.foreign_key "roles"
+        end
+      RUBY
+    end
+    let(:snippet) do
+      <<~RUBY.squish
+        add_foreign_key "users", "roles"
+      RUBY
+    end
+
+    its(:execution) { is_expected.to insert(snippet).into_schema }
+    its(:inversion) { is_expected.not_to change_schema }
+  end
+end

data/spec/operations/foreign_keys/drop_foreign_key_spec.rb

@@ -0,0 +1,167 @@
+# frozen_string_literal: true
+
+describe ActiveRecord::Migration, "#drop_foreign_key" do
+  before_all do
+    run_migration <<~RUBY
+      create_table :roles do |t|
+        t.string :name, index: { unique: true }
+      end
+
+      create_table :users do |t|
+        t.string :role
+      end
+    RUBY
+  end
+
+  context "when fk was given an explicit name" do
+    before { run_migration(snippet) }
+
+    let(:snippet) do
+      <<~RUBY.squish
+        add_foreign_key "users", "roles",
+                        column: "role",
+                        primary_key: "name",
+                        name: "my_fk"
+      RUBY
+    end
+    let(:invalid_query) do
+      <<~Q
+        INSERT INTO users (role) VALUES ('admin');
+      Q
+    end
+    let(:valid_query) do
+      <<~Q
+        INSERT INTO roles (name) VALUES ('admin');
+        INSERT INTO users (role) VALUES ('admin');
+      Q
+    end
+
+    context "when identified by a name only" do
+      let(:migration) do
+        <<~RUBY
+          drop_foreign_key "users", name: "my_fk"
+        RUBY
+      end
+
+      its(:execution) { is_expected.to enable_sql_request(valid_query) }
+      its(:execution) { is_expected.to reenable_sql_request(invalid_query) }
+      its(:execution) { is_expected.to remove(snippet).from_schema }
+
+      it { is_expected.to be_irreversible.because(/reference can't be blank/) }
+    end
+
+    context "with all attributes of the constraint" do
+      let(:migration) do
+        <<~RUBY
+          drop_foreign_key "users", "roles",
+                           column: "role",
+                           primary_key: "name",
+                           name: "my_fk"
+        RUBY
+      end
+
+      its(:execution) { is_expected.to enable_sql_request(valid_query) }
+      its(:execution) { is_expected.to reenable_sql_request(invalid_query) }
+      its(:execution) { is_expected.to remove(snippet).from_schema }
+
+      its(:inversion) { is_expected.to disable_sql_request(invalid_query) }
+      its(:inversion) { is_expected.not_to change_schema }
+    end
+
+    context "without a name" do
+      let(:migration) do
+        <<~RUBY
+          drop_foreign_key "users"
+        RUBY
+      end
+
+      it { is_expected.to fail_validation.because(/name can't be blank/i) }
+    end
+
+    context "without a table" do
+      let(:migration) do
+        <<~RUBY
+          drop_foreign_key name: "my_fk"
+        RUBY
+      end
+
+      it { is_expected.to fail_validation.because(/table can't be blank/i) }
+    end
+  end
+
+  context "when fk got a generated name outside of a table" do
+    before { run_migration(snippet) }
+
+    let(:snippet) do
+      <<~RUBY.squish
+        add_foreign_key "users", "roles",
+                        column: "role",
+                        primary_key: "name"
+      RUBY
+    end
+
+    context "with all attributes of the constraint" do
+      let(:migration) do
+        <<~RUBY
+          drop_foreign_key "users", "roles",
+                           column: "role",
+                           primary_key: "name"
+        RUBY
+      end
+
+      its(:execution) { is_expected.to remove(snippet).from_schema }
+      its(:inversion) { is_expected.not_to change_schema }
+    end
+  end
+
+  context "when fk got a generated name inside a table" do
+    before do
+      run_migration <<~RUBY
+        change_table :users do |t|
+          t.foreign_key :roles, column: :role, primary_key: :name
+        end
+      RUBY
+    end
+
+    let(:migration) do
+      <<~RUBY
+        drop_foreign_key "users", "roles",
+                         column: "role",
+                         primary_key: "name"
+      RUBY
+    end
+    let(:snippet) do
+      <<~RUBY.squish
+        add_foreign_key "users", "roles",
+                        column: "role",
+                        primary_key: "name"
+      RUBY
+    end
+
+    its(:execution) { is_expected.to remove(snippet).from_schema }
+    its(:inversion) { is_expected.not_to change_schema }
+  end
+
+  context "when a key not existed" do
+    context "without the `it_exists: true` option" do
+      let(:migration) do
+        <<~RUBY.squish
+          drop_foreign_key :users, :roles, name: "unknown"
+        RUBY
+      end
+
+      its(:execution) { is_expected.to raise_error(StandardError) }
+    end
+
+    context "with the `it_exists: true` option" do
+      let(:migration) do
+        <<~RUBY
+          drop_foreign_key :users, :roles, name: :unknown, 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
+end

data/spec/operations/foreign_keys/rename_foreign_key_spec.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+describe ActiveRecord::Migration, "#rename_foreign_key" do
+  before_all do
+    run_migration <<~RUBY
+      create_table :roles do |t|
+        t.string :name
+        t.index %i[name id], unique: true
+      end
+
+      create_table :users do |t|
+        t.integer :role_id
+        t.string :role_name
+      end
+    RUBY
+  end
+  before { run_migration(old_snippet) }
+
+  context "when the key had an explicit name" do
+    let(:old_snippet) do
+      <<~RUBY.squish
+        add_foreign_key "users", "roles",
+                        primary_key: %w[name id],
+                        name: "my_key"
+      RUBY
+    end
+
+    context "when both names are explicitly specified" do
+      let(:migration) do
+        <<~RUBY.squish
+          rename_foreign_key "users", name: "my_key", to: "my_new_key"
+        RUBY
+      end
+      let(:new_snippet) do
+        <<~RUBY.squish
+          add_foreign_key "users", "roles",
+                          primary_key: %w[name id],
+                          name: "my_new_key"
+        RUBY
+      end
+
+      its(:execution) { is_expected.to insert(new_snippet).into_schema }
+      its(:execution) { is_expected.to remove(old_snippet).from_schema }
+      its(:reversion) { is_expected.not_to change_schema }
+    end
+
+    context "when new name is not specified" do
+      let(:migration) do
+        <<~RUBY.snippet
+          rename_foreign_key "users", name: "my_key"
+        RUBY
+      end
+      let(:snippet) do
+        <<~RUBY.snippet
+          add_foreign_key "users", "roles",
+                          columns: %i[role_name role_id],
+                          primary_key: %i[name id]
+        RUBY
+      end
+    end
+
+    context "without the old name" do
+      let(:migration) do
+        <<~RUBY.squish
+          rename_foreign_key "users", "roles", to: "my_new_key"
+        RUBY
+      end
+
+      it { is_expected.to fail_validation.because(/name can't be blank/i) }
+    end
+  end
+
+  context "when the key was anonymous" do
+    let(:old_snippet) do
+      <<~RUBY.squish
+        add_foreign_key "users", "roles", primary_key: %w[name id]
+      RUBY
+    end
+
+    context "with a new name" do
+      let(:migration) do
+        <<~RUBY.squish
+          rename_foreign_key "users", "roles",
+                             primary_key: %w[name id],
+                             to: "my_key"
+        RUBY
+      end
+      let(:new_snippet) do
+        <<~RUBY.squish
+          add_foreign_key "users", "roles",
+                          primary_key: %w[name id],
+                          name: "my_key"
+        RUBY
+      end
+
+      its(:execution) { is_expected.to insert(new_snippet).into_schema }
+      its(:execution) { is_expected.to remove(old_snippet).from_schema }
+      its(:inversion) { is_expected.not_to change_schema }
+    end
+  end
+end