fx 0.9.0 → 0.10.0

data/spec/fx/adapters/postgres_spec.rb

@@ -5,14 +5,14 @@ RSpec.describe Fx::Adapters::Postgres, :db do
     it "successfully creates 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 include("test")
@@ -21,15 +21,15 @@ RSpec.describe Fx::Adapters::Postgres, :db do
 
   describe "#create_trigger" do
     it "successfully creates a trigger" do
-      connection.execute <<~EOS
+      connection.execute <<~SQL
         CREATE TABLE users (
             id int PRIMARY KEY,
             name varchar(256),
             upper_name varchar(256)
         );
-      EOS
+      SQL
       adapter = Fx::Adapters::Postgres.new
-      adapter.create_function <<~EOS
+      adapter.create_function <<~SQL
         CREATE OR REPLACE FUNCTION uppercase_users_name()
         RETURNS trigger AS $$
         BEGIN
@@ -37,14 +37,14 @@ RSpec.describe Fx::Adapters::Postgres, :db do
           RETURN NEW;
         END;
         $$ LANGUAGE plpgsql;
-      EOS
+      SQL
       adapter.create_trigger(
-        <<~EOS
+        <<~SQL
           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")
@@ -56,14 +56,14 @@ RSpec.describe Fx::Adapters::Postgres, :db do
       it "successfully drops a function with the entire function signature" do
         adapter = Fx::Adapters::Postgres.new
         adapter.create_function(
-          <<~EOS
+          <<~SQL
             CREATE FUNCTION adder(x int, y int)
             RETURNS int AS $$
             BEGIN
                 RETURN $1 + $2;
             END;
             $$ LANGUAGE plpgsql;
-          EOS
+          SQL
         )
 
         adapter.drop_function(:adder)
@@ -76,14 +76,14 @@ RSpec.describe Fx::Adapters::Postgres, :db 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
         )
 
         adapter.drop_function(:test)
@@ -97,14 +97,14 @@ RSpec.describe Fx::Adapters::Postgres, :db do
     it "finds functions and builds Fx::Function objects" 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"]
@@ -113,15 +113,15 @@ RSpec.describe Fx::Adapters::Postgres, :db do
 
   describe "#triggers" do
     it "finds triggers and builds Fx::Trigger objects" do
-      connection.execute <<~EOS
+      connection.execute <<~SQL
         CREATE TABLE users (
             id int PRIMARY KEY,
             name varchar(256),
             upper_name varchar(256)
         );
-      EOS
+      SQL
       adapter = Fx::Adapters::Postgres.new
-      adapter.create_function <<~EOS
+      adapter.create_function <<~SQL
         CREATE OR REPLACE FUNCTION uppercase_users_name()
         RETURNS trigger AS $$
         BEGIN
@@ -129,16 +129,58 @@ RSpec.describe Fx::Adapters::Postgres, :db do
           RETURN NEW;
         END;
         $$ LANGUAGE plpgsql;
-      EOS
-      sql_definition = <<~EOS
+      SQL
+      sql_definition = <<~SQL
         CREATE TRIGGER uppercase_users_name
             BEFORE INSERT ON users
             FOR EACH ROW
             EXECUTE FUNCTION uppercase_users_name()
-      EOS
+      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/definition_spec.rb

@@ -4,14 +4,14 @@ 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.function(name: "test", version: 1)
@@ -33,14 +33,14 @@ RSpec.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)
@@ -57,12 +57,12 @@ RSpec.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.trigger(name: "test", version: 1)

data/spec/fx/schema_dumper_spec.rb

@@ -2,14 +2,14 @@ require "spec_helper"
 
 RSpec.describe Fx::SchemaDumper, :db do
   it "dumps a create_function for a function in the database" do
-    sql_definition = <<~EOS
+    sql_definition = <<~SQL
       CREATE OR REPLACE FUNCTION my_function()
       RETURNS text AS $$
       BEGIN
           RETURN 'test';
       END;
       $$ LANGUAGE plpgsql;
-    EOS
+    SQL
     connection.create_function :my_function, sql_definition: sql_definition
     connection.create_table :my_table
     stream = StringIO.new
@@ -24,14 +24,14 @@ RSpec.describe Fx::SchemaDumper, :db do
 
   it "dumps a create_function for a function in the database" do
     Fx.configuration.dump_functions_at_beginning_of_schema = true
-    sql_definition = <<~EOS
+    sql_definition = <<~SQL
       CREATE OR REPLACE FUNCTION my_function()
       RETURNS text AS $$
       BEGIN
           RETURN 'test';
       END;
       $$ LANGUAGE plpgsql;
-    EOS
+    SQL
     connection.create_function :my_function, sql_definition: sql_definition
     connection.create_table :my_table
     stream = StringIO.new
@@ -47,22 +47,22 @@ RSpec.describe Fx::SchemaDumper, :db do
   end
 
   it "does not dump a create_function for aggregates in the database" do
-    sql_definition = <<~EOS
+    sql_definition = <<~SQL
       CREATE OR REPLACE FUNCTION test(text, text)
       RETURNS text AS $$
       BEGIN
           RETURN 'test';
       END;
       $$ LANGUAGE plpgsql;
-    EOS
+    SQL
 
-    aggregate_sql_definition = <<~EOS
+    aggregate_sql_definition = <<~SQL
       CREATE AGGREGATE aggregate_test(text)
       (
           sfunc = test,
           stype = text
       );
-    EOS
+    SQL
 
     connection.create_function :test, sql_definition: sql_definition
     connection.execute aggregate_sql_definition
@@ -77,14 +77,14 @@ RSpec.describe Fx::SchemaDumper, :db do
   end
 
   it "dumps a create_trigger for a trigger in the database" do
-    connection.execute <<~EOS
+    connection.execute <<~SQL
       CREATE TABLE users (
           id int PRIMARY KEY,
           name varchar(256),
           upper_name varchar(256)
       );
-    EOS
-    Fx.database.create_function <<~EOS
+    SQL
+    Fx.database.create_function <<~SQL
       CREATE OR REPLACE FUNCTION uppercase_users_name()
       RETURNS trigger AS $$
       BEGIN
@@ -92,13 +92,13 @@ RSpec.describe Fx::SchemaDumper, :db do
         RETURN NEW;
       END;
       $$ LANGUAGE plpgsql;
-    EOS
-    sql_definition = <<~EOS
+    SQL
+    sql_definition = <<~SQL
       CREATE TRIGGER uppercase_users_name
           BEFORE INSERT ON users
           FOR EACH ROW
           EXECUTE FUNCTION uppercase_users_name();
-    EOS
+    SQL
     connection.create_trigger(
       :uppercase_users_name,
       sql_definition: sql_definition
@@ -113,6 +113,52 @@ RSpec.describe Fx::SchemaDumper, :db do
     expect(output).to include("EXECUTE FUNCTION uppercase_users_name()")
   end
 
+  it "dumps functions and triggers for multiple schemas" do
+    connection.schema_search_path = "public,test_schema"
+    connection.create_table :my_table
+    connection.create_function :test1, sql_definition: <<~SQL
+      CREATE OR REPLACE FUNCTION test_public_func()
+      RETURNS TRIGGER AS $$
+      BEGIN
+        RETURN 1;
+      END;
+      $$ LANGUAGE plpgsql;
+    SQL
+    connection.create_trigger :test1_trigger, sql_definition: <<~SQL
+      CREATE TRIGGER test_public_trigger
+      BEFORE INSERT ON my_table
+      FOR EACH ROW
+      EXECUTE FUNCTION test_public_func();
+    SQL
+    connection.execute("CREATE SCHEMA test_schema;")
+    connection.create_table "test_schema.my_table2"
+    connection.execute <<~SQL
+      CREATE OR REPLACE FUNCTION test_schema.test_schema_func()
+      RETURNS TRIGGER AS $$
+      BEGIN
+        RETURN 'test_schema';
+      END;
+      $$ LANGUAGE plpgsql;
+    SQL
+    connection.execute <<~SQL
+      CREATE TRIGGER test_schema_trigger
+      BEFORE INSERT ON test_schema.my_table2
+      FOR EACH ROW
+      EXECUTE FUNCTION test_schema.test_schema_func();
+    SQL
+    stream = StringIO.new
+    output = stream.string
+
+    dump(connection: connection, stream: stream)
+
+    expect(output.scan("create_function :test_public_func").size).to eq(1)
+    expect(output.scan("create_trigger :test_public_trigger").size).to eq(1)
+    expect(output.scan("create_function :test_schema_func").size).to eq(1)
+    expect(output.scan("create_trigger :test_schema_trigger").size).to eq(1)
+
+    connection.schema_search_path = "public"
+  end
+
   def dump(connection:, stream:)
     if Rails.version >= "7.2"
       ActiveRecord::SchemaDumper.dump(connection.pool, stream)

data/spec/fx_spec.rb

@@ -6,10 +6,10 @@ RSpec.describe Fx do
   end
 
   it "loads fx into ActiveRecord" do
+    expect(Fx.load).to eq(true)
     expect(ActiveRecord::Migration::CommandRecorder).to include(Fx::CommandRecorder)
     expect(ActiveRecord::ConnectionAdapters::AbstractAdapter).to include(Fx::Statements)
     expect(ActiveRecord::SchemaDumper).to include(Fx::SchemaDumper)
-    expect(Fx.load).to eq(true)
   end
 
   it "allows configuration" do

data/spec/generators/fx/function/function_generator_spec.rb

@@ -6,11 +6,11 @@ RSpec.describe Fx::Generators::FunctionGenerator, :generator do
     migration = file("db/migrate/create_function_test.rb")
     function_definition = file("db/functions/test_v01.sql")
 
-    run_generator ["test"]
+    run_generator(described_class, ["test"])
 
     expect(function_definition).to exist
-    expect(migration).to be_a_migration
-    expect(migration_file(migration)).to contain("CreateFunctionTest")
+    expect_to_be_a_migration(migration)
+    expect(migration_content(migration)).to include("CreateFunctionTest")
   end
 
   context "when passed --no-migration" do
@@ -18,10 +18,10 @@ RSpec.describe Fx::Generators::FunctionGenerator, :generator do
       migration = file("db/migrate/create_function_test.rb")
       function_definition = file("db/functions/test_v01.sql")
 
-      run_generator ["test", "--no-migration"]
+      run_generator(described_class, ["test"], {migration: false})
 
       expect(function_definition).to exist
-      expect(Pathname.new(migration_file(migration))).not_to exist
+      expect(migration).not_to exist
     end
   end
 
@@ -31,16 +31,16 @@ RSpec.describe Fx::Generators::FunctionGenerator, :generator do
       version: 1,
       sql_definition: "hello"
     ) do
-      allow(Dir).to receive(:entries).and_return(["test_v01.sql"])
       migration = file("db/migrate/update_function_test_to_version_2.rb")
       function_definition = file("db/functions/test_v02.sql")
 
-      run_generator ["test"]
+      run_generator(described_class, ["test"])
 
       expect(function_definition).to exist
-      expect(migration).to be_a_migration
-      expect(migration_file(migration))
-        .to contain("UpdateFunctionTestToVersion2")
+      expect_to_be_a_migration(migration)
+      expect(migration_content(migration)).to include(
+        "UpdateFunctionTestToVersion2"
+      )
     end
   end
 end

data/spec/generators/fx/migration_helper_spec.rb

@@ -0,0 +1,133 @@
+require "spec_helper"
+require "generators/fx/migration_helper"
+
+RSpec.describe Fx::Generators::MigrationHelper do
+  describe "#skip_creation?" do
+    it "returns false by default" do
+      helper = described_class.new({})
+
+      expect(helper.skip_creation?).to be(false)
+    end
+
+    it "returns true when migration option is false" do
+      helper = described_class.new(migration: false)
+
+      expect(helper.skip_creation?).to be(true)
+    end
+  end
+
+  describe "#active_record_migration_class" do
+    it "returns versioned migration class when current_version is available" do
+      allow(ActiveRecord::Migration).to receive(:current_version)
+        .and_return(7.0)
+
+      helper = described_class.new({})
+
+      expect(helper.active_record_migration_class).to eq(
+        "ActiveRecord::Migration[7.0]"
+      )
+    end
+
+    it "returns base migration class when current_version is not available" do
+      allow(ActiveRecord::Migration).to receive(:respond_to?)
+        .with(:current_version)
+        .and_return(false)
+
+      helper = described_class.new({})
+
+      expect(helper.active_record_migration_class).to eq(
+        "ActiveRecord::Migration"
+      )
+    end
+  end
+
+  describe "#update_migration_class_name" do
+    it "generates correct class name for functions" do
+      helper = described_class.new({})
+
+      result = helper.update_migration_class_name(
+        object_type: :function,
+        class_name: "TestFunction",
+        version: 3
+      )
+
+      expect(result).to eq("UpdateFunctionTestFunctionToVersion3")
+    end
+
+    it "generates correct class name for triggers" do
+      helper = described_class.new({})
+
+      result = helper.update_migration_class_name(
+        object_type: :trigger,
+        class_name: "TestTrigger",
+        version: 2
+      )
+
+      expect(result).to eq("UpdateTriggerTestTriggerToVersion2")
+    end
+  end
+
+  describe "#migration_template_info" do
+    it "returns create template info for new objects" do
+      helper = described_class.new({})
+
+      result = helper.migration_template_info(
+        object_type: :function,
+        file_name: "test_func",
+        updating_existing: false,
+        version: 1
+      )
+
+      expect(result).to eq({
+        template: "db/migrate/create_function.erb",
+        filename: "db/migrate/create_function_test_func.rb"
+      })
+    end
+
+    it "returns update template info for existing objects" do
+      helper = described_class.new({})
+
+      result = helper.migration_template_info(
+        object_type: :trigger,
+        file_name: "test_trigger",
+        updating_existing: true,
+        version: 3
+      )
+
+      expect(result).to eq({
+        template: "db/migrate/update_trigger.erb",
+        filename: "db/migrate/update_trigger_test_trigger_to_version_3.rb"
+      })
+    end
+
+    it "handles different object types correctly" do
+      helper = described_class.new({})
+
+      function_result = helper.migration_template_info(
+        object_type: :function,
+        file_name: "my_function",
+        updating_existing: true,
+        version: 2
+      )
+      trigger_result = helper.migration_template_info(
+        object_type: :trigger,
+        file_name: "my_trigger",
+        updating_existing: true,
+        version: 2
+      )
+
+      expect(function_result.fetch(:template)).to eq(
+        "db/migrate/update_function.erb"
+      )
+      expect(trigger_result.fetch(:template)).to eq(
+        "db/migrate/update_trigger.erb"
+      )
+      expect(function_result.fetch(:filename)).to eq(
+        "db/migrate/update_function_my_function_to_version_2.rb"
+      )
+      expect(trigger_result.fetch(:filename)).to eq(
+        "db/migrate/update_trigger_my_trigger_to_version_2.rb"
+      )
+    end
+  end
+end

data/spec/generators/fx/name_helper_spec.rb

@@ -0,0 +1,114 @@
+require "spec_helper"
+require "generators/fx/name_helper"
+
+RSpec.describe Fx::Generators::NameHelper do
+  describe ".format_for_migration" do
+    it "returns symbol format for simple names" do
+      result = described_class.format_for_migration("simple_name")
+
+      expect(result).to eq(":simple_name")
+    end
+
+    it "returns quoted string format for schema-qualified names" do
+      result = described_class.format_for_migration("schema.function_name")
+
+      expect(result).to eq("\"schema.function_name\"")
+    end
+
+    it "handles names with multiple dots" do
+      result = described_class.format_for_migration("db.schema.function")
+
+      expect(result).to eq("\"db.schema.function\"")
+    end
+
+    it "handles empty names" do
+      result = described_class.format_for_migration("")
+
+      expect(result).to eq(":")
+    end
+  end
+
+  describe ".format_table_name_from_hash" do
+    it "formats table_name key correctly" do
+      table_hash = {"table_name" => "users"}
+
+      result = described_class.format_table_name_from_hash(table_hash)
+
+      expect(result).to eq(":users")
+    end
+
+    it "formats on key correctly" do
+      table_hash = {"on" => "posts"}
+
+      result = described_class.format_table_name_from_hash(table_hash)
+
+      expect(result).to eq(":posts")
+    end
+
+    it "prefers table_name over on when both are present" do
+      table_hash = {"table_name" => "users", "on" => "posts"}
+
+      result = described_class.format_table_name_from_hash(table_hash)
+
+      expect(result).to eq(":users")
+    end
+
+    it "handles schema-qualified table names" do
+      table_hash = {"table_name" => "public.users"}
+
+      result = described_class.format_table_name_from_hash(table_hash)
+
+      expect(result).to eq("\"public.users\"")
+    end
+
+    it "raises error when neither key is present" do
+      table_hash = {"something_else" => "value"}
+
+      expect {
+        described_class.format_table_name_from_hash(table_hash)
+      }.to raise_error(
+        ArgumentError,
+        "Either `table_name:NAME` or `on:NAME` must be specified"
+      )
+    end
+
+    it "raises error when both keys have nil values" do
+      table_hash = {"table_name" => nil, "on" => nil}
+
+      expect {
+        described_class.format_table_name_from_hash(table_hash)
+      }.to raise_error(
+        ArgumentError,
+        "Either `table_name:NAME` or `on:NAME` must be specified"
+      )
+    end
+
+    it "uses on key when table_name is nil" do
+      table_hash = {"table_name" => nil, "on" => "comments"}
+
+      result = described_class.format_table_name_from_hash(table_hash)
+
+      expect(result).to eq(":comments")
+    end
+  end
+
+  describe ".validate_and_format" do
+    it "formats valid names correctly" do
+      result = described_class.validate_and_format("test_function")
+
+      expect(result).to eq(":test_function")
+    end
+
+    it "formats schema-qualified names correctly" do
+      result = described_class.validate_and_format("schema.test")
+
+      expect(result).to eq("\"schema.test\"")
+    end
+
+    it "raises error for blank names" do
+      expect {
+        described_class.validate_and_format("")
+      }.to raise_error(ArgumentError, "Name cannot be blank")
+    end
+  end
+end