pg_trunk 0.1.0

data/spec/operations/indexes/add_index_spec.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+describe ActiveRecord::Migration, "#add_index" do
+  context "when index added inside a table definition" do
+    let(:migration) do
+      <<~RUBY
+        create_table :users do |t|
+          t.string "name", index: true
+        end
+      RUBY
+    end
+    let(:snippet) do
+      <<~RUBY
+        create_table "users", force: :cascade do |t|
+          t.string "name"
+        end
+
+        add_index "users", ["name"], name: "index_users_on_name"
+      RUBY
+    end
+
+    its(:execution) { is_expected.to insert(snippet).into_schema }
+  end
+
+  context "when primary key added inside a table definition" do
+    let(:migration) do
+      <<~RUBY
+        create_table :users, primary_key: :name do |t|
+        end
+      RUBY
+    end
+    let(:snippet) do
+      <<~RUBY
+        create_table "users", primary_key: "name", force: :cascade do |t|
+        end
+      RUBY
+    end
+
+    its(:execution) { is_expected.to insert(snippet).into_schema }
+  end
+
+  context "when index is added outside of a table definition" do
+    let(:migration) do
+      <<~RUBY
+        create_table :users do |t|
+          t.string "name"
+        end
+
+        add_index :users, :name
+      RUBY
+    end
+    let(:snippet) do
+      <<~RUBY
+        create_table "users", force: :cascade do |t|
+          t.string "name"
+        end
+
+        add_index "users", ["name"], name: "index_users_on_name"
+      RUBY
+    end
+
+    its(:execution) { is_expected.to insert(snippet).into_schema }
+  end
+
+  context "with several indexes" do
+    let(:migration) do
+      <<~RUBY
+        create_table :users do |t|
+          t.string :role, index: true
+          t.string :name, index: true
+        end
+
+        create_table :roles do |t|
+          t.string :name, index: true
+          t.string :access, array: true, index: true
+        end
+      RUBY
+    end
+    let(:snippet) do
+      # Ordered by table and name
+      <<~RUBY
+        add_index "roles", ["access"], name: "index_roles_on_access"
+
+        add_index "roles", ["name"], name: "index_roles_on_name"
+
+        add_index "users", ["name"], name: "index_users_on_name"
+
+        add_index "users", ["role"], name: "index_users_on_role"
+      RUBY
+    end
+
+    its(:execution) { is_expected.to insert(snippet).into_schema }
+  end
+end

data/spec/operations/materialized_views/change_materialized_view_spec.rb

@@ -0,0 +1,190 @@
+# frozen_string_literal: true
+
+describe ActiveRecord::Migration, "#change_materialized_view" do
+  before_all do
+    run_migration <<~RUBY
+      create_table "users" do |t|
+        t.string "name"
+        t.boolean "admin"
+      end
+    RUBY
+  end
+
+  before do
+    run_migration <<~RUBY
+      create_materialized_view "admins" do |v|
+        v.sql_definition <<~Q.chomp
+          SELECT users.id, users.name
+          FROM users
+          WHERE users.admin
+        Q
+        v.comment "Initial comment"
+      end
+
+      add_index :admins, :name, name: "view_index"
+    RUBY
+  end
+
+  context "with renaming a column" do
+    let(:migration) do
+      <<~RUBY
+        change_materialized_view "admins" do |v|
+          v.rename_column "name", to: "full_name"
+        end
+      RUBY
+    end
+    let(:snippet) do
+      <<~RUBY
+        create_materialized_view "admins" do |v|
+          v.sql_definition <<~Q.chomp
+            SELECT users.id, users.name AS full_name
+            FROM users
+            WHERE users.admin
+          Q
+          v.comment "Initial comment"
+        end
+      RUBY
+    end
+    let(:query) { "SELECT full_name FROM admins;" }
+
+    its(:execution) { is_expected.to enable_sql_request(query) }
+    its(:execution) { is_expected.to insert(snippet).into_schema }
+    its(:inversion) { is_expected.not_to change_schema }
+  end
+
+  context "with changing column storage" do
+    let(:migration) do
+      <<~RUBY
+        change_materialized_view "admins" do |v|
+          v.column "name", storage: "external", from_storage: "extended"
+        end
+      RUBY
+    end
+    let(: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
+          v.column "name", storage: :external
+          v.comment "Initial comment"
+        end
+      RUBY
+    end
+
+    its(:execution) { is_expected.to insert(snippet).into_schema }
+    its(:inversion) { is_expected.not_to change_schema }
+  end
+
+  context "with clustering a view by index" do
+    let(:migration) do
+      <<~RUBY
+        change_materialized_view "admins", cluster_on: "view_index"
+      RUBY
+    end
+
+    its(:execution) { is_expected.not_to raise_error }
+    its(:inversion) { is_expected.not_to change_schema }
+  end
+
+  context "with changing column's statistics" do
+    let(:migration) do
+      <<~RUBY
+        change_materialized_view "admins" do |v|
+          v.column "name", statistics: 10, n_distinct: 1
+        end
+      RUBY
+    end
+
+    its(:execution) { is_expected.not_to change_schema }
+    its(:inversion) { is_expected.not_to change_schema }
+  end
+
+  context "with a new comment" do
+    let(:migration) do
+      <<~RUBY
+        change_materialized_view "admins" do |v|
+          v.comment "Admin users only", from: "Initial comment"
+        end
+      RUBY
+    end
+    let(: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
+          v.comment "Admin users only"
+        end
+      RUBY
+    end
+
+    its(:execution) { is_expected.to insert(snippet).into_schema }
+    its(:inversion) { is_expected.not_to change_schema }
+  end
+
+  context "with an empty comment" do
+    let(:migration) do
+      <<~RUBY
+        change_materialized_view "admins" do |v|
+          v.comment "", from: "Initial comment"
+        end
+      RUBY
+    end
+    let(: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
+
+    its(:execution) { is_expected.to insert(snippet).into_schema }
+    its(:inversion) { is_expected.not_to change_schema }
+  end
+
+  context "when a view was absent" do
+    context "without the `if_exists` option" do
+      let(:migration) do
+        <<~RUBY
+          change_materialized_view "weird" do |v|
+            v.column "name", storage: :extended
+          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_materialized_view "weird", if_exists: true do |v|
+            v.column "name", storage: :extended
+          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 "with no changes" do
+    let(:migration) do
+      <<~RUBY
+        change_materialized_view "admins"
+      RUBY
+    end
+
+    it { is_expected.to fail_validation.because(/changes can't be blank/i) }
+  end
+end

data/spec/operations/materialized_views/create_materialized_view_spec.rb

@@ -0,0 +1,144 @@
+# frozen_string_literal: true
+
+describe ActiveRecord::Migration, "#create_materialized_view" do
+  before_all do
+    run_migration <<~RUBY
+      create_table "users", force: :cascade do |t|
+        t.string "name"
+        t.boolean "admin"
+      end
+    RUBY
+  end
+
+  let(:query) { "SELECT * FROM admin_users;" }
+
+  context "when a materialized view was absent" do
+    let(:migration) 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
+          v.column "name", storage: :external
+          v.comment "Admin users only"
+        end
+      RUBY
+    end
+
+    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 "with the `with_data: false` option" do
+    let(:migration) 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
+          v.with_data false
+        end
+      RUBY
+    end
+
+    its(:execution) { is_expected.to disable_sql_request(query) }
+    its(:execution) { is_expected.to insert(migration).into_schema }
+    its(:inversion) { is_expected.not_to change_schema }
+  end
+
+  context "when a materialized view was present" do
+    before do
+      run_migration <<~RUBY
+        create_materialized_view "admin_users" do |v|
+          v.sql_definition "SELECT * FROM users"
+        end
+      RUBY
+    end
+
+    context "without the `if_not_exists` option" do
+      let(:migration) do
+        <<~RUBY
+          create_materialized_view "admin_users" do |v|
+            v.sql_definition "SELECT * FROM users WHERE admin"
+          end
+        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_materialized_view "admin_users", if_not_exists: true do |v|
+            v.sql_definition "SELECT * FROM users WHERE admin"
+          end
+        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 "without sql definition" do
+    context "with an existing version" do
+      let(:migration) do
+        <<~RUBY
+          create_materialized_view "admin_users", version: 1
+        RUBY
+      end
+      let(: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
+
+      its(:execution) { is_expected.to insert(snippet).into_schema }
+      its(:inversion) { is_expected.not_to change_schema }
+    end
+
+    context "with an absent version" do
+      let(:migration) do
+        <<~RUBY
+          create_materialized_view "admin_users", version: 2
+        RUBY
+      end
+
+      its(:execution) { is_expected.to raise_error(StandardError) }
+    end
+
+    context "without version" do
+      let(:migration) do
+        <<~RUBY
+          create_materialized_view "admin_users"
+        RUBY
+      end
+
+      it { is_expected.to fail_validation.because(/sql definition can't be blank/i) }
+    end
+  end
+
+  context "without a name" do
+    let(:migration) do
+      <<~RUBY
+        create_materialized_view sql_definition: "SELECT * FROM users"
+      RUBY
+    end
+
+    it { is_expected.to fail_validation.because(/name can't be blank/i) }
+  end
+end

data/spec/operations/materialized_views/drop_materialized_view_spec.rb

@@ -0,0 +1,145 @@
+# frozen_string_literal: true
+
+describe ActiveRecord::Migration, "#drop_materialized_view" do
+  before_all do
+    run_migration <<~RUBY
+      create_table "users", force: :cascade do |t|
+        t.string "name"
+        t.boolean "admin"
+      end
+
+      create_table "weird"
+    RUBY
+  end
+  before { run_migration(snippet) }
+
+  let(: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
+        v.column "name", storage: :external
+        v.comment "Admin users only"
+      end
+    RUBY
+  end
+  let(:query) { "SELECT * FROM admin_users;" }
+
+  context "with a full definition" do
+    let(:migration) do
+      <<~RUBY
+        drop_materialized_view "admin_users" do |v|
+          v.sql_definition <<~Q.chomp
+            SELECT users.id, users.name
+            FROM users
+            WHERE users.admin
+          Q
+          v.column "name", storage: :external
+          v.comment "Admin users only"
+        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 version-based definition" do
+    let(:migration) do
+      <<~RUBY
+        drop_materialized_view "admin_users", revert_to_version: 1 do |v|
+          v.column "name", storage: :external
+          v.comment "Admin users only"
+        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 name only" do
+    let(:migration) do
+      <<~RUBY
+        drop_materialized_view "admin_users"
+      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(/sql_definition can't be blank/i) }
+  end
+
+  context "when a view was absent" do
+    context "without the `if_exists` option" do
+      let(:migration) do
+        <<~RUBY
+          drop_materialized_view "unknown"
+        RUBY
+      end
+
+      its(:execution) { is_expected.to raise_error(StandardError) }
+    end
+
+    context "with the `replace_existing: true` option" do
+      let(:migration) do
+        <<~RUBY
+          drop_materialized_view "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
+
+  context "when a view was used" do
+    before do
+      run_migration <<~RUBY
+        create_function "do_nothing() admin_users",
+                        body: "SELECT * FROM admin_users;"
+      RUBY
+    end
+
+    context "without the `:force` option" do
+      let(:migration) do
+        <<~RUBY
+          drop_materialized_view "admin_users"
+        RUBY
+      end
+
+      its(:execution) { is_expected.to raise_error(StandardError) }
+    end
+
+    context "with the `force: :cascade` option" do
+      let(:migration) do
+        <<~RUBY
+          drop_materialized_view "admin_users", 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 "without a name" do
+    let(:migration) do
+      <<~RUBY
+        drop_materialized_view sql_definition: "SELECT * FROM users"
+      RUBY
+    end
+
+    it { is_expected.to fail_validation.because(/name can't be blank/i) }
+  end
+end

data/spec/operations/materialized_views/refresh_materialized_view_spec.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+describe ActiveRecord::Migration, "#refresh_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(:query) { "SELECT * FROM admins;" }
+  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
+        v.with_data false
+      end
+    RUBY
+  end
+  let(:new_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
+
+  context "without options" do
+    let(:migration) do
+      <<~RUBY
+        refresh_materialized_view :admins
+      RUBY
+    end
+
+    its(:execution) { is_expected.to enable_sql_request(query) }
+    its(:execution) { is_expected.to insert(new_snippet).into_schema }
+    its(:execution) { is_expected.to remove(old_snippet).from_schema }
+
+    # Inversion (up, then down) keeps the schema in the migrated (valid) state
+    its(:execution) { is_expected.to enable_sql_request(query) }
+    its(:inversion) { is_expected.to insert(new_snippet).into_schema }
+    its(:inversion) { is_expected.to remove(old_snippet).from_schema }
+  end
+
+  context "with the `with_data: false` option" do
+    let(:migration) do
+      <<~RUBY
+        refresh_materialized_view :admins, with_data: false
+      RUBY
+    end
+
+    its(:execution) { is_expected.to disable_sql_request(query) }
+    its(:inversion) { is_expected.not_to change_schema }
+  end
+
+  context "with both `with_data` and `algorithm` option" do
+    let(:migration) do
+      <<~RUBY
+        refresh_materialized_view :admins do |v|
+          v.with_data false
+          v.algorithm :concurrently
+        end
+      RUBY
+    end
+
+    it { is_expected.to fail_validation.because(/algorithm must be blank/i) }
+  end
+end