pg_trunk 0.1.0

data/spec/operations/materialized_views/rename_materialized_view_spec.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+describe ActiveRecord::Migration, "#rename_materialized_view" do
+  before_all do
+    run_migration <<~RUBY
+      create_table :users do |t|
+        t.string :name
+        t.boolean :admin
+      end
+    RUBY
+  end
+  before { run_migration(old_snippet) }
+
+  let(:old_snippet) do
+    <<~RUBY
+      create_materialized_view "admins" do |v|
+        v.sql_definition <<~Q.chomp
+          SELECT users.id, users.name
+          FROM users
+          WHERE users.admin
+        Q
+      end
+    RUBY
+  end
+  let(:old_query) { "SELECT * FROM admins;" }
+
+  context "with a new name" do
+    let(:migration) do
+      <<~RUBY
+        rename_materialized_view :admins, to: :admin_users
+      RUBY
+    end
+    let(:new_snippet) do
+      <<~RUBY
+        create_materialized_view "admin_users" do |v|
+          v.sql_definition <<~Q.chomp
+            SELECT users.id, users.name
+            FROM users
+            WHERE users.admin
+          Q
+        end
+      RUBY
+    end
+    let(:new_query) { "SELECT * FROM admin_users;" }
+
+    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 insert(new_snippet).into_schema }
+    its(:execution) { is_expected.to remove(old_snippet).from_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" do
+    let(:migration) do
+      <<~RUBY
+        rename_materialized_view :admins, to: "public.admins"
+      RUBY
+    end
+
+    it { is_expected.to fail_validation.because(/new name must be different/i) }
+  end
+
+  context "when a materialized view was absent" do
+    context "without the `if_exists` option" do
+      let(:migration) do
+        <<~RUBY
+          rename_materialized_view :weird, to: :admin_users
+        RUBY
+      end
+
+      its(:execution) { is_expected.to raise_error(StandardError) }
+    end
+
+    context "with the `if_exists: true` option" do
+      let(:migration) do
+        <<~RUBY
+          rename_materialized_view :weird, to: :admin_users, 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/procedures/change_procedure_spec.rb

@@ -0,0 +1,175 @@
+# frozen_string_literal: true
+
+describe ActiveRecord::Migration, "#change_procedure", since_version: 11 do
+  before do
+    run_migration <<~RUBY
+      create_procedure "set_foo(a integer)" do |p|
+        p.language "plpgsql"
+        p.body "BEGIN set custom.foo = a; END;"
+        p.comment "Set foo"
+      end
+
+      # Overload the procedure to ensure a proper one is found
+      create_procedure "set_foo(a text)",
+                       language: "plpgsql",
+                       body: "BEGIN set custom.foo = a; END;"
+    RUBY
+  end
+
+  let(:old_snippet) do
+    <<~RUBY
+      create_procedure "set_foo(a integer)" do |p|
+        p.language "plpgsql"
+        p.body "BEGIN set custom.foo = a; END;"
+        p.comment "Set foo"
+      end
+    RUBY
+  end
+
+  context "with implicitly reversible changes" do
+    let(:migration) do
+      <<~RUBY
+        change_procedure "set_foo(a integer)", security: :definer
+      RUBY
+    end
+    let(:new_snippet) do
+      <<~RUBY
+        create_procedure "set_foo(a integer)" do |p|
+          p.language "plpgsql"
+          p.security :definer
+          p.body "BEGIN set custom.foo = a; END;"
+          p.comment "Set foo"
+        end
+      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
+
+  context "with explicitly reversible changes" do
+    let(:migration) do
+      <<~RUBY
+        change_procedure "set_foo(a integer)" do |p|
+          p.body <<~PLPGSQL.chomp, from: <<~PLPGSQL.chomp
+            DECLARE
+              b integer := 2 * a;
+            BEGIN
+              set custom.foo = b;
+            END;
+          PLPGSQL
+            BEGIN set custom.foo = a; END;
+          PLPGSQL
+          p.comment "Set doubled value to foo", from: "Set foo"
+        end
+      RUBY
+    end
+    let(:new_snippet) do
+      <<~RUBY
+        create_procedure "set_foo(a integer)" do |p|
+          p.language "plpgsql"
+          p.body <<~Q.chomp
+            DECLARE
+            b integer := 2 * a;
+            BEGIN
+            set custom.foo = b;
+            END;
+          Q
+          p.comment "Set doubled value to foo"
+        end
+      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
+
+  context "with irreversible changes" do
+    let(:migration) do
+      <<~RUBY
+        change_procedure "set_foo(a integer)" do |p|
+          p.body <<~PLPGSQL.chomp
+            DECLARE
+              b integer := 2 * a;
+            BEGIN
+              set custom.foo = b;
+            END;
+          PLPGSQL
+          p.comment "Set doubled value to foo"
+        end
+      RUBY
+    end
+    let(:new_snippet) do
+      <<~RUBY
+        create_procedure "set_foo(a integer)" do |p|
+          p.language "plpgsql"
+          p.body <<~Q.chomp
+            DECLARE
+            b integer := 2 * a;
+            BEGIN
+            set custom.foo = b;
+            END;
+          Q
+          p.comment "Set doubled value to foo"
+        end
+      RUBY
+    end
+
+    its(:execution) { is_expected.to insert(new_snippet).into_schema }
+    its(:execution) { is_expected.to remove(old_snippet).from_schema }
+    it { is_expected.to be_irreversible.because_of(/body|comment/i) }
+  end
+
+  context "with no changes" do
+    let(:migration) do
+      <<~RUBY
+        change_procedure "set_foo(a integer)"
+      RUBY
+    end
+
+    it { is_expected.to fail_validation.because(/changes can't be blank/i) }
+  end
+
+  context "when the procedure is absent" do
+    let(:migration) do
+      <<~RUBY
+        change_procedure "unknown(integer)" do |p|
+          p.comment <<~COMMENT
+            New comment
+          COMMENT
+        end
+      RUBY
+    end
+
+    context "without the `if_exists` option" do
+      its(:execution) { is_expected.to raise_error(StandardError) }
+    end
+
+    context "with the `if_exists: true` option" do
+      let(:migration) do
+        <<~RUBY
+          change_procedure "unknown(integer)", if_exists: true do |p|
+            p.comment <<~COMMENT
+              New comment
+            COMMENT
+          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 name" do
+    let(:migration) do
+      <<~RUBY
+        change_procedure security: :invoker
+      RUBY
+    end
+
+    it { is_expected.to fail_validation.because(/name can't be blank/i) }
+  end
+end

data/spec/operations/procedures/create_procedure_spec.rb

@@ -0,0 +1,151 @@
+# frozen_string_literal: true
+
+describe ActiveRecord::Migration, "#create_procedure", since_version: 11 do
+  context "with a minimal definition" do
+    let(:migration) do
+      <<~RUBY
+        create_procedure "set_foo(a integer)", body: "SET custom.foo = a"
+      RUBY
+    end
+    let(:snippet) do
+      <<~RUBY
+        create_procedure "set_foo(a integer)" do |p|
+          p.body "SET custom.foo = a"
+        end
+      RUBY
+    end
+    let(:query) { "CALL set_foo(42);" }
+
+    its(:execution) { is_expected.to enable_sql_request(query) }
+    its(:execution) { is_expected.to insert(snippet).into_schema }
+
+    its(:inversion) { is_expected.to disable_sql_request(query) }
+    its(:inversion) { is_expected.not_to change_schema }
+  end
+
+  context "with options" do
+    let(:migration) do
+      <<~RUBY
+        create_procedure "set_foo(a integer)" do |p|
+          p.language "plpgsql"
+          p.body "BEGIN set custom.foo = a; END;"
+          p.comment "Multiply 2 values"
+        end
+      RUBY
+    end
+
+    its(:execution) { is_expected.to insert(migration).into_schema }
+    its(:inversion) { is_expected.not_to change_schema }
+  end
+
+  context "when a procedure existed" do
+    before do
+      run_migration <<~RUBY
+        create_procedure "set_foo", body: "SET custom.foo = 42"
+      RUBY
+    end
+
+    context "without replace_existing: true" do
+      let(:migration) do
+        <<~RUBY
+          create_procedure "set_foo", body: "SET custom.foo = 666"
+        RUBY
+      end
+
+      its(:execution) { is_expected.to raise_error(StandardError) }
+    end
+
+    context "with replace_existing: true" do
+      let(:migration) do
+        <<~RUBY
+          create_procedure "set_foo",
+                           body: "SET custom.foo = 666",
+                           replace_existing: true
+        RUBY
+      end
+      let(:old_snippet) do
+        <<~RUBY
+          create_procedure "set_foo()" do |p|
+            p.body "SET custom.foo = 42"
+          end
+        RUBY
+      end
+      let(:new_snippet) do
+        <<~RUBY
+          create_procedure "set_foo()" do |p|
+            p.body "SET custom.foo = 666"
+          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(/replace_existing: true/i) }
+    end
+  end
+
+  context "when a procedure contains SQL injection" do
+    # Running it would inject the SQL code going after $$
+    let(:migration) do
+      <<~RUBY
+        create_procedure "set_foo(a integer)" do |p|
+          p.body <<~Q.chomp
+            SET custom.foo = a$$;DROP TABLE priceless;
+          Q
+        end
+      RUBY
+    end
+
+    it { is_expected.to fail_validation.because_of(/SQL injection/i) }
+  end
+
+  context "when a procedure has named $-quotations" do
+    # This code is safe because `$greeting$` doesn't closes `$$`
+    let(:migration) do
+      <<~RUBY
+        create_procedure "greet()" do |p|
+          p.body "SET custom.foo = $greeting$Hi$greeting$;"
+        end
+      RUBY
+    end
+
+    its(:execution) { is_expected.to insert(migration).into_schema }
+  end
+
+  context "without arguments" do
+    let(:migration) do
+      <<~RUBY
+        create_procedure "set_foo", body: "SET custom.foo = 42"
+      RUBY
+    end
+    let(:snippet) do
+      <<~RUBY
+        create_procedure "set_foo()" do |p|
+          p.body "SET custom.foo = 42"
+        end
+      RUBY
+    end
+
+    its(:execution) { is_expected.to insert(snippet).into_schema }
+  end
+
+  context "without name" do
+    let(:migration) do
+      <<~RUBY
+        create_procedure body: "SET custom.foo = 42;"
+      RUBY
+    end
+
+    it { is_expected.to fail_validation.because(/name can't be blank/i) }
+  end
+
+  context "without body" do
+    let(:migration) do
+      <<~RUBY
+        create_procedure "foo ()"
+      RUBY
+    end
+
+    it { is_expected.to fail_validation.because(/body can't be blank/i) }
+  end
+end

data/spec/operations/procedures/drop_procedure_spec.rb

@@ -0,0 +1,159 @@
+# frozen_string_literal: true
+
+describe ActiveRecord::Migration, "#drop_procedure", since_version: 11 do
+  context "when a procedure was present" do
+    before { run_migration(snippet) }
+
+    let(:snippet) do
+      <<~RUBY
+        create_procedure "set_foo(a integer)" do |p|
+          p.body "SET custom.foo = a"
+        end
+      RUBY
+    end
+    let(:query) { "CALL set_foo(42);" }
+
+    context "with a procedure name only" do
+      let(:migration) do
+        <<~RUBY
+          drop_procedure "set_foo"
+        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(/body can't be blank/i) }
+    end
+
+    context "with a procedure signature" do
+      let(:migration) do
+        <<~RUBY
+          drop_procedure "set_foo(int)"
+        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(/body can't be blank/i) }
+    end
+
+    context "with a procedure body" do
+      let(:migration) do
+        <<~RUBY
+          drop_procedure "set_foo(a int)", body: "SET custom.foo = a"
+        RUBY
+      end
+
+      its(:execution) { is_expected.to disable_sql_request(query) }
+      its(:execution) { is_expected.to remove(snippet).from_schema }
+
+      its(:inversion) { is_expected.not_to change_schema }
+    end
+
+    context "with additional options" do
+      let(:migration) do
+        <<~RUBY
+          drop_procedure "set_foo(a integer)" do |p|
+            p.language "plpgsql"
+            p.body "BEGIN SET custom.foo = a; END;"
+            p.comment "Multiply 2 integers"
+          end
+        RUBY
+      end
+      let(:old_snippet) do
+        <<~RUBY.indent(2)
+          create_procedure "set_foo(a integer)" do |p|
+            p.body "SET custom.foo = a"
+          end
+        RUBY
+      end
+      let(:new_snippet) do
+        <<~RUBY.indent(2)
+          create_procedure "set_foo(a integer)" do |p|
+            p.language "plpgsql"
+            p.body "BEGIN SET custom.foo = a; END;"
+            p.comment "Multiply 2 integers"
+          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.to remove(old_snippet).from_schema }
+      its(:inversion) { is_expected.to insert(new_snippet).into_schema }
+    end
+
+    context "without a name" do
+      let(:migration) do
+        <<~RUBY
+          drop_procedure
+        RUBY
+      end
+
+      it { is_expected.to fail_validation.because(/name can't be blank/i) }
+    end
+  end
+
+  context "when several procedures existed" do
+    before do
+      run_migration <<~RUBY
+        create_procedure "set_foo(a text)", body: "SET custom.foo = a"
+        create_procedure "set_foo(a integer)", body: "SET custom.foo = a"
+      RUBY
+    end
+
+    context "with a name only" do
+      let(:migration) do
+        <<~RUBY
+          drop_procedure "set_foo"
+        RUBY
+      end
+
+      its(:execution) { is_expected.to raise_exception(StandardError) }
+    end
+
+    context "with a signature" do
+      let(:migration) do
+        <<~RUBY
+          drop_procedure "set_foo(text)"
+        RUBY
+      end
+      let(:snippet) do
+        <<~RUBY
+          create_procedure "set_foo(a text)" do |p|
+            p.body "SET custom.foo = a"
+          end
+        RUBY
+      end
+
+      its(:execution) { is_expected.to remove(snippet).from_schema }
+    end
+  end
+
+  context "when a procedure was absent" do
+    context "without the :if_exists option" do
+      let(:migration) do
+        <<~RUBY
+          drop_procedure "set_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_procedure "set_foo", if_exists: true
+        RUBY
+      end
+
+      its(:execution) { is_expected.not_to raise_error }
+      it { is_expected.to be_irreversible.because_of(/if_exists: true/i) }
+    end
+  end
+end

data/spec/operations/procedures/rename_procedure_spec.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+describe ActiveRecord::Migration, "#rename_procedure", since_version: 11 do
+  before do
+    run_migration <<~RUBY
+      create_schema "meta"
+      create_procedure "set_foo(a int)", body: "SET custom.foo = a"
+    RUBY
+  end
+
+  let(:old_query) { "CALL set_foo(42);" }
+  let(:old_snippet) do
+    <<~RUBY
+      create_procedure "set_foo(a integer)" do |p|
+        p.body "SET custom.foo = a"
+      end
+    RUBY
+  end
+
+  context "with new name and schema" do
+    let(:migration) do
+      <<~RUBY
+        rename_procedure "set_foo", to: "meta.set_foo_value"
+      RUBY
+    end
+    let(:new_snippet) do
+      <<~RUBY
+        create_procedure "meta.set_foo_value(a integer)" do |p|
+          p.body "SET custom.foo = a"
+        end
+      RUBY
+    end
+    let(:new_query) { "CALL meta.set_foo_value(42);" }
+
+    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 insert(new_snippet).into_schema }
+    its(:execution) { is_expected.to remove(old_snippet).from_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_procedure "set_foo", to: "public.set_foo"
+      RUBY
+    end
+
+    it { is_expected.to fail_validation.because(/new name must be different/i) }
+  end
+
+  context "when several procedures exist" do
+    before do
+      run_migration <<~RUBY
+        create_procedure "set_foo(a text)", body: "SET custom.foo = a"
+      RUBY
+    end
+
+    context "without a signature" do
+      let(:migration) do
+        <<~RUBY
+          rename_procedure "set_foo", to: "set_foo_value"
+        RUBY
+      end
+
+      its(:execution) { is_expected.to raise_error(StandardError) }
+    end
+
+    context "with a signature" do
+      let(:migration) do
+        <<~RUBY
+          rename_procedure "set_foo(int)", to: "meta.set_foo_value"
+        RUBY
+      end
+      let(:new_snippet) do
+        <<~RUBY
+          create_procedure "meta.set_foo_value(a integer)" do |p|
+            p.body "SET custom.foo = a"
+          end
+        RUBY
+      end
+      let(:new_query) { "CALL meta.set_foo_value(42);" }
+
+      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 insert(new_snippet).into_schema }
+      its(:execution) { is_expected.to remove(old_snippet).from_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
+  end
+
+  context "without a name" do
+    let(:migration) do
+      <<~RUBY
+        rename_procedure to: "meta.set_foo"
+      RUBY
+    end
+
+    it { is_expected.to fail_validation.because(/name can't be blank/i) }
+  end
+end