amalgalite 1.8.0-x64-mingw-ucrt

data/spec/integeration_spec.rb

@@ -0,0 +1,97 @@
+require 'spec_helper'
+
+require 'date'
+require 'time'
+
+describe "Integration specifications" do
+
+  describe " - invalid queries" do
+    it "raises error with an invalid syntax" do
+      lambda{ @iso_db.prepare "SELECT from country" }.should raise_error( ::Amalgalite::SQLite3::Error )
+    end
+
+    it "raises error with invalid table" do
+      lambda{ @iso_db.prepare "SELECT * FROM foo" }.should raise_error( ::Amalgalite::SQLite3::Error )
+    end
+    
+    it "raises error with invalid column" do
+      lambda{ @iso_db.prepare "SELECT foo FROM country" }.should raise_error( ::Amalgalite::SQLite3::Error )
+    end
+  end
+
+  describe " - default types conversion" do
+
+    { 
+      "datetime"  => { :value => DateTime.now, :klass => DateTime }, 
+      "timestamp" => { :value => Time.now, :klass => Time   } ,
+      "date"      => { :value => Date.today, :klass => Date },
+      "integer"   => { :value => 42, :klass => Integer },
+      "double"    => { :value => 3.14, :klass => Float },
+      "varchar"   => { :value => "foobarbaz", :klass => String },
+      "boolean"   => { :value => true, :klass => TrueClass },
+      "varchar(2)"=> { :value => nil, :klass => NilClass }
+    }.each_pair do |sql_type, ruby_info|
+      it "converts a ruby obj (#{ruby_info[:value].to_s}) of #{ruby_info[:klass]} to an SQL type of #{sql_type} and back again " do
+        db = Amalgalite::Database.new( SpecInfo.test_db )
+        db.execute "CREATE TABLE t( c #{sql_type} )"
+        db.execute "insert into t (c) values ( ? )", ruby_info[:value]
+        rows = db.execute "select * from t"
+        rows.first['c'].should be_kind_of(ruby_info[:klass])
+
+        if [ DateTime, Time ].include?( ruby_info[:klass] ) then
+          rows.first['c'].strftime("%Y-%m-%d %H:%M:%S").should eql(ruby_info[:value].strftime("%Y-%m-%d %H:%M:%S"))
+        else
+          rows.first['c'].should eql(ruby_info[:value])
+        end
+        db.close
+      end
+    end
+  end
+
+  describe " - storage type conversion" do
+    { 
+      "datetime"  => { :value => DateTime.now, :result => DateTime.now.strftime("%Y-%m-%dT%H:%M:%S%Z") } ,
+      "timestamp" => { :value => Time.now,     :result => Time.now.to_s },
+      "date"      => { :value => Date.today,   :result => Date.today.to_s },
+      "integer"   => { :value => 42,           :result => 42   } ,
+      "double"    => { :value => 3.14,         :result => 3.14 }  ,
+      "varchar"   => { :value => "foobarbaz",  :result => "foobarbaz" },
+      "boolean"   => { :value => true,         :result => "true" },
+      "varchar(2)"=> { :value => nil,          :result => nil }
+    }.each_pair do |sql_type, ruby_info|
+      it "converts a ruby obj (#{ruby_info[:value].to_s}) of class #{ruby_info[:value].class.name} to an SQL type of #{sql_type} and back to a storage type" do
+        db = Amalgalite::Database.new( SpecInfo.test_db )
+        db.type_map = Amalgalite::TypeMaps::StorageMap.new
+        db.execute "CREATE TABLE t( c #{sql_type} )"
+        db.execute "insert into t (c) values ( ? )", ruby_info[:value]
+        rows = db.execute "select * from t"
+        rows.first['c'].should eql(ruby_info[:result])
+        db.close
+      end
+    end
+  end
+
+  describe " - text type conversion" do
+    { 
+      "datetime"  => { :value => DateTime.now, :result => DateTime.now.strftime("%Y-%m-%dT%H:%M:%S%Z") } ,
+      "timestamp" => { :value => Time.now,     :result => Time.now.to_s },
+      "date"      => { :value => Date.today,   :result => Date.today.to_s },
+      "integer"   => { :value => 42,           :result => "42"   } ,
+      "double"    => { :value => 3.14,         :result => "3.14" }  ,
+      "varchar"   => { :value => "foobarbaz",  :result => "foobarbaz" },
+      "boolean"   => { :value => true,         :result => "true" },
+      "varchar(2)"=> { :value => nil,          :result => "" }
+    }.each_pair do |sql_type, ruby_info|
+      it "converts a ruby obj (#{ruby_info[:value].to_s}) of class #{ruby_info[:value].class.name} to an SQL type of #{sql_type} and back to text" do
+        db = Amalgalite::Database.new( SpecInfo.test_db )
+        db.type_map = Amalgalite::TypeMaps::TextMap.new
+        db.execute "CREATE TABLE t( c #{sql_type} )"
+        db.execute "insert into t (c) values ( ? )", ruby_info[:value]
+        rows = db.execute "select * from t"
+        rows.first['c'].should eql(ruby_info[:result])
+        db.close
+      end
+    end
+  end
+end
+

data/spec/iso_3166_database.rb

@@ -0,0 +1,58 @@
+require 'amalgalite'
+
+module Amalgalite
+  class Iso3166Database < Database
+    def self.country_data_file
+      @country_data_file ||= File.expand_path( File.join( File.dirname(__FILE__), "data", "iso-3166-country.txt" ) )
+    end
+
+    def self.subcountry_data_file
+      @subcountry_data_file ||= File.expand_path( File.join( File.dirname(__FILE__), "data", "iso-3166-subcountry.txt" ) )
+    end
+
+    def self.schema_file
+      @schema_file ||= File.expand_path(File.join(File.dirname(__FILE__), "data", "iso-3166-schema.sql"))
+    end
+
+    def self.default_db_file
+      @db_file ||= File.expand_path(File.join(File.dirname(__FILE__), "data", "iso-3166.db"))
+
+    end
+
+    def self.memory
+      Iso3166Database.new( ":memory:" )
+    end
+
+    def initialize( path = Iso3166Database.default_db_file )
+      @path = path 
+      super( @path )
+      install_schema( self )
+      populate( self )
+    end
+
+    def duplicate( slug )
+      dirname = File.dirname( @path )
+      bname = File.basename( @path, ".db" )
+      new_name = File.join( dirname, "#{bname}_#{slug}.db" )
+      File.unlink( new_name ) if File.exist?( new_name )
+      new_db = replicate_to( new_name )
+      new_db.close
+      return new_name
+    end
+
+    def install_schema( db )
+      db.execute_batch( IO.read( Iso3166Database.schema_file ) );
+    end
+
+    def populate( db )
+      db.import_csv_to_table( Iso3166Database.country_data_file, "country", :col_sep => "|" )
+      db.import_csv_to_table( Iso3166Database.subcountry_data_file, "subcountry", :col_sep => "|" )
+    end
+
+    def remove
+      File.unlink( @path ) if File.exist?( @path )
+    end
+  end
+end
+
+

data/spec/json_spec.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+require 'amalgalite/sqlite3'
+require 'rbconfig'
+
+describe "Amalgalite handles the JSON extension" do
+  it "can parse a `json_each` call" do
+    db = Amalgalite::Database.new( ":memory:" )
+    values = %w[ a b c d e f g ]
+    db.execute("CREATE TABLE jtest(id, json)")
+    db.execute("INSERT INTO jtest(id, json) values (1, json($json))", { "$json" => values })
+    rows = db.execute("SELECT jtest.id as i, value as v FROM jtest, json_each(jtest.json)")
+
+    rows.size.should eq(values.size)
+  end
+
+  it "can return a proper json column" do
+    db = Amalgalite::Database.new( ":memory:" )
+    values = %w[ a b c d e f g ]
+    db.execute("CREATE TABLE jtest(id INTEGER, json JSON)")
+    db.execute("INSERT INTO jtest(id, json) values (1, json($json))", { "$json" => values })
+
+    db.execute("select * from jtest")
+  end
+end

data/spec/packer_spec.rb

@@ -0,0 +1,60 @@
+require 'spec_helper'
+
+require 'amalgalite/packer'
+
+describe "Amalgalite::Packer" do
+  before( :each ) do
+    @table = Amalgalite::Requires::Bootstrap::DEFAULT_BOOTSTRAP_TABLE
+    @packer = Amalgalite::Packer.new( :table_name => @table )
+  end
+
+  after( :each ) do 
+    FileUtils.rm_f Amalgalite::Requires::Bootstrap::DEFAULT_DB
+  end
+
+  it "does not load the amalgalite/requires file" do
+    $LOADED_FEATURES.should_not be_include("amalgalite/requires")
+  end
+
+  it "packs amalgalite into a bootstrap database" do
+    @packer.pack( Amalgalite::Packer.amalgalite_require_order )
+    db = Amalgalite::Database.new( @packer.dbfile )
+    db.schema.tables[ @table ].should_not be_nil
+    count = db.execute("SELECT count(1) FROM #{@table}").first
+    count.first.should eql(Amalgalite::Packer.amalgalite_require_order.size)
+  end
+
+  it "recreates the table if :drop_table option is given " do
+    @packer.pack( Amalgalite::Packer.amalgalite_require_order )
+    db = Amalgalite::Database.new( @packer.dbfile )
+    db.schema.tables[ @table ].should_not be_nil
+    count = db.execute("SELECT count(1) FROM #{@table}").first
+    count.first.should eql(Amalgalite::Packer.amalgalite_require_order.size)
+
+    np = Amalgalite::Packer.new( :drop_table => true, :table_name => @table  )
+    np.options[ :drop_table ].should eql(true)
+    np.check_db( db )
+    count = db.execute("SELECT count(1) FROM #{@table}").first
+    count.first.should eql(0)
+
+  end
+
+  it "compresses the content if told too" do 
+    @packer.options[ :compressed ] = true
+    @packer.pack( Amalgalite::Packer.amalgalite_require_order )
+    db = Amalgalite::Database.new( @packer.dbfile )
+    orig = IO.read( File.join( File.dirname( __FILE__ ), "..", "lib", "amalgalite.rb" ) )
+    zipped = db.execute("SELECT contents FROM #{@table} WHERE filename = 'amalgalite'")
+    expanded = Amalgalite::Packer.gunzip( zipped.first['contents'].to_s )
+    expanded.should eql(orig)
+  end
+
+  it "has all the lib files in the amalgalite gem" do
+    ro = Amalgalite::Packer.amalgalite_require_order
+    glist = IO.readlines("Manifest.txt").select { |l| l.index("lib/amalgalite") == 0 }
+    glist.map! { |l| l.strip.sub("lib/","") }
+    (glist - ro).each do |l|
+      l.should_not =~ /amalgalite/
+    end
+  end
+end

data/spec/paths_spec.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+
+describe Amalgalite::Paths do
+  before(:each) do
+    @root_dir = File.expand_path(File.join(File.dirname(__FILE__), ".."))
+    @root_dir += "/"
+  end
+
+  it "root dir should be correct" do
+    Amalgalite::Paths.root_dir.should == @root_dir
+  end
+
+  it "config_path should be correct" do
+    Amalgalite::Paths.config_path.should == File.join(@root_dir, "config/")
+  end
+
+  it "data path should be correct" do
+    Amalgalite::Paths.data_path.should == File.join(@root_dir, "data/")
+  end
+
+  it "lib path should be correct" do
+    Amalgalite::Paths.lib_path.should == File.join(@root_dir, "lib/")
+  end
+
+  it "ext path should be correct" do
+    Amalgalite::Paths.ext_path.should == File.join(@root_dir, "ext/")
+  end
+end

data/spec/progress_handler_spec.rb

@@ -0,0 +1,91 @@
+require 'spec_helper'
+
+class PH < ::Amalgalite::ProgressHandler
+  attr_reader :call_count
+  def initialize( max = nil )
+    @call_count = 0
+    @max = max
+  end
+
+  def call
+    @call_count += 1
+    if @max && ( @call_count >= @max ) then
+      return false
+    end
+    return true
+  end
+end
+
+def query_thread( database )
+  Thread.new( database ) do |db|
+    begin
+      db.execute("select count(id) from country")
+    rescue => e
+      Thread.current[:exception] = e
+    end
+  end
+end
+
+describe "Progress Handlers" do
+
+  it "raises NotImplemented if #call is not overwritten" do
+    bh = ::Amalgalite::ProgressHandler.new
+    lambda { bh.call }.should raise_error( ::NotImplementedError, /The progress handler call\(\) method must be implemented/ )
+  end
+
+  it "can be registered as block" do
+    call_count = 0
+    @iso_db.progress_handler( 50 ) do ||
+      call_count += 1
+    true
+    end
+    qt = query_thread( @iso_db )
+    qt.join
+    call_count.should > 10
+  end
+
+  it "can be registered as lambda" do
+    call_count = 0
+    callable = lambda { || call_count += 1; true }
+    @iso_db.progress_handler( 42, callable ) 
+    qt = query_thread( @iso_db )
+    qt.join
+    call_count.should > 10
+  end
+
+  it "can be registered as a class" do
+    ph = PH.new 
+    @iso_db.progress_handler( 5, ph )
+    qt = query_thread( @iso_db )
+    qt.join
+    ph.call_count.should > 100
+  end
+
+  it "behaves like #interrupt! if returning a false value" do
+    ph = PH.new( 25 )
+    @iso_db.progress_handler( 5, ph )
+    qt = query_thread( @iso_db )
+    qt.join
+    ph.call_count.should eql(25)
+    qt[:exception].should be_instance_of( ::Amalgalite::SQLite3::Error )
+    @iso_db.api.last_error_code.should be == 9
+    @iso_db.api.last_error_message.should  =~ /interrupted/
+    qt[:exception].message.should =~ /interrupted/
+  end
+
+  it "cannot register a block with the wrong arity" do
+    lambda do 
+      @iso_db.define_progress_handler { |x,y| puts "What!" }
+    end.should raise_error( ::Amalgalite::Database::ProgressHandlerError, /A progress handler expects 0 arguments, not 2/)
+  end
+
+  it "can remove a progress handler" do
+    ph = PH.new 
+    @iso_db.progress_handler( 5, ph )
+    @iso_db.remove_progress_handler
+    qt = query_thread( @iso_db )
+    qt.join
+    ph.call_count.should eql(0)
+    qt[:exception].should be_nil
+  end
+end

data/spec/requires_spec.rb

@@ -0,0 +1,54 @@
+require 'spec_helper'
+require 'amalgalite/requires'
+
+#describe Amalgalite::Requires do
+#  it "#require_order has all files in 'lib' and no more" do
+#    dir_files = Dir.glob( File.join( Amalgalite::Paths.lib_path , "**", "*.rb" ) )
+#    require_files = Amalgalite::Requires.require_order.collect { |r| Amalgalite::Paths.lib_path r }
+#    dir_files.size.should == require_files.size
+#    (dir_files - require_files).size.should == 0
+#    (require_files - dir_files).size.should == 0
+#  end
+#
+#  it "can compress and uncompress data" do
+#    s = IO.read( __FILE__ )
+#    s_gz = Amalgalite::Requires.gzip( s )
+#    s.should == Amalgalite::Requires.gunzip( s_gz )
+#  end
+#end
+
+
+describe Amalgalite::Requires do
+  it "can import to an in-memory database" do
+    sql = <<-SQL
+CREATE TABLE rubylibs (
+      id                   INTEGER PRIMARY KEY AUTOINCREMENT,
+      filename   TEXT UNIQUE,
+      compressed BOOLEAN,
+      contents   BLOB
+      );
+INSERT INTO "rubylibs" VALUES(1, "application", "false", 'A=1');
+SQL
+    r = Amalgalite::Requires.new(:dbfile_name => ":memory:")
+    r.import(sql)
+    r.file_contents( "application" ).should == "A=1"
+  end
+
+
+  it "gives equal instances for file databases" do
+    a = Amalgalite::Requires.new( :dbfile_name => SpecInfo.test_db )
+    b = Amalgalite::Requires.new( :dbfile_name => SpecInfo.test_db )    
+
+    a.db_connection.should equal( b.db_connection )
+  end
+
+
+  it "gives separate instances for in-memory databases" do
+    a = Amalgalite::Requires.new( :dbfile_name => ":memory:" )
+    b = Amalgalite::Requires.new( :dbfile_name => ":memory:" )
+
+    a.db_connection.should_not equal(b.db_connection)
+  end
+
+  
+end

data/spec/rtree_spec.rb

@@ -0,0 +1,66 @@
+require 'spec_helper'
+
+#
+# Example from http://sqlite.org/rtree.html
+#
+describe "SQLite3 R*Tree extension" do
+  before( :each ) do
+    @db = Amalgalite::Database.new( ":memory:" )
+    x = @db.execute_batch <<-sql
+    CREATE VIRTUAL TABLE demo_index USING rtree(
+       id,              -- Integer primary key
+       minX, maxX,      -- Minimum and maximum X coordinate
+       minY, maxY       -- Minimum and maximum Y coordinate
+    );
+    -- 
+    INSERT INTO demo_index VALUES(
+        1,                   -- Primary key
+        -80.7749, -80.7747,  -- Longitude range
+        30.3776, 30.3778     -- Latitude range
+    );
+    INSERT INTO demo_index VALUES(
+        2,
+        -81.0, -79.6,
+        35.0, 36.2
+    );
+    sql
+    x.should == 3
+  end
+
+  after( :each ) do
+    @db.close
+  end
+
+  it "has 2 rows" do
+    r = @db.first_value_from( "SELECT count(*) FROM demo_index")
+    r.should == 2
+  end
+
+  it "queries normally" do
+    r = @db.execute "SELECT * FROM demo_index WHERE id=1;"
+    r.size.should be == 1
+    row = r.first
+    row['id'].should be == 1
+  end
+
+  it "does a 'contained within' query" do
+    r = @db.execute <<-sql
+    SELECT id FROM demo_index
+     WHERE minX>=-81.08 AND maxX<=-80.58
+       AND minY>=30.00  AND maxY<=30.44;
+    sql
+
+    r.size.should be == 1
+    r.first['id'].should be == 1
+  end
+
+  it "does an 'overlapping' query" do
+    r = @db.execute <<-sql
+    SELECT id FROM demo_index
+     WHERE maxX>=-81.08 AND minX<=-80.58
+       AND maxY>=30.00  AND minY<=35.44;
+    sql
+    r.size.should == 2
+  end
+end
+

data/spec/schema_spec.rb

@@ -0,0 +1,131 @@
+require 'spec_helper'
+
+require 'amalgalite'
+require 'amalgalite/schema'
+
+describe Amalgalite::Schema do
+
+  it "loads the schema of a database" do
+    schema = @iso_db.schema
+    schema.load_tables
+    schema.tables.size.should eql(2)
+  end
+
+  it "loads the views in the database" do
+    s = @iso_db.schema
+    sql = "CREATE VIEW v1 AS SELECT c.name, c.two_letter, s.name, s.subdivision FROM country AS c JOIN subcountry AS s ON c.two_letter = s.country"
+    @iso_db.execute( sql )
+    s.dirty?.should be == true
+    @iso_db.schema.load_views
+    @iso_db.schema.views.size.should eql(1)
+    @iso_db.schema.views["v1"].sql.should eql(sql)
+  end
+
+  it "removes quotes from around default values in columns" do
+    s = @iso_db.schema
+    sql = "CREATE TABLE t1( d1 default 't' )"
+    @iso_db.execute( sql )
+    s.dirty?.should be == true
+    tt = @iso_db.schema.tables['t1']
+    tt.columns['d1'].default_value.should be == "t"
+  end
+
+  it "loads the tables and columns" do
+    ct = @iso_db.schema.tables['country']
+    ct.name.should eql("country")
+    ct.columns.size.should eql(3)
+    ct.indexes.size.should eql(2)
+    ct.column_names.should eql(%w[ name two_letter id ])
+    @iso_db.schema.tables.size.should eql(2)
+
+
+    ct.columns['two_letter'].should be_primary_key
+    ct.columns['two_letter'].declared_data_type.should eql("TEXT")
+    ct.columns['name'].should_not be_nullable
+    ct.columns['name'].should be_not_null_constraint
+    ct.columns['name'].should_not be_has_default_value
+    ct.columns['id'].should_not be_auto_increment
+  end
+
+  it "knows what the primary key of a table is" do
+    ct = @iso_db.schema.tables['country']
+    ct.primary_key.should == [ ct.columns['two_letter'] ]
+  end
+
+  it "knows the primary key of a table even without an explicity unique index" do
+    s = @iso_db.schema
+    sql = "CREATE TABLE u( id INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL , other text )"
+    @iso_db.execute( sql )
+    s.dirty?.should be == true
+    ut = @iso_db.schema.tables['u']
+    ut.primary_key.should == [ ut.columns['id'] ]
+  end
+
+  it "knows the primary key of a temporary table" do
+    @iso_db.execute "CREATE TEMPORARY TABLE tt( a, b INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, c )"
+    tt = @iso_db.schema.tables[ 'tt' ]
+    tt.primary_key.should == [ tt.columns['b'] ]
+  end
+
+  it "knows what the primary key of a table is when it is a multiple column primary key" do
+    sql = "CREATE TABLE m ( id1, id2, PRIMARY KEY (id2, id1) )"
+    s = @iso_db.schema
+    @iso_db.execute( sql )
+    s.dirty?.should be == true
+    mt = @iso_db.schema.tables['m']
+    mt.primary_key.should == [ mt.columns['id2'], mt.columns['id1'] ]
+  end
+
+  it "loads the indexes" do
+    c = @iso_db.schema.tables['country']
+    c.indexes.size.should eql(2)
+    c.indexes['country_name'].columns.size.should eql(1)
+    c.indexes['country_name'].should_not be_unique
+    c.indexes['country_name'].sequence_number.should eql(0)
+    c.indexes['country_name'].columns.first.should eql(@iso_db.schema.tables['country'].columns['name'])
+    c.indexes['sqlite_autoindex_country_1'].should be_unique
+
+    subc = @iso_db.schema.tables['subcountry']
+    subc.indexes.size.should eql(3)
+    subc.indexes['subcountry_country'].columns.first.should eql(@iso_db.schema.tables['subcountry'].columns['country'])
+  end
+
+  it "knows the schema is dirty when a table is created" do
+    s = @iso_db.schema
+    s.tables['country']
+    s.dirty?.should be == false
+    @iso_db.execute( "create table x1( a, b )" )
+    s.dirty?.should be == true
+  end
+
+  it "knows the schema is dirty when a table is dropped" do
+    s = @iso_db.schema
+    s.tables['country']
+    @iso_db.execute( "create table x1( a, b )" )
+    s.dirty?.should be == true
+
+    @iso_db.schema.load_schema!
+    s = @iso_db.schema
+
+    s.dirty?.should be == false
+    @iso_db.execute("drop table x1")
+    s.dirty?.should be == true
+  end
+
+  it "knows if a temporary table exists" do
+    @iso_db.execute "CREATE TEMPORARY TABLE tt(a,b,c)"
+    @iso_db.schema.tables.keys.include?('tt').should be == true
+    @iso_db.schema.tables['tt'].temporary?.should be == true
+  end
+
+  it "sees that temporary tables shadow real tables" do
+    @iso_db.execute "CREATE TABLE tt(x)"
+    @iso_db.schema.tables['tt'].temporary?.should be == false
+    @iso_db.execute "CREATE TEMP TABLE tt(a,b,c)"
+    @iso_db.schema.tables['tt'].temporary?.should be == true
+    @iso_db.execute "DROP TABLE tt"
+    @iso_db.schema.tables['tt'].temporary?.should be == false
+    @iso_db.schema.tables['tt'].columns.size.should be == 1
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,48 @@
+require 'rspec'
+require 'fileutils'
+
+require 'amalgalite'
+require Amalgalite::Paths.spec_path( "iso_3166_database.rb" )
+
+class SpecInfo
+  class << self
+    def test_db
+      @test_db ||= Amalgalite::Paths.spec_path("data", "test.db")
+    end
+
+    def make_master_iso_db
+      @master_db ||= Amalgalite::Iso3166Database.new
+    end
+
+    def make_clone_iso_db
+      make_master_iso_db.duplicate( 'testing' )
+    end
+  end
+end
+
+RSpec.configure do |config|
+  config.expect_with :rspec do |c|
+    c.syntax = [:should, :expect]
+  end
+
+  config.before(:all) do 
+    SpecInfo.make_master_iso_db
+  end
+
+  config.after(:all) do
+    File.unlink( Amalgalite::Iso3166Database.default_db_file ) if File.exist?( Amalgalite::Iso3166Database.default_db_file )
+  end
+
+  config.before( :each ) do
+    @iso_db_path = SpecInfo.make_clone_iso_db
+    @iso_db      = Amalgalite::Database.new( @iso_db_path )
+    @schema      = IO.read( Amalgalite::Iso3166Database.schema_file )
+  end
+
+  config.after( :each ) do
+    @iso_db.close
+    File.unlink( @iso_db_path ) if File.exist?( @iso_db_path )
+    File.unlink( SpecInfo.test_db ) if File.exist?( SpecInfo.test_db )
+  end
+end
+