fx 0.1.0 → 0.11.0

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 <<~SQL
       CREATE TABLE users (
           id int PRIMARY KEY,
           name varchar(256),
           upper_name varchar(256)
       );
-    EOS
-    Fx.database.create_function <<~EOS
+    SQL
+    Fx.database.create_function <<~SQL
       CREATE OR REPLACE FUNCTION uppercase_users_name()
       RETURNS trigger AS $$
       BEGIN
@@ -17,23 +17,23 @@ describe "Reverting migrations", :db do
         RETURN NEW;
       END;
       $$ LANGUAGE plpgsql;
-    EOS
-    sql_definition = <<~EOS
+    SQL
+    sql_definition = <<~SQL
       CREATE TRIGGER uppercase_users_name
           BEFORE INSERT ON users
           FOR EACH ROW
-          EXECUTE PROCEDURE uppercase_users_name();
-    EOS
+          EXECUTE FUNCTION uppercase_users_name();
+    SQL
     with_trigger_definition(
       name: :uppercase_users_name,
-      sql_definition: sql_definition,
+      sql_definition: sql_definition
     ) do
       example.run
     end
   end
 
   it "can run reversible migrations for creating triggers" do
-    migration = Class.new(ActiveRecord::Migration) do
+    migration = Class.new(migration_class) do
       def change
         create_trigger :uppercase_users_name, on: :users
       end
@@ -45,46 +45,46 @@ describe "Reverting migrations", :db do
   it "can run reversible migrations for dropping triggers" do
     connection.create_trigger(:uppercase_users_name, on: :users)
 
-    good_migration = Class.new(ActiveRecord::Migration) do
+    good_migration = Class.new(migration_class) do
       def change
         drop_trigger :uppercase_users_name, on: :users, revert_to_version: 1
       end
     end
-    bad_migration = Class.new(ActiveRecord::Migration) do
+    bad_migration = Class.new(migration_class) do
       def change
         drop_trigger :uppercase_users_name, on: :users
       end
     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 = <<~SQL
       CREATE TRIGGER uppercase_users_name
           BEFORE UPDATE ON users
           FOR EACH ROW
-          EXECUTE PROCEDURE uppercase_users_name();
-    EOS
+          EXECUTE FUNCTION uppercase_users_name();
+    SQL
     with_trigger_definition(
       name: :uppercase_users_name,
       sql_definition: sql_definition,
-      version: 2,
+      version: 2
     ) do
-      migration = Class.new(ActiveRecord::Migration) do
+      migration = Class.new(migration_class) do
         def change
           update_trigger(
             :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

@@ -0,0 +1,40 @@
+require "spec_helper"
+
+RSpec.describe Fx::Adapters::Postgres::Functions, :db do
+  describe ".all" do
+    it "returns `Function` objects" do
+      connection = ActiveRecord::Base.connection
+      connection.execute <<~SQL
+        CREATE OR REPLACE FUNCTION test()
+        RETURNS text AS $$
+        BEGIN
+            RETURN 'test';
+        END;
+        $$ LANGUAGE plpgsql;
+      SQL
+
+      functions = Fx::Adapters::Postgres::Functions.all(connection)
+
+      first = functions.first
+      expect(functions.size).to eq(1)
+      expect(first.name).to eq("test")
+      expect(first.definition).to eq(<<~SQL)
+        CREATE OR REPLACE FUNCTION public.test()
+         RETURNS text
+         LANGUAGE plpgsql
+        AS $function$
+        BEGIN
+            RETURN 'test';
+        END;
+        $function$
+      SQL
+
+      connection.execute "CREATE SCHEMA IF NOT EXISTS other;"
+      connection.execute "SET search_path = 'other';"
+
+      functions = Fx::Adapters::Postgres::Functions.all(connection)
+
+      expect(functions).to be_empty
+    end
+  end
+end

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

@@ -0,0 +1,75 @@
+require "spec_helper"
+
+RSpec.describe Fx::Adapters::Postgres::QueryExecutor, :db do
+  it "executes the query and maps results to objects" do
+    connection = ActiveRecord::Base.connection
+    query = "SELECT 'Hello World' as message, 'english' as language"
+    greeter = Class.new do
+      attr_reader :message, :language
+
+      def initialize(row)
+        @message = row.fetch("message")
+        @language = row.fetch("language")
+      end
+    end
+
+    results = described_class.call(
+      connection: connection,
+      query: query,
+      model_class: greeter
+    )
+
+    expect(results.size).to eq(1)
+    expect(results.first).to be_a(greeter)
+    expect(results.first.message).to eq("Hello World")
+    expect(results.first.language).to eq("english")
+  end
+
+  it "executes query with multiple results" do
+    connection = ActiveRecord::Base.connection
+    query = <<~SQL
+      SELECT 'first' as name
+      UNION ALL
+      SELECT 'second' as name
+      ORDER BY name
+    SQL
+    simple_name = Class.new do
+      attr_reader :name
+
+      def initialize(row)
+        @name = row.fetch("name")
+      end
+    end
+
+    results = described_class.call(
+      connection: connection,
+      query: query,
+      model_class: simple_name
+    )
+
+    expect(results.size).to eq(2)
+    expect(results).to all(be_a(simple_name))
+    expect(results.first.name).to eq("first")
+    expect(results.last.name).to eq("second")
+  end
+
+  it "returns an empty array when query returns no results" do
+    connection = ActiveRecord::Base.connection
+    query = "SELECT 'test' as name WHERE 1 = 0"
+    simple_name = Class.new do
+      attr_reader :name
+
+      def initialize(row)
+        @name = row.fetch("name")
+      end
+    end
+
+    results = described_class.call(
+      connection: connection,
+      query: query,
+      model_class: simple_name
+    )
+
+    expect(results).to eq([])
+  end
+end

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

@@ -0,0 +1,48 @@
+require "spec_helper"
+
+RSpec.describe Fx::Adapters::Postgres::Triggers, :db do
+  describe ".all" do
+    it "returns `Trigger` objects" do
+      connection = ActiveRecord::Base.connection
+      connection.execute <<~SQL
+        CREATE TABLE users (
+            id int PRIMARY KEY,
+            name varchar(256),
+            upper_name varchar(256)
+        );
+      SQL
+      connection.execute <<~SQL
+        CREATE OR REPLACE FUNCTION uppercase_users_name()
+        RETURNS trigger AS $$
+        BEGIN
+          NEW.upper_name = UPPER(NEW.name);
+          RETURN NEW;
+        END;
+        $$ LANGUAGE plpgsql;
+      SQL
+      connection.execute <<~SQL
+        CREATE TRIGGER uppercase_users_name
+            BEFORE INSERT ON users
+            FOR EACH ROW
+            EXECUTE FUNCTION uppercase_users_name();
+      SQL
+
+      triggers = Fx::Adapters::Postgres::Triggers.all(connection)
+
+      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()")
+
+      connection.execute "CREATE SCHEMA IF NOT EXISTS other;"
+      connection.execute "SET search_path = 'other';"
+
+      triggers = Fx::Adapters::Postgres::Triggers.all(connection)
+
+      expect(triggers).to be_empty
+    end
+  end
+end

data/spec/fx/adapters/postgres_spec.rb

@@ -1,149 +1,153 @@
 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(
+        <<~SQL
+          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
-        )
+        SQL
+      )
 
-        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
-      it "successfully drops a function" do
-        adapter = Postgres.new
+  describe "#create_trigger" do
+    it "successfully creates a trigger" do
+      connection.execute <<~SQL
+        CREATE TABLE users (
+            id int PRIMARY KEY,
+            name varchar(256),
+            upper_name varchar(256)
+        );
+      SQL
+      adapter = Fx::Adapters::Postgres.new
+      adapter.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
+      adapter.create_trigger(
+        <<~SQL
+          CREATE TRIGGER uppercase_users_name
+              BEFORE INSERT ON users
+              FOR EACH ROW
+              EXECUTE FUNCTION uppercase_users_name();
+        SQL
+      )
+
+      expect(adapter.triggers.map(&:name)).to include("uppercase_users_name")
+    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 = Fx::Adapters::Postgres.new
         adapter.create_function(
-          <<~EOS
-            CREATE OR REPLACE FUNCTION test()
-            RETURNS text AS $$
+          <<~SQL
+            CREATE FUNCTION adder(x int, y int)
+            RETURNS int AS $$
             BEGIN
-                RETURN 'test';
+                RETURN $1 + $2;
             END;
             $$ LANGUAGE plpgsql;
-          EOS
+          SQL
         )
 
-        adapter.drop_function(:test)
+        adapter.drop_function(:adder)
 
-        expect(adapter.functions.map(&:name)).not_to include("test")
+        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
+          <<~SQL
             CREATE OR REPLACE FUNCTION test()
             RETURNS text AS $$
             BEGIN
                 RETURN 'test';
             END;
             $$ LANGUAGE plpgsql;
-          EOS
+          SQL
         )
 
-        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
-          ),
-        ])
+        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(
+        <<~SQL
+          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).to eq(
-          [
-            Fx::Trigger.new(
-              "name" => "uppercase_users_name",
-              "definition" => format_trigger(sql_definition),
-            ),
-          ],
-        )
-      end
+        SQL
+      )
+
+      expect(adapter.functions.map(&:name)).to eq ["test"]
     end
+  end
+
+  describe "#triggers" do
+    it "finds triggers and builds Fx::Trigger objects" do
+      connection.execute <<~SQL
+        CREATE TABLE users (
+            id int PRIMARY KEY,
+            name varchar(256),
+            upper_name varchar(256)
+        );
+      SQL
+      adapter = Fx::Adapters::Postgres.new
+      adapter.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
+      adapter.create_trigger(sql_definition)
+
+      expect(adapter.triggers.map(&:name)).to eq ["uppercase_users_name"]
+    end
+  end
+
+  describe "#support_drop_function_without_args" do
+    it "returns true for all supported PostgreSQL versions" do
+      adapter = Fx::Adapters::Postgres.new
+      connection = adapter.send(:connection)
 
-    def format_trigger(trigger)
-      trigger.gsub("\n", "").gsub("    ", " ")
+      expect(connection.support_drop_function_without_args).to be(true)
     end
   end
 end