fx 0.1.0 → 0.11.0

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,47 +1,82 @@
 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
+    it "creates a only trigger definition file" do
+      migration = file("db/migrate/create_trigger_test.rb")
+      trigger_definition = file("db/triggers/test_v01.sql")
+
+      run_generator(
+        described_class,
+        ["test", {"table_name" => "some_table"}],
+        {migration: false}
+      )
+
+      expect(trigger_definition).to exist
+      expect(migration).not_to exist
+    end
   end
 
   it "supports naming the table as `on` aswell as `table_name`" 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

@@ -1,17 +1,29 @@
 ENV["RAILS_ENV"] = "test"
-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"
-  DatabaseCleaner.strategy = :transaction
+  config.disable_monkey_patching!
+
+  config.define_derived_metadata(file_path: %r{spec/(fx|features)/}) do |metadata|
+    metadata[:db] = true
+  end
+
+  config.before(:suite) do
+    DatabaseReset.call
+  end
 
   config.around(:each, db: true) do |example|
-    DatabaseCleaner.start
+    DatabaseReset.call
+
     example.run
-    DatabaseCleaner.clean
+
+    DatabaseReset.call
   end
 
   unless defined?(silence_stream)

data/spec/support/database_reset.rb

@@ -0,0 +1,24 @@
+module DatabaseReset
+  def self.call
+    connection = ActiveRecord::Base.connection
+    connection.execute("SET search_path TO DEFAULT;")
+
+    connection.execute <<~SQL
+      DO $$
+      DECLARE
+        schema_name TEXT;
+      BEGIN
+        FOR schema_name IN
+          SELECT nspname FROM pg_namespace
+          WHERE nspname NOT LIKE 'pg_%'
+            AND nspname != 'information_schema'
+        LOOP
+          EXECUTE format('DROP SCHEMA IF EXISTS %I CASCADE', schema_name);
+        END LOOP;
+      END $$;
+    SQL
+
+    connection.execute("CREATE SCHEMA public;")
+    connection.schema_search_path = "public"
+  end
+end

data/spec/support/definition_helpers.rb

@@ -1,31 +1,27 @@
 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,
       sql_definition: sql_definition,
-      block: block,
+      block: block
     )
   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,
       sql_definition: sql_definition,
-      block: block,
+      block: block
     )
   end
 
   def with_definition(definition:, sql_definition:, block:)
     FileUtils.mkdir_p(File.dirname(definition.full_path))
-    File.open(definition.full_path, "w") { |f| f.write(sql_definition) }
+    File.write(definition.full_path, sql_definition)
     block.call
   ensure
     File.delete definition.full_path

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", __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/migration_helpers.rb

@@ -1,12 +1,20 @@
 module MigrationsHelper
   def run_migration(migration, directions)
-    silence_stream(STDOUT) do
+    silence_stream($stdout) do
       Array.wrap(directions).each do |direction|
         migration.migrate(direction)
       end
     end
   end
 
+  def migration_class
+    if Rails::VERSION::MAJOR >= 5
+      ::ActiveRecord::Migration[5.0]
+    else
+      ::ActiveRecord::Migration
+    end
+  end
+
   def connection
     @_connection ||= ActiveRecord::Base.connection
   end

data/spec/support/warning_helper.rb

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