fx 0.7.0 → 0.9.0

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,54 +33,56 @@ 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
       recorder = ActiveRecord::Migration::CommandRecorder.new
-      args = [:test, { revert_to_version: 3 }]
-      revert_args = [:test, { version: 3 }]
+      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]]
+      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 }]
+      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
 
   describe "#update_function" do
     it "records the updated function" do
       recorder = ActiveRecord::Migration::CommandRecorder.new
-      args = [:test, { version: 2 }]
+      args = [:test, {version: 2}]
 
       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
       recorder = ActiveRecord::Migration::CommandRecorder.new
-      args = [:test, { version: 2, revert_to_version: 1 }]
-      revert_args = [:test, { version: 1 }]
+      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]]
+      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 }]
+      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,54 +118,56 @@ 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
       recorder = ActiveRecord::Migration::CommandRecorder.new
-      args = [:users, { revert_to_version: 3 }]
-      revert_args = [:users, { version: 3 }]
+      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]]
+      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 }]
+      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
 
   describe "#update_trigger" do
     it "records the updated trigger" do
       recorder = ActiveRecord::Migration::CommandRecorder.new
-      args = [:users, { version: 2 }]
+      args = [:users, {version: 2}]
 
       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
       recorder = ActiveRecord::Migration::CommandRecorder.new
-      args = [:users, { version: 2, revert_to_version: 1 }]
-      revert_args = [:users, { version: 1 }]
+      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]]
+      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 }]
+      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,6 +1,6 @@
 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
@@ -14,24 +14,26 @@ describe Fx::Definition do
         EOS
         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),
+          %r{Define function in db/functions/test_v01.sql before migrating}
         )
       end
 
       context "when definition is at Rails engine" do
         it "returns the content of a function definition" do
-          sql_definition = <<-EOS
+          sql_definition = <<~EOS
             CREATE OR REPLACE FUNCTION test()
             RETURNS text AS $$
             BEGIN
@@ -44,9 +46,9 @@ describe Fx::Definition do
           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,34 +57,28 @@ describe Fx::Definition do
 
     context "representing a trigger definition" do
       it "returns the content of a trigger definition" do
-        sql_definition = <<-EOS
+        sql_definition = <<~EOS
           CREATE TRIGGER check_update
           BEFORE UPDATE ON accounts
           FOR EACH ROW
-          EXECUTE PROCEDURE check_account_update();
+          EXECUTE FUNCTION check_account_update();
         EOS
         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),
+          %r{Define trigger in db/triggers/test_v01.sql before migrating}
         )
       end
     end
@@ -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

data/spec/fx/function_spec.rb

@@ -1,68 +1,65 @@
 require "spec_helper"
-require "fx/function"
 
-module Fx
-  describe Function do
-    describe "#<=>" do
-      it "delegates to `name`" do
-        function_a = Function.new(
-          "name" => "name_a",
-          "definition" => "some definition",
-        )
-        function_b = Function.new(
-          "name" => "name_b",
-          "definition" => "some definition",
-        )
-        function_c = Function.new(
-          "name" => "name_c",
-          "definition" => "some definition",
-        )
+RSpec.describe Fx::Function do
+  describe "#<=>" do
+    it "delegates to `name`" do
+      function_a = Fx::Function.new(
+        "name" => "name_a",
+        "definition" => "some definition"
+      )
+      function_b = Fx::Function.new(
+        "name" => "name_b",
+        "definition" => "some definition"
+      )
+      function_c = Fx::Function.new(
+        "name" => "name_c",
+        "definition" => "some definition"
+      )
 
-        expect(function_b).to be_between(function_a, function_c)
-      end
+      expect(function_b).to be_between(function_a, function_c)
     end
+  end
 
-    describe "#==" do
-      it "compares `name` and `definition`" do
-        function_a = Function.new(
-          "name" => "name_a",
-          "definition" => "some definition",
-        )
-        function_b = Function.new(
-          "name" => "name_b",
-          "definition" => "some other definition",
-        )
+  describe "#==" do
+    it "compares `name` and `definition`" do
+      function_a = Fx::Function.new(
+        "name" => "name_a",
+        "definition" => "some definition"
+      )
+      function_b = Fx::Function.new(
+        "name" => "name_b",
+        "definition" => "some other definition"
+      )
 
-        expect(function_a).not_to eq(function_b)
-      end
+      expect(function_a).not_to eq(function_b)
     end
+  end
 
-    describe "#to_schema" do
-      it "returns a schema compatible version of the function" do
-        function = Function.new(
-          "name" => "uppercase_users_name",
-          "definition" => "CREATE OR REPLACE TRIGGER uppercase_users_name ...",
-        )
+  describe "#to_schema" do
+    it "returns a schema compatible version of the function" do
+      function = Fx::Function.new(
+        "name" => "uppercase_users_name",
+        "definition" => "CREATE OR REPLACE TRIGGER uppercase_users_name ..."
+      )
 
-        expect(function.to_schema).to eq <<-'EOS'
+      expect(function.to_schema).to eq(<<-EOS)
   create_function :uppercase_users_name, sql_definition: <<-'SQL'
       CREATE OR REPLACE TRIGGER uppercase_users_name ...
   SQL
-        EOS
-      end
+      EOS
+    end
 
-      it "maintains backslashes" do
-        function = Function.new(
-          "name" => "regex",
-          "definition" => "CREATE OR REPLACE FUNCTION regex \\1",
-        )
+    it "maintains backslashes" do
+      function = Fx::Function.new(
+        "name" => "regex",
+        "definition" => "CREATE OR REPLACE FUNCTION regex \\1"
+      )
 
-        expect(function.to_schema).to eq <<-'EOS'
+      expect(function.to_schema).to eq(<<-'EOS')
   create_function :regex, sql_definition: <<-'SQL'
       CREATE OR REPLACE FUNCTION regex \1
   SQL
-        EOS
-      end
+      EOS
     end
   end
 end

data/spec/fx/schema_dumper_spec.rb

@@ -0,0 +1,123 @@
+require "spec_helper"
+
+RSpec.describe Fx::SchemaDumper, :db do
+  it "dumps a create_function for a function in the database" do
+    sql_definition = <<~EOS
+      CREATE OR REPLACE FUNCTION my_function()
+      RETURNS text AS $$
+      BEGIN
+          RETURN 'test';
+      END;
+      $$ LANGUAGE plpgsql;
+    EOS
+    connection.create_function :my_function, sql_definition: sql_definition
+    connection.create_table :my_table
+    stream = StringIO.new
+    output = stream.string
+
+    dump(connection: connection, stream: stream)
+
+    expect(output).to match(
+      /table "my_table".*function :my_function.*RETURN 'test';/m
+    )
+  end
+
+  it "dumps a create_function for a function in the database" do
+    Fx.configuration.dump_functions_at_beginning_of_schema = true
+    sql_definition = <<~EOS
+      CREATE OR REPLACE FUNCTION my_function()
+      RETURNS text AS $$
+      BEGIN
+          RETURN 'test';
+      END;
+      $$ LANGUAGE plpgsql;
+    EOS
+    connection.create_function :my_function, sql_definition: sql_definition
+    connection.create_table :my_table
+    stream = StringIO.new
+    output = stream.string
+
+    dump(connection: connection, stream: stream)
+
+    expect(output).to(
+      match(/function :my_function.*RETURN 'test';.*table "my_table"/m)
+    )
+
+    Fx.configuration.dump_functions_at_beginning_of_schema = false
+  end
+
+  it "does not dump a create_function for aggregates in the database" do
+    sql_definition = <<~EOS
+      CREATE OR REPLACE FUNCTION test(text, text)
+      RETURNS text AS $$
+      BEGIN
+          RETURN 'test';
+      END;
+      $$ LANGUAGE plpgsql;
+    EOS
+
+    aggregate_sql_definition = <<~EOS
+      CREATE AGGREGATE aggregate_test(text)
+      (
+          sfunc = test,
+          stype = text
+      );
+    EOS
+
+    connection.create_function :test, sql_definition: sql_definition
+    connection.execute aggregate_sql_definition
+    stream = StringIO.new
+
+    dump(connection: connection, stream: stream)
+
+    output = stream.string
+    expect(output).to include("create_function :test, sql_definition: <<-'SQL'")
+    expect(output).to include("RETURN 'test';")
+    expect(output).not_to include("aggregate_test")
+  end
+
+  it "dumps a create_trigger for a trigger in the database" do
+    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 FUNCTION uppercase_users_name();
+    EOS
+    connection.create_trigger(
+      :uppercase_users_name,
+      sql_definition: sql_definition
+    )
+    stream = StringIO.new
+
+    dump(connection: connection, stream: stream)
+
+    output = stream.string
+    expect(output).to include("create_trigger :uppercase_users_name")
+    expect(output).to include("sql_definition: <<-SQL")
+    expect(output).to include("EXECUTE FUNCTION uppercase_users_name()")
+  end
+
+  def dump(connection:, stream:)
+    if Rails.version >= "7.2"
+      ActiveRecord::SchemaDumper.dump(connection.pool, stream)
+    else
+      ActiveRecord::SchemaDumper.dump(connection, stream)
+    end
+  end
+end