fx 0.8.0 → 0.9.0

data/spec/fx/adapters/postgres/triggers_spec.rb

@@ -1,45 +1,41 @@
 require "spec_helper"
 
-module Fx
-  module Adapters
-    describe Postgres::Triggers, :db do
-      describe ".all" do
-        it "returns `Trigger` objects" do
-          connection = ActiveRecord::Base.connection
-          connection.execute <<-EOS.strip_heredoc
-            CREATE TABLE users (
-                id int PRIMARY KEY,
-                name varchar(256),
-                upper_name varchar(256)
-            );
-          EOS
-          connection.execute <<-EOS.strip_heredoc
-            CREATE OR REPLACE FUNCTION uppercase_users_name()
-            RETURNS trigger AS $$
-            BEGIN
-              NEW.upper_name = UPPER(NEW.name);
-              RETURN NEW;
-            END;
-            $$ LANGUAGE plpgsql;
-          EOS
-          connection.execute <<-EOS.strip_heredoc
-            CREATE TRIGGER uppercase_users_name
-                BEFORE INSERT ON users
-                FOR EACH ROW
-                EXECUTE FUNCTION uppercase_users_name();
-          EOS
+RSpec.describe Fx::Adapters::Postgres::Triggers, :db do
+  describe ".all" do
+    it "returns `Trigger` objects" do
+      connection = ActiveRecord::Base.connection
+      connection.execute <<~EOS
+        CREATE TABLE users (
+            id int PRIMARY KEY,
+            name varchar(256),
+            upper_name varchar(256)
+        );
+      EOS
+      connection.execute <<~EOS
+        CREATE OR REPLACE FUNCTION uppercase_users_name()
+        RETURNS trigger AS $$
+        BEGIN
+          NEW.upper_name = UPPER(NEW.name);
+          RETURN NEW;
+        END;
+        $$ LANGUAGE plpgsql;
+      EOS
+      connection.execute <<~EOS
+        CREATE TRIGGER uppercase_users_name
+            BEFORE INSERT ON users
+            FOR EACH ROW
+            EXECUTE FUNCTION uppercase_users_name();
+      EOS
 
-          triggers = Postgres::Triggers.new(connection).all
+      triggers = Fx::Adapters::Postgres::Triggers.new(connection).all
 
-          first = triggers.first
-          expect(triggers.size).to eq 1
-          expect(first.name).to eq "uppercase_users_name"
-          expect(first.definition).to include("BEFORE INSERT")
-          expect(first.definition).to match(/ON [public.ser|]/)
-          expect(first.definition).to include("FOR EACH ROW")
-          expect(first.definition).to include("EXECUTE FUNCTION uppercase_users_name()")
-        end
-      end
+      first = triggers.first
+      expect(triggers.size).to eq(1)
+      expect(first.name).to eq("uppercase_users_name")
+      expect(first.definition).to include("BEFORE INSERT")
+      expect(first.definition).to match(/ON [public.ser|]/)
+      expect(first.definition).to include("FOR EACH ROW")
+      expect(first.definition).to include("EXECUTE FUNCTION uppercase_users_name()")
     end
   end
 end

data/spec/fx/adapters/postgres_spec.rb

@@ -1,104 +1,82 @@
 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(
+        <<~EOS
+          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
-        )
+      )
 
-        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)
+  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 = Fx::Adapters::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 FUNCTION uppercase_users_name();
+        EOS
+      )
 
-          expect(adapter.functions.map(&:name)).not_to include("adder")
-        end
-      end
+      expect(adapter.triggers.map(&:name)).to include("uppercase_users_name")
+    end
+  end
 
-      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
-          )
+  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(
+          <<~EOS
+            CREATE FUNCTION adder(x int, y int)
+            RETURNS int AS $$
+            BEGIN
+                RETURN $1 + $2;
+            END;
+            $$ LANGUAGE plpgsql;
+          EOS
+        )
 
-          adapter.drop_function(:test)
+        adapter.drop_function(:adder)
 
-          expect(adapter.functions.map(&:name)).not_to include("test")
-        end
+        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
+          <<~EOS
             CREATE OR REPLACE FUNCTION test()
             RETURNS text AS $$
             BEGIN
@@ -108,39 +86,59 @@ module Fx::Adapters
           EOS
         )
 
-        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(
+        <<~EOS
+          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)
+      )
 
-        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 <<~EOS
+        CREATE TABLE users (
+            id int PRIMARY KEY,
+            name varchar(256),
+            upper_name varchar(256)
+        );
+      EOS
+      adapter = Fx::Adapters::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 FUNCTION uppercase_users_name()
+      EOS
+      adapter.create_trigger(sql_definition)
+
+      expect(adapter.triggers.map(&:name)).to eq ["uppercase_users_name"]
     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