amalgalite 0.10.1-x86-mswin32

data/spec/default_map_spec.rb

@@ -0,0 +1,87 @@
+require 'rubygems'
+require 'spec'
+
+$: << File.expand_path(File.join(File.dirname(__FILE__),"..","lib"))
+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 "Fixnum 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 "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 declated types of 'blob'" do
+      blob = @map.result_value_of( "blob", "stuff")
+      blob.to_s.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,94 @@
+require 'rubygems'
+require 'spec'
+
+$: << File.expand_path(File.join(File.dirname(__FILE__),"..","lib"))
+require 'amalgalite'
+require 'amalgalite/database'
+
+describe "Scalar SQL Functions" do
+
+  before(:each) do
+    @schema = IO.read( SpecInfo.test_schema_file )
+    @iso_db_file = SpecInfo.make_iso_db
+    @iso_db = Amalgalite::Database.new( SpecInfo.make_iso_db )
+  end
+
+  after(:each) do
+    File.unlink SpecInfo.test_db if File.exist?( SpecInfo.test_db )
+    @iso_db.close
+    File.unlink @iso_db_file if File.exist?( @iso_db_file )
+  end
+
+  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 name() "ftest3"; end
+      def arity() 128; end
+    end
+    lambda { @iso_db.define_aggregate("ftest3", FunctionTest3) }.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,111 @@
+require 'rubygems'
+require 'spec'
+require 'date'
+require 'time'
+
+$: << File.expand_path(File.join(File.dirname(__FILE__),"..","lib"))
+require 'amalgalite'
+
+describe "Integration specifications" do
+  before(:each) do
+    @schema = IO.read( SpecInfo.test_schema_file )
+    @iso_db_file = SpecInfo.make_iso_db
+    @iso_db = Amalgalite::Database.new( SpecInfo.make_iso_db )
+  end
+  
+  after(:each) do
+    File.unlink SpecInfo.test_db if File.exist?( SpecInfo.test_db )
+    @iso_db.close
+    File.unlink @iso_db_file if File.exist?( @iso_db_file )
+  end
+
+  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 => Fixnum } ,
+      "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'].class.should eql(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/packer_spec.rb

@@ -0,0 +1,60 @@
+require File.expand_path(File.join(File.dirname(__FILE__),"spec_helper.rb"))
+require 'amalgalite/packer'
+require 'gemspec'
+
+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 = Amalgalite::GEM_SPEC.files.select { |l| l.index("lib/amalgalite") == 0 }
+    glist.map! { |l| l.sub("lib/","") }
+    (glist - ro).each do |l|
+      l.should_not =~ /amalgalite/
+    end
+  end
+end

data/spec/paths_spec.rb

@@ -0,0 +1,28 @@
+require File.expand_path(File.join(File.dirname(__FILE__),"spec_helper.rb"))
+
+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,105 @@
+require 'rubygems'
+require 'spec'
+require File.expand_path( File.join( File.dirname( __FILE__ ), "spec_helper.rb" ) )
+
+require 'amalgalite'
+require 'amalgalite/database'
+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( db )
+  Thread.new( db ) do |db|
+    begin
+      db.execute("select count(id) from country")
+    rescue => e
+      had_error = e
+      Thread.current[:exception] = e
+    end
+  end
+end
+
+describe "Progress Handlers" do
+  before(:each) do
+    @db_name = SpecInfo.make_iso_db
+    @iso_db = Amalgalite::Database.new( @db_name )
+  end
+
+  after(:each) do
+    @iso_db.close
+    File.unlink @db_name if File.exist?( @db_name )
+  end
+
+  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 == 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