pg_trunk 0.1.0

data/spec/operations/views/change_view_spec.rb

@@ -0,0 +1,144 @@
+# frozen_string_literal: true
+
+describe ActiveRecord::Migration, "#change_view" do
+  before_all do
+    run_migration <<~RUBY
+      create_table "users", force: :cascade do |t|
+        t.string "name"
+        t.boolean "admin"
+      end
+    RUBY
+  end
+  before { run_migration(old_snippet) }
+
+  let(:old_snippet) do
+    <<~RUBY
+      create_view "admin_users" do |v|
+        v.sql_definition <<~Q.chomp
+          SELECT users.id, users.name
+          FROM users
+          WHERE users.admin
+        Q
+        v.check :local
+        v.comment "Old comment"
+      end
+    RUBY
+  end
+  let(:new_snippet) do
+    <<~RUBY
+      create_view "admin_users" do |v|
+        v.sql_definition <<~Q.chomp
+          SELECT NULL::bigint AS id, users.name
+          FROM users
+          WHERE users.admin
+        Q
+        v.check :cascaded
+        v.comment "New comment"
+      end
+    RUBY
+  end
+
+  context "with explicitly reversible inline changes" do
+    let(:migration) do
+      <<~RUBY
+        change_view "admin_users" do |v|
+          v.sql_definition <<~Q.chomp, from: <<~Q.chomp
+            -- the column can be nullified but neither deleted nor retyped
+            SELECT NULL::bigint AS id, users.name
+            FROM users
+            WHERE users.admin
+          Q
+            SELECT users.id, users.name
+            FROM users
+            WHERE users.admin
+          Q
+          v.check :cascaded, from: :local
+          v.comment "New comment", from: "Old comment"
+        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 version changes" do
+    let(:migration) do
+      <<~RUBY
+        change_view "admin_users" do |v|
+          v.version 2, from: 1
+          v.check :cascaded, from: :local
+          v.comment "New comment", from: "Old comment"
+        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_view "admin_users" do |v|
+          v.version 2
+          v.check :cascaded
+          v.comment "New comment"
+        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(/version|check|comment/i) }
+  end
+
+  context "with no changes" do
+    let(:migration) do
+      <<~RUBY
+        change_view "admin_users"
+      RUBY
+    end
+
+    it { is_expected.to fail_validation.because(/changes can't be blank/i) }
+  end
+
+  context "when the view is absent" do
+    let(:migration) do
+      <<~RUBY
+        change_view "unknown" do |v|
+          v.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_view "unknown(integer)", if_exists: true do |v|
+            v.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 view name" do
+    let(:migration) do
+      <<~RUBY
+        change_view check: :cascaded
+      RUBY
+    end
+
+    it { is_expected.to fail_validation.because(/name can't be blank/i) }
+  end
+end

data/spec/operations/views/create_view_spec.rb

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+describe ActiveRecord::Migration, "#create_view" do
+  before_all do
+    run_migration <<~RUBY
+      create_table "users", force: :cascade do |t|
+        t.string "name"
+        t.boolean "admin"
+      end
+    RUBY
+  end
+
+  # from /spec/dummy/db/views/admin_users_v01.sql
+  let(:snippet) do
+    <<~RUBY
+      create_view "admin_users" do |v|
+        v.sql_definition <<~Q.chomp
+          SELECT users.id, users.name
+          FROM users
+          WHERE users.admin
+        Q
+      end
+    RUBY
+  end
+
+  context "when a view was absent" do
+    let(:migration) do
+      <<~RUBY
+        create_view "admin_users" do |v|
+          v.sql_definition <<~Q.chomp
+            SELECT users.id, users.name
+            FROM users
+            WHERE users.admin
+          Q
+          v.check :local
+          v.comment "Admin users only"
+        end
+      RUBY
+    end
+    let(:query) { "SELECT * FROM admin_users;" }
+
+    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 "when a view was present" do
+    before do
+      run_migration <<~RUBY
+        create_view "admin_users", sql_definition: "SELECT id, name FROM users"
+      RUBY
+    end
+
+    context "without the `replace_existing` option" do
+      let(:migration) do
+        <<~RUBY
+          create_view "admin_users" do |v|
+            v.sql_definition <<~Q.chomp
+              SELECT users.id, users.name
+              FROM users
+              WHERE users.admin
+            Q
+            v.check :local
+            v.comment "Admin users only"
+          end
+        RUBY
+      end
+
+      its(:execution) { is_expected.to raise_error(StandardError) }
+    end
+
+    context "with the `replace_existing: true` option" do
+      let(:migration) do
+        <<~RUBY
+          create_view "admin_users", replace_existing: true 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 }
+      it { is_expected.to be_irreversible.because_of(/replace_existing: true/i) }
+    end
+  end
+
+  context "without sql definition" do
+    context "with an existing version" do
+      let(:migration) do
+        <<~RUBY
+          create_view "admin_users", version: 1
+        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_view "admin_users", version: 99
+        RUBY
+      end
+
+      its(:execution) { is_expected.to raise_error(StandardError) }
+    end
+
+    context "without version" do
+      let(:migration) do
+        <<~RUBY
+          create_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_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/views/drop_view_spec.rb

@@ -0,0 +1,146 @@
+# frozen_string_literal: true
+
+describe ActiveRecord::Migration, "#drop_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_view "admin_users" do |v|
+        v.sql_definition <<~Q.chomp
+          SELECT users.id, users.name
+          FROM users
+          WHERE users.admin
+        Q
+        v.check :local
+        v.comment "Admin users only"
+      end
+    RUBY
+  end
+
+  context "with a full definition" do
+    let(:migration) do
+      <<~RUBY
+        drop_view "admin_users" do |v|
+          v.sql_definition <<~Q.chomp
+            SELECT users.id, users.name
+            FROM users
+            WHERE users.admin
+          Q
+          v.check :local
+          v.comment "Admin users only"
+        end
+      RUBY
+    end
+    let(:query) { "SELECT * FROM admin_users;" }
+
+    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_view "admin_users", revert_to_version: 1 do |v|
+          v.check :local
+          v.comment "Admin users only"
+        end
+      RUBY
+    end
+
+    its(:execution) { is_expected.to remove(snippet).from_schema }
+    its(:inversion) { is_expected.not_to change_schema }
+  end
+
+  context "with a name only" do
+    let(:migration) do
+      <<~RUBY
+        drop_view "admin_users"
+      RUBY
+    end
+
+    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
+    before do
+      run_migration <<~RUBY
+        drop_view "admin_users"
+      RUBY
+    end
+
+    context "without the `if_exists` option" do
+      let(:migration) do
+        <<~RUBY
+          drop_view "admin_users"
+        RUBY
+      end
+
+      its(:execution) { is_expected.to raise_error(StandardError) }
+    end
+
+    context "with the `replace_existing: true` option" do
+      let(:migration) do
+        <<~RUBY
+          drop_view "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
+
+  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_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_view "admin_users", 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 "without a name" do
+    let(:migration) do
+      <<~RUBY
+        drop_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/views/rename_view_spec.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+describe ActiveRecord::Migration, "#rename_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_view "admins" do |v|
+        v.sql_definition <<~Q.chomp
+          SELECT users.id, users.name
+          FROM users
+          WHERE users.admin
+        Q
+      end
+    RUBY
+  end
+  let(:new_snippet) do
+    <<~RUBY
+      create_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(:query) { "SELECT * FROM admin_users;" }
+
+  context "with a new name" do
+    let(:migration) do
+      <<~RUBY
+        rename_view :admins, to: :admin_users
+      RUBY
+    end
+
+    its(:execution) { is_expected.to remove(old_snippet).from_schema }
+    its(:execution) { is_expected.to insert(new_snippet).into_schema }
+    its(:execution) { is_expected.to enable_sql_request(query) }
+
+    its(:inversion) { is_expected.to disable_sql_request(query) }
+    its(:inversion) { is_expected.not_to change_schema }
+  end
+
+  context "with the same name" do
+    let(:migration) do
+      <<~RUBY
+        rename_view :admin_users, to: "public.admin_users"
+      RUBY
+    end
+
+    it { is_expected.to fail_validation.because(/new name must be different/i) }
+  end
+
+  context "when a view was absent" do
+    context "without the `if_exists` option" do
+      let(:migration) do
+        <<~RUBY
+          rename_view :administrators, to: :admins
+        RUBY
+      end
+
+      its(:execution) { is_expected.to raise_error(StandardError) }
+    end
+
+    context "with the `if_exists: true` option" do
+      let(:migration) do
+        <<~RUBY
+          rename_view :administrators, to: :admins, 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/pg_trunk/dependencies_resolver_spec.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+# noinspection RubyResolve
+require "spec_helper"
+
+RSpec.describe PGTrunk::DependenciesResolver do
+  subject { described_class.resolve(input).map(&:oid) }
+
+  let(:input) { (1..10).map { |oid| object.new(oid) }.freeze }
+  # For simplicity we presume objects are sorted by oid
+  let(:object) do
+    Struct.new(:oid) do
+      include Comparable
+
+      def <=>(other)
+        oid <=> other.oid
+      end
+    end
+  end
+
+  before do
+    # We mock the method here to avoid polluting the `pg_depend` catalog.
+    allow(described_class).to receive(:dependencies).and_return(dependencies)
+  end
+
+  describe "List of independent objects" do
+    let(:dependencies) { {} }
+    let(:output) { (1..10).to_a }
+
+    it "restores the natural order" do
+      expect(subject).to eq(output)
+    end
+  end
+
+  describe "List of dependent objects" do
+    let(:dependencies) { { 2 => [7], 3 => [5], 5 => [8] } }
+    let(:output) { [1, 7, 2, 8, 5, 3, 4, 6, 9, 10] }
+
+    it "is sorted so that dependencies are resolved" do
+      expect(subject).to eq(output)
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+ENV["RAILS_ENV"] = "test"
+
+require "pry"
+require "pry-byebug"
+require "database_cleaner/active_record"
+require "pg_trunk"
+require "rspec/its"
+require "test_prof/recipes/rspec/before_all"
+
+require File.expand_path("dummy/config/environment", __dir__)
+
+# noinspection RubyResolve
+Dir["spec/support/**/*.rb"].sort.each { |file| load file }
+
+RSpec.configure do |config|
+  config.example_status_persistence_file_path = ".rspec_status"
+  config.order = "random"
+  config.expect_with :rspec do |c|
+    c.syntax = :expect
+  end
+
+  # Filter examples by server version
+  server_version = PGTrunk.database.server_version.first(2).to_i
+  config.filter_run_excluding(before_version: ->(v) { v <= server_version })
+  config.filter_run_excluding(since_version: ->(v) { v > server_version })
+end