fx 0.1.0 → 0.11.0

data/spec/fx/schema_dumper_spec.rb

@@ -0,0 +1,241 @@
+require "spec_helper"
+
+RSpec.describe Fx::SchemaDumper, :db do
+  it "dumps a create_function for a function in the database" do
+    sql_definition = <<~SQL
+      CREATE OR REPLACE FUNCTION my_function()
+      RETURNS text AS $$
+      BEGIN
+          RETURN 'test';
+      END;
+      $$ LANGUAGE plpgsql;
+    SQL
+    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 = <<~SQL
+      CREATE OR REPLACE FUNCTION my_function()
+      RETURNS text AS $$
+      BEGIN
+          RETURN 'test';
+      END;
+      $$ LANGUAGE plpgsql;
+    SQL
+    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 = <<~SQL
+      CREATE OR REPLACE FUNCTION test(text, text)
+      RETURNS text AS $$
+      BEGIN
+          RETURN 'test';
+      END;
+      $$ LANGUAGE plpgsql;
+    SQL
+
+    aggregate_sql_definition = <<~SQL
+      CREATE AGGREGATE aggregate_test(text)
+      (
+          sfunc = test,
+          stype = text
+      );
+    SQL
+
+    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 <<~SQL
+      CREATE TABLE users (
+          id int PRIMARY KEY,
+          name varchar(256),
+          upper_name varchar(256)
+      );
+    SQL
+    Fx.database.create_function <<~SQL
+      CREATE OR REPLACE FUNCTION uppercase_users_name()
+      RETURNS trigger AS $$
+      BEGIN
+        NEW.upper_name = UPPER(NEW.name);
+        RETURN NEW;
+      END;
+      $$ LANGUAGE plpgsql;
+    SQL
+    sql_definition = <<~SQL
+      CREATE TRIGGER uppercase_users_name
+          BEFORE INSERT ON users
+          FOR EACH ROW
+          EXECUTE FUNCTION uppercase_users_name();
+    SQL
+    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
+
+  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)
+  ensure
+    connection.schema_search_path = "public"
+  end
+
+  it "puts a blank line before each function and trigger" do
+    connection.create_table :users do |t|
+      t.string :name
+      t.string :upper_name
+      t.string :down_name
+    end
+    Fx.database.create_function <<~SQL
+      CREATE OR REPLACE FUNCTION uppercase_users_name()
+      RETURNS trigger AS $$
+      BEGIN
+        NEW.upper_name = UPPER(NEW.name);
+        RETURN NEW;
+      END;
+      $$ LANGUAGE plpgsql;
+    SQL
+    sql_definition = <<~SQL
+      CREATE TRIGGER uppercase_users_name
+          BEFORE INSERT ON users
+          FOR EACH ROW
+          EXECUTE FUNCTION uppercase_users_name();
+    SQL
+    connection.create_trigger(
+      :uppercase_users_name,
+      sql_definition: sql_definition
+    )
+    Fx.database.create_function <<~SQL
+      CREATE OR REPLACE FUNCTION downcase_users_name()
+      RETURNS trigger AS $$
+      BEGIN
+        NEW.down_name = LOWER(NEW.name);
+        RETURN NEW;
+      END;
+      $$ LANGUAGE plpgsql;
+    SQL
+    sql_definition = <<~SQL
+      CREATE TRIGGER downcase_users_name
+          BEFORE INSERT ON users
+          FOR EACH ROW
+          EXECUTE FUNCTION downcase_users_name();
+    SQL
+    connection.create_trigger(
+      :downcase_users_name,
+      sql_definition: sql_definition
+    )
+    stream = StringIO.new
+    output = stream.string
+
+    dump(connection: connection, stream: stream)
+
+    pattern = /(end|SQL)\n\n  (create_function|create_trigger)/
+    # a blank line between:
+    # - the table and the uppercase_users_name function,
+    # - the uppercase_users_name function and the downcase_users_name function,
+    # - the downcase_users_name function and the uppercase_users_name trigger,
+    # - the uppercase_users_name trigger and the downcase_users_name trigger,
+    expect(output.scan(pattern).size).to eq(4)
+  end
+
+  it "does not add blank lines when there are no functions or triggers" do
+    connection.create_table :users do |t|
+      t.string :name
+    end
+    stream = StringIO.new
+    output = stream.string
+
+    dump(connection: connection, stream: stream)
+
+    expect(output).not_to match(/create_function/)
+    expect(output).not_to match(/create_trigger/)
+    expect(output).not_to match(/end\n\n\nend/)
+  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

data/spec/fx/statements_spec.rb

@@ -0,0 +1,219 @@
+require "spec_helper"
+
+RSpec.describe Fx::Statements, :db do
+  describe "#create_function" do
+    it "creates a function from a file" do
+      database = stubbed_database
+      definition = stubbed_definition
+
+      connection.create_function(:test)
+
+      expect(database).to have_received(:create_function)
+        .with(definition.to_sql)
+      expect(Fx::Definition).to have_received(:function)
+        .with(name: :test, version: 1)
+    end
+
+    it "allows creating a function with a specific version" do
+      database = stubbed_database
+      definition = stubbed_definition
+
+      connection.create_function(:test, version: 2)
+
+      expect(database).to have_received(:create_function)
+        .with(definition.to_sql)
+      expect(Fx::Definition).to have_received(:function)
+        .with(name: :test, version: 2)
+    end
+
+    it "raises an error if both arguments are nil" do
+      expect do
+        connection.create_function(
+          :whatever,
+          version: nil,
+          sql_definition: nil
+        )
+      end.to raise_error(
+        ArgumentError,
+        /version or sql_definition must be specified/
+      )
+    end
+  end
+
+  describe "#drop_function" do
+    it "drops the function" do
+      database = stubbed_database
+
+      connection.drop_function(:test)
+
+      expect(database).to have_received(:drop_function).with(:test)
+    end
+  end
+
+  describe "#update_function" do
+    it "updates the function" do
+      database = stubbed_database
+      definition = stubbed_definition
+
+      connection.update_function(:test, version: 3)
+
+      expect(database).to have_received(:update_function)
+        .with(:test, definition.to_sql)
+      expect(Fx::Definition).to have_received(:function)
+        .with(name: :test, version: 3)
+    end
+
+    it "updates a function from a text definition" do
+      database = stubbed_database
+
+      connection.update_function(:test, sql_definition: "a definition")
+
+      expect(database).to have_received(:update_function)
+        .with(:test, "a definition")
+    end
+
+    it "raises an error if not supplied a version" do
+      expect do
+        connection.update_function(
+          :whatever,
+          version: nil,
+          sql_definition: nil
+        )
+      end.to raise_error(
+        ArgumentError,
+        /version or sql_definition must be specified/
+      )
+    end
+  end
+
+  describe "#create_trigger" do
+    it "creates a trigger from a file" do
+      database = stubbed_database
+      definition = stubbed_definition
+
+      connection.create_trigger(:test)
+
+      expect(database).to have_received(:create_trigger)
+        .with(definition.to_sql)
+      expect(Fx::Definition).to have_received(:trigger)
+        .with(name: :test, version: 1)
+    end
+
+    it "allows creating a trigger with a specific version" do
+      database = stubbed_database
+      definition = stubbed_definition
+
+      connection.create_trigger(:test, version: 2)
+
+      expect(database).to have_received(:create_trigger)
+        .with(definition.to_sql)
+      expect(Fx::Definition).to have_received(:trigger)
+        .with(name: :test, version: 2)
+    end
+
+    it "raises an error if both arguments are set" do
+      stubbed_database
+
+      expect do
+        connection.create_trigger(
+          :whatever,
+          version: 1,
+          sql_definition: "a definition"
+        )
+      end.to raise_error(
+        ArgumentError,
+        /cannot both be set/
+      )
+    end
+  end
+
+  describe "#drop_trigger" do
+    it "drops the trigger" do
+      database = stubbed_database
+
+      connection.drop_trigger(:test, on: :users)
+
+      expect(database).to have_received(:drop_trigger)
+        .with(:test, on: :users)
+    end
+  end
+
+  describe "#update_trigger" do
+    it "updates the trigger" do
+      database = stubbed_database
+      definition = stubbed_definition
+
+      connection.update_trigger(:test, on: :users, version: 3)
+
+      expect(database).to have_received(:update_trigger).with(
+        :test,
+        on: :users,
+        sql_definition: definition.to_sql
+      )
+      expect(Fx::Definition).to have_received(:trigger).with(
+        name: :test,
+        version: 3
+      )
+    end
+
+    it "updates a trigger from a text definition" do
+      database = stubbed_database
+
+      connection.update_trigger(
+        :test,
+        on: :users,
+        sql_definition: "a definition"
+      )
+
+      expect(database).to have_received(:update_trigger).with(
+        :test,
+        on: :users,
+        sql_definition: "a definition"
+      )
+    end
+
+    it "raises an error if not supplied a version" do
+      expect do
+        connection.update_trigger(
+          :whatever,
+          on: :users,
+          version: nil,
+          sql_definition: nil
+        )
+      end.to raise_error(
+        ArgumentError,
+        /version or sql_definition must be specified/
+      )
+    end
+
+    it "raises an error if both arguments are set" do
+      stubbed_database
+
+      expect do
+        connection.update_trigger(
+          :whatever,
+          on: :users,
+          version: 1,
+          sql_definition: "a definition"
+        )
+      end.to raise_error(
+        ArgumentError,
+        /cannot both be set/
+      )
+    end
+  end
+
+  def stubbed_definition
+    instance_double("Fx::Definition", to_sql: nil).tap do |stubbed_definition|
+      allow(Fx::Definition).to receive(:function).and_return(stubbed_definition)
+      allow(Fx::Definition).to receive(:trigger).and_return(stubbed_definition)
+    end
+  end
+
+  def stubbed_database
+    database = instance_spy("StubbedDatabase")
+    allow(Fx).to receive(:database).and_return(database)
+
+    database
+  end
+end

data/spec/fx/trigger_spec.rb

@@ -0,0 +1,52 @@
+require "spec_helper"
+
+RSpec.describe Fx::Trigger do
+  describe "#<=>" do
+    it "delegates to `name`" do
+      trigger_a = Fx::Trigger.new(
+        "name" => "name_a",
+        "definition" => "some definition"
+      )
+      trigger_b = Fx::Trigger.new(
+        "name" => "name_b",
+        "definition" => "some definition"
+      )
+      trigger_c = Fx::Trigger.new(
+        "name" => "name_c",
+        "definition" => "some definition"
+      )
+
+      expect(trigger_b).to be_between(trigger_a, trigger_c)
+    end
+  end
+
+  describe "#==" do
+    it "compares `name` and `definition`" do
+      trigger_a = Fx::Trigger.new(
+        "name" => "name_a",
+        "definition" => "some definition"
+      )
+      trigger_b = Fx::Trigger.new(
+        "name" => "name_b",
+        "definition" => "some other definition"
+      )
+
+      expect(trigger_a).not_to eq(trigger_b)
+    end
+  end
+
+  describe "#to_schema" do
+    it "returns a schema compatible version of the trigger" do
+      trigger = Fx::Trigger.new(
+        "name" => "uppercase_users_name",
+        "definition" => "CREATE TRIGGER uppercase_users_name ..."
+      )
+
+      expect(trigger.to_schema).to eq(<<-EOS)
+  create_trigger :uppercase_users_name, sql_definition: <<-\SQL
+      CREATE TRIGGER uppercase_users_name ...
+  SQL
+      EOS
+    end
+  end
+end

data/spec/fx_spec.rb

@@ -0,0 +1,28 @@
+require "spec_helper"
+
+RSpec.describe Fx do
+  it "has a version number" do
+    expect(Fx::VERSION).to be_present
+  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)
+  end
+
+  it "allows configuration" do
+    adapter = double("Fx Adapter")
+
+    Fx.configure do |config|
+      config.database = adapter
+      config.dump_functions_at_beginning_of_schema = true
+    end
+
+    expect(Fx.configuration.database).to eq(adapter)
+    expect(Fx.configuration.dump_functions_at_beginning_of_schema).to eq(true)
+
+    Fx.configuration = nil
+  end
+end

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

@@ -1,34 +1,46 @@
 require "spec_helper"
 require "generators/fx/function/function_generator"
 
-describe Fx::Generators::FunctionGenerator, :generator do
+RSpec.describe Fx::Generators::FunctionGenerator, :generator do
   it "creates a function definition file, and a migration" 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
+    it "creates a only function definition file" do
+      migration = file("db/migrate/create_function_test.rb")
+      function_definition = file("db/functions/test_v01.sql")
+
+      run_generator(described_class, ["test"], {migration: false})
+
+      expect(function_definition).to exist
+      expect(migration).not_to exist
+    end
   end
 
   it "updates an existing function" do
     with_function_definition(
       name: "test",
       version: 1,
-      sql_definition: "hello",
+      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,108 @@
+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 "#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