fx 0.8.0 → 0.10.0

data/spec/fx/adapters/postgres_spec.rb

@@ -1,146 +1,186 @@
 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 $$
+RSpec.describe Fx::Adapters::Postgres, :db do
+  describe "#create_function" do
+    it "successfully creates a function" do
+      adapter = Fx::Adapters::Postgres.new
+      adapter.create_function(
+        <<~SQL
+          CREATE OR REPLACE FUNCTION test()
+          RETURNS text AS $$
           BEGIN
-            NEW.upper_name = UPPER(NEW.name);
-            RETURN NEW;
+              RETURN 'test';
           END;
           $$ LANGUAGE plpgsql;
-        EOS
-        adapter.create_trigger(
-          <<-EOS
-            CREATE TRIGGER uppercase_users_name
-                BEFORE INSERT ON users
-                FOR EACH ROW
-                EXECUTE FUNCTION uppercase_users_name();
-          EOS
-        )
+        SQL
+      )
 
-        expect(adapter.triggers.map(&:name)).to include("uppercase_users_name")
-      end
+      expect(adapter.functions.map(&:name)).to include("test")
     end
+  end
 
-    describe "#drop_function" do
-      context "when the function has arguments" do
-        it "successfully drops a function with the entire function signature" do
-          adapter = Postgres.new
-          adapter.create_function(
-            <<-EOS
-              CREATE FUNCTION adder(x int, y int)
-              RETURNS int AS $$
-              BEGIN
-                  RETURN $1 + $2;
-              END;
-              $$ LANGUAGE plpgsql;
-            EOS
-          )
-
-          adapter.drop_function(:adder)
-
-          expect(adapter.functions.map(&:name)).not_to include("adder")
-        end
-      end
+  describe "#create_trigger" do
+    it "successfully creates a trigger" do
+      connection.execute <<~SQL
+        CREATE TABLE users (
+            id int PRIMARY KEY,
+            name varchar(256),
+            upper_name varchar(256)
+        );
+      SQL
+      adapter = Fx::Adapters::Postgres.new
+      adapter.create_function <<~SQL
+        CREATE OR REPLACE FUNCTION uppercase_users_name()
+        RETURNS trigger AS $$
+        BEGIN
+          NEW.upper_name = UPPER(NEW.name);
+          RETURN NEW;
+        END;
+        $$ LANGUAGE plpgsql;
+      SQL
+      adapter.create_trigger(
+        <<~SQL
+          CREATE TRIGGER uppercase_users_name
+              BEFORE INSERT ON users
+              FOR EACH ROW
+              EXECUTE FUNCTION uppercase_users_name();
+        SQL
+      )
+
+      expect(adapter.triggers.map(&:name)).to include("uppercase_users_name")
+    end
+  end
+
+  describe "#drop_function" do
+    context "when the function has arguments" do
+      it "successfully drops a function with the entire function signature" do
+        adapter = Fx::Adapters::Postgres.new
+        adapter.create_function(
+          <<~SQL
+            CREATE FUNCTION adder(x int, y int)
+            RETURNS int AS $$
+            BEGIN
+                RETURN $1 + $2;
+            END;
+            $$ LANGUAGE plpgsql;
+          SQL
+        )
 
-      context "when the function does not have arguments" 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
+        adapter.drop_function(:adder)
+
+        expect(adapter.functions.map(&:name)).not_to include("adder")
       end
     end
 
-    describe "#functions" do
-      it "finds functions and builds Fx::Function objects" do
-        adapter = Postgres.new
+    context "when the function does not have arguments" do
+      it "successfully drops a function" do
+        adapter = Fx::Adapters::Postgres.new
         adapter.create_function(
-          <<-EOS
+          <<~SQL
             CREATE OR REPLACE FUNCTION test()
             RETURNS text AS $$
             BEGIN
                 RETURN 'test';
             END;
             $$ LANGUAGE plpgsql;
-          EOS
+          SQL
         )
 
-        expect(adapter.functions.map(&:name)).to eq ["test"]
+        adapter.drop_function(:test)
+
+        expect(adapter.functions.map(&:name)).not_to include("test")
       end
     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 $$
+  describe "#functions" do
+    it "finds functions and builds Fx::Function objects" do
+      adapter = Fx::Adapters::Postgres.new
+      adapter.create_function(
+        <<~SQL
+          CREATE OR REPLACE FUNCTION test()
+          RETURNS text AS $$
           BEGIN
-            NEW.upper_name = UPPER(NEW.name);
-            RETURN NEW;
+              RETURN 'test';
           END;
           $$ LANGUAGE plpgsql;
-        EOS
-        sql_definition = <<-EOS
-          CREATE TRIGGER uppercase_users_name
-              BEFORE INSERT ON users
-              FOR EACH ROW
-              EXECUTE FUNCTION uppercase_users_name()
-        EOS
-        adapter.create_trigger(sql_definition)
+        SQL
+      )
 
-        expect(adapter.triggers.map(&:name)).to eq ["uppercase_users_name"]
-      end
+      expect(adapter.functions.map(&:name)).to eq ["test"]
+    end
+  end
+
+  describe "#triggers" do
+    it "finds triggers and builds Fx::Trigger objects" do
+      connection.execute <<~SQL
+        CREATE TABLE users (
+            id int PRIMARY KEY,
+            name varchar(256),
+            upper_name varchar(256)
+        );
+      SQL
+      adapter = Fx::Adapters::Postgres.new
+      adapter.create_function <<~SQL
+        CREATE OR REPLACE FUNCTION uppercase_users_name()
+        RETURNS trigger AS $$
+        BEGIN
+          NEW.upper_name = UPPER(NEW.name);
+          RETURN NEW;
+        END;
+        $$ LANGUAGE plpgsql;
+      SQL
+      sql_definition = <<~SQL
+        CREATE TRIGGER uppercase_users_name
+            BEFORE INSERT ON users
+            FOR EACH ROW
+            EXECUTE FUNCTION uppercase_users_name()
+      SQL
+      adapter.create_trigger(sql_definition)
+
+      expect(adapter.triggers.map(&:name)).to eq ["uppercase_users_name"]
+    end
+  end
+
+  describe "#support_drop_function_without_args" do
+    it "returns true for PostgreSQL version 10.0" do
+      adapter = Fx::Adapters::Postgres.new
+      connection = adapter.send(:connection)
+      allow(connection).to receive(:server_version).and_return(10_00_00)
+
+      result = connection.support_drop_function_without_args
+
+      expect(result).to be(true)
+    end
+
+    it "returns true for PostgreSQL version 11.0" do
+      adapter = Fx::Adapters::Postgres.new
+      connection = adapter.send(:connection)
+      allow(connection).to receive(:server_version).and_return(11_00_00)
+
+      result = connection.support_drop_function_without_args
+
+      expect(result).to be(true)
+    end
+
+    it "returns false for PostgreSQL version 9.6" do
+      adapter = Fx::Adapters::Postgres.new
+      connection = adapter.send(:connection)
+      allow(connection).to receive(:server_version).and_return(9_06_00)
+
+      result = connection.support_drop_function_without_args
+
+      expect(result).to be(false)
+    end
+
+    it "returns false for PostgreSQL version 9.5" do
+      adapter = Fx::Adapters::Postgres.new
+      connection = adapter.send(:connection)
+      allow(connection).to receive(:server_version).and_return(9_05_00)
+
+      result = connection.support_drop_function_without_args
+
+      expect(result).to be(false)
     end
   end
 end

data/spec/fx/command_recorder_spec.rb

@@ -1,13 +1,13 @@
 require "spec_helper"
 
-describe Fx::CommandRecorder, :db do
+RSpec.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]]
+      expect(recorder.commands).to eq([[:create_function, [:test], nil]])
     end
 
     it "reverts to drop_function" do
@@ -15,7 +15,7 @@ describe Fx::CommandRecorder, :db do
 
       recorder.create_function :test
 
-      expect(recorder.commands).to eq [[:create_function, [:test], nil]]
+      expect(recorder.commands).to eq([[:create_function, [:test], nil]])
     end
 
     it "reverts to drop_function" do
@@ -23,7 +23,7 @@ describe Fx::CommandRecorder, :db do
 
       recorder.revert { recorder.create_function :test }
 
-      expect(recorder.commands).to eq [[:drop_function, [:test]]]
+      expect(recorder.commands).to eq([[:drop_function, [:test]]])
     end
   end
 
@@ -33,7 +33,7 @@ describe Fx::CommandRecorder, :db do
 
       recorder.drop_function :test
 
-      expect(recorder.commands).to eq [[:drop_function, [:test], nil]]
+      expect(recorder.commands).to eq([[:drop_function, [:test], nil]])
     end
 
     it "reverts to create_function with specified revert_to_version" do
@@ -43,15 +43,16 @@ describe Fx::CommandRecorder, :db do
 
       recorder.revert { recorder.drop_function(*args) }
 
-      expect(recorder.commands).to eq [[:create_function, revert_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)
+      expect do
+        recorder.revert { recorder.drop_function(*args) }
+      end.to raise_error(ActiveRecord::IrreversibleMigration)
     end
   end
 
@@ -62,7 +63,7 @@ describe Fx::CommandRecorder, :db do
 
       recorder.update_function(*args)
 
-      expect(recorder.commands).to eq [[:update_function, args, nil]]
+      expect(recorder.commands).to eq([[:update_function, args, nil]])
     end
 
     it "reverts to update_function with the specified revert_to_version" do
@@ -72,15 +73,16 @@ describe Fx::CommandRecorder, :db do
 
       recorder.revert { recorder.update_function(*args) }
 
-      expect(recorder.commands).to eq [[:update_function, revert_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)
+      expect do
+        recorder.revert { recorder.update_function(*args) }
+      end.to raise_error(ActiveRecord::IrreversibleMigration)
     end
   end
 
@@ -90,7 +92,7 @@ describe Fx::CommandRecorder, :db do
 
       recorder.create_trigger :greetings
 
-      expect(recorder.commands).to eq [[:create_trigger, [:greetings], nil]]
+      expect(recorder.commands).to eq([[:create_trigger, [:greetings], nil]])
     end
 
     it "reverts to drop_trigger" do
@@ -98,9 +100,7 @@ describe Fx::CommandRecorder, :db do
 
       recorder.create_trigger :greetings
 
-      expect(recorder.commands).to eq [
-        [:create_trigger, [:greetings], nil]
-      ]
+      expect(recorder.commands).to eq([[:create_trigger, [:greetings], nil]])
     end
 
     it "reverts to drop_trigger" do
@@ -108,7 +108,7 @@ describe Fx::CommandRecorder, :db do
 
       recorder.revert { recorder.create_trigger :greetings }
 
-      expect(recorder.commands).to eq [[:drop_trigger, [:greetings]]]
+      expect(recorder.commands).to eq([[:drop_trigger, [:greetings]]])
     end
   end
 
@@ -118,7 +118,7 @@ describe Fx::CommandRecorder, :db do
 
       recorder.drop_trigger :users
 
-      expect(recorder.commands).to eq [[:drop_trigger, [:users], nil]]
+      expect(recorder.commands).to eq([[:drop_trigger, [:users], nil]])
     end
 
     it "reverts to create_trigger with specified revert_to_version" do
@@ -128,15 +128,16 @@ describe Fx::CommandRecorder, :db do
 
       recorder.revert { recorder.drop_trigger(*args) }
 
-      expect(recorder.commands).to eq [[:create_trigger, revert_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)
+      expect do
+        recorder.revert { recorder.drop_trigger(*args) }
+      end.to raise_error(ActiveRecord::IrreversibleMigration)
     end
   end
 
@@ -147,7 +148,7 @@ describe Fx::CommandRecorder, :db do
 
       recorder.update_trigger(*args)
 
-      expect(recorder.commands).to eq [[:update_trigger, args, nil]]
+      expect(recorder.commands).to eq([[:update_trigger, args, nil]])
     end
 
     it "reverts to update_trigger with the specified revert_to_version" do
@@ -157,15 +158,16 @@ describe Fx::CommandRecorder, :db do
 
       recorder.revert { recorder.update_trigger(*args) }
 
-      expect(recorder.commands).to eq [[:update_trigger, revert_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)
+      expect do
+        recorder.revert { recorder.update_trigger(*args) }
+      end.to raise_error(ActiveRecord::IrreversibleMigration)
     end
   end
 end

data/spec/fx/configuration_spec.rb

@@ -1,21 +1,32 @@
 require "spec_helper"
 
-describe Fx::Configuration do
+RSpec.describe Fx::Configuration do
   it "defaults the database adapter to postgres" do
-    expect(Fx.configuration.database).to be_a Fx::Adapters::Postgres
-    expect(Fx.database).to be_a Fx::Adapters::Postgres
+    configuration = Fx::Configuration.new
+
+    expect(configuration.database).to be_a(Fx::Adapters::Postgres)
+  end
+
+  it "defaults `dump_functions_at_beginning_of_schema` to false" do
+    configuration = Fx::Configuration.new
+
+    expect(configuration.dump_functions_at_beginning_of_schema).to eq(false)
   end
 
   it "allows the database adapter to be set" do
+    configuration = Fx::Configuration.new
     adapter = double("Fx Adapter")
 
-    Fx.configure do |config|
-      config.database = adapter
-    end
+    configuration.database = adapter
+
+    expect(configuration.database).to eq(adapter)
+  end
+
+  it "allows `dump_functions_at_beginning_of_schema` to be set" do
+    configuration = Fx::Configuration.new
 
-    expect(Fx.configuration.database).to eq adapter
-    expect(Fx.database).to eq adapter
+    configuration.dump_functions_at_beginning_of_schema = true
 
-    Fx.configuration = Fx::Configuration.new
+    expect(configuration.dump_functions_at_beginning_of_schema).to eq(true)
   end
 end

data/spec/fx/definition_spec.rb

@@ -1,29 +1,31 @@
 require "spec_helper"
 
-describe Fx::Definition do
+RSpec.describe Fx::Definition do
   describe "#to_sql" do
     context "representing a function definition" do
       it "returns the content of a function definition" do
-        sql_definition = <<-EOS
+        sql_definition = <<~SQL
           CREATE OR REPLACE FUNCTION test()
           RETURNS text AS $$
           BEGIN
               RETURN 'test';
           END;
           $$ LANGUAGE plpgsql;
-        EOS
+        SQL
         allow(File).to receive(:read).and_return(sql_definition)
 
-        definition = Fx::Definition.new(name: "test", version: 1)
+        definition = Fx::Definition.function(name: "test", version: 1)
 
-        expect(definition.to_sql).to eq sql_definition
+        expect(definition.to_sql).to eq(sql_definition)
       end
 
       it "raises an error if the file is empty" do
         allow(File).to receive(:read).and_return("")
-        definition = Fx::Definition.new(name: "test", version: 1)
+        definition = Fx::Definition.function(name: "test", version: 1)
 
-        expect { definition.to_sql }.to raise_error(
+        expect do
+          definition.to_sql
+        end.to raise_error(
           RuntimeError,
           %r{Define function in db/functions/test_v01.sql before migrating}
         )
@@ -31,22 +33,22 @@ describe Fx::Definition do
 
       context "when definition is at Rails engine" do
         it "returns the content of a function definition" do
-          sql_definition = <<-EOS
+          sql_definition = <<~SQL
             CREATE OR REPLACE FUNCTION test()
             RETURNS text AS $$
             BEGIN
                 RETURN 'test';
             END;
             $$ LANGUAGE plpgsql;
-          EOS
+          SQL
           engine_path = Rails.root.join("tmp", "engine")
           FileUtils.mkdir_p(engine_path.join("db", "functions"))
           File.write(engine_path.join("db", "functions", "custom_test_v01.sql"), sql_definition)
           Rails.application.config.paths["db/migrate"].push(engine_path.join("db", "migrate"))
 
-          definition = Fx::Definition.new(name: "custom_test", version: 1)
+          definition = Fx::Definition.function(name: "custom_test", version: 1)
 
-          expect(definition.to_sql).to eq sql_definition
+          expect(definition.to_sql).to eq(sql_definition)
 
           FileUtils.rm_rf(engine_path)
         end
@@ -55,32 +57,26 @@ describe Fx::Definition do
 
     context "representing a trigger definition" do
       it "returns the content of a trigger definition" do
-        sql_definition = <<-EOS
+        sql_definition = <<~SQL
           CREATE TRIGGER check_update
           BEFORE UPDATE ON accounts
           FOR EACH ROW
           EXECUTE FUNCTION check_account_update();
-        EOS
+        SQL
         allow(File).to receive(:read).and_return(sql_definition)
 
-        definition = Fx::Definition.new(
-          name: "test",
-          version: 1,
-          type: "trigger"
-        )
+        definition = Fx::Definition.trigger(name: "test", version: 1)
 
-        expect(definition.to_sql).to eq sql_definition
+        expect(definition.to_sql).to eq(sql_definition)
       end
 
       it "raises an error if the file is empty" do
         allow(File).to receive(:read).and_return("")
-        definition = Fx::Definition.new(
-          name: "test",
-          version: 1,
-          type: "trigger"
-        )
+        definition = Fx::Definition.trigger(name: "test", version: 1)
 
-        expect { definition.to_sql }.to raise_error(
+        expect do
+          definition.to_sql
+        end.to raise_error(
           RuntimeError,
           %r{Define trigger in db/triggers/test_v01.sql before migrating}
         )
@@ -91,44 +87,40 @@ describe Fx::Definition do
   describe "#path" do
     context "representing a function definition" do
       it "returns a sql file with padded version and function name" do
-        definition = Fx::Definition.new(name: "test", version: 1)
+        definition = Fx::Definition.function(name: "test", version: 1)
 
-        expect(definition.path).to eq "db/functions/test_v01.sql"
+        expect(definition.path).to eq("db/functions/test_v01.sql")
       end
     end
 
     context "representing a trigger definition" do
       it "returns a sql file with padded version and trigger name" do
-        definition = Fx::Definition.new(
-          name: "test",
-          version: 1,
-          type: "trigger"
-        )
+        definition = Fx::Definition.trigger(name: "test", version: 1)
 
-        expect(definition.path).to eq "db/triggers/test_v01.sql"
+        expect(definition.path).to eq("db/triggers/test_v01.sql")
       end
     end
   end
 
   describe "#full_path" do
     it "joins the path with Rails.root" do
-      definition = Fx::Definition.new(name: "test", version: 15)
+      definition = Fx::Definition.function(name: "test", version: 15)
 
-      expect(definition.full_path).to eq Rails.root.join(definition.path)
+      expect(definition.full_path).to eq(Rails.root.join(definition.path))
     end
   end
 
   describe "#version" do
     it "pads the version number with 0" do
-      definition = Fx::Definition.new(name: :_, version: 1)
+      definition = Fx::Definition.function(name: :_, version: 1)
 
-      expect(definition.version).to eq "01"
+      expect(definition.version).to eq("01")
     end
 
     it "does not pad more than 2 characters" do
-      definition = Fx::Definition.new(name: :_, version: 15)
+      definition = Fx::Definition.function(name: :_, version: 15)
 
-      expect(definition.version).to eq "15"
+      expect(definition.version).to eq("15")
     end
   end
 end