fx 0.2.0 → 0.6.0

data/spec/fx/adapters/postgres/triggers_spec.rb

@@ -0,0 +1,45 @@
+require "spec_helper"
+
+module Fx
+  module Adapters
+    describe Postgres::Triggers, :db do
+      describe ".all" do
+        it "returns `Trigger` objects" do
+          connection = ActiveRecord::Base.connection
+          connection.execute <<-EOS.strip_heredoc
+            CREATE TABLE users (
+                id int PRIMARY KEY,
+                name varchar(256),
+                upper_name varchar(256)
+            );
+          EOS
+          connection.execute <<-EOS.strip_heredoc
+            CREATE OR REPLACE FUNCTION uppercase_users_name()
+            RETURNS trigger AS $$
+            BEGIN
+              NEW.upper_name = UPPER(NEW.name);
+              RETURN NEW;
+            END;
+            $$ LANGUAGE plpgsql;
+          EOS
+          connection.execute <<-EOS.strip_heredoc
+            CREATE TRIGGER uppercase_users_name
+                BEFORE INSERT ON users
+                FOR EACH ROW
+                EXECUTE PROCEDURE uppercase_users_name();
+          EOS
+
+          triggers = Postgres::Triggers.new(connection).all
+
+          first = triggers.first
+          expect(triggers.size).to eq 1
+          expect(first.name).to eq "uppercase_users_name"
+          expect(first.definition).to include("BEFORE INSERT")
+          expect(first.definition).to match(/ON [public\.users|users]/)
+          expect(first.definition).to include("FOR EACH ROW")
+          expect(first.definition).to include("EXECUTE PROCEDURE uppercase_users_name()")
+        end
+      end
+    end
+  end
+end

data/spec/fx/adapters/postgres_spec.rb

@@ -6,7 +6,7 @@ module Fx::Adapters
       it "successfully creates a function" do
         adapter = Postgres.new
         adapter.create_function(
-          <<~EOS
+          <<-EOS
             CREATE OR REPLACE FUNCTION test()
             RETURNS text AS $$
             BEGIN
@@ -22,7 +22,7 @@ module Fx::Adapters
 
     describe "#create_trigger" do
       it "successfully creates a trigger" do
-        connection.execute <<~EOS
+        connection.execute <<-EOS
           CREATE TABLE users (
               id int PRIMARY KEY,
               name varchar(256),
@@ -30,7 +30,7 @@ module Fx::Adapters
           );
         EOS
         adapter = Postgres.new
-        adapter.create_function <<~EOS
+        adapter.create_function <<-EOS
           CREATE OR REPLACE FUNCTION uppercase_users_name()
           RETURNS trigger AS $$
           BEGIN
@@ -40,7 +40,7 @@ module Fx::Adapters
           $$ LANGUAGE plpgsql;
         EOS
         adapter.create_trigger(
-          <<~EOS
+          <<-EOS
             CREATE TRIGGER uppercase_users_name
                 BEFORE INSERT ON users
                 FOR EACH ROW
@@ -53,22 +53,44 @@ module Fx::Adapters
     end
 
     describe "#drop_function" do
-      it "successfully drops a function" do
-        adapter = Postgres.new
-        adapter.create_function(
-          <<~EOS
-            CREATE OR REPLACE FUNCTION test()
-            RETURNS text AS $$
-            BEGIN
-                RETURN 'test';
-            END;
-            $$ LANGUAGE plpgsql;
-          EOS
-        )
+      context "when the function has arguments" do
+        it "successfully drops a function with the entire function signature" do
+          adapter = Postgres.new
+          adapter.create_function(
+            <<-EOS
+              CREATE FUNCTION adder(x int, y int)
+              RETURNS int AS $$
+              BEGIN
+                  RETURN $1 + $2;
+              END;
+              $$ LANGUAGE plpgsql;
+            EOS
+          )
+
+          adapter.drop_function(:adder)
 
-        adapter.drop_function(:test)
+          expect(adapter.functions.map(&:name)).not_to include("adder")
+        end
+      end
+
+      context "when the function does not have arguments" do
+        it "successfully drops a function" do
+          adapter = Postgres.new
+          adapter.create_function(
+            <<-EOS
+              CREATE OR REPLACE FUNCTION test()
+              RETURNS text AS $$
+              BEGIN
+                  RETURN 'test';
+              END;
+              $$ LANGUAGE plpgsql;
+            EOS
+          )
+
+          adapter.drop_function(:test)
 
-        expect(adapter.functions.map(&:name)).not_to include("test")
+          expect(adapter.functions.map(&:name)).not_to include("test")
+        end
       end
     end
 
@@ -76,7 +98,7 @@ module Fx::Adapters
       it "finds functions and builds Fx::Function objects" do
         adapter = Postgres.new
         adapter.create_function(
-          <<~EOS
+          <<-EOS
             CREATE OR REPLACE FUNCTION test()
             RETURNS text AS $$
             BEGIN
@@ -86,27 +108,13 @@ module Fx::Adapters
           EOS
         )
 
-        expect(adapter.functions).to eq([
-          Fx::Function.new(
-            "name" => "test",
-            "definition" => <<~EOS
-              CREATE OR REPLACE FUNCTION public.test()
-               RETURNS text
-               LANGUAGE plpgsql
-              AS $function$
-              BEGIN
-                  RETURN 'test';
-              END;
-              $function$
-            EOS
-          ),
-        ])
+        expect(adapter.functions.map(&:name)).to eq ["test"]
       end
     end
 
     describe "#triggers" do
       it "finds triggers and builds Fx::Trigger objects" do
-        connection.execute <<~EOS
+        connection.execute <<-EOS
           CREATE TABLE users (
               id int PRIMARY KEY,
               name varchar(256),
@@ -114,7 +122,7 @@ module Fx::Adapters
           );
         EOS
         adapter = Postgres.new
-        adapter.create_function <<~EOS
+        adapter.create_function <<-EOS
           CREATE OR REPLACE FUNCTION uppercase_users_name()
           RETURNS trigger AS $$
           BEGIN
@@ -123,7 +131,7 @@ module Fx::Adapters
           END;
           $$ LANGUAGE plpgsql;
         EOS
-        sql_definition = <<~EOS
+        sql_definition = <<-EOS
           CREATE TRIGGER uppercase_users_name
               BEFORE INSERT ON users
               FOR EACH ROW
@@ -131,19 +139,8 @@ module Fx::Adapters
         EOS
         adapter.create_trigger(sql_definition)
 
-        expect(adapter.triggers).to eq(
-          [
-            Fx::Trigger.new(
-              "name" => "uppercase_users_name",
-              "definition" => format_trigger(sql_definition),
-            ),
-          ],
-        )
+        expect(adapter.triggers.map(&:name)).to eq ["uppercase_users_name"]
       end
     end
-
-    def format_trigger(trigger)
-      trigger.gsub("\n", "").gsub("    ", " ")
-    end
   end
 end

data/spec/fx/definition_spec.rb

@@ -4,7 +4,7 @@ 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 = <<-EOS
           CREATE OR REPLACE FUNCTION test()
           RETURNS text AS $$
           BEGIN
@@ -28,11 +28,34 @@ describe Fx::Definition do
           %r(Define function in db/functions/test_v01.sql before migrating),
         )
       end
+
+      context "when definition is at Rails engine" do
+        it "returns the content of a function definition" do
+          sql_definition = <<-EOS
+            CREATE OR REPLACE FUNCTION test()
+            RETURNS text AS $$
+            BEGIN
+                RETURN 'test';
+            END;
+            $$ LANGUAGE plpgsql;
+          EOS
+          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)
+          Rails.application.config.paths["db/migrate"].push(engine_path.join("db", "migrate"))
+
+          definition = Fx::Definition.new(name: "custom_test", version: 1)
+
+          expect(definition.to_sql).to eq sql_definition
+
+          FileUtils.rm_rf(engine_path)
+        end
+      end
     end
 
     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

data/spec/fx/function_spec.rb

@@ -0,0 +1,55 @@
+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 defintion",
+        )
+        function_b = Function.new(
+          "name" => "name_b",
+          "definition" => "some defintion",
+        )
+        function_c = Function.new(
+          "name" => "name_c",
+          "definition" => "some defintion",
+        )
+
+        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 defintion",
+        )
+        function_b = Function.new(
+          "name" => "name_b",
+          "definition" => "some other defintion",
+        )
+
+        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 ...",
+        )
+
+        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
+    end
+  end
+end

data/spec/fx/schema_dumper/function_spec.rb

@@ -2,15 +2,70 @@ require "spec_helper"
 
 describe Fx::SchemaDumper::Function, :db do
   it "dumps a create_function for a function in the database" do
-    sql_definition = <<~EOS
-      CREATE OR REPLACE FUNCTION test()
+    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
+
+    ActiveRecord::SchemaDumper.dump(connection, 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
+
+    ActiveRecord::SchemaDumper.dump(connection, stream)
+
+    expect(output).to(
+      match(/function :my_function.*RETURN 'test';.*table "my_table"/m),
+    )
+  ensure
+    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
 
     ActiveRecord::SchemaDumper.dump(connection, stream)
@@ -18,5 +73,6 @@ describe Fx::SchemaDumper::Function, :db do
     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
 end

data/spec/fx/schema_dumper/trigger_spec.rb

@@ -2,14 +2,14 @@ require "spec_helper"
 
 describe Fx::SchemaDumper::Trigger, :db do
   it "dumps a create_trigger for a trigger in the database" do
-    connection.execute <<~EOS
+    connection.execute <<-EOS
       CREATE TABLE users (
           id int PRIMARY KEY,
           name varchar(256),
           upper_name varchar(256)
       );
     EOS
-    Fx.database.create_function <<~EOS
+    Fx.database.create_function <<-EOS
       CREATE OR REPLACE FUNCTION uppercase_users_name()
       RETURNS trigger AS $$
       BEGIN
@@ -18,7 +18,7 @@ describe Fx::SchemaDumper::Trigger, :db do
       END;
       $$ LANGUAGE plpgsql;
     EOS
-    sql_definition = <<~EOS
+    sql_definition = <<-EOS
       CREATE TRIGGER uppercase_users_name
           BEFORE INSERT ON users
           FOR EACH ROW

data/spec/fx/trigger_spec.rb

@@ -0,0 +1,55 @@
+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 defintion",
+        )
+        trigger_b = Trigger.new(
+          "name" => "name_b",
+          "definition" => "some defintion",
+        )
+        trigger_c = Trigger.new(
+          "name" => "name_c",
+          "definition" => "some defintion",
+        )
+
+        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 defintion",
+        )
+        trigger_b = Trigger.new(
+          "name" => "name_b",
+          "definition" => "some other defintion",
+        )
+
+        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 ...",
+        )
+
+        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
+end