fx 0.1.0

data/spec/features/triggers/migrations_spec.rb

@@ -0,0 +1,56 @@
+require "spec_helper"
+
+describe "Trigger migrations", :db do
+  around do |example|
+    connection.execute <<~EOS
+      CREATE TABLE users (
+          id int PRIMARY KEY,
+          name varchar(256),
+          upper_name varchar(256)
+      );
+    EOS
+    Fx.database.create_function <<~EOS
+      CREATE OR REPLACE FUNCTION uppercase_users_name()
+      RETURNS trigger AS $$
+      BEGIN
+        NEW.upper_name = UPPER(NEW.name);
+        RETURN NEW;
+      END;
+      $$ LANGUAGE plpgsql;
+    EOS
+    sql_definition = <<~EOS
+      CREATE TRIGGER uppercase_users_name
+          BEFORE INSERT ON users
+          FOR EACH ROW
+          EXECUTE PROCEDURE uppercase_users_name();
+    EOS
+    with_trigger_definition(
+      name: :uppercase_users_name,
+      sql_definition: sql_definition,
+    ) do
+      example.run
+    end
+  end
+
+  it "can run migrations that create triggers" do
+    migration = Class.new(ActiveRecord::Migration) do
+      def up
+        create_trigger :uppercase_users_name
+      end
+    end
+
+    expect { run_migration(migration, :up) }.not_to raise_error
+  end
+
+  it "can run migrations that drop triggers" do
+    connection.create_trigger(:uppercase_users_name)
+
+    migration = Class.new(ActiveRecord::Migration) do
+      def up
+        drop_trigger :uppercase_users_name, on: :users
+      end
+    end
+
+    expect { run_migration(migration, :up) }.not_to raise_error
+  end
+end

data/spec/features/triggers/revert_spec.rb

@@ -0,0 +1,95 @@
+require "spec_helper"
+
+describe "Reverting migrations", :db do
+  around do |example|
+    connection.execute <<~EOS
+      CREATE TABLE users (
+          id int PRIMARY KEY,
+          name varchar(256),
+          upper_name varchar(256)
+      );
+    EOS
+    Fx.database.create_function <<~EOS
+      CREATE OR REPLACE FUNCTION uppercase_users_name()
+      RETURNS trigger AS $$
+      BEGIN
+        NEW.upper_name = UPPER(NEW.name);
+        RETURN NEW;
+      END;
+      $$ LANGUAGE plpgsql;
+    EOS
+    sql_definition = <<~EOS
+      CREATE TRIGGER uppercase_users_name
+          BEFORE INSERT ON users
+          FOR EACH ROW
+          EXECUTE PROCEDURE uppercase_users_name();
+    EOS
+    with_trigger_definition(
+      name: :uppercase_users_name,
+      sql_definition: sql_definition,
+    ) do
+      example.run
+    end
+  end
+
+  it "can run reversible migrations for creating triggers" do
+    migration = Class.new(ActiveRecord::Migration) do
+      def change
+        create_trigger :uppercase_users_name, on: :users
+      end
+    end
+
+    expect { run_migration(migration, [:up, :down]) }.not_to raise_error
+  end
+
+  it "can run reversible migrations for dropping triggers" do
+    connection.create_trigger(:uppercase_users_name, on: :users)
+
+    good_migration = Class.new(ActiveRecord::Migration) do
+      def change
+        drop_trigger :uppercase_users_name, on: :users, revert_to_version: 1
+      end
+    end
+    bad_migration = Class.new(ActiveRecord::Migration) do
+      def change
+        drop_trigger :uppercase_users_name, on: :users
+      end
+    end
+
+    expect { run_migration(good_migration, [:up, :down]) }.not_to raise_error
+    expect { run_migration(bad_migration, [:up, :down]) }.
+      to raise_error(
+        ActiveRecord::IrreversibleMigration,
+        /`create_trigger` is reversible only if given a `revert_to_version`/,
+      )
+  end
+
+  it "can run reversible migrations for updating triggers" do
+    connection.create_trigger(:uppercase_users_name)
+
+    sql_definition = <<~EOS
+      CREATE TRIGGER uppercase_users_name
+          BEFORE UPDATE ON users
+          FOR EACH ROW
+          EXECUTE PROCEDURE uppercase_users_name();
+    EOS
+    with_trigger_definition(
+      name: :uppercase_users_name,
+      sql_definition: sql_definition,
+      version: 2,
+    ) do
+      migration = Class.new(ActiveRecord::Migration) do
+        def change
+          update_trigger(
+            :uppercase_users_name,
+            on: :users,
+            version: 2,
+            revert_to_version: 1,
+          )
+        end
+      end
+
+      expect { run_migration(migration, [:up, :down]) }.not_to raise_error
+    end
+  end
+end

data/spec/fx/adapters/postgres_spec.rb

@@ -0,0 +1,149 @@
+require "spec_helper"
+
+module Fx::Adapters
+  describe Postgres, :db do
+    describe "#create_function" do
+      it "successfully creates a function" do
+        adapter = Postgres.new
+        adapter.create_function(
+          <<~EOS
+            CREATE OR REPLACE FUNCTION test()
+            RETURNS text AS $$
+            BEGIN
+                RETURN 'test';
+            END;
+            $$ LANGUAGE plpgsql;
+          EOS
+        )
+
+        expect(adapter.functions.map(&:name)).to include("test")
+      end
+    end
+
+    describe "#create_trigger" do
+      it "successfully creates a trigger" do
+        connection.execute <<~EOS
+          CREATE TABLE users (
+              id int PRIMARY KEY,
+              name varchar(256),
+              upper_name varchar(256)
+          );
+        EOS
+        adapter = Postgres.new
+        adapter.create_function <<~EOS
+          CREATE OR REPLACE FUNCTION uppercase_users_name()
+          RETURNS trigger AS $$
+          BEGIN
+            NEW.upper_name = UPPER(NEW.name);
+            RETURN NEW;
+          END;
+          $$ LANGUAGE plpgsql;
+        EOS
+        adapter.create_trigger(
+          <<~EOS
+            CREATE TRIGGER uppercase_users_name
+                BEFORE INSERT ON users
+                FOR EACH ROW
+                EXECUTE PROCEDURE uppercase_users_name();
+          EOS
+        )
+
+        expect(adapter.triggers.map(&:name)).to include("uppercase_users_name")
+      end
+    end
+
+    describe "#drop_function" do
+      it "successfully drops a function" do
+        adapter = Postgres.new
+        adapter.create_function(
+          <<~EOS
+            CREATE OR REPLACE FUNCTION test()
+            RETURNS text AS $$
+            BEGIN
+                RETURN 'test';
+            END;
+            $$ LANGUAGE plpgsql;
+          EOS
+        )
+
+        adapter.drop_function(:test)
+
+        expect(adapter.functions.map(&:name)).not_to include("test")
+      end
+    end
+
+    describe "#functions" do
+      it "finds functions and builds Fx::Function objects" do
+        adapter = Postgres.new
+        adapter.create_function(
+          <<~EOS
+            CREATE OR REPLACE FUNCTION test()
+            RETURNS text AS $$
+            BEGIN
+                RETURN 'test';
+            END;
+            $$ LANGUAGE plpgsql;
+          EOS
+        )
+
+        expect(adapter.functions).to eq([
+          Fx::Function.new(
+            "name" => "test",
+            "definition" => <<~EOS
+              CREATE OR REPLACE FUNCTION public.test()
+               RETURNS text
+               LANGUAGE plpgsql
+              AS $function$
+              BEGIN
+                  RETURN 'test';
+              END;
+              $function$
+            EOS
+          ),
+        ])
+      end
+    end
+
+    describe "#triggers" do
+      it "finds triggers and builds Fx::Trigger objects" do
+        connection.execute <<~EOS
+          CREATE TABLE users (
+              id int PRIMARY KEY,
+              name varchar(256),
+              upper_name varchar(256)
+          );
+        EOS
+        adapter = Postgres.new
+        adapter.create_function <<~EOS
+          CREATE OR REPLACE FUNCTION uppercase_users_name()
+          RETURNS trigger AS $$
+          BEGIN
+            NEW.upper_name = UPPER(NEW.name);
+            RETURN NEW;
+          END;
+          $$ LANGUAGE plpgsql;
+        EOS
+        sql_definition = <<~EOS
+          CREATE TRIGGER uppercase_users_name
+              BEFORE INSERT ON users
+              FOR EACH ROW
+              EXECUTE PROCEDURE uppercase_users_name()
+        EOS
+        adapter.create_trigger(sql_definition)
+
+        expect(adapter.triggers).to eq(
+          [
+            Fx::Trigger.new(
+              "name" => "uppercase_users_name",
+              "definition" => format_trigger(sql_definition),
+            ),
+          ],
+        )
+      end
+    end
+
+    def format_trigger(trigger)
+      trigger.gsub("\n", "").gsub("    ", " ")
+    end
+  end
+end

data/spec/fx/command_recorder/arguments_spec.rb

@@ -0,0 +1,41 @@
+require "spec_helper"
+
+module Fx::CommandRecorder
+  describe Arguments do
+    describe "#function" do
+      it "returns the function name" do
+        raw_args = [:spaceships, { foo: :bar }]
+        args = Arguments.new(raw_args)
+
+        expect(args.function).to eq :spaceships
+      end
+    end
+
+    describe "#revert_to_version" do
+      it "is the revert_to_version from the keyword arguments" do
+        raw_args = [:spaceships, { revert_to_version: 42 }]
+        args = Arguments.new(raw_args)
+
+        expect(args.revert_to_version).to eq 42
+      end
+
+      it "is nil if the revert_to_version was not supplied" do
+        raw_args = [:spaceships, { foo: :bar }]
+        args = Arguments.new(raw_args)
+
+        expect(args.revert_to_version).to be nil
+      end
+    end
+
+    describe "#invert_version" do
+      it "returns object with version set to revert_to_version" do
+        raw_args = [:meatballs, { version: 42, revert_to_version: 15 }]
+
+        inverted_args = Arguments.new(raw_args).invert_version
+
+        expect(inverted_args.version).to eq 15
+        expect(inverted_args.revert_to_version).to be nil
+      end
+    end
+  end
+end

data/spec/fx/command_recorder_spec.rb

@@ -0,0 +1,171 @@
+require "spec_helper"
+
+describe Fx::CommandRecorder, :db do
+  describe "#create_function" do
+    it "records the created function" do
+      recorder = ActiveRecord::Migration::CommandRecorder.new
+
+      recorder.create_function :test
+
+      expect(recorder.commands).to eq [[:create_function, [:test], nil]]
+    end
+
+    it "reverts to drop_function" do
+      recorder = ActiveRecord::Migration::CommandRecorder.new
+
+      recorder.create_function :test
+
+      expect(recorder.commands).to eq [[:create_function, [:test], nil]]
+    end
+
+    it "reverts to drop_function" do
+      recorder = ActiveRecord::Migration::CommandRecorder.new
+
+      recorder.revert { recorder.create_function :test }
+
+      expect(recorder.commands).to eq [[:drop_function, [:test]]]
+    end
+  end
+
+  describe "#drop_function" do
+    it "records the dropped function" do
+      recorder = ActiveRecord::Migration::CommandRecorder.new
+
+      recorder.drop_function :test
+
+      expect(recorder.commands).to eq [[:drop_function, [:test], nil]]
+    end
+
+    it "reverts to create_function with specified revert_to_version" do
+      recorder = ActiveRecord::Migration::CommandRecorder.new
+      args = [:test, { revert_to_version: 3 }]
+      revert_args = [:test, { version: 3 }]
+
+      recorder.revert { recorder.drop_function(*args) }
+
+      expect(recorder.commands).to eq [[:create_function, revert_args]]
+    end
+
+    it "raises when reverting without revert_to_version set" do
+      recorder = ActiveRecord::Migration::CommandRecorder.new
+      args = [:test, { another_argument: 1 }]
+
+      expect { recorder.revert { recorder.drop_function(*args) } }.
+        to raise_error(ActiveRecord::IrreversibleMigration)
+    end
+  end
+
+  describe "#update_function" do
+    it "records the updated function" do
+      recorder = ActiveRecord::Migration::CommandRecorder.new
+      args = [:test, { version: 2 }]
+
+      recorder.update_function(*args)
+
+      expect(recorder.commands).to eq [[:update_function, args, nil]]
+    end
+
+    it "reverts to update_function with the specified revert_to_version" do
+      recorder = ActiveRecord::Migration::CommandRecorder.new
+      args = [:test, { version: 2, revert_to_version: 1 }]
+      revert_args = [:test, { version: 1 }]
+
+      recorder.revert { recorder.update_function(*args) }
+
+      expect(recorder.commands).to eq [[:update_function, revert_args]]
+    end
+
+    it "raises when reverting without revert_to_version set" do
+      recorder = ActiveRecord::Migration::CommandRecorder.new
+      args = [:test, { version: 42, another_argument: 1 }]
+
+      expect { recorder.revert { recorder.update_function(*args) } }.
+        to raise_error(ActiveRecord::IrreversibleMigration)
+    end
+  end
+
+  describe "#create_trigger" do
+    it "records the created trigger" do
+      recorder = ActiveRecord::Migration::CommandRecorder.new
+
+      recorder.create_trigger :greetings
+
+      expect(recorder.commands).to eq [[:create_trigger, [:greetings], nil]]
+    end
+
+    it "reverts to drop_trigger" do
+      recorder = ActiveRecord::Migration::CommandRecorder.new
+
+      recorder.create_trigger :greetings
+
+      expect(recorder.commands).to eq [
+        [:create_trigger, [:greetings], nil],
+      ]
+    end
+
+    it "reverts to drop_trigger" do
+      recorder = ActiveRecord::Migration::CommandRecorder.new
+
+      recorder.revert { recorder.create_trigger :greetings }
+
+      expect(recorder.commands).to eq [[:drop_trigger, [:greetings]]]
+    end
+  end
+
+  describe "#drop_trigger" do
+    it "records the dropped trigger" do
+      recorder = ActiveRecord::Migration::CommandRecorder.new
+
+      recorder.drop_trigger :users
+
+      expect(recorder.commands).to eq [[:drop_trigger, [:users], nil]]
+    end
+
+    it "reverts to create_trigger with specified revert_to_version" do
+      recorder = ActiveRecord::Migration::CommandRecorder.new
+      args = [:users, { revert_to_version: 3 }]
+      revert_args = [:users, { version: 3 }]
+
+      recorder.revert { recorder.drop_trigger(*args) }
+
+      expect(recorder.commands).to eq [[:create_trigger, revert_args]]
+    end
+
+    it "raises when reverting without revert_to_version set" do
+      recorder = ActiveRecord::Migration::CommandRecorder.new
+      args = [:users, { another_argument: 1 }]
+
+      expect { recorder.revert { recorder.drop_trigger(*args) } }.
+        to raise_error(ActiveRecord::IrreversibleMigration)
+    end
+  end
+
+  describe "#update_trigger" do
+    it "records the updated trigger" do
+      recorder = ActiveRecord::Migration::CommandRecorder.new
+      args = [:users, { version: 2 }]
+
+      recorder.update_trigger(*args)
+
+      expect(recorder.commands).to eq [[:update_trigger, args, nil]]
+    end
+
+    it "reverts to update_trigger with the specified revert_to_version" do
+      recorder = ActiveRecord::Migration::CommandRecorder.new
+      args = [:users, { version: 2, revert_to_version: 1 }]
+      revert_args = [:users, { version: 1 }]
+
+      recorder.revert { recorder.update_trigger(*args) }
+
+      expect(recorder.commands).to eq [[:update_trigger, revert_args]]
+    end
+
+    it "raises when reverting without revert_to_version set" do
+      recorder = ActiveRecord::Migration::CommandRecorder.new
+      args = [:users, { version: 42, another_argument: 1 }]
+
+      expect { recorder.revert { recorder.update_trigger(*args) } }.
+        to raise_error(ActiveRecord::IrreversibleMigration)
+    end
+  end
+end