pg_trunk 0.1.0

data/spec/operations/functions/change_function_spec.rb

@@ -0,0 +1,166 @@
+# frozen_string_literal: true
+
+describe ActiveRecord::Migration, "#change_function" do
+  before do
+    run_migration <<~RUBY
+      create_function "mult(a integer, b integer) integer" do |f|
+        f.volatility :immutable
+        f.body "SELECT a * b"
+      end
+
+      # Overload the function to ensure a proper one is found
+      create_function "mult(a int, b int, c int) int",
+                      body: "SELECT a * b * c"
+
+      # Use the function to ensure it can be chanded
+      # even though it has dependent objects.
+      create_table "sums" do |t|
+        t.integer :a
+        t.integer :b
+        t.index "mult(a, b)"
+      end
+    RUBY
+  end
+
+  let(:old_snippet) do
+    <<~RUBY
+      create_function "mult(a integer, b integer) integer" do |f|
+        f.volatility :immutable
+        f.body "SELECT a * b"
+      end
+    RUBY
+  end
+
+  context "with implicitly reversible changes" do
+    let(:migration) do
+      <<~RUBY
+        change_function "mult(integer, integer)" do |f|
+          f.strict true
+          f.leakproof true
+          f.security :definer
+        end
+      RUBY
+    end
+    let(:new_snippet) do
+      <<~RUBY
+        create_function "mult(a integer, b integer) integer" do |f|
+          f.volatility :immutable
+          f.leakproof true
+          f.strict true
+          f.security :definer
+          f.body "SELECT a * b"
+        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_function "mult(integer, integer)" do |f|
+          f.parallel :safe, from: :unsafe
+          f.body <<~Q, from: <<~Q
+            SELECT a + b
+          Q
+            SELECT a * b
+          Q
+        end
+      RUBY
+    end
+    let(:new_snippet) do
+      <<~RUBY
+        create_function "mult(a integer, b integer) integer" do |f|
+          f.volatility :immutable
+          f.parallel :safe
+          f.body "SELECT a + b"
+        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_function "mult(integer, integer)" do |f|
+          f.strict true
+          f.leakproof true
+          f.security :definer
+          f.parallel :safe
+          f.cost 5.0
+        end
+      RUBY
+    end
+    let(:new_snippet) do
+      <<~RUBY
+        create_function "mult(a integer, b integer) integer" do |f|
+          f.volatility :immutable
+          f.leakproof true
+          f.strict true
+          f.security :definer
+          f.parallel :safe
+          f.cost 5.0
+          f.body "SELECT a * b"
+        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(/parallel|cost/i) }
+  end
+
+  context "with no changes" do
+    let(:migration) do
+      <<~RUBY
+        change_function "mult(integer, integer)"
+      RUBY
+    end
+
+    it { is_expected.to fail_validation.because(/changes can't be blank/i) }
+  end
+
+  context "when the function is absent" do
+    let(:migration) do
+      <<~RUBY
+        change_function "unknown(integer)" do |f|
+          f.comment "New 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_function "unknown(integer)", if_exists: true do |f|
+            f.comment "New 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_function strict: true
+      RUBY
+    end
+
+    it { is_expected.to fail_validation.because(/name can't be blank/i) }
+  end
+end

data/spec/operations/functions/create_function_spec.rb

@@ -0,0 +1,192 @@
+# frozen_string_literal: true
+
+describe ActiveRecord::Migration, "#create_function" do
+  context "with a minimal definition" do
+    let(:migration) do
+      <<~RUBY
+        create_function "mult(a integer, b integer) integer", body: "SELECT a * b"
+      RUBY
+    end
+    let(:snippet) do
+      <<~RUBY
+        create_function "mult(a integer, b integer) integer" do |f|
+          f.body "SELECT a * b"
+        end
+      RUBY
+    end
+    let(:query) { "SELECT mult(1, 3);" }
+
+    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_function "mult(a integer, b integer) integer" do |f|
+          f.language "plpgsql"
+          f.volatility :immutable
+          f.leakproof true
+          f.strict true
+          f.parallel :safe
+          f.cost 1.0
+          f.body "BEGIN return a * b; END;"
+          f.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 function existed" do
+    before do
+      run_migration <<~RUBY
+        create_function "mult(a int, b int) int", body: "SELECT 0"
+      RUBY
+    end
+
+    context "without replace_existing: true" do
+      let(:migration) do
+        <<~RUBY
+          create_function "mult(a integer, b integer) integer",
+                          body: "SELECT a * b"
+        RUBY
+      end
+
+      its(:execution) { is_expected.to raise_error(StandardError) }
+    end
+
+    context "with replace_existing: true" do
+      let(:migration) do
+        <<~RUBY
+          create_function "mult(a integer, b integer) integer",
+                          body: "SELECT a * b",
+                          replace_existing: true
+        RUBY
+      end
+      let(:new_snippet) do
+        <<~RUBY
+          create_function "mult(a integer, b integer) integer" do |f|
+            f.body "SELECT a * b"
+          end
+        RUBY
+      end
+      let(:old_snippet) do
+        <<~RUBY
+          create_function "mult(a integer, b integer) integer" do |f|
+            f.body "SELECT 0"
+          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 function contains SQL injection" do
+    # Running it would inject the SQL code going after $$
+    let(:migration) do
+      <<~RUBY
+        create_function "mult(a integer, b integer) integer" do |f|
+          f.body <<~Q
+            SELECT a * b$$;DROP TABLE priceless;--
+          Q
+        end
+      RUBY
+    end
+
+    it { is_expected.to fail_validation.because_of(/SQL injection/i) }
+  end
+
+  context "when a function has named $-quotations" do
+    # This code is safe because `$greeting$` doesn't closes `$$`
+    let(:migration) do
+      <<~RUBY
+        create_function "greet(name text) text" do |f|
+          f.body "SELECT $greeting$Hi $greeting$ || name"
+        end
+      RUBY
+    end
+
+    its(:execution) { is_expected.to insert(migration).into_schema }
+  end
+
+  context "without returned value" do
+    let(:migration) do
+      <<~RUBY.squish
+        create_function "mult(a integer, b integer, OUT c integer)",
+                        body: "SELECT a * b"
+      RUBY
+    end
+    let(:snippet) do
+      <<~RUBY
+        create_function "mult(a integer, b integer, OUT c integer) integer" do |f|
+          f.body "SELECT a * b"
+        end
+      RUBY
+    end
+    let(:query) { "SELECT mult(1, 3);" }
+
+    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 "without arguments" do
+    let(:migration) do
+      <<~RUBY
+        create_function "set_foo", body: "SET foo = 42"
+      RUBY
+    end
+    let(:snippet) do
+      <<~RUBY
+        create_function "set_foo() void" do |f|
+          f.body "SET foo = 42"
+        end
+      RUBY
+    end
+
+    its(:execution) { is_expected.to insert(snippet).into_schema }
+  end
+
+  context "without name" do
+    let(:migration) do
+      <<~RUBY
+        create_function body: "INSERT INTO foo(bar) VALUES (1);"
+      RUBY
+    end
+
+    it { is_expected.to fail_validation.because(/name can't be blank/i) }
+  end
+
+  context "with unknown volatility" do
+    let(:migration) do
+      <<~RUBY
+        create_function "mult(a int, b int) int",
+                        body: "SELECT a * b",
+                        volatility: :whatever
+      RUBY
+    end
+
+    it { is_expected.to fail_validation.because(/not included in the list/i) }
+  end
+
+  context "without body" do
+    let(:migration) do
+      <<~RUBY
+        create_function "foo () void"
+      RUBY
+    end
+
+    it { is_expected.to fail_validation.because(/body can't be blank/i) }
+  end
+end

data/spec/operations/functions/drop_function_spec.rb

@@ -0,0 +1,182 @@
+# frozen_string_literal: true
+
+describe ActiveRecord::Migration, "#drop_function" do
+  before { run_migration(snippet) }
+
+  let(:snippet) do
+    <<~RUBY
+      create_function "mult(a integer, b integer) integer" do |f|
+        f.body "SELECT a * b"
+      end
+    RUBY
+  end
+  let(:query) { "SELECT mult(6, 7);" }
+
+  context "with a function name only" do
+    let(:migration) do
+      <<~RUBY
+        drop_function "mult"
+      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 function signature" do
+    let(:migration) do
+      <<~RUBY
+        drop_function "mult (int, 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 function body" do
+    let(:migration) do
+      <<~RUBY
+        drop_function "mult (a int, b int) int", body: "SELECT a * b"
+      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_function "mult(a integer, b integer) integer" do |f|
+          f.language "plpgsql"
+          f.volatility :immutable
+          f.leakproof true
+          f.strict true
+          f.parallel :safe
+          f.cost 5.0
+          f.body "BEGIN RETURN a * b; END;"
+          f.comment "Multiply 2 integers"
+        end
+      RUBY
+    end
+    let(:new_snippet) do
+      <<~RUBY
+        create_function "mult(a integer, b integer) integer" do |f|
+          f.language "plpgsql"
+          f.volatility :immutable
+          f.leakproof true
+          f.strict true
+          f.parallel :safe
+          f.cost 5.0
+          f.body "BEGIN RETURN a * b; END;"
+          f.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 insert(new_snippet).into_schema }
+  end
+
+  context "without a name" do
+    let(:migration) do
+      <<~RUBY
+        drop_function
+      RUBY
+    end
+
+    it { is_expected.to fail_validation.because(/name can't be blank/i) }
+  end
+
+  context "when several functions existed" do
+    before do
+      run_migration <<~RUBY
+        create_function "mult(a int, b int, c int) int",
+                        body: "SELECT a * b * c"
+      RUBY
+    end
+
+    context "with a name only" do
+      let(:migration) do
+        <<~RUBY
+          drop_function "mult"
+        RUBY
+      end
+
+      its(:execution) { is_expected.to raise_exception(StandardError) }
+    end
+
+    context "with a signature" do
+      let(:migration) do
+        <<~RUBY
+          drop_function "mult(integer, integer)"
+        RUBY
+      end
+
+      its(:execution) { is_expected.to remove(snippet).from_schema }
+    end
+  end
+
+  context "when the function was used" do
+    before do
+      run_migration <<~RUBY
+        create_table "foo" do |t|
+          t.integer "a"
+          t.integer "b"
+          t.index "mult(a, b)"
+        end
+      RUBY
+    end
+
+    context "without the :force option" do
+      let(:migration) do
+        <<~RUBY
+          drop_function "mult"
+        RUBY
+      end
+
+      its(:execution) { is_expected.to raise_exception(StandardError) }
+    end
+
+    context "with the force: :cascade option" do
+      let(:migration) do
+        <<~RUBY
+          drop_function "mult", force: :cascade
+        RUBY
+      end
+
+      its(:execution) { is_expected.to remove(snippet).from_schema }
+      it { is_expected.to be_irreversible.because_of(/force: :cascade/i) }
+    end
+  end
+
+  context "when the function was absent" do
+    context "without the :if_exists option" do
+      let(:migration) do
+        <<~RUBY
+          drop_function "unknown"
+        RUBY
+      end
+
+      its(:execution) { is_expected.to raise_error(StandardError) }
+    end
+
+    context "with the if_exists: true option" do
+      let(:migration) do
+        <<~RUBY
+          drop_function "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/functions/rename_function_spec.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+describe ActiveRecord::Migration, "#rename_function" do
+  before do
+    run_migration <<~RUBY
+      create_schema :math
+    RUBY
+
+    run_migration(old_snippet)
+  end
+
+  let(:new_snippet) do
+    <<~RUBY
+      create_function "math.multiply(a integer, b integer) integer" do |f|
+        f.body "SELECT a * b"
+      end
+    RUBY
+  end
+  let(:old_snippet) do
+    <<~RUBY
+      create_function "mult(a integer, b integer) integer" do |f|
+        f.body "SELECT a * b"
+      end
+    RUBY
+  end
+  let(:old_query) { "SELECT mult(7, 6);" }
+  let(:new_query) { "SELECT math.multiply(7, 6);" }
+
+  context "with new name and schema" do
+    let(:migration) do
+      <<~RUBY
+        rename_function "mult", to: "math.multiply"
+      RUBY
+    end
+
+    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_function "mult", to: "public.mult"
+      RUBY
+    end
+
+    it { is_expected.to fail_validation.because(/new name must be different/i) }
+  end
+
+  context "when several functions exist" do
+    before do
+      run_migration <<~RUBY
+        create_function "mult(a integer, b integer, c integer) integer",
+                        body: "SELECT a * b * c"
+      RUBY
+    end
+
+    context "without a signature" do
+      let(:migration) do
+        <<~RUBY
+          rename_function "mult", to: "math.multiply"
+        RUBY
+      end
+
+      its(:execution) { is_expected.to raise_error(StandardError) }
+    end
+
+    context "with a signature" do
+      let(:migration) do
+        <<~RUBY
+          rename_function "mult(int, integer)", to: "math.multiply"
+        RUBY
+      end
+
+      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_function to: "math.mult"
+      RUBY
+    end
+
+    it { is_expected.to fail_validation.because(/name can't be blank/i) }
+  end
+end