fx 0.8.0 → 0.9.0

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,16 +14,18 @@ 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}
         )
@@ -31,7 +33,7 @@ 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 = <<~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,7 +57,7 @@ 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
@@ -63,24 +65,18 @@ describe Fx::Definition do
         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}
         )
@@ -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

data/spec/fx/statements_spec.rb

@@ -0,0 +1,217 @@
+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,
+          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,
+          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

@@ -1,55 +1,52 @@
 require "spec_helper"
-require "fx/trigger"
 
-module Fx
-  describe Trigger do
-    describe "#<=>" do
-      it "delegates to `name`" do
-        trigger_a = Trigger.new(
-          "name" => "name_a",
-          "definition" => "some definition"
-        )
-        trigger_b = Trigger.new(
-          "name" => "name_b",
-          "definition" => "some definition"
-        )
-        trigger_c = Trigger.new(
-          "name" => "name_c",
-          "definition" => "some definition"
-        )
+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
+      expect(trigger_b).to be_between(trigger_a, trigger_c)
     end
+  end
 
-    describe "#==" do
-      it "compares `name` and `definition`" do
-        trigger_a = Trigger.new(
-          "name" => "name_a",
-          "definition" => "some definition"
-        )
-        trigger_b = Trigger.new(
-          "name" => "name_b",
-          "definition" => "some other definition"
-        )
+  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
+      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 = Trigger.new(
-          "name" => "uppercase_users_name",
-          "definition" => "CREATE TRIGGER uppercase_users_name ..."
-        )
+  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
+      expect(trigger.to_schema).to eq(<<-EOS)
   create_trigger :uppercase_users_name, sql_definition: <<-\SQL
       CREATE TRIGGER uppercase_users_name ...
   SQL
-        EOS
-      end
+      EOS
     end
   end
 end