amalgalite 1.6.0-x64-mingw32

data/spec/default_map_spec.rb

@@ -0,0 +1,92 @@
+require 'spec_helper'
+require 'amalgalite/type_maps/default_map'
+
+describe Amalgalite::TypeMaps::DefaultMap do
+  before(:each) do
+    @map = Amalgalite::TypeMaps::DefaultMap.new
+  end
+
+  describe "#bind_type_of" do
+
+    it "Float is bound to DataType::FLOAT" do
+      @map.bind_type_of( 3.14 ).should == ::Amalgalite::SQLite3::Constants::DataType::FLOAT
+    end
+
+    it "Integer is bound to DataType::INTGER" do
+      @map.bind_type_of( 42 ).should == ::Amalgalite::SQLite3::Constants::DataType::INTEGER
+    end
+
+    it "nil is bound to DataType::NULL" do
+      @map.bind_type_of( nil ).should == ::Amalgalite::SQLite3::Constants::DataType::NULL
+    end
+
+    it "::Amalgalite::Blob is bound to DataType::BLOB" do
+      @map.bind_type_of( ::Amalgalite::Blob.new( :column => true, :string => "just a test" ) ).should == ::Amalgalite::SQLite3::Constants::DataType::BLOB
+    end
+
+    it "everything else is bound to DataType::TEXT" do
+      @map.bind_type_of( "everything else" ).should == ::Amalgalite::SQLite3::Constants::DataType::TEXT
+    end
+
+  end
+
+
+  describe "#result_value_of" do
+
+    it "Numeric's are returned" do
+      y = 42
+      x = @map.result_value_of( "INT", 42 )
+      x.object_id.should == y.object_id
+    end
+
+    it "Nil is returned" do
+      @map.result_value_of( "NULL", nil ).should == nil
+    end
+
+    it "DateTime is returned for delcared types of 'datetime'" do
+      @map.result_value_of( "DaTeTiME", "2008-04-01 23:23:23" ).should be_kind_of(DateTime)
+    end
+
+    it "Date is returned for declared types of 'date'" do
+      @map.result_value_of( "date", "2008-04-01 23:42:42" ).should be_kind_of(Date)
+    end
+
+    it "Time is returned for declared types of 'time'" do
+      @map.result_value_of( "timestamp", "2008-04-01T23:42:42" ).should be_kind_of(Time)
+    end
+
+    it "Float is returned for declared types of 'double'" do
+      @map.result_value_of( "double", "3.14" ).should be_kind_of(Float)
+    end
+    
+    it "Float is returned for declared types of 'float'" do
+      @map.result_value_of( "float", "3.14" ).should be_kind_of(Float)
+    end
+
+    it "Integer is returned for declared types of 'int'" do
+      @map.result_value_of( "int", "42" ).should be_kind_of(Integer)
+    end
+
+    it "boolean is returned for declared types of 'bool'" do
+      @map.result_value_of( "bool", "True" ).should == true
+    end
+
+    it "Blob is returned for declared types of 'blob'" do
+      blob = @map.result_value_of( "blob", "stuff")
+      blob.to_s.should == "stuff"
+    end
+
+    it "String is returned for delcared types of 'string'" do
+      @map.result_value_of( "string", "stuff").should == "stuff"
+    end
+
+    it "raises and error if an unknown sql type is returned" do
+      x = nil
+      lambda{ x = @map.result_value_of( "footype", "foo" ) }.should raise_error( ::Amalgalite::Error )
+    end
+    
+    it "raises and error if an ruby class is attempted to be mapped" do
+      lambda{ @map.result_value_of( "footype", 1..3 ) }.should raise_error( ::Amalgalite::Error )
+    end
+  end
+end

data/spec/function_spec.rb

@@ -0,0 +1,78 @@
+require 'spec_helper'
+
+describe "Scalar SQL Functions" do
+
+  it "can define a custom SQL function as a block with 0 params" do
+    @iso_db.define_function("foo") do 
+        "foo"
+    end
+    r = @iso_db.execute("SELECT foo() AS f");
+    r.first['f'].should == "foo"
+  end
+
+  it "has a signature" do
+    ::Amalgalite::Function.new( "testing_name", 42 ).signature.should == "testing_name/42"
+  end
+
+  it "can define a custom SQL function as a lambda with 2 param" do
+    @iso_db.define_function("foo2", lambda{ |x,y| "foo2 -> #{x} #{y}" } )
+    r = @iso_db.execute("SELECT foo2( 'bar', 'baz' ) as f")
+    r.first['f'].should == "foo2 -> bar baz"
+  end
+
+  it "can define a custom SQL function as a class with N params" do
+    class FunctionTest1 < ::Amalgalite::Function
+      def initialize
+        super('ftest', -1)
+      end
+      def call( *args )
+          "#{args.length} args #{args.join(', ')}"
+      end
+    end
+
+    @iso_db.define_function("ftest1", FunctionTest1.new )
+    r = @iso_db.execute("SELECT ftest1(1,2,3,'baz') as f")
+    r.first['f'].should == "4 args 1, 2, 3, baz"
+  end
+
+  [ [   1,   lambda { true  } ],
+    [   0,   lambda { false } ],
+    [   nil, lambda { nil   } ],
+    [ "foo", lambda { "foo" } ],
+    [ 42,    lambda { 42 }    ],
+    [ 42.2 , lambda { 42.2 }  ], ].each do |expected, func|
+    it "returns the appropriate class #{expected.class} " do
+      @iso_db.define_function("ctest", func )
+      r = @iso_db.execute( "SELECT ctest() AS c" )
+      r.first['c'].should == expected
+    end
+  end
+
+  it "does not allow outrageous arity" do
+    class FunctionTest3 < ::Amalgalite::Function
+      def initialize
+        super( 'ftest3', 128)
+      end
+    end
+    lambda { @iso_db.define_function("ftest3", FunctionTest3.new) }.should raise_error( ::Amalgalite::SQLite3::Error, /SQLITE_ERROR .* Library used incorrectly/ )
+  end
+
+  it "raises an error if the function returns a complex Ruby object" do
+    l = lambda { Hash.new }
+    @iso_db.define_function("htest", l)
+    begin
+      @iso_db.execute( "SELECT htest() AS h" ) 
+    rescue => e
+      e.should be_instance_of( ::Amalgalite::SQLite3::Error )
+      e.message.should =~ /Unable to convert ruby object to an SQL function result/
+    end
+  end
+
+  it "an error raised during the sql function is handled correctly" do
+    @iso_db.define_function( "etest" ) do 
+      raise "error from within an sql function"
+    end
+    lambda { @iso_db.execute( "SELECT etest() AS e" ) }.should raise_error( ::Amalgalite::SQLite3::Error, /error from within an sql function/ )
+  end
+end
+

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/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