fx 0.7.0 → 0.9.0

data/spec/features/functions/migrations_spec.rb

@@ -1,8 +1,8 @@
 require "spec_helper"
 
-describe "Function migrations", :db do
+RSpec.describe "Function migrations", :db do
   around do |example|
-    sql_definition = <<-EOS
+    sql_definition = <<~EOS
       CREATE OR REPLACE FUNCTION test()
       RETURNS text AS $$
       BEGIN
@@ -40,7 +40,7 @@ describe "Function migrations", :db do
   it "can run migrations that updates functions" do
     connection.create_function(:test)
 
-    sql_definition = <<-EOS
+    sql_definition = <<~EOS
       CREATE OR REPLACE FUNCTION test()
       RETURNS text AS $$
       BEGIN
@@ -51,7 +51,7 @@ describe "Function migrations", :db do
     with_function_definition(
       name: :test,
       version: 2,
-      sql_definition: sql_definition,
+      sql_definition: sql_definition
     ) do
       migration = Class.new(migration_class) do
         def change

data/spec/features/functions/revert_spec.rb

@@ -1,8 +1,8 @@
 require "spec_helper"
 
-describe "Reverting migrations", :db do
+RSpec.describe "Reverting migrations", :db do
   around do |example|
-    sql_definition = <<-EOS
+    sql_definition = <<~EOS
       CREATE OR REPLACE FUNCTION test()
       RETURNS text AS $$
       BEGIN
@@ -40,17 +40,17 @@ describe "Reverting migrations", :db do
     end
 
     expect { run_migration(good_migration, [:up, :down]) }.not_to raise_error
-    expect { run_migration(bad_migration, [:up, :down]) }.
-      to raise_error(
+    expect { run_migration(bad_migration, [:up, :down]) }
+      .to raise_error(
         ActiveRecord::IrreversibleMigration,
-        /`create_function` is reversible only if given a `revert_to_version`/,
+        /`create_function` is reversible only if given a `revert_to_version`/
       )
   end
 
   it "can run reversible migrations for updating functions" do
     connection.create_function(:test)
 
-    sql_definition = <<-EOS
+    sql_definition = <<~EOS
       CREATE OR REPLACE FUNCTION test()
       RETURNS text AS $$
       BEGIN
@@ -61,7 +61,7 @@ describe "Reverting migrations", :db do
     with_function_definition(
       name: :test,
       version: 2,
-      sql_definition: sql_definition,
+      sql_definition: sql_definition
     ) do
       migration = Class.new(migration_class) do
         def change

data/spec/features/triggers/migrations_spec.rb

@@ -1,15 +1,15 @@
 require "spec_helper"
 
-describe "Trigger migrations", :db do
+RSpec.describe "Trigger migrations", :db do
   around do |example|
-    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,15 +18,15 @@ describe "Trigger migrations", :db do
       END;
       $$ LANGUAGE plpgsql;
     EOS
-    sql_definition = <<-EOS
+    sql_definition = <<~EOS
       CREATE TRIGGER uppercase_users_name
           BEFORE INSERT ON users
           FOR EACH ROW
-          EXECUTE PROCEDURE uppercase_users_name();
+          EXECUTE FUNCTION uppercase_users_name();
     EOS
     with_trigger_definition(
       name: :uppercase_users_name,
-      sql_definition: sql_definition,
+      sql_definition: sql_definition
     ) do
       example.run
     end

data/spec/features/triggers/revert_spec.rb

@@ -1,15 +1,15 @@
 require "spec_helper"
 
-describe "Reverting migrations", :db do
+RSpec.describe "Reverting migrations", :db do
   around do |example|
-    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,15 +18,15 @@ describe "Reverting migrations", :db do
       END;
       $$ LANGUAGE plpgsql;
     EOS
-    sql_definition = <<-EOS
+    sql_definition = <<~EOS
       CREATE TRIGGER uppercase_users_name
           BEFORE INSERT ON users
           FOR EACH ROW
-          EXECUTE PROCEDURE uppercase_users_name();
+          EXECUTE FUNCTION uppercase_users_name();
     EOS
     with_trigger_definition(
       name: :uppercase_users_name,
-      sql_definition: sql_definition,
+      sql_definition: sql_definition
     ) do
       example.run
     end
@@ -57,26 +57,26 @@ describe "Reverting migrations", :db do
     end
 
     expect { run_migration(good_migration, [:up, :down]) }.not_to raise_error
-    expect { run_migration(bad_migration, [:up, :down]) }.
-      to raise_error(
+    expect { run_migration(bad_migration, [:up, :down]) }
+      .to raise_error(
         ActiveRecord::IrreversibleMigration,
-        /`create_trigger` is reversible only if given a `revert_to_version`/,
+        /`create_trigger` is reversible only if given a `revert_to_version`/
       )
   end
 
   it "can run reversible migrations for updating triggers" do
     connection.create_trigger(:uppercase_users_name)
 
-    sql_definition = <<-EOS
+    sql_definition = <<~EOS
       CREATE TRIGGER uppercase_users_name
           BEFORE UPDATE ON users
           FOR EACH ROW
-          EXECUTE PROCEDURE uppercase_users_name();
+          EXECUTE FUNCTION uppercase_users_name();
     EOS
     with_trigger_definition(
       name: :uppercase_users_name,
       sql_definition: sql_definition,
-      version: 2,
+      version: 2
     ) do
       migration = Class.new(migration_class) do
         def change
@@ -84,7 +84,7 @@ describe "Reverting migrations", :db do
             :uppercase_users_name,
             on: :users,
             version: 2,
-            revert_to_version: 1,
+            revert_to_version: 1
           )
         end
       end

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

@@ -1,37 +1,33 @@
 require "spec_helper"
 
-module Fx
-  module Adapters
-    describe Postgres::Functions, :db do
-      describe ".all" do
-        it "returns `Function` objects" do
-          connection = ActiveRecord::Base.connection
-          connection.execute <<-EOS.strip_heredoc
-            CREATE OR REPLACE FUNCTION test()
-            RETURNS text AS $$
-            BEGIN
-                RETURN 'test';
-            END;
-            $$ LANGUAGE plpgsql;
-          EOS
+RSpec.describe Fx::Adapters::Postgres::Functions, :db do
+  describe ".all" do
+    it "returns `Function` objects" do
+      connection = ActiveRecord::Base.connection
+      connection.execute <<~EOS
+        CREATE OR REPLACE FUNCTION test()
+        RETURNS text AS $$
+        BEGIN
+            RETURN 'test';
+        END;
+        $$ LANGUAGE plpgsql;
+      EOS
 
-          functions = Postgres::Functions.new(connection).all
+      functions = Fx::Adapters::Postgres::Functions.new(connection).all
 
-          first = functions.first
-          expect(functions.size).to eq 1
-          expect(first.name).to eq "test"
-          expect(first.definition).to eq <<-EOS.strip_heredoc
-            CREATE OR REPLACE FUNCTION public.test()
-             RETURNS text
-             LANGUAGE plpgsql
-            AS $function$
-            BEGIN
-                RETURN 'test';
-            END;
-            $function$
-          EOS
-        end
-      end
+      first = functions.first
+      expect(functions.size).to eq(1)
+      expect(first.name).to eq("test")
+      expect(first.definition).to eq(<<~EOS)
+        CREATE OR REPLACE FUNCTION public.test()
+         RETURNS text
+         LANGUAGE plpgsql
+        AS $function$
+        BEGIN
+            RETURN 'test';
+        END;
+        $function$
+      EOS
     end
   end
 end

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

@@ -1,45 +1,41 @@
 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
+RSpec.describe Fx::Adapters::Postgres::Triggers, :db do
+  describe ".all" do
+    it "returns `Trigger` objects" do
+      connection = ActiveRecord::Base.connection
+      connection.execute <<~EOS
+        CREATE TABLE users (
+            id int PRIMARY KEY,
+            name varchar(256),
+            upper_name varchar(256)
+        );
+      EOS
+      connection.execute <<~EOS
+        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
+        CREATE TRIGGER uppercase_users_name
+            BEFORE INSERT ON users
+            FOR EACH ROW
+            EXECUTE FUNCTION uppercase_users_name();
+      EOS
 
-          triggers = Postgres::Triggers.new(connection).all
+      triggers = Fx::Adapters::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
+      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.ser|]/)
+      expect(first.definition).to include("FOR EACH ROW")
+      expect(first.definition).to include("EXECUTE FUNCTION uppercase_users_name()")
     end
   end
 end

data/spec/fx/adapters/postgres_spec.rb

@@ -1,104 +1,82 @@
 require "spec_helper"
 
-module Fx::Adapters
-  describe Postgres, :db do
-    describe "#create_function" do
-      it "successfully creates 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
-        )
-
-        expect(adapter.functions.map(&:name)).to include("test")
-      end
-    end
-
-    describe "#create_trigger" do
-      it "successfully creates a trigger" do
-        connection.execute <<-EOS
-          CREATE TABLE users (
-              id int PRIMARY KEY,
-              name varchar(256),
-              upper_name varchar(256)
-          );
-        EOS
-        adapter = Postgres.new
-        adapter.create_function <<-EOS
-          CREATE OR REPLACE FUNCTION uppercase_users_name()
-          RETURNS trigger AS $$
+RSpec.describe Fx::Adapters::Postgres, :db do
+  describe "#create_function" do
+    it "successfully creates a function" do
+      adapter = Fx::Adapters::Postgres.new
+      adapter.create_function(
+        <<~EOS
+          CREATE OR REPLACE FUNCTION test()
+          RETURNS text AS $$
           BEGIN
-            NEW.upper_name = UPPER(NEW.name);
-            RETURN NEW;
+              RETURN 'test';
           END;
           $$ LANGUAGE plpgsql;
         EOS
-        adapter.create_trigger(
-          <<-EOS
-            CREATE TRIGGER uppercase_users_name
-                BEFORE INSERT ON users
-                FOR EACH ROW
-                EXECUTE PROCEDURE uppercase_users_name();
-          EOS
-        )
+      )
 
-        expect(adapter.triggers.map(&:name)).to include("uppercase_users_name")
-      end
+      expect(adapter.functions.map(&:name)).to include("test")
     end
+  end
 
-    describe "#drop_function" do
-      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)
+  describe "#create_trigger" do
+    it "successfully creates a trigger" do
+      connection.execute <<~EOS
+        CREATE TABLE users (
+            id int PRIMARY KEY,
+            name varchar(256),
+            upper_name varchar(256)
+        );
+      EOS
+      adapter = Fx::Adapters::Postgres.new
+      adapter.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
+      adapter.create_trigger(
+        <<~EOS
+          CREATE TRIGGER uppercase_users_name
+              BEFORE INSERT ON users
+              FOR EACH ROW
+              EXECUTE FUNCTION uppercase_users_name();
+        EOS
+      )
 
-          expect(adapter.functions.map(&:name)).not_to include("adder")
-        end
-      end
+      expect(adapter.triggers.map(&:name)).to include("uppercase_users_name")
+    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
-          )
+  describe "#drop_function" do
+    context "when the function has arguments" do
+      it "successfully drops a function with the entire function signature" do
+        adapter = Fx::Adapters::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(:test)
+        adapter.drop_function(:adder)
 
-          expect(adapter.functions.map(&:name)).not_to include("test")
-        end
+        expect(adapter.functions.map(&:name)).not_to include("adder")
       end
     end
 
-    describe "#functions" do
-      it "finds functions and builds Fx::Function objects" do
-        adapter = Postgres.new
+    context "when the function does not have arguments" do
+      it "successfully drops a function" do
+        adapter = Fx::Adapters::Postgres.new
         adapter.create_function(
-          <<-EOS
+          <<~EOS
             CREATE OR REPLACE FUNCTION test()
             RETURNS text AS $$
             BEGIN
@@ -108,39 +86,59 @@ module Fx::Adapters
           EOS
         )
 
-        expect(adapter.functions.map(&:name)).to eq ["test"]
+        adapter.drop_function(:test)
+
+        expect(adapter.functions.map(&:name)).not_to include("test")
       end
     end
+  end
 
-    describe "#triggers" do
-      it "finds triggers and builds Fx::Trigger objects" do
-        connection.execute <<-EOS
-          CREATE TABLE users (
-              id int PRIMARY KEY,
-              name varchar(256),
-              upper_name varchar(256)
-          );
-        EOS
-        adapter = Postgres.new
-        adapter.create_function <<-EOS
-          CREATE OR REPLACE FUNCTION uppercase_users_name()
-          RETURNS trigger AS $$
+  describe "#functions" do
+    it "finds functions and builds Fx::Function objects" do
+      adapter = Fx::Adapters::Postgres.new
+      adapter.create_function(
+        <<~EOS
+          CREATE OR REPLACE FUNCTION test()
+          RETURNS text AS $$
           BEGIN
-            NEW.upper_name = UPPER(NEW.name);
-            RETURN NEW;
+              RETURN 'test';
           END;
           $$ LANGUAGE plpgsql;
         EOS
-        sql_definition = <<-EOS
-          CREATE TRIGGER uppercase_users_name
-              BEFORE INSERT ON users
-              FOR EACH ROW
-              EXECUTE PROCEDURE uppercase_users_name()
-        EOS
-        adapter.create_trigger(sql_definition)
+      )
 
-        expect(adapter.triggers.map(&:name)).to eq ["uppercase_users_name"]
-      end
+      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
+        CREATE TABLE users (
+            id int PRIMARY KEY,
+            name varchar(256),
+            upper_name varchar(256)
+        );
+      EOS
+      adapter = Fx::Adapters::Postgres.new
+      adapter.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
+      adapter.create_trigger(sql_definition)
+
+      expect(adapter.triggers.map(&:name)).to eq ["uppercase_users_name"]
     end
   end
 end