ardb 0.27.3 → 0.29.0

data/test/unit/adapter/mysql_tests.rb

@@ -1,29 +1,15 @@
-require 'assert'
-require 'ardb/adapter/mysql'
+require "assert"
+require "ardb/adapter/mysql"
 
 class Ardb::Adapter::Mysql
-
   class UnitTests < Assert::Context
     desc "Ardb::Adapter::Mysql"
     setup do
-      @adapter = Ardb::Adapter::Mysql.new
+      @config  = Factory.ardb_config
+      @adapter = Ardb::Adapter::Mysql.new(@config)
     end
     subject{ @adapter }
 
-    should "know its foreign key add sql" do
-      exp_add_sql = "ALTER TABLE :from_table"\
-                    " ADD CONSTRAINT :name"\
-                    " FOREIGN KEY (:from_column)"\
-                    " REFERENCES :to_table (:to_column)"
-      assert_equal exp_add_sql, subject.foreign_key_add_sql
-    end
-
-    should "know its foreign key drop sql" do
-      exp_drop_sql = "ALTER TABLE :from_table"\
-                     " DROP FOREIGN KEY :name"
-      assert_equal exp_drop_sql, subject.foreign_key_drop_sql
-    end
-
     # not currently implemented, see: https://github.com/redding/ardb/issues/13
     should "not implement the create and drop db methods" do
       assert_raises(NotImplementedError){ subject.create_db }
@@ -34,7 +20,5 @@ class Ardb::Adapter::Mysql
     should "not implement the drop tables method" do
       assert_raises(NotImplementedError){ subject.drop_tables }
     end
-
   end
-
 end

data/test/unit/adapter/postgresql_tests.rb

@@ -1,50 +1,42 @@
-require 'assert'
-require 'ardb/adapter/postgresql'
+require "assert"
+require "ardb/adapter/postgresql"
 
-require 'scmd'
+require "scmd"
 
 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({
-        'database' => 'postgres',
-        'schema_search_path' => 'public'
+    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
-    end
-
-    should "know its foreign key add sql" do
-      exp_add_sql = "ALTER TABLE :from_table"\
-                    " ADD CONSTRAINT :name"\
-                    " FOREIGN KEY (:from_column)"\
-                    " REFERENCES :to_table (:to_column)"
-      assert_equal exp_add_sql, subject.foreign_key_add_sql
+      assert_equal exp, subject.public_connect_hash
     end
 
-    should "know its foreign key drop sql" do
-      exp_drop_sql = "ALTER TABLE :from_table"\
-                     " DROP CONSTRAINT :name"
-      assert_equal exp_drop_sql, subject.foreign_key_drop_sql
+    should "complain if given a database name with non-word characters" do
+      @config.database = "#{Factory.string}-#{Factory.string}"
+      assert_raises(Ardb::ConfigurationError){
+        Ardb::Adapter::Postgresql.new(@config)
+      }
     end
-
   end
 
   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

@@ -1,12 +1,12 @@
-require 'assert'
-require 'ardb/adapter/sqlite'
+require "assert"
+require "ardb/adapter/sqlite"
 
 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,20 +20,17 @@ 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
-    end
+      exp = File.expand_path(@config.database, @config.root_path)
+      assert_equal exp, subject.db_file_path
 
-    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 }
+      @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
 
     # not currently implemented, see: https://github.com/redding/ardb/issues/29
     should "not implement the drop tables method" do
       assert_raises(NotImplementedError){ subject.drop_tables }
     end
-
   end
-
 end

data/test/unit/adapter_spy_tests.rb

@@ -1,106 +1,83 @@
-require 'assert'
-require 'ardb/adapter_spy'
-
-require 'much-plugin'
-
-module Ardb::AdapterSpy
+require "assert"
+require "ardb/adapter_spy"
 
+class Ardb::AdapterSpy
   class UnitTests < Assert::Context
     desc "Ardb::AdapterSpy"
     setup do
-      @adapter = MyAdapter.new
+      @adapter_spy_class = Ardb::AdapterSpy
     end
-    subject{ @adapter }
+    subject{ @adapter_spy_class }
+
+    should "be a kind of ardb adapter" do
+      assert subject < Ardb::Adapter::Base
+    end
+  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 :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?
-
-      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?
+      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,149 @@
-require 'assert'
-require 'ardb'
+require "assert"
+require "ardb"
 
-module 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
+      @module.reset_adapter
     end
     subject{ @module }
 
-    should have_imeths :config, :configure, :adapter, :validate!, :init
-    should have_imeths :escape_like_pattern
+    should have_imeths :config, :configure, :adapter, :reset_adapter
+    should have_imeths :init, :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 "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 "know its config" do
+      assert_instance_of Config, subject.config
+      result = subject.config
+      assert_same result, subject.config
     end
 
-    should "init the adapter on init" do
-      assert_nil Adapter.current
-      begin
-        subject.init
-      rescue LoadError
+    should "yield its config using `configure`" do
+      yielded = nil
+      subject.configure{ |c| yielded = c }
+      assert_same subject.config, yielded
+    end
+  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
 
-    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
+  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 "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 "set ActiveRecord::Base attributes" do
+      subject.init
+
+      assert_equal subject.config.logger, ActiveRecord::Base.logger
+      assert_equal subject.config.default_timezone, ActiveRecord::Base.default_timezone
+    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
+
+    should "raise a not initialized error using its adapter before init" do
+      subject.reset_adapter
+      assert_raises(NotInitializedError){ subject.adapter }
+      assert_raises(NotInitializedError){ subject.escape_like_pattern(Factory.string) }
+
+      subject.init
+      assert_nothing_raised{ subject.adapter }
+      assert_nothing_raised{ subject.escape_like_pattern(Factory.string) }
+    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
@@ -69,7 +151,225 @@ module Ardb
       exp = subject.adapter.escape_like_pattern(pattern)
       assert_equal exp, subject.escape_like_pattern(pattern)
     end
+  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 :default_timezone, :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_equal :utc, subject.default_timezone
+      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 + [
+        :default_timezone,
+        :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