fx-jets 0.6.3s

data/spec/fx/command_recorder/arguments_spec.rb

@@ -0,0 +1,41 @@
+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/command_recorder_spec.rb

@@ -0,0 +1,171 @@
+require "spec_helper"
+
+describe Fx::CommandRecorder, :db do
+  describe "#create_function" do
+    it "records the created function" do
+      recorder = ActiveRecord::Migration::CommandRecorder.new
+
+      recorder.create_function :test
+
+      expect(recorder.commands).to eq [[:create_function, [:test], nil]]
+    end
+
+    it "reverts to drop_function" do
+      recorder = ActiveRecord::Migration::CommandRecorder.new
+
+      recorder.create_function :test
+
+      expect(recorder.commands).to eq [[:create_function, [:test], nil]]
+    end
+
+    it "reverts to drop_function" do
+      recorder = ActiveRecord::Migration::CommandRecorder.new
+
+      recorder.revert { recorder.create_function :test }
+
+      expect(recorder.commands).to eq [[:drop_function, [:test]]]
+    end
+  end
+
+  describe "#drop_function" do
+    it "records the dropped function" do
+      recorder = ActiveRecord::Migration::CommandRecorder.new
+
+      recorder.drop_function :test
+
+      expect(recorder.commands).to eq [[:drop_function, [:test], nil]]
+    end
+
+    it "reverts to create_function with specified revert_to_version" do
+      recorder = ActiveRecord::Migration::CommandRecorder.new
+      args = [:test, { revert_to_version: 3 }]
+      revert_args = [:test, { version: 3 }]
+
+      recorder.revert { recorder.drop_function(*args) }
+
+      expect(recorder.commands).to eq [[:create_function, revert_args]]
+    end
+
+    it "raises when reverting without revert_to_version set" do
+      recorder = ActiveRecord::Migration::CommandRecorder.new
+      args = [:test, { another_argument: 1 }]
+
+      expect { recorder.revert { recorder.drop_function(*args) } }.
+        to raise_error(ActiveRecord::IrreversibleMigration)
+    end
+  end
+
+  describe "#update_function" do
+    it "records the updated function" do
+      recorder = ActiveRecord::Migration::CommandRecorder.new
+      args = [:test, { version: 2 }]
+
+      recorder.update_function(*args)
+
+      expect(recorder.commands).to eq [[:update_function, args, nil]]
+    end
+
+    it "reverts to update_function with the specified revert_to_version" do
+      recorder = ActiveRecord::Migration::CommandRecorder.new
+      args = [:test, { version: 2, revert_to_version: 1 }]
+      revert_args = [:test, { version: 1 }]
+
+      recorder.revert { recorder.update_function(*args) }
+
+      expect(recorder.commands).to eq [[:update_function, revert_args]]
+    end
+
+    it "raises when reverting without revert_to_version set" do
+      recorder = ActiveRecord::Migration::CommandRecorder.new
+      args = [:test, { version: 42, another_argument: 1 }]
+
+      expect { recorder.revert { recorder.update_function(*args) } }.
+        to raise_error(ActiveRecord::IrreversibleMigration)
+    end
+  end
+
+  describe "#create_trigger" do
+    it "records the created trigger" do
+      recorder = ActiveRecord::Migration::CommandRecorder.new
+
+      recorder.create_trigger :greetings
+
+      expect(recorder.commands).to eq [[:create_trigger, [:greetings], nil]]
+    end
+
+    it "reverts to drop_trigger" do
+      recorder = ActiveRecord::Migration::CommandRecorder.new
+
+      recorder.create_trigger :greetings
+
+      expect(recorder.commands).to eq [
+        [:create_trigger, [:greetings], nil],
+      ]
+    end
+
+    it "reverts to drop_trigger" do
+      recorder = ActiveRecord::Migration::CommandRecorder.new
+
+      recorder.revert { recorder.create_trigger :greetings }
+
+      expect(recorder.commands).to eq [[:drop_trigger, [:greetings]]]
+    end
+  end
+
+  describe "#drop_trigger" do
+    it "records the dropped trigger" do
+      recorder = ActiveRecord::Migration::CommandRecorder.new
+
+      recorder.drop_trigger :users
+
+      expect(recorder.commands).to eq [[:drop_trigger, [:users], nil]]
+    end
+
+    it "reverts to create_trigger with specified revert_to_version" do
+      recorder = ActiveRecord::Migration::CommandRecorder.new
+      args = [:users, { revert_to_version: 3 }]
+      revert_args = [:users, { version: 3 }]
+
+      recorder.revert { recorder.drop_trigger(*args) }
+
+      expect(recorder.commands).to eq [[:create_trigger, revert_args]]
+    end
+
+    it "raises when reverting without revert_to_version set" do
+      recorder = ActiveRecord::Migration::CommandRecorder.new
+      args = [:users, { another_argument: 1 }]
+
+      expect { recorder.revert { recorder.drop_trigger(*args) } }.
+        to raise_error(ActiveRecord::IrreversibleMigration)
+    end
+  end
+
+  describe "#update_trigger" do
+    it "records the updated trigger" do
+      recorder = ActiveRecord::Migration::CommandRecorder.new
+      args = [:users, { version: 2 }]
+
+      recorder.update_trigger(*args)
+
+      expect(recorder.commands).to eq [[:update_trigger, args, nil]]
+    end
+
+    it "reverts to update_trigger with the specified revert_to_version" do
+      recorder = ActiveRecord::Migration::CommandRecorder.new
+      args = [:users, { version: 2, revert_to_version: 1 }]
+      revert_args = [:users, { version: 1 }]
+
+      recorder.revert { recorder.update_trigger(*args) }
+
+      expect(recorder.commands).to eq [[:update_trigger, revert_args]]
+    end
+
+    it "raises when reverting without revert_to_version set" do
+      recorder = ActiveRecord::Migration::CommandRecorder.new
+      args = [:users, { version: 42, another_argument: 1 }]
+
+      expect { recorder.revert { recorder.update_trigger(*args) } }.
+        to raise_error(ActiveRecord::IrreversibleMigration)
+    end
+  end
+end

data/spec/fx/configuration_spec.rb

@@ -0,0 +1,21 @@
+require "spec_helper"
+
+describe Fx::Configuration do
+  it "defaults the database adapter to postgres" do
+    expect(Fx.configuration.database).to be_a Fx::Adapters::Postgres
+    expect(Fx.database).to be_a Fx::Adapters::Postgres
+  end
+
+  it "allows the database adapter to be set" do
+    adapter = double("Fx Adapter")
+
+    Fx.configure do |config|
+      config.database = adapter
+    end
+
+    expect(Fx.configuration.database).to eq adapter
+    expect(Fx.database).to eq adapter
+
+    Fx.configuration = Fx::Configuration.new
+  end
+end

data/spec/fx/definition_spec.rb

@@ -0,0 +1,134 @@
+require "spec_helper"
+
+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
+          CREATE OR REPLACE FUNCTION test()
+          RETURNS text AS $$
+          BEGIN
+              RETURN 'test';
+          END;
+          $$ LANGUAGE plpgsql;
+        EOS
+        allow(File).to receive(:read).and_return(sql_definition)
+
+        definition = Fx::Definition.new(name: "test", version: 1)
+
+        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)
+
+        expect { definition.to_sql }.to raise_error(
+          RuntimeError,
+          %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 = Jets.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)
+          Jets.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
+          CREATE TRIGGER check_update
+          BEFORE UPDATE ON accounts
+          FOR EACH ROW
+          EXECUTE PROCEDURE check_account_update();
+        EOS
+        allow(File).to receive(:read).and_return(sql_definition)
+
+        definition = Fx::Definition.new(
+          name: "test",
+          version: 1,
+          type: "trigger",
+        )
+
+        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",
+        )
+
+        expect { definition.to_sql }.to raise_error(
+          RuntimeError,
+          %r(Define trigger in db/triggers/test_v01.sql before migrating),
+        )
+      end
+    end
+  end
+
+  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)
+
+        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",
+        )
+
+        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)
+
+      expect(definition.full_path).to eq Jets.root.join(definition.path)
+    end
+  end
+
+  describe "#version" do
+    it "pads the version number with 0" do
+      definition = Fx::Definition.new(name: :_, version: 1)
+
+      expect(definition.version).to eq "01"
+    end
+
+    it "does not pad more than 2 characters" do
+      definition = Fx::Definition.new(name: :_, version: 15)
+
+      expect(definition.version).to eq "15"
+    end
+  end
+end

data/spec/fx/function_spec.rb

@@ -0,0 +1,68 @@
+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
+
+      it "maintains backslashes" do
+        function = Function.new(
+          "name" => "regex",
+          "definition" => "CREATE OR REPLACE FUNCTION regex \\1",
+        )
+
+        expect(function.to_schema).to eq <<-'EOS'
+  create_function :regex, sql_definition: <<-'SQL'
+      CREATE OR REPLACE FUNCTION regex \1
+  SQL
+        EOS
+      end
+    end
+  end
+end

data/spec/fx/schema_dumper/function_spec.rb

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

@@ -0,0 +1,40 @@
+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 PROCEDURE 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 PROCEDURE uppercase_users_name()"
+  end
+end

data/spec/fx/statements/function_spec.rb

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