fx 0.8.0 → 0.10.0

data/lib/fx/statements/trigger.rb

@@ -1,144 +0,0 @@
-module Fx
-  module Statements
-    # Methods that are made available in migrations for managing Fx triggers.
-    module Trigger
-      # @api private
-      DEFINITION_TYPE = "trigger".freeze
-
-      # Create a new database trigger.
-      #
-      # @param name [String, Symbol] The name of the database trigger.
-      # @param version [Fixnum] The version number of the trigger, used to
-      #   find the definition file in `db/triggers`. This defaults to `1` if
-      #   not provided.
-      # @param sql_definition [String] The SQL query for the function. An error
-      #   will be raised if `sql_definition` and `version` are both set,
-      #   as they are mutually exclusive.
-      # @return The database response from executing the create statement.
-      #
-      # @example Create trigger from `db/triggers/uppercase_users_name_v01.sql`
-      #   create_trigger(:uppercase_users_name, version: 1)
-      #
-      # @example Create trigger from provided SQL string
-      #   create_trigger(:uppercase_users_name, sql_definition: <<-SQL)
-      #     CREATE TRIGGER uppercase_users_name
-      #         BEFORE INSERT ON users
-      #         FOR EACH ROW
-      #         EXECUTE FUNCTION uppercase_users_name();
-      #    SQL
-      #
-      def create_trigger(name, options = {})
-        version = options[:version]
-        _on = options[:on]
-        sql_definition = options[:sql_definition]
-
-        if version.present? && sql_definition.present?
-          raise(
-            ArgumentError,
-            "sql_definition and version cannot both be set"
-          )
-        end
-
-        if version.nil?
-          version = 1
-        end
-
-        sql_definition = sql_definition.strip_heredoc if sql_definition
-        sql_definition ||= Fx::Definition.new(
-          name: name,
-          version: version,
-          type: DEFINITION_TYPE
-        ).to_sql
-
-        Fx.database.create_trigger(sql_definition)
-      end
-
-      # Drop a database trigger by name.
-      #
-      # @param name [String, Symbol] The name of the database trigger.
-      # @param on [String, Symbol] The name of the table the database trigger
-      #   is associated with.
-      # @param revert_to_version [Fixnum] Used to reverse the `drop_trigger`
-      #   command on `rake db:rollback`. The provided version will be passed as
-      #   the `version` argument to {#create_trigger}.
-      # @return The database response from executing the drop statement.
-      #
-      # @example Drop a trigger, rolling back to version 3 on rollback
-      #   drop_trigger(:log_inserts, on: :users, revert_to_version: 3)
-      #
-      def drop_trigger(name, options = {})
-        on = options.fetch(:on)
-        Fx.database.drop_trigger(name, on: on)
-      end
-
-      # Update a database trigger to a new version.
-      #
-      # The existing trigger is dropped and recreated using the supplied `on`
-      # and `version` parameter.
-      #
-      # @param name [String, Symbol] The name of the database trigger.
-      # @param version [Fixnum] The version number of the trigger.
-      # @param on [String, Symbol] The name of the table the database trigger
-      #   is associated with.
-      # @param sql_definition [String] The SQL query for the function. An error
-      #   will be raised if `sql_definition` and `version` are both set,
-      #   as they are mutually exclusive.
-      # @param revert_to_version [Fixnum] The version number to rollback to on
-      #   `rake db rollback`
-      # @return The database response from executing the create statement.
-      #
-      # @example Update trigger to a given version
-      #   update_trigger(
-      #     :log_inserts,
-      #     on: :users,
-      #     version: 3,
-      #     revert_to_version: 2,
-      #   )
-      #
-      # @example Update trigger from provided SQL string
-      #   update_trigger(:uppercase_users_name, sql_definition: <<-SQL)
-      #     CREATE TRIGGER uppercase_users_name
-      #         BEFORE INSERT ON users
-      #         FOR EACH ROW
-      #         EXECUTE FUNCTION uppercase_users_name();
-      #    SQL
-      #
-      def update_trigger(name, options = {})
-        version = options[:version]
-        on = options[:on]
-        sql_definition = options[:sql_definition]
-
-        if version.nil? && sql_definition.nil?
-          raise(
-            ArgumentError,
-            "version or sql_definition must be specified"
-          )
-        end
-
-        if version.present? && sql_definition.present?
-          raise(
-            ArgumentError,
-            "sql_definition and version cannot both be set"
-          )
-        end
-
-        if on.nil?
-          raise ArgumentError, "on is required"
-        end
-
-        sql_definition = sql_definition.strip_heredoc if sql_definition
-        sql_definition ||= Fx::Definition.new(
-          name: name,
-          version: version,
-          type: DEFINITION_TYPE
-        ).to_sql
-
-        Fx.database.update_trigger(
-          name,
-          on: on,
-          sql_definition: sql_definition
-        )
-      end
-    end
-  end
-end

data/spec/fx/command_recorder/arguments_spec.rb

@@ -1,41 +0,0 @@
-require "spec_helper"
-
-module Fx::CommandRecorder
-  describe Arguments do
-    describe "#function" do
-      it "returns the function name" do
-        raw_args = [:spaceships, {foo: :bar}]
-        args = Arguments.new(raw_args)
-
-        expect(args.function).to eq :spaceships
-      end
-    end
-
-    describe "#revert_to_version" do
-      it "is the revert_to_version from the keyword arguments" do
-        raw_args = [:spaceships, {revert_to_version: 42}]
-        args = Arguments.new(raw_args)
-
-        expect(args.revert_to_version).to eq 42
-      end
-
-      it "is nil if the revert_to_version was not supplied" do
-        raw_args = [:spaceships, {foo: :bar}]
-        args = Arguments.new(raw_args)
-
-        expect(args.revert_to_version).to be nil
-      end
-    end
-
-    describe "#invert_version" do
-      it "returns object with version set to revert_to_version" do
-        raw_args = [:meatballs, {version: 42, revert_to_version: 15}]
-
-        inverted_args = Arguments.new(raw_args).invert_version
-
-        expect(inverted_args.version).to eq 15
-        expect(inverted_args.revert_to_version).to be nil
-      end
-    end
-  end
-end

data/spec/fx/schema_dumper/function_spec.rb

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

@@ -1,40 +0,0 @@
-require "spec_helper"
-
-describe Fx::SchemaDumper::Trigger, :db do
-  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
-
-    ActiveRecord::SchemaDumper.dump(connection, 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
-end

data/spec/fx/statements/function_spec.rb

@@ -1,103 +0,0 @@
-require "spec_helper"
-require "fx/statements/function"
-
-describe Fx::Statements::Function, :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(:new)
-        .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(:new)
-        .with(name: :test, version: 2)
-    end
-
-    it "raises an error if both arguments are nil" do
-      expect {
-        connection.create_function(
-          :whatever,
-          version: nil,
-          sql_definition: nil
-        )
-      }.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(:new)
-        .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 {
-        connection.update_function(
-          :whatever,
-          version: nil,
-          sql_definition: nil
-        )
-      }.to raise_error(
-        ArgumentError,
-        /version or sql_definition must be specified/
-      )
-    end
-  end
-
-  def stubbed_database
-    instance_spy("StubbedDatabase").tap do |stubbed_database|
-      allow(Fx).to receive(:database).and_return(stubbed_database)
-    end
-  end
-
-  def stubbed_definition
-    instance_double("Fx::Definition", to_sql: nil).tap do |stubbed_definition|
-      allow(Fx::Definition).to receive(:new).and_return(stubbed_definition)
-    end
-  end
-end

data/spec/fx/statements/trigger_spec.rb

@@ -1,132 +0,0 @@
-require "spec_helper"
-require "fx/statements/trigger"
-
-describe Fx::Statements::Trigger, :db do
-  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(:new)
-        .with(name: :test, version: 1, type: "trigger")
-    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(:new)
-        .with(name: :test, version: 2, type: "trigger")
-    end
-
-    it "raises an error if both arguments are set" do
-      stubbed_database
-
-      expect {
-        connection.create_trigger(
-          :whatever,
-          version: 1,
-          sql_definition: "a definition"
-        )
-      }.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(:new).with(
-        name: :test,
-        version: 3,
-        type: "trigger"
-      )
-    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 {
-        connection.update_trigger(
-          :whatever,
-          version: nil,
-          sql_definition: nil
-        )
-      }.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 {
-        connection.update_trigger(
-          :whatever,
-          version: 1,
-          sql_definition: "a definition"
-        )
-      }.to raise_error(
-        ArgumentError,
-        /cannot both be set/
-      )
-    end
-  end
-
-  def stubbed_database
-    instance_spy("StubbedDatabase").tap do |stubbed_database|
-      allow(Fx).to receive(:database).and_return(stubbed_database)
-    end
-  end
-
-  def stubbed_definition
-    instance_double("Fx::Definition", to_sql: nil).tap do |stubbed_definition|
-      allow(Fx::Definition).to receive(:new).and_return(stubbed_definition)
-    end
-  end
-end