ardb 0.27.3 → 0.28.0

data/test/unit/adapter/postgresql_tests.rb

@@ -8,18 +8,19 @@ class Ardb::Adapter::Postgresql
   class UnitTests < Assert::Context
     desc "Ardb::Adapter::Postgresql"
     setup do
-      @adapter = Ardb::Adapter::Postgresql.new
+      @config  = Factory.ardb_config
+      @adapter = Ardb::Adapter::Postgresql.new(@config)
     end
     subject{ @adapter }
 
-    should have_imeths :public_schema_settings
+    should have_imeths :public_connect_hash
 
-    should "know its public schema connection settings" do
-      exp_settings = subject.config_settings.merge({
+    should "know its public connect hash" do
+      exp = subject.connect_hash.merge({
         'database' => 'postgres',
         'schema_search_path' => 'public'
       })
-      assert_equal exp_settings, subject.public_schema_settings
+      assert_equal exp, subject.public_connect_hash
     end
 
     should "know its foreign key add sql" do
@@ -41,10 +42,10 @@ class Ardb::Adapter::Postgresql
   class SQLSchemaTests < UnitTests
     setup do
       @env = {
-        'PGHOST'     => @adapter.config_settings['host'],
-        'PGPORT'     => @adapter.config_settings['port'],
-        'PGUSER'     => @adapter.config_settings['username'],
-        'PGPASSWORD' => @adapter.config_settings['password']
+        'PGHOST'     => @adapter.connect_hash['host'],
+        'PGPORT'     => @adapter.connect_hash['port'],
+        'PGUSER'     => @adapter.connect_hash['username'],
+        'PGPASSWORD' => @adapter.connect_hash['password']
       }
     end
 

data/test/unit/adapter/sqlite_tests.rb

@@ -6,7 +6,8 @@ class Ardb::Adapter::Sqlite
   class UnitTests < Assert::Context
     desc "Ardb::Adapter::Sqlite"
     setup do
-      @adapter = Ardb::Adapter::Sqlite.new
+      @config  = Factory.ardb_config
+      @adapter = Ardb::Adapter::Sqlite.new(@config)
     end
     subject{ @adapter }
 
@@ -20,8 +21,12 @@ class Ardb::Adapter::Sqlite
     end
 
     should "know its db file path" do
-      exp_path = Ardb.config.root_path.join(Ardb.config.db.database).to_s
-      assert_equal exp_path, subject.db_file_path
+      exp = File.expand_path(@config.database, @config.root_path)
+      assert_equal exp, subject.db_file_path
+
+      @config.database = File.join(TMP_PATH, 'abs_sqlite_db_test')
+      adapter = Ardb::Adapter::Sqlite.new(@config)
+      assert_equal @config.database, adapter.db_file_path
     end
 
     should "not implement the foreign key sql meths" do

data/test/unit/adapter_spy_tests.rb

@@ -1,106 +1,97 @@
 require 'assert'
 require 'ardb/adapter_spy'
 
-require 'much-plugin'
-
-module Ardb::AdapterSpy
+class Ardb::AdapterSpy
 
   class UnitTests < Assert::Context
     desc "Ardb::AdapterSpy"
     setup do
-      @adapter = MyAdapter.new
+      @adapter_spy_class = Ardb::AdapterSpy
+    end
+    subject{ @adapter_spy_class }
+
+    should "be a kind of ardb adapter" do
+      assert subject < Ardb::Adapter::Base
     end
-    subject{ @adapter }
+
+  end
+
+  class InitTests < UnitTests
+    desc "when init"
+    setup do
+      @config      = Factory.ardb_config
+      @adapter_spy = @adapter_spy_class.new(@config)
+    end
+    subject{ @adapter_spy }
 
     should have_accessors :drop_tables_called_count
     should have_accessors :dump_schema_called_count, :load_schema_called_count
     should have_accessors :drop_db_called_count, :create_db_called_count
     should have_accessors :connect_db_called_count, :migrate_db_called_count
-    should have_imeths :drop_tables_called?, :drop_tables
-    should have_imeths :dump_schema_called?, :dump_schema
-    should have_imeths :load_schema_called?, :load_schema
-    should have_imeths :drop_db_called?, :drop_db
-    should have_imeths :create_db_called?, :create_db
-    should have_imeths :connect_db_called?, :connect_db
-    should have_imeths :migrate_db_called?, :migrate_db
-
-    should "use much-plugin" do
-      assert_includes MuchPlugin, Ardb::AdapterSpy
-    end
-
-    should "included the adapter spy instance methods" do
-      assert_includes Ardb::AdapterSpy::InstanceMethods, subject.class
-    end
+    should have_imeths :foreign_key_add_sql, :foreign_key_drop_sql
+    should have_imeths :create_db_called?, :drop_db_called?, :drop_tables_called?
+    should have_imeths :connect_db_called?, :migrate_db_called?
+    should have_imeths :dump_schema_called?, :load_schema_called?
+    should have_imeths :create_db, :drop_db, :drop_tables
+    should have_imeths :connect_db, :migrate_db
+    should have_imeths :dump_schema, :load_schema
 
     should "default all call counts to zero" do
-      assert_equal 0, subject.drop_tables_called_count
-      assert_equal 0, subject.dump_schema_called_count
-      assert_equal 0, subject.load_schema_called_count
-      assert_equal 0, subject.drop_db_called_count
       assert_equal 0, subject.create_db_called_count
+      assert_equal 0, subject.drop_db_called_count
+      assert_equal 0, subject.drop_tables_called_count
       assert_equal 0, subject.connect_db_called_count
       assert_equal 0, subject.migrate_db_called_count
+      assert_equal 0, subject.load_schema_called_count
+      assert_equal 0, subject.dump_schema_called_count
     end
 
-    should "know if and how many times a method is called" do
-      assert_equal false, subject.drop_tables_called?
-      subject.drop_tables
-      assert_equal 1, subject.drop_tables_called_count
-      assert_equal true, subject.drop_tables_called?
-
-      assert_equal false, subject.dump_schema_called?
-      subject.dump_schema
-      assert_equal 1, subject.dump_schema_called_count
-      assert_equal true, subject.dump_schema_called?
+    should "know its add and drop foreign key sql" do
+      exp = "FAKE ADD FOREIGN KEY SQL :from_table :from_column " \
+            ":to_table :to_column :name"
+      assert_equal exp, subject.foreign_key_add_sql
+      exp = "FAKE DROP FOREIGN KEY SQL :from_table :from_column " \
+            ":to_table :to_column :name"
+      assert_equal exp, subject.foreign_key_drop_sql
+    end
 
-      assert_equal false, subject.load_schema_called?
-      subject.load_schema
-      assert_equal 1, subject.load_schema_called_count
-      assert_equal true, subject.load_schema_called?
+    should "know if and how many times a method is called" do
+      assert_equal false, subject.create_db_called?
+      subject.create_db
+      assert_equal 1, subject.create_db_called_count
+      assert_equal true, subject.create_db_called?
 
       assert_equal false, subject.drop_db_called?
       subject.drop_db
       assert_equal 1, subject.drop_db_called_count
       assert_equal true, subject.drop_db_called?
 
-      assert_equal false, subject.create_db_called?
-      subject.create_db
-      assert_equal 1, subject.create_db_called_count
-      assert_equal true, subject.create_db_called?
-
-      assert_equal false, subject.migrate_db_called?
-      subject.migrate_db
-      assert_equal 1, subject.migrate_db_called_count
-      assert_equal true, subject.migrate_db_called?
+      assert_equal false, subject.drop_tables_called?
+      subject.drop_tables
+      assert_equal 1, subject.drop_tables_called_count
+      assert_equal true, subject.drop_tables_called?
 
       assert_equal false, subject.connect_db_called?
       subject.connect_db
       assert_equal 1, subject.connect_db_called_count
       assert_equal true, subject.connect_db_called?
-    end
 
-  end
+      assert_equal false, subject.migrate_db_called?
+      subject.migrate_db
+      assert_equal 1, subject.migrate_db_called_count
+      assert_equal true, subject.migrate_db_called?
 
-  class NewMethTests < UnitTests
-    desc "`new` method"
-    setup do
-      @adapter_spy_class = Ardb::AdapterSpy.new do
-        attr_accessor :name
-      end
-      @adapter = @adapter_spy_class.new
-    end
-    subject{ @adapter }
+      assert_equal false, subject.dump_schema_called?
+      subject.dump_schema
+      assert_equal 1, subject.dump_schema_called_count
+      assert_equal true, subject.dump_schema_called?
 
-    should "build a new spy class and use any custom definition" do
-      assert_includes Ardb::AdapterSpy, subject.class
-      assert subject.respond_to? :name
-      assert subject.respond_to? :name=
+      assert_equal false, subject.load_schema_called?
+      subject.load_schema
+      assert_equal 1, subject.load_schema_called_count
+      assert_equal true, subject.load_schema_called?
     end
 
   end
 
-  class MyAdapter
-    include Ardb::AdapterSpy
-  end
-
 end

data/test/unit/ardb_tests.rb

@@ -1,67 +1,133 @@
 require 'assert'
 require 'ardb'
 
+require 'logger'
+require 'ardb/adapter_spy'
+require 'ardb/adapter/mysql'
+require 'ardb/adapter/postgresql'
+require 'ardb/adapter/sqlite'
+
 module Ardb
 
   class UnitTests < Assert::Context
     desc "Ardb"
     setup do
-      @orig_ar_logger = ActiveRecord::Base.logger
-      Adapter.reset
-
       @module = Ardb
     end
-    teardown do
-      Adapter.reset
-      ActiveRecord::Base.logger = @orig_ar_logger
-    end
     subject{ @module }
 
-    should have_imeths :config, :configure, :adapter, :validate!, :init
+    should have_imeths :config, :configure, :adapter, :init
     should have_imeths :escape_like_pattern
 
-    should "return its `Config` class with the `config` method" do
-      assert_same Config, subject.config
+    should "default the db file env var" do
+      assert_equal 'config/db', ENV['ARDB_DB_FILE']
+    end
+
+    should "know its config" do
+      assert_instance_of Config, subject.config
+      result = subject.config
+      assert_same result, subject.config
     end
 
-    should "complain if init'ing and not all configs are set" do
-      orig_adapter = Ardb.config.db.adapter
-      Ardb.config.db.adapter = nil
-      assert_raises(NotConfiguredError){ subject.init }
-      Ardb.config.db.adapter = orig_adapter
+    should "yield its config using `configure`" do
+      yielded = nil
+      subject.configure{ |c| yielded = c }
+      assert_same subject.config, yielded
     end
 
-    should "init the adapter on init" do
-      assert_nil Adapter.current
-      begin
-        subject.init
-      rescue LoadError
+  end
+
+  class InitMethodSetupTests < UnitTests
+    setup do
+      @orig_env_pwd          = ENV['PWD']
+      @orig_env_ardb_db_file = ENV['ARDB_DB_FILE']
+      @orig_ar_logger        = ActiveRecord::Base.logger
+
+      # stub in a temporary config, this allows us to modify it and not worry
+      # about affecting Ardb's global config which could cause issues on other
+      # tests
+      @ardb_config = Config.new
+      Assert.stub(Ardb, :config){ @ardb_config }
+
+      @ardb_adapter = nil
+      Assert.stub(Ardb::Adapter, :new) do |*args|
+        @ardb_adapter ||= Ardb::AdapterSpy.new(*args)
       end
 
-      assert_not_nil Adapter.current
-      exp_adapter = Adapter.send(subject.config.db.adapter)
-      assert_equal exp_adapter, Adapter.current
-      assert_same Adapter.current, subject.adapter
+      ENV['ARDB_DB_FILE']   = 'test/support/require_test_db_file'
+      @ardb_config.adapter  = Adapter::VALID_ADAPTERS.sample
+      @ardb_config.database = Factory.string
+    end
+    teardown do
+      ActiveRecord::Base.logger = @orig_ar_logger
+      ENV['ARDB_DB_FILE']       = @orig_env_ardb_db_file
+      ENV['PWD']                = @orig_env_pwd
+    end
+
+  end
+
+  class InitMethodTests < InitMethodSetupTests
+    desc "`init` method"
+
+    should "require the autoloaded active record files" do
+      subject.init
+      assert_false require('ardb/require_autoloaded_active_record_files')
     end
 
-    should "establish an AR connection on init" do
-      assert_raises(LoadError) do
-        # not going to test this b/c I don't want to bring in all the crap it
-        # takes to actually establish a connection with AR (adapters, etc)
-        # plus, most of this should be handled by AR, ns-options, and the above
-        # tests anyway
-        subject.init
-      end
+    should "require the db file" do
+      subject.init
+      assert_false require(ENV['ARDB_DB_FILE'])
+    end
+
+    should "require the db file relative to the working directory if needed" do
+      ENV['PWD']          = 'test/support'
+      ENV['ARDB_DB_FILE'] = 'relative_require_test_db_file'
+      subject.init
+      assert_false require(File.expand_path(ENV['ARDB_DB_FILE'], ENV['PWD']))
+    end
+
+    should "raise an invalid db file error when it can't require it" do
+      ENV['ARDB_DB_FILE'] = Factory.file_path
+      error = assert_raises(InvalidDBFileError){ subject.init }
+      exp = "can't require `#{ENV['ARDB_DB_FILE']}`, check that the " \
+            "ARDB_DB_FILE env var is set to the file path of your db file"
+      assert_equal exp, error.message
+    end
+
+    should "validate its config" do
+      validate_called = false
+      Assert.stub(@ardb_config, :validate!){ validate_called = true }
+
+      subject.init
+      assert_true validate_called
+    end
+
+    should "build an adapter using its config" do
+      subject.init
+
+      assert_not_nil @ardb_adapter
+      assert_equal subject.config, @ardb_adapter.config
+      assert_same @ardb_adapter, subject.adapter
+    end
+
+    should "optionally establish an AR connection" do
+      assert_nil @ardb_adapter
+      subject.init
+      assert_equal 1, @ardb_adapter.connect_db_called_count
+
+      subject.init(true)
+      assert_equal 2, @ardb_adapter.connect_db_called_count
+
+      subject.init(false)
+      assert_equal 2, @ardb_adapter.connect_db_called_count
     end
 
   end
 
-  class InitTests < UnitTests
+  class InitTests < InitMethodSetupTests
     desc "when init"
     setup do
-      # don't establish connection, otherwise this errors if it can't connect to
-      # an actual DB
-      @module.init(false)
+      @module.init
     end
 
     should "demeter its adapter" do
@@ -72,4 +138,225 @@ module Ardb
 
   end
 
+  class ConfigTests < UnitTests
+    desc "Config"
+    setup do
+      @config_class = Ardb::Config
+    end
+    subject{ @config_class }
+
+    should "know its activerecord attrs" do
+      exp = [
+        :adapter,
+        :database,
+        :encoding,
+        :host,
+        :port,
+        :username,
+        :password,
+        :pool,
+        :checkout_timeout,
+        :min_messages
+      ]
+      assert_equal exp, subject::ACTIVERECORD_ATTRS
+    end
+
+    should "know its default migrations path" do
+      assert_equal 'db/migrations', subject::DEFAULT_MIGRATIONS_PATH
+    end
+
+    should "know its default schema path" do
+      assert_equal 'db/schema', subject::DEFAULT_SCHEMA_PATH
+    end
+
+    should "know its schema formats" do
+      assert_equal :ruby, subject::RUBY_SCHEMA_FORMAT
+      assert_equal :sql,  subject::SQL_SCHEMA_FORMAT
+      exp = [subject::RUBY_SCHEMA_FORMAT, subject::SQL_SCHEMA_FORMAT]
+      assert_equal exp, subject::VALID_SCHEMA_FORMATS
+    end
+
+  end
+
+  class ConfigInitTests < ConfigTests
+    desc "when init"
+    setup do
+      @config = @config_class.new
+    end
+    subject{ @config }
+
+    should have_accessors *Ardb::Config::ACTIVERECORD_ATTRS
+    should have_accessors :logger, :root_path
+    should have_readers :schema_format
+    should have_writers :migrations_path, :schema_path
+    should have_imeths :activerecord_connect_hash, :validate!
+
+    should "default its attributs" do
+      assert_instance_of Logger, subject.logger
+      assert_equal ENV['PWD'], subject.root_path
+      exp = File.expand_path(@config_class::DEFAULT_MIGRATIONS_PATH, subject.root_path)
+      assert_equal exp, subject.migrations_path
+      exp = File.expand_path(@config_class::DEFAULT_SCHEMA_PATH, subject.root_path)
+      assert_equal exp, subject.schema_path
+      assert_equal @config_class::RUBY_SCHEMA_FORMAT, subject.schema_format
+    end
+
+    should "allow reading/writing its paths" do
+      new_root_path       = Factory.path
+      new_migrations_path = Factory.path
+      new_schema_path     = Factory.path
+
+      subject.root_path       = new_root_path
+      subject.migrations_path = new_migrations_path
+      subject.schema_path     = new_schema_path
+      assert_equal new_root_path, subject.root_path
+      exp = File.expand_path(new_migrations_path, new_root_path)
+      assert_equal exp, subject.migrations_path
+      exp = File.expand_path(new_schema_path, new_root_path)
+      assert_equal exp, subject.schema_path
+    end
+
+    should "allow setting absolute paths" do
+      new_migrations_path = "/#{Factory.path}"
+      new_schema_path     = "/#{Factory.path}"
+
+      subject.root_path       = [Factory.path, nil].sample
+      subject.migrations_path = new_migrations_path
+      subject.schema_path     = new_schema_path
+      assert_equal new_migrations_path, subject.migrations_path
+      assert_equal new_schema_path,     subject.schema_path
+    end
+
+    should "allow reading/writing the schema format" do
+      new_schema_format = Factory.string
+
+      subject.schema_format = new_schema_format
+      assert_equal new_schema_format.to_sym, subject.schema_format
+    end
+
+    should "know its activerecord connection hash" do
+      attrs_and_values = @config_class::ACTIVERECORD_ATTRS.map do |attr_name|
+        value = [Factory.string,  nil].sample
+        subject.send("#{attr_name}=", value)
+        [attr_name.to_s, value] if !value.nil?
+      end.compact
+      assert_equal Hash[attrs_and_values], subject.activerecord_connect_hash
+    end
+
+    should "raise errors with invalid attribute values using `validate!`" do
+      subject.adapter  = Factory.string
+      subject.database = Factory.string
+      assert_nothing_raised{ subject.validate! }
+
+      subject.adapter = nil
+      assert_raises(ConfigurationError){ subject.validate! }
+
+      subject.adapter  = Factory.string
+      subject.database = nil
+      assert_raises(ConfigurationError){ subject.validate! }
+
+      subject.database      = Factory.string
+      subject.schema_format = Factory.string
+      assert_raises(ConfigurationError){ subject.validate! }
+
+      subject.schema_format = @config_class::VALID_SCHEMA_FORMATS.sample
+      assert_nothing_raised{ subject.validate! }
+    end
+
+    should "know if its equal to another config" do
+      attrs = @config_class::ACTIVERECORD_ATTRS + [
+        :logger,
+        :root_path,
+        :schema_format,
+        :migrations_path,
+        :schema_path
+      ]
+      attrs.each do |attr_name|
+        subject.send("#{attr_name}=", Factory.string)
+      end
+
+      other_config = @config_class.new
+      attrs.each do |attr_name|
+        other_config.send("#{attr_name}=", subject.send(attr_name))
+      end
+      assert_equal other_config, subject
+
+      attr_name = attrs.sample
+      other_config.send("#{attr_name}=", Factory.string)
+      assert_not_equal other_config, subject
+    end
+
+  end
+
+  class AdapterTests < UnitTests
+    desc "Adapter"
+    setup do
+      @config = Factory.ardb_config
+
+      @adapter_module = Ardb::Adapter
+    end
+    subject{ @adapter_module }
+
+    should have_imeths :new
+    should have_imeths :sqlite, :sqlite3
+    should have_imeths :postgresql, :postgres
+    should have_imeths :mysql, :mysql2
+
+    should "know its valid adapters" do
+      exp = [
+        'sqlite',
+        'sqlite3',
+        'postgresql',
+        'postgres',
+        'mysql',
+        'mysql2'
+      ]
+      assert_equal exp, subject::VALID_ADAPTERS
+    end
+
+    should "build an adapter specific class using the passed config" do
+      adapter_key, exp_adapter_class = [
+        ['sqlite',     Ardb::Adapter::Sqlite],
+        ['postgresql', Ardb::Adapter::Postgresql],
+        ['mysql',      Ardb::Adapter::Mysql]
+      ].sample
+      @config.adapter = adapter_key
+
+      adapter = subject.new(@config)
+      assert_instance_of exp_adapter_class, adapter
+      assert_equal @config, adapter.config
+    end
+
+    should "know how to build a sqlite adapter" do
+      adapter = subject.sqlite(@config)
+      assert_instance_of Ardb::Adapter::Sqlite, adapter
+      assert_equal @config, adapter.config
+
+      adapter = subject.sqlite3(@config)
+      assert_instance_of Ardb::Adapter::Sqlite, adapter
+      assert_equal @config, adapter.config
+    end
+
+    should "know how to build a postgresql adapter" do
+      adapter = subject.postgresql(@config)
+      assert_instance_of Ardb::Adapter::Postgresql, adapter
+      assert_equal @config, adapter.config
+
+      adapter = subject.postgres(@config)
+      assert_instance_of Ardb::Adapter::Postgresql, adapter
+      assert_equal @config, adapter.config
+    end
+
+    should "know how to build a mysql adapter" do
+      adapter = subject.mysql(@config)
+      assert_instance_of Ardb::Adapter::Mysql, adapter
+      assert_equal @config, adapter.config
+
+      adapter = subject.mysql2(@config)
+      assert_instance_of Ardb::Adapter::Mysql, adapter
+      assert_equal @config, adapter.config
+    end
+
+  end
+
 end