activerecord-nulldb-adapter 0.0.3

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License
+
+Copyright (c) 2008 Avdi Grimm
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README

@@ -0,0 +1,143 @@
+= The NullDB Connection Adapter Plugin
+
+== What
+
+NullDB is the Null Object pattern as applied to ActiveRecord database
+adapters.  It is a database backend that translates database
+interactions into no-ops.  Using NullDB enables you to test your model
+business logic - including +after_save+ hooks - without ever touching
+a real database.
+
+== How 
+
+Once installed, NullDB can be used much like any other ActiveRecord
+database adapter:
+
+  ActiveRecord::Base.establish_connection :adapter => :nulldb
+
+NullDB needs to know where you keep your schema file in order to
+reflect table metadata.  By default it looks in
+RAILS_ROOT/db/schema.rb.  You can override that by setting the
++schema+ option:
+
+  ActiveRecord::Base.establish_connection :adapter => :nulldb,
+                                          :schema  => foo/myschema.rb
+
+NullDB comes with RSpec integration.  To replace the database with
+NullDB in all of your specs, put the following in your
+spec/spec_helper:
+
+  require 'nulldb_rspec'
+  include NullDB::RSpec::NullifiedDatabase
+
+Or if you just want to use NullDB in a specific spec context, you can
+include the same module inside a context:
+
+  require 'nulldb_rspec'
+
+  describe Employee, "with access to the database" do
+    fixtures :employees
+    # ...
+  end
+
+  describe Employee, "with NullDB" do
+    include NullDB::RSpec::NullifiedDatabase
+    # ...
+  end
+
+NullDB::Rspec provides some custom matcher support for verifying
+expectations about interactions with the database:
+
+  describe Employee do
+    include NullDB::RSpec::NullifiedDatabase
+
+    it "should cause an insert statement to be executed" do
+      Employee.create!
+      Employee.connection.should have_executed(:insert)
+    end
+  end
+
+UnitRecord-style verification that no database calls have been made at
+all can be achieved by using the special +:anything+ symbol:
+
+  describe "stuff that shouldn't touch the database" do
+    after :each do
+      Employee.connection.should_not have_executed(:anything)
+    end
+    # ...
+  end
+
+You can also experiment with putting NullDB in your database.yml:
+
+  unit_test:
+    adapter: nulldb
+
+However, due to the way Rails hard-codes specific database adapters
+into its standard Rake tasks, you may find that this generates
+unexpected and difficult-to-debug behavior.  Workarounds for this are
+under development.
+
+== Why 
+
+There are a number of advantages to writing unit tests that never
+touch the database.  The biggest is probably speed of execution - unit
+tests must be fast for test-driven development to be practical.
+Another is separation of concerns: unit tests should be exercising
+only the business logic contained in your models, not ActiveRecord.
+For more on why testing-sans-database is a god idea, see:
+http://www.dcmanges.com/blog/rails-unit-record-test-without-the-database.
+
+NullDB is one way to separate your unit tests from the database.  It
+was inspired by the ARBS[http://arbs.rubyforge.org/] and
+UnitRecord[http://unit-test-ar.rubyforge.org/] libraries.  It differs
+from them in a couple of ways:
+
+1. It works.  At the time of writing both ARBS and UnitRecord were
+   not working for me out of the box with Rails 2.0. 
+
+2. It avoids monkey-patching as much as possible.  Rather than
+   re-wiring the secret inner workings of ActiveRecord (and thus being
+   tightly coupled to those inner workings), NullDB implements the
+   same [semi-]well-documented public interface that the other standard
+   database adapters, like MySQL and SQLServer, implement.
+
+3. UnitRecord takes the approach of eliminating database interaction
+   in tests by turning almost every database interaction into an
+   exception.  NullDB recognizes that ActiveRecord objects typically
+   can't take two steps without consulting the database, so instead it
+   turns database interactions into no-ops.
+
+One concrete advantage of this null-object pattern design is that it
+is possible with NullDB to test +after_save+ hooks.  With NullDB, you
+can call +#save+ and all of the usual callbacks will be called - but
+nothing will be saved.
+
+== Limitations
+
+* It is *not* an in-memory database.  Finds will not work.  Neither
+  will +reload+, currently.  Test fixtures won't work either, for
+  obvious reasons.
+* It has only the most rudimentery schema/migration support.  Complex
+  migrations will probably break it.
+* Lots of other things probably don't work.  Patches welcome!
+
+== Who 
+
+NullDB was written by Avdi Grimm <mailto:avdi@avdi.org>
+
+== Where
+
+* Homepage: http://nulldb.rubyforge.org
+* Project Info: http://rubyforge.org/projects/nulldb/
+* SCM: http://rubyforge.org/scm/?group_id=7512
+
+== Changes
+
+ * Version 0.0.1 (2007-02-18)
+   - Initial Release
+ * Version 0.0.2 (2007-05-31)
+   - Moved to Rubyforge
+
+== License
+
+See the LICENSE file for licensing information.

data/Rakefile

@@ -0,0 +1,53 @@
+require 'rake'
+require 'rake/rdoctask'
+require 'spec/rake/spectask'
+
+# active_record connection_adapters abstract connection_specification
+GEM_NAME = 'activerecord-nulldb-adapter'
+
+desc "Run all examples"
+Spec::Rake::SpecTask.new('spec') do |t|
+  t.spec_files = FileList['spec/**/*_spec.rb']
+end
+
+Rake::RDocTask.new do |rd|
+  rd.main = "README"
+  rd.rdoc_files.include("README", "LICENSE", "lib/**/*.rb")
+end
+
+desc "Publish project home page"
+task :publish => ["rdoc"] do
+  sh "scp -r html/* avdi@rubyforge.org:/var/www/gforge-projects/nulldb"
+end
+
+desc "Tag release"
+task :tag do
+  warn "This needs to be updated for git"
+  exit 1
+  repos   = "http://svn.avdi.org/nulldb"
+  version = ENV["VERSION"]
+  raise "No version specified" unless version
+  sh "svn cp #{repos}/trunk #{repos}/tags/nulldb-#{version}"
+end
+
+desc "Build gem"
+task :gem do
+  system 'rake gemspec'
+  system "gem build #{GEM_NAME}.gemspec"
+end
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = GEM_NAME
+    gem.summary = %Q{NullDB lets you to test your models without ever touching a real database.}
+    gem.email = "avdi@avdi.org"
+    gem.homepage = 'http://nulldb.rubyforge.org'
+    gem.description = "An ActiveRecord null database adapter for greater speed and isolation in unit tests"
+    gem.rubyforge_project = 'nulldb' 
+    gem.authors = ['Avdi Grimm']
+  end
+
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: sudo gem install jeweler"
+end

data/VERSION

@@ -0,0 +1 @@
+0.0.3

data/activerecord-nulldb-adapter.gemspec

@@ -0,0 +1,51 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{activerecord-nulldb-adapter}
+  s.version = "0.0.3"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Avdi Grimm"]
+  s.date = %q{2009-12-30}
+  s.description = %q{An ActiveRecord null database adapter for greater speed and isolation in unit tests}
+  s.email = %q{avdi@avdi.org}
+  s.extra_rdoc_files = [
+    "LICENSE",
+     "README"
+  ]
+  s.files = [
+    "LICENSE",
+     "README",
+     "Rakefile",
+     "VERSION",
+     "activerecord-nulldb-adapter.gemspec",
+     "init.rb",
+     "lib/active_record/connection_adapters/nulldb_adapter.rb",
+     "lib/nulldb_rspec.rb",
+     "spec/nulldb_spec.rb",
+     "tasks/database.rake"
+  ]
+  s.homepage = %q{http://nulldb.rubyforge.org}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubyforge_project = %q{nulldb}
+  s.rubygems_version = %q{1.3.5}
+  s.summary = %q{NullDB lets you to test your models without ever touching a real database.}
+  s.test_files = [
+    "spec/nulldb_spec.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+    else
+    end
+  else
+  end
+end
+

data/init.rb

@@ -0,0 +1 @@
+#require 'active_record/connection_adapters/nulldb_adapter'

data/lib/active_record/connection_adapters/nulldb_adapter.rb

@@ -0,0 +1,231 @@
+require 'logger'
+require 'stringio'
+require 'singleton'
+require 'active_record/connection_adapters/abstract_adapter'
+
+class ActiveRecord::Base
+  # Instantiate a new NullDB connection.  Used by ActiveRecord internally.
+  def self.nulldb_connection(config)
+    ActiveRecord::ConnectionAdapters::NullDBAdapter.new(config)
+  end
+end
+
+module ActiveRecord
+  # Just make sure you have the latest version of your schema
+  class Schema < Migration
+    def self.define(info={}, &block)
+      instance_eval(&block)
+    end
+  end
+end
+
+class ActiveRecord::ConnectionAdapters::NullDBAdapter <
+    ActiveRecord::ConnectionAdapters::AbstractAdapter
+
+  class Statement
+    attr_reader :entry_point, :content
+
+    def initialize(entry_point, content = "")
+      @entry_point, @content = entry_point, content
+    end
+
+    def ==(other)
+      self.entry_point == other.entry_point
+    end
+  end
+
+  class Checkpoint < Statement
+    def initialize
+      super(:checkpoint, "")
+    end
+
+    def ==(other)
+      self.class == other.class
+    end
+  end
+
+  TableDefinition = ActiveRecord::ConnectionAdapters::TableDefinition
+
+  class NullObject
+    def method_missing(*args, &block)
+      nil
+    end
+  end
+
+  # A convenience method for integratinginto RSpec.  See README for example of
+  # use.
+  def self.insinuate_into_spec(config)
+    config.before :all do
+      ActiveRecord::Base.establish_connection(:adapter => :nulldb)
+    end
+
+    config.after :all do
+      ActiveRecord::Base.establish_connection(:test)
+    end
+  end
+
+  # Recognized options:
+  #
+  # [+:schema+] path to the schema file, relative to RAILS_ROOT
+  def initialize(config={})
+    @log            = StringIO.new
+    @logger         = Logger.new(@log)
+    @last_unique_id = 0
+    @tables         = {'schema_info' =>  TableDefinition.new(nil)}
+    @schema_path    = config.fetch(:schema){ "db/schema.rb" }
+    super(nil, @logger)
+  end
+
+  # A log of every statement that has been "executed" by this connection adapter
+  # instance.
+  def execution_log
+    (@execution_log ||= [])
+  end
+
+  # A log of every statement that has been "executed" since the last time
+  # #checkpoint! was called, or since the connection was created.
+  def execution_log_since_checkpoint
+    checkpoint_index = @execution_log.rindex(Checkpoint.new)
+    checkpoint_index = checkpoint_index ? checkpoint_index + 1 : 0
+    @execution_log[(checkpoint_index..-1)]
+  end
+
+  # Inserts a checkpoint in the log.  See also #execution_log_since_checkpoint.
+  def checkpoint!
+    self.execution_log << Checkpoint.new
+  end
+
+  def adapter_name
+    "NullDB"
+  end
+
+  def supports_migrations?
+    true
+  end
+
+  def create_table(table_name, options = {})
+    table_definition = ActiveRecord::ConnectionAdapters::TableDefinition.new(self)
+    unless options[:id] == false
+      table_definition.primary_key(options[:primary_key] || "id")
+    end
+
+    yield table_definition
+
+    @tables[table_name] = table_definition
+  end
+
+  def add_fk_constraint(*args)
+    # NOOP
+  end
+
+  def add_pk_constraint(*args)
+    # NOOP
+  end
+
+  # Retrieve the table names defined by the schema
+  def tables
+    @tables.keys.map(&:to_s)
+  end
+
+  # Retrieve table columns as defined by the schema
+  def columns(table_name, name = nil)
+    if @tables.size <= 1
+      ActiveRecord::Migration.verbose = false
+      Kernel.load(File.join(RAILS_ROOT, @schema_path))
+    end
+    table = @tables[table_name]
+    table.columns.map do |col_def|
+      ActiveRecord::ConnectionAdapters::Column.new(col_def.name.to_s,
+                                                    col_def.default,
+                                                    col_def.type,
+                                                    col_def.null)
+    end
+  end
+
+  def execute(statement, name = nil)
+    self.execution_log << Statement.new(entry_point, statement)
+    NullObject.new
+  end
+
+  def select_rows(statement, name = nil)
+    returning([]) do
+      self.execution_log << Statement.new(entry_point, statement)
+    end
+  end  
+
+  def insert(statement, name, primary_key, object_id, sequence_name)
+    returning(object_id || next_unique_id) do
+      with_entry_point(:insert) do
+        super(statement, name, primary_key, object_id, sequence_name)
+      end
+    end
+  end
+
+  def update(statement, name=nil)
+    with_entry_point(:update) do
+      super(statement, name)
+    end
+  end
+
+  def delete(statement, name=nil)
+    with_entry_point(:delete) do
+      super(statement, name)
+    end
+  end
+
+  def select_all(statement, name=nil)
+    with_entry_point(:select_all) do
+      super(statement, name)
+    end
+  end
+
+  def select_one(statement, name=nil)
+    with_entry_point(:select_one) do
+      super(statement, name)
+    end
+  end
+
+  def select_value(statement, name=nil)
+    with_entry_point(:select_value) do
+      super(statement, name)
+    end
+  end
+
+  protected
+
+  def select(statement, name)
+    returning([]) do
+      self.execution_log << Statement.new(entry_point, statement)
+    end
+  end
+
+  private
+
+  def next_unique_id
+    @last_unique_id += 1
+  end
+
+  def with_entry_point(method)
+    if entry_point.nil?
+      with_thread_local_variable(:entry_point, method) do
+        yield
+      end
+    else
+      yield
+    end
+  end
+
+  def entry_point
+    Thread.current[:entry_point]
+  end
+
+  def with_thread_local_variable(name, value)
+    old_value = Thread.current[name]
+    Thread.current[name] = value
+    begin
+      yield
+    ensure
+      Thread.current[name] = old_value
+    end
+  end
+end

data/lib/nulldb_rspec.rb

@@ -0,0 +1,93 @@
+require 'active_record/connection_adapters/nulldb_adapter'
+
+module NullDB
+  module RSpec
+  end
+end
+
+module NullDB::RSpec::NullifiedDatabase
+  NullDBAdapter = ActiveRecord::ConnectionAdapters::NullDBAdapter
+
+  class HaveExecuted
+
+    def initialize(entry_point)
+      @entry_point = entry_point
+    end
+
+    def matches?(connection)
+      log = connection.execution_log_since_checkpoint
+      if entry_point == :anything
+        not log.empty?
+      else
+        log.include?(NullDBAdapter::Statement.new(@entry_point))
+      end
+    end
+
+    def description
+      "connection should execute #{@entry_point} statement"
+    end
+
+    def failure_message
+      " did not execute #{@entry_point} statement when it should have"
+    end
+
+    def negative_failure_message
+      " executed #{@entry_point} statement when it should not have"
+    end
+  end
+
+  def self.globally_nullify_database
+    Spec::Runner.configure do |config|
+      nullify_database(config)
+    end
+  end
+
+  def self.contextually_nullify_database(context)
+    nullify_database(context)
+  end
+
+  # A matcher for asserting that database statements have (or have not) been
+  # executed.  Usage:
+  #
+  #   ActiveRecord::Base.connection.should have_executed(:insert)
+  #
+  # The types of statement that can be matched mostly mirror the public
+  # operations available in
+  # ActiveRecord::ConnectionAdapters::DatabaseStatements:
+  # - :select_one
+  # - :select_all
+  # - :select_value
+  # - :insert
+  # - :update
+  # - :delete
+  # - :execute
+  #
+  # There is also a special :anything symbol that will match any operation.
+  def have_executed(entry_point)
+    HaveExecuted.new(entry_point)
+  end
+
+  private
+
+  def self.included(other)
+    if other.ancestors.include?(ActiveSupport::TestCase)
+      contextually_nullify_database(other)
+    else
+      globally_nullify_database
+    end
+  end
+
+  def self.nullify_database(receiver)
+    receiver.before :all do
+      ActiveRecord::Base.establish_connection(:adapter => :nulldb)
+    end
+
+    receiver.before :each do
+      ActiveRecord::Base.connection.checkpoint!
+    end
+
+    receiver.after :all do
+      ActiveRecord::Base.establish_connection(:test)
+    end
+  end
+end

data/spec/nulldb_spec.rb

@@ -0,0 +1,189 @@
+require 'rubygems'
+require 'spec'
+require 'active_record'
+$: << File.join(File.dirname(__FILE__), "..", "lib")
+
+class Employee < ActiveRecord::Base
+  after_save :on_save_finished
+
+  def on_save_finished
+  end
+end
+
+RAILS_ROOT = "RAILS_ROOT"
+
+describe "NullDB with no schema pre-loaded" do
+  before :each do
+    Kernel.stub!(:load)
+    ActiveRecord::Migration.stub!(:verbose=)
+  end
+
+  it "should load RAILS_ROOT/db/schema.rb if no alternate is specified" do
+    ActiveRecord::Base.establish_connection :adapter => :nulldb
+    Kernel.should_receive(:load).with("RAILS_ROOT/db/schema.rb")
+    ActiveRecord::Base.connection.columns('schema_info')
+  end
+
+  it "should load the specified schema relative to RAILS_ROOT" do
+    Kernel.should_receive(:load).with("RAILS_ROOT/foo/myschema.rb")
+    ActiveRecord::Base.establish_connection :adapter => :nulldb,
+                                            :schema => "foo/myschema.rb"
+    ActiveRecord::Base.connection.columns('schema_info')
+  end
+
+  it "should suppress migration output" do
+    ActiveRecord::Migration.should_receive(:verbose=).with(false)
+    ActiveRecord::Base.establish_connection :adapter => :nulldb,
+                                            :schema => "foo/myschema.rb"
+    ActiveRecord::Base.connection.columns('schema_info')
+  end
+end
+
+describe "NullDB" do
+  before :all do
+    ActiveRecord::Base.establish_connection :adapter => :nulldb
+    ActiveRecord::Migration.verbose = false
+    ActiveRecord::Schema.define do
+      create_table(:employees) do |t|
+        t.string  :name
+        t.date    :hire_date
+        t.integer :employee_number
+        t.decimal :salary
+      end
+
+      add_fk_constraint "foo", "bar", "baz", "buz", "bungle"
+      add_pk_constraint "foo", "bar", {}, "baz", "buz"
+    end
+  end
+
+  before :each do
+    @employee =  Employee.new(:name           => "John Smith",
+                             :hire_date       => Date.civil(2000, 1, 1),
+                             :employee_number => 42,
+                             :salary          => 56000.00)
+  end
+
+  it "should enable instantiation of AR objects without a database" do
+    @employee.should_not be_nil
+    @employee.should be_a_kind_of(ActiveRecord::Base)
+  end
+
+  it "should remember columns defined in migrations" do
+    should_have_column(Employee, :name, :string)
+    should_have_column(Employee, :hire_date, :date)
+    should_have_column(Employee, :employee_number, :integer)
+    should_have_column(Employee, :salary, :decimal)
+  end
+
+  it "should enable simulated saving of AR objects" do
+    lambda { @employee.save! }.should_not raise_error
+  end
+
+  it "should enable AR callbacks during simulated save" do
+    @employee.should_receive(:on_save_finished)
+    @employee.save
+  end
+
+  it "should enable simulated deletes of AR objects" do
+    lambda { @employee.destroy }.should_not raise_error
+  end
+
+  it "should enable simulated creates of AR objects" do
+    emp = Employee.create(:name => "Bob Jones")
+    emp.name.should == "Bob Jones"
+  end
+
+  it "should generate new IDs when inserting unsaved objects" do
+    cxn = Employee.connection
+    id1 = cxn.insert("some sql", "SomeClass Create", "id", nil, nil)
+    id2 = cxn.insert("some sql", "SomeClass Create", "id", nil, nil)
+    id2.should == (id1 + 1)
+  end
+
+  it "should re-use object ID when inserting saved objects" do
+    cxn = Employee.connection
+    id1 = cxn.insert("some sql", "SomeClass Create", "id", 23, nil)
+    id1.should == 23
+  end
+
+  it "should log executed SQL statements" do
+    cxn = @employee.connection
+    exec_count = cxn.execution_log.size
+    @employee.save!
+    cxn.execution_log.size.should == (exec_count + 1)
+  end
+
+  it "should have the adapter name 'NullDB'" do
+    @employee.connection.adapter_name.should == "NullDB"
+  end
+
+  it "should support migrations" do
+    @employee.connection.supports_migrations?.should be_true
+  end
+
+  it "should always have a schema_info table definition" do
+    @employee.connection.tables.should include("schema_info")
+  end
+
+  it "should return an empty array from #select" do
+    @employee.connection.select_all("who cares", "blah").should == []
+  end
+
+  it "should provide a way to set log checkpoints" do
+    cxn = @employee.connection
+    @employee.save!
+    cxn.execution_log_since_checkpoint.size.should > 0
+    cxn.checkpoint!
+    cxn.execution_log_since_checkpoint.size.should == 0
+    @employee.save!
+    cxn.execution_log_since_checkpoint.size.should == 1
+  end
+
+  def should_contain_statement(cxn, entry_point)
+    cxn.execution_log_since_checkpoint.should \
+      include(ActiveRecord::ConnectionAdapters::NullDBAdapter::Statement.new(entry_point))
+  end
+
+  def should_not_contain_statement(cxn, entry_point)
+    cxn.execution_log_since_checkpoint.should_not \
+      include(ActiveRecord::ConnectionAdapters::NullDBAdapter::Statement.new(entry_point))
+  end
+
+  it "should tag logged statements with their entry point" do
+    cxn = @employee.connection
+
+    should_not_contain_statement(cxn, :insert)
+    @employee.save
+    should_contain_statement(cxn, :insert)
+
+    cxn.checkpoint!
+    should_not_contain_statement(cxn, :update)
+    @employee.save
+    should_contain_statement(cxn, :update)
+
+    cxn.checkpoint!
+    should_not_contain_statement(cxn, :delete)
+    @employee.destroy
+    should_contain_statement(cxn, :delete)
+
+    cxn.checkpoint!
+    should_not_contain_statement(cxn, :select_all)
+    Employee.find(:all)
+    should_contain_statement(cxn, :select_all)
+
+    cxn.checkpoint!
+    should_not_contain_statement(cxn, :select_value)
+    Employee.count_by_sql("frobozz")
+    should_contain_statement(cxn, :select_value)
+  end
+
+  it "should allow #finish to be called on the result of #execute" do
+    @employee.connection.execute("blah").finish
+  end
+
+  def should_have_column(klass, col_name, col_type)
+    col = klass.columns_hash[col_name.to_s]
+    col.should_not be_nil
+    col.type.should == col_type
+  end
+end

data/tasks/database.rake

@@ -0,0 +1,33 @@
+# Sadly, we have to monkeypatch Rake because all of the Rails database tasks are
+# hardcoded for specific adapters, with no extension points (!)
+Rake::TaskManager.class_eval do
+  def remove_task(task_name)
+    @tasks.delete(task_name.to_s)
+  end
+end
+
+def remove_task(task_name)
+  Rake.application.remove_task(task_name)
+end
+
+def wrap_task(task_name, &wrapper)
+  wrapped_task = Rake::Task[task_name]
+  remove_task(Rake::Task.scope_name(Rake.application.current_scope,
+                                    task_name))
+  task(task_name) do
+    wrapper.call(wrapped_task)
+  end
+end
+
+# For later exploration...
+# namespace :db do
+#   namespace :test do
+#     wrap_task :purge do |wrapped_task|
+#       if ActiveRecord::Base.configurations["test"]["adapter"] == "nulldb"
+#         # NO-OP
+#       else
+#         wrapped_task.invoke
+#       end
+#     end
+#   end
+# end

metadata

@@ -0,0 +1,65 @@
+--- !ruby/object:Gem::Specification 
+name: activerecord-nulldb-adapter
+version: !ruby/object:Gem::Version 
+  version: 0.0.3
+platform: ruby
+authors: 
+- Avdi Grimm
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-12-30 00:00:00 -08:00
+default_executable: 
+dependencies: []
+
+description: An ActiveRecord null database adapter for greater speed and isolation in unit tests
+email: avdi@avdi.org
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README
+files: 
+- LICENSE
+- README
+- Rakefile
+- VERSION
+- activerecord-nulldb-adapter.gemspec
+- init.rb
+- lib/active_record/connection_adapters/nulldb_adapter.rb
+- lib/nulldb_rspec.rb
+- spec/nulldb_spec.rb
+- tasks/database.rake
+has_rdoc: true
+homepage: http://nulldb.rubyforge.org
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: nulldb
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: NullDB lets you to test your models without ever touching a real database.
+test_files: 
+- spec/nulldb_spec.rb