ardb 0.27.3 → 0.29.0

data/lib/ardb/use_db_default.rb

@@ -1,22 +1,16 @@
-require 'much-plugin'
+require "much-plugin"
 
 module Ardb
-
   module UseDbDefault
     include MuchPlugin
 
     plugin_included do
-      extend ClassMethods
-      include InstanceMethods
-
       @ardb_use_db_default_attrs = []
 
       around_create :ardb_allow_db_to_default_attrs
-
     end
 
-    module ClassMethods
-
+    plugin_class_methods do
       def ardb_use_db_default_attrs
         @ardb_use_db_default_attrs
       end
@@ -25,11 +19,9 @@ module Ardb
         @ardb_use_db_default_attrs += attrs.map(&:to_s)
         @ardb_use_db_default_attrs.uniq!
       end
-
     end
 
-    module InstanceMethods
-
+    plugin_instance_methods do
       private
 
       def ardb_allow_db_to_default_attrs
@@ -42,15 +34,12 @@ module Ardb
         unchanged_names.each{ |name| @attributes.delete(name) }
         yield
         # we have to go and fetch the attr value from the DB, otherwise
-        # activerecord doesn't know the value that the DB used
+        # activerecord doesn"t know the value that the DB used
         scope = self.class.where(:id => self.id)
         unchanged_names.each do |name|
           @attributes[name] = scope.pluck(name).first
         end
       end
-
     end
-
   end
-
 end

data/lib/ardb/version.rb

@@ -1,3 +1,3 @@
 module Ardb
-  VERSION = "0.27.3"
+  VERSION = "0.29.0"
 end

data/script/determine_autoloaded_active_record_files.rb

@@ -1,8 +1,8 @@
-require 'active_record'
+require "active_record"
 
-# this can be slow, this is one of the reasons this shouldn't be done during
+# this can be slow, this is one of the reasons this shouldn"t be done during
 # the startup of our apps
-gemspec = Gem.loaded_specs['activerecord']
+gemspec = Gem.loaded_specs["activerecord"]
 
 puts "Looking at files in: "
 puts "  #{gemspec.lib_dirs_glob.inspect}"
@@ -11,15 +11,18 @@ paths = Dir["#{gemspec.lib_dirs_glob}/**/*.rb"]
 
 # these are regexs for files we want to ignore requiring. for example,
 # generators fail when we try to require them. the others are pieces of active
-# record we don't use in a production environment
+# record we don"t use in a production environment
 ignored_regexes = [
   /rails\/generators/,
   /active_record\/railtie/,
   /active_record\/migration/,
   /active_record\/fixtures/,
+  /active_record\/fixture_set/,
   /active_record\/schema/,
   /active_record\/connection_adapters/,
   /active_record\/test_case/,
+  /active_record\/test_databases/,
+  /active_record\/test_fixtures/,
   /active_record\/coders\/yaml_column/
 ]
 
@@ -31,12 +34,12 @@ ignored              = []
 errored              = []
 
 paths.sort.each do |full_path|
-  relative_path_with_rb = full_path.gsub("#{gemspec.lib_dirs_glob}/", '')
-  relative_path = relative_path_with_rb.gsub(/\.rb\z/, '')
+  relative_path_with_rb = full_path.gsub("#{gemspec.lib_dirs_glob}/", "")
+  relative_path = relative_path_with_rb.gsub(/\.rb\z/, "")
 
   result = Result.new(relative_path)
 
-  # see if it's ignored
+  # see if it"s ignored
   ignored_regexes.each do |regex|
     if relative_path =~ regex
       result.state  = :ignored
@@ -87,5 +90,5 @@ puts "\n"
 
 puts "Needs To Be Required:\n"
 needs_to_be_required.each do |result|
-  puts "require '#{result.file}'"
+  puts "require \"#{result.file}\""
 end

data/test/helper.rb

@@ -4,10 +4,13 @@
 # add the root dir to the load path
 $LOAD_PATH.unshift(File.expand_path("../..", __FILE__))
 
-# require pry for debugging (`binding.pry`)
-require 'pry'
-require 'test/support/factory'
+TEST_SUPPORT_PATH = File.expand_path("../support", __FILE__)
+TMP_PATH          = File.expand_path("../../tmp", __FILE__)
+
+require "logger"
+log_path = File.expand_path("../../log/test.log", __FILE__)
+TEST_LOGGER = Logger.new(File.open(log_path, "w"))
 
-ENV['ARDB_DB_FILE'] = 'tmp/testdb/config/db'
-require 'ardb'
-Ardb.init(false)
+# require pry for debugging (`binding.pry`)
+require "pry"
+require "test/support/factory"

data/test/support/factory.rb

@@ -1,11 +1,26 @@
-require 'assert/factory'
+require "assert/factory"
 
 module Factory
   extend Assert::Factory
 
   def self.migration_id
-    # identifiers need to be plural b/c af activesupport's pluralize
+    # identifiers need to be plural b/c af activesupport"s pluralize
     "#{Factory.string}_things"
   end
 
+  def self.ardb_config
+    Ardb::Config.new.tap do |c|
+      c.adapter          = Factory.string
+      c.database         = Factory.string
+      c.encoding         = Factory.string
+      c.host             = Factory.string
+      c.port             = Factory.integer
+      c.username         = Factory.string
+      c.password         = Factory.string
+      c.pool             = Factory.integer
+      c.checkout_timeout = Factory.integer
+      c.min_messages     = Factory.string
+    end
+  end
+
 end

data/test/support/fake_schema.rb

@@ -0,0 +1,5 @@
+if !defined?(FAKE_SCHEMA)
+  fake_schema_class = Struct.new(:load_count)
+  FAKE_SCHEMA = fake_schema_class.new(0)
+end
+FAKE_SCHEMA.load_count += 1

data/test/support/postgresql/schema.rb

@@ -0,0 +1,2 @@
+ActiveRecord::Schema.define(:version => 0) do
+end

data/test/support/postgresql/setup_test_db.rb

@@ -0,0 +1,51 @@
+require "assert"
+require "ardb"
+
+class PostgresqlDbTests < Assert::Context
+  setup do
+    @orig_env_ardb_db_file    = ENV["ARDB_DB_FILE"]
+    ActiveRecord::Base.logger = @orig_ar_loggerF
+
+    # no-op, we"re manually configuring ardb so we don"t need this to do anything
+    ENV["ARDB_DB_FILE"] = File.join(TEST_SUPPORT_PATH, "require_test_db_file")
+
+    @ardb_config = Ardb::Config.new.tap do |c|
+      c.adapter      = "postgresql"
+      c.database     = "redding_ardb_test"
+      c.encoding     = "unicode"
+      c.min_messages = "WARNING"
+
+      c.logger          = TEST_LOGGER
+      c.root_path       = File.join(TEST_SUPPORT_PATH, "postgresql")
+      c.migrations_path = "migrations"
+      c.schema_path     = "schema"
+      c.schema_format   = :ruby
+    end
+    Assert.stub(Ardb, :config){ @ardb_config }
+
+    Ardb.init(false)
+
+    Ardb.adapter.drop_db
+    Ardb.adapter.create_db
+    Ardb.adapter.load_schema
+    Ardb.adapter.connect_db
+  end
+  teardown do
+    Ardb.reset_adapter
+    ActiveRecord::Base.logger = @orig_ar_logger
+    ENV["ARDB_DB_FILE"]       = @orig_env_ardb_db_file
+  end
+
+  private
+
+  # useful when testing creating/dropping/migrating DBs
+  def silence_stdout
+    current_stdout = $stdout.dup
+    $stdout = File.new("/dev/null", "w")
+    begin
+      yield
+    ensure
+      $stdout = current_stdout
+    end
+  end
+end

data/test/support/relative_require_test_db_file.rb

@@ -0,0 +1,2 @@
+# this file is used to test that Ardb will relatively require a db file when
+# init

data/test/support/require_test_db_file.rb

@@ -0,0 +1 @@
+# this file is used to test that Ardb will require a db file when init

data/test/unit/adapter/base_tests.rb

@@ -1,34 +1,44 @@
-require 'assert'
-require 'ardb/adapter/base'
+require "assert"
+require "ardb/adapter/base"
 
-class Ardb::Adapter::Base
+require "ardb"
+# This is needed by the schema dumper but it doesn"t handle requiring it so we
+# have to manually, otherwise this errors when you try to run the adapter base
+# tests by themselves
+require "active_support/core_ext/class/attribute_accessors"
 
+class Ardb::Adapter::Base
   class UnitTests < Assert::Context
     desc "Ardb::Adapter::Base"
     setup do
-      @adapter = Ardb::Adapter::Base.new
+      @config  = Factory.ardb_config
+      @adapter = Ardb::Adapter::Base.new(@config)
     end
     subject{ @adapter }
 
-    should have_readers :config_settings, :database
-    should have_readers :ruby_schema_path, :sql_schema_path
+    should have_readers :config
+    should have_imeths :connect_hash, :database, :migrations_path
+    should have_imeths :schema_format, :ruby_schema_path, :sql_schema_path
     should have_imeths :escape_like_pattern
-    should have_imeths :foreign_key_add_sql, :foreign_key_drop_sql
-    should have_imeths :create_db, :drop_db, :connect_db, :migrate_db
+    should have_imeths :create_db, :drop_db, :drop_tables
+    should have_imeths :connect_db, :migrate_db
     should have_imeths :load_schema, :load_ruby_schema, :load_sql_schema
     should have_imeths :dump_schema, :dump_ruby_schema, :dump_sql_schema
 
-    should "know its config settings " do
-      assert_equal Ardb.config.db_settings, subject.config_settings
+    should "know its config" do
+      assert_equal @config, subject.config
     end
 
-    should "know its database" do
-      assert_equal Ardb.config.db.database, subject.database
+    should "demeter its config" do
+      assert_equal @config.activerecord_connect_hash, subject.connect_hash
+      assert_equal @config.database,                  subject.database
+      assert_equal @config.migrations_path,           subject.migrations_path
+      assert_equal @config.schema_format,             subject.schema_format
     end
 
-    should "know its schema paths" do
-      assert_equal "#{Ardb.config.schema_path}.rb",  subject.ruby_schema_path
-      assert_equal "#{Ardb.config.schema_path}.sql", subject.sql_schema_path
+    should "know its ruby and sql schema paths" do
+      assert_equal "#{@config.schema_path}.rb",  subject.ruby_schema_path
+      assert_equal "#{@config.schema_path}.sql", subject.sql_schema_path
     end
 
     should "know how to escape like patterns" do
@@ -37,12 +47,15 @@ class Ardb::Adapter::Base
                 "#{Factory.string}\\" \
                 "#{Factory.string} " \
                 "#{Factory.string}"
-      exp = pattern.gsub("\\"){ "\\\\" }.gsub('%', "\\%").gsub('_', "\\_")
+      exp = pattern.gsub("\\"){ "\\\\" }.gsub("%", "\\%").gsub("_", "\\_")
       assert_equal exp, subject.escape_like_pattern(pattern)
+
+      pattern = Factory.string
+      assert_equal pattern, subject.escape_like_pattern(pattern)
     end
 
     should "allow using a custom escape char when escaping like patterns" do
-      escape_char = '#'
+      escape_char = "#"
       pattern = "#{Factory.string}%" \
                 "#{Factory.string}_" \
                 "#{Factory.string}\\" \
@@ -50,15 +63,10 @@ class Ardb::Adapter::Base
                 "#{Factory.string} " \
                 "#{Factory.string}"
       exp = pattern.gsub(escape_char, "#{escape_char}#{escape_char}")
-      exp = exp.gsub('%', "#{escape_char}%").gsub('_', "#{escape_char}_")
+      exp = exp.gsub("%", "#{escape_char}%").gsub("_", "#{escape_char}_")
       assert_equal exp, subject.escape_like_pattern(pattern, escape_char)
     end
 
-    should "not implement the foreign key sql meths" do
-      assert_raises(NotImplementedError){ subject.foreign_key_add_sql }
-      assert_raises(NotImplementedError){ subject.foreign_key_drop_sql }
-    end
-
     should "not implement the create and drop db methods" do
       assert_raises(NotImplementedError){ subject.create_db }
       assert_raises(NotImplementedError){ subject.drop_db }
@@ -73,60 +81,89 @@ class Ardb::Adapter::Base
       assert_raises(NotImplementedError){ subject.dump_sql_schema }
     end
 
+    should "know if its equal to another adapter" do
+      matching_adapter = Ardb::Adapter::Base.new(@config)
+      assert_equal matching_adapter, subject
+
+      non_matching_adapter = Ardb::Adapter::Base.new(Factory.ardb_config)
+      assert_not_equal non_matching_adapter, subject
+    end
   end
 
   class ConnectDbTests < UnitTests
     desc "`connect_db`"
     setup do
-      @ar_base_conn_called = false
-      Assert.stub(ActiveRecord::Base, :connection) do |*args|
-        @ar_base_conn_called = true
+      @ar_establish_connection_called_with = nil
+      Assert.stub(ActiveRecord::Base, :establish_connection) do |options|
+        @ar_establish_connection_called_with = options
       end
 
-      @adapter.connect_db
-    end
+      @ar_connection_pool = FakeConnectionPool.new
+      Assert.stub(ActiveRecord::Base, :connection_pool){ @ar_connection_pool }
+
+      @ar_with_connection_called = false
+      Assert.stub(@ar_connection_pool, :with_connection) do
+        @ar_with_connection_called = true
+      end
 
-    should "call activerecord base's connection method" do
-      assert_true @ar_base_conn_called
+      subject.connect_db
     end
 
+    should "use activerecord to establish and then checkout a connection" do
+      assert_equal subject.connect_hash, @ar_establish_connection_called_with
+      assert_true @ar_with_connection_called
+    end
   end
 
-  class MigrateDbTests < UnitTests
-    desc "`migrate_db`"
+  class MigrateTests < UnitTests
     setup do
-      ENV["MIGRATE_VERSION"] = Factory.integer.to_s if Factory.boolean
-      ENV["MIGRATE_QUIET"]   = Factory.boolean.to_s if Factory.boolean
-
-      @migrator_called_with = []
-      Assert.stub(ActiveRecord::Migrator, :migrate) do |*args|
-        @migrator_called_with = args
+      Assert.stub(ActiveRecord::MigrationContext, :new) do |*args, &block|
+        @fake_migration_context ||= FakeMigrationContext.new(*args)
       end
-
-      @adapter.migrate_db
     end
 
-    should "add the ardb migration helper recorder to activerecord's command recorder" do
-      exp = Ardb::MigrationHelpers::RecorderMixin
-      assert_includes exp, ActiveRecord::Migration::CommandRecorder
+    should "migrate the db with `migrate_db`" do
+      subject.migrate_db
+
+      assert_equal [subject.migrations_path], @fake_migration_context.init_with
+      assert_equal [nil], @fake_migration_context.up_called_with
     end
 
-    should "set the activerecord migrator's migrations path" do
-      exp = Ardb.config.migrations_path
-      assert_equal exp, ActiveRecord::Migrator.migrations_path
+    should "migrate the db with `migrate_db_up`" do
+      subject.migrate_db_up
+      assert_equal [nil], @fake_migration_context.up_called_with
+
+      target = Factory.string
+      subject.migrate_db_up(target)
+      assert_equal [target], @fake_migration_context.up_called_with
     end
 
-    should "set the activerecord migration's verbose attr" do
-      exp = ENV["MIGRATE_QUIET"].nil?
-      assert_equal exp, ActiveRecord::Migration.verbose
+    should "migrate the db with `migrate_db_down`" do
+      subject.migrate_db_down
+      assert_equal [nil], @fake_migration_context.down_called_with
+
+      target = Factory.string
+      subject.migrate_db_down(target)
+      assert_equal [target], @fake_migration_context.down_called_with
     end
 
-    should "call the activerecord migrator's migrate method" do
-      version = ENV.key?("MIGRATE_VERSION") ? ENV["MIGRATE_VERSION"].to_i : nil
-      exp = [Ardb.config.migrations_path, version]
-      assert_equal exp, @migrator_called_with
+    should "migrate the db with `migrate_db_forward`" do
+      subject.migrate_db_forward
+      assert_equal [1], @fake_migration_context.forward_called_with
+
+      steps = Factory.integer(3)
+      subject.migrate_db_forward(steps)
+      assert_equal [steps], @fake_migration_context.forward_called_with
     end
 
+    should "migrate the db with `migrate_db_backward`" do
+      subject.migrate_db_backward
+      assert_equal [1], @fake_migration_context.rollback_called_with
+
+      steps = Factory.integer(3)
+      subject.migrate_db_backward(steps)
+      assert_equal [steps], @fake_migration_context.rollback_called_with
+    end
   end
 
   class LoadAndDumpSchemaTests < UnitTests
@@ -135,18 +172,15 @@ class Ardb::Adapter::Base
       @captured_stdout = ""
       $stdout = StringIO.new(@captured_stdout)
 
-      @orig_schema_format = Ardb.config.schema_format
-
-      @adapter = SchemaSpyAdapter.new
+      @adapter = SchemaSpyAdapter.new(@config)
     end
     teardown do
-      Ardb.config.schema_format = @orig_schema_format
       $stdout = @orig_stdout
     end
 
     should "load a ruby schema using `load_schema` when the format is ruby" do
-      Ardb.config.schema_format = :ruby
-      adapter = SchemaSpyAdapter.new
+      @config.schema_format = Ardb::Config::RUBY_SCHEMA_FORMAT
+      adapter = SchemaSpyAdapter.new(@config)
 
       assert_false adapter.load_ruby_schema_called
       assert_false adapter.load_sql_schema_called
@@ -156,8 +190,8 @@ class Ardb::Adapter::Base
     end
 
     should "load a SQL schema using `load_schema` when the format is sql" do
-      Ardb.config.schema_format = :sql
-      adapter = SchemaSpyAdapter.new
+      @config.schema_format = Ardb::Config::SQL_SCHEMA_FORMAT
+      adapter = SchemaSpyAdapter.new(@config)
 
       assert_false adapter.load_ruby_schema_called
       assert_false adapter.load_sql_schema_called
@@ -172,8 +206,8 @@ class Ardb::Adapter::Base
     end
 
     should "always dump a ruby schema using `dump_schema`" do
-      Ardb.config.schema_format = :ruby
-      adapter = SchemaSpyAdapter.new
+      @config.schema_format = Ardb::Config::RUBY_SCHEMA_FORMAT
+      adapter = SchemaSpyAdapter.new(@config)
 
       assert_false adapter.dump_ruby_schema_called
       assert_false adapter.dump_sql_schema_called
@@ -181,8 +215,8 @@ class Ardb::Adapter::Base
       assert_true adapter.dump_ruby_schema_called
       assert_false adapter.dump_sql_schema_called
 
-      Ardb.config.schema_format = :sql
-      adapter = SchemaSpyAdapter.new
+      @config.schema_format = Ardb::Config::SQL_SCHEMA_FORMAT
+      adapter = SchemaSpyAdapter.new(@config)
 
       assert_false adapter.dump_ruby_schema_called
       adapter.dump_schema
@@ -190,8 +224,8 @@ class Ardb::Adapter::Base
     end
 
     should "dump a SQL schema using `dump_schema` when the format is sql" do
-      Ardb.config.schema_format = :sql
-      adapter = SchemaSpyAdapter.new
+      @config.schema_format = Ardb::Config::SQL_SCHEMA_FORMAT
+      adapter = SchemaSpyAdapter.new(@config)
 
       assert_false adapter.dump_ruby_schema_called
       adapter.dump_schema
@@ -202,18 +236,12 @@ class Ardb::Adapter::Base
       subject.load_schema
       assert_empty @captured_stdout
     end
-
   end
 
   class LoadRubySchemaTests < UnitTests
     setup do
-      @orig_schema_path = Ardb.config.schema_path
-      Ardb.config.schema_path = 'fake_schema'
-
-      @adapter = Ardb::Adapter::Base.new
-    end
-    teardown do
-      Ardb.config.schema_path = @orig_schema_path
+      @config.schema_path = File.join(TEST_SUPPORT_PATH, "fake_schema")
+      @adapter = Ardb::Adapter::Base.new(@config)
     end
 
     should "load a ruby schema file using `load_ruby_schema`" do
@@ -224,9 +252,40 @@ class Ardb::Adapter::Base
       subject.load_ruby_schema
       assert_equal 2, FAKE_SCHEMA.load_count
     end
+  end
+
+  class DumpRubySchemaTests < UnitTests
+    setup do
+      @config.schema_path = File.join(TMP_PATH, "testdb", "test_dump_ruby_schema")
+      FileUtils.rm_rf(File.dirname(@config.schema_path))
+
+      @schema_dumper_connection, @schema_dumper_file = [nil, nil]
+      Assert.stub(ActiveRecord::SchemaDumper, :dump) do |connection, file|
+        @schema_dumper_connection = connection
+        @schema_dumper_file       = file
+      end
+
+      @fake_connection = FakeConnection.new
+      Assert.stub(ActiveRecord::Base, :connection){ @fake_connection }
+
+      @adapter = Ardb::Adapter::Base.new(@config)
+    end
+    teardown do
+      FileUtils.rm_rf(File.dirname(@config.schema_path))
+    end
 
+    should "dump a ruby schema file using `dump_ruby_schema`" do
+      assert_false File.exists?(subject.ruby_schema_path)
+      subject.dump_ruby_schema
+      assert_true File.exists?(subject.ruby_schema_path)
+      assert_equal @fake_connection, @schema_dumper_connection
+      assert_instance_of File, @schema_dumper_file
+      assert_equal subject.ruby_schema_path, @schema_dumper_file.path
+    end
   end
 
+  class FakeConnection; end
+
   class SchemaSpyAdapter < Ardb::Adapter::Base
     attr_reader :load_ruby_schema_called, :dump_ruby_schema_called
     attr_reader :load_sql_schema_called, :dump_sql_schema_called
@@ -260,4 +319,33 @@ class Ardb::Adapter::Base
     end
   end
 
+  class FakeConnectionPool
+    def with_connection(&block); end
+  end
+
+  class FakeMigrationContext
+    attr_reader :init_with
+    attr_reader :up_called_with, :down_called_with
+    attr_reader :forward_called_with, :rollback_called_with
+
+    def initialize(*args)
+      @init_with = args
+    end
+
+    def up(*args)
+      @up_called_with = args
+    end
+
+    def down(*args)
+      @down_called_with = args
+    end
+
+    def forward(*args)
+      @forward_called_with = args
+    end
+
+    def rollback(*args)
+      @rollback_called_with = args
+    end
+  end
 end