fx 0.8.0 → 0.10.0

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

data/spec/generators/fx/trigger/trigger_generator_spec.rb

@@ -1,17 +1,20 @@
 require "spec_helper"
 require "generators/fx/trigger/trigger_generator"
 
-describe Fx::Generators::TriggerGenerator, :generator do
+RSpec.describe Fx::Generators::TriggerGenerator, :generator do
   it "creates a trigger definition file, and a migration" do
     migration = file("db/migrate/create_trigger_test.rb")
     trigger_definition = file("db/triggers/test_v01.sql")
 
-    run_generator ["test", "table_name" => "some_table"]
+    run_generator(
+      described_class,
+      ["test", {"table_name" => "some_table"}]
+    )
 
     expect(trigger_definition).to exist
-    expect(migration).to be_a_migration
-    expect(migration_file(migration)).to contain "CreateTriggerTest"
-    expect(migration_file(migration)).to contain "on: :some_table"
+    expect_to_be_a_migration(migration)
+    expect(migration_content(migration)).to include("CreateTriggerTest")
+    expect(migration_content(migration)).to include("on: :some_table")
   end
 
   context "when passed --no-migration" do
@@ -19,10 +22,14 @@ describe Fx::Generators::TriggerGenerator, :generator do
       migration = file("db/migrate/create_trigger_test.rb")
       trigger_definition = file("db/triggers/test_v01.sql")
 
-      run_generator ["test", {"table_name" => "some_table"}, "--no-migration"]
+      run_generator(
+        described_class,
+        ["test", {"table_name" => "some_table"}],
+        {migration: false}
+      )
 
       expect(trigger_definition).to exist
-      expect(migration_file(migration)).not_to exist
+      expect(migration).not_to exist
     end
   end
 
@@ -30,30 +37,46 @@ describe Fx::Generators::TriggerGenerator, :generator do
     migration = file("db/migrate/create_trigger_test.rb")
     trigger_definition = file("db/triggers/test_v01.sql")
 
-    run_generator ["test", "on" => "some_table"]
+    run_generator(
+      described_class,
+      ["test", {"on" => "some_table"}]
+    )
 
     expect(trigger_definition).to exist
-    expect(migration).to be_a_migration
-    expect(migration_file(migration)).to contain "CreateTriggerTest"
-    expect(migration_file(migration)).to contain "on: :some_table"
+    expect_to_be_a_migration(migration)
+    expect(migration_content(migration)).to include("CreateTriggerTest")
+    expect(migration_content(migration)).to include("on: :some_table")
   end
 
   it "requires `table_name` or `on` to be specified" do
-    expect {
-      run_generator ["test", "foo" => "some_table"]
-    }.to raise_error ArgumentError
+    expect do
+      run_generator(
+        described_class,
+        ["test", {"foo" => "some_table"}]
+      )
+    end.to raise_error(ArgumentError)
   end
 
   it "updates an existing trigger" do
-    allow(Dir).to receive(:entries).and_return(["test_v01.sql"])
-    migration = file("db/migrate/update_trigger_test_to_version_2.rb")
-    trigger_definition = file("db/triggers/test_v02.sql")
+    with_trigger_definition(
+      name: "test",
+      version: 1,
+      sql_definition: "hello"
+    ) do
+      migration = file("db/migrate/update_trigger_test_to_version_2.rb")
+      trigger_definition = file("db/triggers/test_v02.sql")
 
-    run_generator ["test", "table_name" => "some_table"]
+      run_generator(
+        described_class,
+        ["test", {"table_name" => "some_table"}]
+      )
 
-    expect(trigger_definition).to exist
-    expect(migration).to be_a_migration
-    expect(migration_file(migration)).to contain "UpdateTriggerTestToVersion2"
-    expect(migration_file(migration)).to contain "on: :some_table"
+      expect(trigger_definition).to exist
+      expect_to_be_a_migration(migration)
+      expect(migration_content(migration)).to include(
+        "UpdateTriggerTestToVersion2"
+      )
+      expect(migration_content(migration)).to include("on: :some_table")
+    end
   end
 end

data/spec/generators/fx/version_helper_spec.rb

@@ -0,0 +1,157 @@
+require "spec_helper"
+require "generators/fx/version_helper"
+
+RSpec.describe Fx::Generators::VersionHelper do
+  describe "#previous_version" do
+    it "returns 0 when no existing versions found" do
+      with_temp_directory do |temp_dir|
+        helper = described_class.new(file_name: "test_function", definition_path: temp_dir)
+
+        expect(helper.previous_version).to eq(0)
+      end
+    end
+
+    it "returns highest version number from existing files" do
+      with_temp_directory do |temp_dir|
+        create_version_file(temp_dir, "test_function", 1)
+        create_version_file(temp_dir, "test_function", 3)
+        create_version_file(temp_dir, "test_function", 2)
+
+        helper = described_class.new(file_name: "test_function", definition_path: temp_dir)
+
+        expect(helper.previous_version).to eq(3)
+      end
+    end
+
+    it "ignores files that don't match the pattern" do
+      with_temp_directory do |temp_dir|
+        create_version_file(temp_dir, "test_function", 2)
+        FileUtils.touch(temp_dir.join("other_function_v3.sql"))
+        FileUtils.touch(temp_dir.join("test_function.sql"))
+
+        helper = described_class.new(file_name: "test_function", definition_path: temp_dir)
+
+        expect(helper.previous_version).to eq(2)
+      end
+    end
+  end
+
+  describe "#current_version" do
+    it "returns previous version + 1" do
+      with_temp_directory do |temp_dir|
+        create_version_file(temp_dir, "test_function", 5)
+
+        helper = described_class.new(file_name: "test_function", definition_path: temp_dir)
+
+        expect(helper.current_version).to eq(6)
+      end
+    end
+
+    it "returns 1 when no previous versions exist" do
+      with_temp_directory do |temp_dir|
+        helper = described_class.new(file_name: "test_function", definition_path: temp_dir)
+
+        expect(helper.current_version).to eq(1)
+      end
+    end
+  end
+
+  describe "#updating_existing?" do
+    it "returns false when no previous versions exist" do
+      with_temp_directory do |temp_dir|
+        helper = described_class.new(file_name: "test_function", definition_path: temp_dir)
+
+        expect(helper.updating_existing?).to be false
+      end
+    end
+
+    it "returns true when previous versions exist" do
+      with_temp_directory do |temp_dir|
+        create_version_file(temp_dir, "test_function", 1)
+
+        helper = described_class.new(file_name: "test_function", definition_path: temp_dir)
+
+        expect(helper.updating_existing?).to be true
+      end
+    end
+  end
+
+  describe "#creating_new?" do
+    it "returns true when no previous versions exist" do
+      with_temp_directory do |temp_dir|
+        helper = described_class.new(file_name: "test_function", definition_path: temp_dir)
+
+        expect(helper.creating_new?).to be true
+      end
+    end
+
+    it "returns false when previous versions exist" do
+      with_temp_directory do |temp_dir|
+        create_version_file(temp_dir, "test_function", 1)
+
+        helper = described_class.new(file_name: "test_function", definition_path: temp_dir)
+
+        expect(helper.creating_new?).to be false
+      end
+    end
+  end
+
+  describe "#definition_for_version" do
+    it "returns function definition for function type" do
+      with_temp_directory do |temp_dir|
+        helper = described_class.new(file_name: "test_function", definition_path: temp_dir)
+        allow(Fx::Definition).to receive(:function)
+          .and_return("function_definition")
+
+        result = helper.definition_for_version(version: 2, type: :function)
+
+        expect(result).to eq("function_definition")
+        expect(Fx::Definition).to have_received(:function).with(
+          name: "test_function",
+          version: 2
+        )
+      end
+    end
+
+    it "returns trigger definition for trigger type" do
+      with_temp_directory do |temp_dir|
+        helper = described_class.new(file_name: "test_trigger", definition_path: temp_dir)
+        allow(Fx::Definition).to receive(:trigger)
+          .and_return("trigger_definition")
+
+        result = helper.definition_for_version(version: 3, type: :trigger)
+
+        expect(result).to eq("trigger_definition")
+        expect(Fx::Definition).to have_received(:trigger).with(
+          name: "test_trigger",
+          version: 3
+        )
+      end
+    end
+
+    it "raises error for unknown type" do
+      with_temp_directory do |temp_dir|
+        helper = described_class.new(file_name: "test_function", definition_path: temp_dir)
+
+        expect {
+          helper.definition_for_version(version: 1, type: :unknown)
+        }.to raise_error(
+          ArgumentError,
+          "Unknown type: unknown. Must be :function or :trigger"
+        )
+      end
+    end
+  end
+
+  private
+
+  def with_temp_directory
+    Dir.mktmpdir do |path|
+      yield Pathname.new(path)
+    end
+  end
+
+  def create_version_file(dir, name, version)
+    FileUtils.touch(dir.join("#{name}_v#{version}.sql"))
+  end
+end

data/spec/spec_helper.rb

@@ -4,11 +4,18 @@ require "database_cleaner"
 require File.expand_path("../dummy/config/environment", __FILE__)
 Dir["spec/support/**/*.rb"].sort.each { |file| load file }
 
+$LOAD_PATH.unshift File.expand_path("../lib", __dir__)
+require "fx"
+
 RSpec.configure do |config|
   config.order = "random"
+  config.disable_monkey_patching!
+
   DatabaseCleaner.strategy = :transaction
 
   config.around(:each, db: true) do |example|
+    ActiveRecord::Base.connection.execute("SET search_path TO DEFAULT;")
+
     DatabaseCleaner.start
     example.run
     DatabaseCleaner.clean

data/spec/support/definition_helpers.rb

@@ -1,6 +1,6 @@
 module DefinitionHelpers
   def with_function_definition(name:, sql_definition:, version: 1, &block)
-    definition = Fx::Definition.new(name: name, version: version)
+    definition = Fx::Definition.function(name: name, version: version)
 
     with_definition(
       definition: definition,
@@ -10,11 +10,7 @@ module DefinitionHelpers
   end
 
   def with_trigger_definition(name:, sql_definition:, version: 1, &block)
-    definition = Fx::Definition.new(
-      name: name,
-      version: version,
-      type: "trigger"
-    )
+    definition = Fx::Definition.trigger(name: name, version: version)
 
     with_definition(
       definition: definition,

data/spec/support/generator_setup.rb

@@ -1,11 +1,52 @@
-require "ammeter/init"
+module GeneratorSetup
+  RAILS_ROOT = Pathname.new(File.expand_path("../../../tmp/dummy", __dir__)).freeze
+  MIGRATION_TIMESTAMP_PATTERN = /\A\d{14}_/
+
+  def run_generator(generator_class, args = [], options = {})
+    allow(Rails).to receive(:root).and_return(RAILS_ROOT)
+    generator = generator_class.new(args, options, destination_root: RAILS_ROOT)
+
+    silence_stream($stdout) do
+      generator.invoke_all
+    end
+  end
+
+  def file(relative_path)
+    RAILS_ROOT.join(relative_path)
+  end
+
+  def migration_content(file_path)
+    migration_path = find_migration_files(file_path).first
+    return if migration_path.nil?
+
+    Pathname.new(migration_path).read
+  end
+
+  def find_migration_files(file_path)
+    directory = File.dirname(file_path)
+    basename = File.basename(file_path, ".rb")
+    Dir.glob(File.join(directory, "*#{basename}.rb"))
+  end
+
+  def expect_to_be_a_migration(pathname)
+    migration_files = find_migration_files(pathname)
+
+    expect(migration_files).to be_present,
+      "expected #{pathname} to be a migration file"
+    first_migration = migration_files.first
+    migration_basename = File.basename(first_migration)
+    expect(migration_basename).to match(MIGRATION_TIMESTAMP_PATTERN),
+      "expected #{migration_basename} to have timestamp prefix (format: YYYYMMDDHHMMSS_)"
+  end
+end
 
 RSpec.configure do |config|
+  config.include GeneratorSetup, :generator
+
   config.before(:each, :generator) do
-    fake_rails_root = File.expand_path("../../../tmp/dummy", __FILE__)
-    allow(Rails).to receive(:root).and_return(Pathname.new(fake_rails_root))
+    FileUtils.rm_rf(GeneratorSetup::RAILS_ROOT) if File.exist?(GeneratorSetup::RAILS_ROOT)
+    FileUtils.mkdir_p(GeneratorSetup::RAILS_ROOT)
 
-    destination fake_rails_root
-    prepare_destination
+    allow(Rails).to receive(:root).and_return(Pathname.new(GeneratorSetup::RAILS_ROOT))
   end
 end

data/spec/support/warning_helper.rb

@@ -0,0 +1,5 @@
+require "warning"
+
+Warning.process do |_|
+  :raise
+end