fx 0.7.0 → 0.9.0

data/spec/fx/statements_spec.rb

@@ -0,0 +1,217 @@
+require "spec_helper"
+
+RSpec.describe Fx::Statements, :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(:function)
+        .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(:function)
+        .with(name: :test, version: 2)
+    end
+
+    it "raises an error if both arguments are nil" do
+      expect do
+        connection.create_function(
+          :whatever,
+          version: nil,
+          sql_definition: nil
+        )
+      end.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(:function)
+        .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 do
+        connection.update_function(
+          :whatever,
+          version: nil,
+          sql_definition: nil
+        )
+      end.to raise_error(
+        ArgumentError,
+        /version or sql_definition must be specified/
+      )
+    end
+  end
+
+  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(:trigger)
+        .with(name: :test, version: 1)
+    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(:trigger)
+        .with(name: :test, version: 2)
+    end
+
+    it "raises an error if both arguments are set" do
+      stubbed_database
+
+      expect do
+        connection.create_trigger(
+          :whatever,
+          version: 1,
+          sql_definition: "a definition"
+        )
+      end.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(:trigger).with(
+        name: :test,
+        version: 3
+      )
+    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 do
+        connection.update_trigger(
+          :whatever,
+          version: nil,
+          sql_definition: nil
+        )
+      end.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 do
+        connection.update_trigger(
+          :whatever,
+          version: 1,
+          sql_definition: "a definition"
+        )
+      end.to raise_error(
+        ArgumentError,
+        /cannot both be set/
+      )
+    end
+  end
+
+  def stubbed_definition
+    instance_double("Fx::Definition", to_sql: nil).tap do |stubbed_definition|
+      allow(Fx::Definition).to receive(:function).and_return(stubbed_definition)
+      allow(Fx::Definition).to receive(:trigger).and_return(stubbed_definition)
+    end
+  end
+
+  def stubbed_database
+    database = instance_spy("StubbedDatabase")
+    allow(Fx).to receive(:database).and_return(database)
+
+    database
+  end
+end

data/spec/fx/trigger_spec.rb

@@ -1,55 +1,52 @@
 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 definition",
-        )
-        trigger_b = Trigger.new(
-          "name" => "name_b",
-          "definition" => "some definition",
-        )
-        trigger_c = Trigger.new(
-          "name" => "name_c",
-          "definition" => "some definition",
-        )
+RSpec.describe Fx::Trigger do
+  describe "#<=>" do
+    it "delegates to `name`" do
+      trigger_a = Fx::Trigger.new(
+        "name" => "name_a",
+        "definition" => "some definition"
+      )
+      trigger_b = Fx::Trigger.new(
+        "name" => "name_b",
+        "definition" => "some definition"
+      )
+      trigger_c = Fx::Trigger.new(
+        "name" => "name_c",
+        "definition" => "some definition"
+      )
 
-        expect(trigger_b).to be_between(trigger_a, trigger_c)
-      end
+      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 definition",
-        )
-        trigger_b = Trigger.new(
-          "name" => "name_b",
-          "definition" => "some other definition",
-        )
+  describe "#==" do
+    it "compares `name` and `definition`" do
+      trigger_a = Fx::Trigger.new(
+        "name" => "name_a",
+        "definition" => "some definition"
+      )
+      trigger_b = Fx::Trigger.new(
+        "name" => "name_b",
+        "definition" => "some other definition"
+      )
 
-        expect(trigger_a).not_to eq(trigger_b)
-      end
+      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 ...",
-        )
+  describe "#to_schema" do
+    it "returns a schema compatible version of the trigger" do
+      trigger = Fx::Trigger.new(
+        "name" => "uppercase_users_name",
+        "definition" => "CREATE TRIGGER uppercase_users_name ..."
+      )
 
-        expect(trigger.to_schema).to eq <<-EOS
+      expect(trigger.to_schema).to eq(<<-EOS)
   create_trigger :uppercase_users_name, sql_definition: <<-\SQL
       CREATE TRIGGER uppercase_users_name ...
   SQL
-        EOS
-      end
+      EOS
     end
   end
 end

data/spec/fx_spec.rb

@@ -0,0 +1,28 @@
+require "spec_helper"
+
+RSpec.describe Fx do
+  it "has a version number" do
+    expect(Fx::VERSION).to be_present
+  end
+
+  it "loads fx into ActiveRecord" do
+    expect(ActiveRecord::Migration::CommandRecorder).to include(Fx::CommandRecorder)
+    expect(ActiveRecord::ConnectionAdapters::AbstractAdapter).to include(Fx::Statements)
+    expect(ActiveRecord::SchemaDumper).to include(Fx::SchemaDumper)
+    expect(Fx.load).to eq(true)
+  end
+
+  it "allows configuration" do
+    adapter = double("Fx Adapter")
+
+    Fx.configure do |config|
+      config.database = adapter
+      config.dump_functions_at_beginning_of_schema = true
+    end
+
+    expect(Fx.configuration.database).to eq(adapter)
+    expect(Fx.configuration.dump_functions_at_beginning_of_schema).to eq(true)
+
+    Fx.configuration = nil
+  end
+end

data/spec/generators/fx/function/function_generator_spec.rb

@@ -1,7 +1,7 @@
 require "spec_helper"
 require "generators/fx/function/function_generator"
 
-describe Fx::Generators::FunctionGenerator, :generator do
+RSpec.describe Fx::Generators::FunctionGenerator, :generator do
   it "creates a function definition file, and a migration" do
     migration = file("db/migrate/create_function_test.rb")
     function_definition = file("db/functions/test_v01.sql")
@@ -10,7 +10,7 @@ describe Fx::Generators::FunctionGenerator, :generator do
 
     expect(function_definition).to exist
     expect(migration).to be_a_migration
-    expect(migration_file(migration)).to contain "CreateFunctionTest"
+    expect(migration_file(migration)).to contain("CreateFunctionTest")
   end
 
   context "when passed --no-migration" do
@@ -21,7 +21,7 @@ describe Fx::Generators::FunctionGenerator, :generator do
       run_generator ["test", "--no-migration"]
 
       expect(function_definition).to exist
-      expect(migration_file(migration)).not_to exist
+      expect(Pathname.new(migration_file(migration))).not_to exist
     end
   end
 
@@ -29,7 +29,7 @@ describe Fx::Generators::FunctionGenerator, :generator do
     with_function_definition(
       name: "test",
       version: 1,
-      sql_definition: "hello",
+      sql_definition: "hello"
     ) do
       allow(Dir).to receive(:entries).and_return(["test_v01.sql"])
       migration = file("db/migrate/update_function_test_to_version_2.rb")
@@ -39,8 +39,8 @@ describe Fx::Generators::FunctionGenerator, :generator do
 
       expect(function_definition).to exist
       expect(migration).to be_a_migration
-      expect(migration_file(migration)).
-        to contain("UpdateFunctionTestToVersion2")
+      expect(migration_file(migration))
+        .to contain("UpdateFunctionTestToVersion2")
     end
   end
 end

data/spec/generators/fx/trigger/trigger_generator_spec.rb

@@ -1,7 +1,7 @@
 require "spec_helper"
 require "generators/fx/trigger/trigger_generator"
 
-describe Fx::Generators::TriggerGenerator, :generator do
+RSpec.describe Fx::Generators::TriggerGenerator, :generator do
   it "creates a trigger definition file, and a migration" do
     migration = file("db/migrate/create_trigger_test.rb")
     trigger_definition = file("db/triggers/test_v01.sql")
@@ -10,8 +10,8 @@ describe Fx::Generators::TriggerGenerator, :generator do
 
     expect(trigger_definition).to exist
     expect(migration).to be_a_migration
-    expect(migration_file(migration)).to contain "CreateTriggerTest"
-    expect(migration_file(migration)).to contain "on: :some_table"
+    expect(migration_file(migration)).to contain("CreateTriggerTest")
+    expect(migration_file(migration)).to contain("on: :some_table")
   end
 
   context "when passed --no-migration" do
@@ -22,7 +22,7 @@ describe Fx::Generators::TriggerGenerator, :generator do
       run_generator ["test", {"table_name" => "some_table"}, "--no-migration"]
 
       expect(trigger_definition).to exist
-      expect(migration_file(migration)).not_to exist
+      expect(Pathname.new(migration_file(migration))).not_to exist
     end
   end
 
@@ -34,14 +34,14 @@ describe Fx::Generators::TriggerGenerator, :generator do
 
     expect(trigger_definition).to exist
     expect(migration).to be_a_migration
-    expect(migration_file(migration)).to contain "CreateTriggerTest"
-    expect(migration_file(migration)).to contain "on: :some_table"
+    expect(migration_file(migration)).to contain("CreateTriggerTest")
+    expect(migration_file(migration)).to contain("on: :some_table")
   end
 
   it "requires `table_name` or `on` to be specified" do
-    expect {
+    expect do
       run_generator ["test", "foo" => "some_table"]
-    }.to raise_error ArgumentError
+    end.to raise_error(ArgumentError)
   end
 
   it "updates an existing trigger" do
@@ -53,7 +53,7 @@ describe Fx::Generators::TriggerGenerator, :generator do
 
     expect(trigger_definition).to exist
     expect(migration).to be_a_migration
-    expect(migration_file(migration)).to contain "UpdateTriggerTestToVersion2"
-    expect(migration_file(migration)).to contain "on: :some_table"
+    expect(migration_file(migration)).to contain("UpdateTriggerTestToVersion2")
+    expect(migration_file(migration)).to contain("on: :some_table")
   end
 end

data/spec/spec_helper.rb

@@ -4,8 +4,13 @@ require "database_cleaner"
 require File.expand_path("../dummy/config/environment", __FILE__)
 Dir["spec/support/**/*.rb"].sort.each { |file| load file }
 
+$LOAD_PATH.unshift File.expand_path("../lib", __dir__)
+require "fx"
+
 RSpec.configure do |config|
   config.order = "random"
+  config.disable_monkey_patching!
+
   DatabaseCleaner.strategy = :transaction
 
   config.around(:each, db: true) do |example|

data/spec/support/definition_helpers.rb

@@ -1,31 +1,27 @@
 module DefinitionHelpers
   def with_function_definition(name:, sql_definition:, version: 1, &block)
-    definition = Fx::Definition.new(name: name, version: version)
+    definition = Fx::Definition.function(name: name, version: version)
 
     with_definition(
       definition: definition,
       sql_definition: sql_definition,
-      block: block,
+      block: block
     )
   end
 
   def with_trigger_definition(name:, sql_definition:, version: 1, &block)
-    definition = Fx::Definition.new(
-      name: name,
-      version: version,
-      type: "trigger",
-    )
+    definition = Fx::Definition.trigger(name: name, version: version)
 
     with_definition(
       definition: definition,
       sql_definition: sql_definition,
-      block: block,
+      block: block
     )
   end
 
   def with_definition(definition:, sql_definition:, block:)
     FileUtils.mkdir_p(File.dirname(definition.full_path))
-    File.open(definition.full_path, "w") { |f| f.write(sql_definition) }
+    File.write(definition.full_path, sql_definition)
     block.call
   ensure
     File.delete definition.full_path

data/spec/support/generator_setup.rb

@@ -2,7 +2,7 @@ require "ammeter/init"
 
 RSpec.configure do |config|
   config.before(:each, :generator) do
-    fake_rails_root = File.expand_path("../../../tmp", __FILE__)
+    fake_rails_root = File.expand_path("../../../tmp/dummy", __FILE__)
     allow(Rails).to receive(:root).and_return(Pathname.new(fake_rails_root))
 
     destination fake_rails_root

data/spec/support/migration_helpers.rb

@@ -1,6 +1,6 @@
 module MigrationsHelper
   def run_migration(migration, directions)
-    silence_stream(STDOUT) do
+    silence_stream($stdout) do
       Array.wrap(directions).each do |direction|
         migration.migrate(direction)
       end

data/spec/support/warning_helper.rb

@@ -0,0 +1,5 @@
+require "warning"
+
+Warning.process do |_|
+  :raise
+end