sequel 4.41.0 → 4.42.0

data/spec/core/expression_filters_spec.rb

@@ -2,13 +2,14 @@ require File.join(File.dirname(File.expand_path(__FILE__)), 'spec_helper')
 
 describe "Blockless Ruby Filters" do
   before do
-    db = Sequel::Database.new
-    @d = db[:items]
-    def @d.l(*args, &block)
-      literal(filter_expr(*args, &block))
-    end
-    def @d.lit(*args)
-      literal(*args)
+    db = Sequel.mock
+    @d = db[:items].with_extend do
+      def l(*args, &block)
+        literal(filter_expr(*args, &block))
+      end
+      def lit(*args)
+        literal(*args)
+      end
     end
   end
   
@@ -62,7 +63,7 @@ describe "Blockless Ruby Filters" do
   end
 
   it "should use = 't' and != 't' OR IS NULL if IS TRUE is not supported" do
-    meta_def(@d, :supports_is_true?){false}
+    @d = @d.with_extend{def supports_is_true?; false end}
     @d.l(:x => true).must_equal "(x = 't')"
     @d.l(~Sequel.expr(:x => true)).must_equal "((x != 't') OR (x IS NULL))"
     @d.l(:x => false).must_equal "(x = 'f')"
@@ -94,7 +95,7 @@ describe "Blockless Ruby Filters" do
     @d.l{(x + y) =~ (1...5)}.must_equal '(((x + y) >= 1) AND ((x + y) < 5))'
     @d.l{(x + y) =~ [1,2,3]}.must_equal '((x + y) IN (1, 2, 3))'
 
-    def @d.supports_regexp?; true end
+    @d = @d.with_extend{def supports_regexp?; true end}
     @d.l{x =~ /blah/}.must_equal '(x ~ \'blah\')'
     @d.l{(x + y) =~ /blah/}.must_equal '((x + y) ~ \'blah\')'
   end
@@ -117,19 +118,19 @@ describe "Blockless Ruby Filters" do
       @d.l{(x + y) !~ (1...5)}.must_equal '(((x + y) < 1) OR ((x + y) >= 5))'
       @d.l{(x + y) !~ [1,2,3]}.must_equal '((x + y) NOT IN (1, 2, 3))'
 
-      def @d.supports_regexp?; true end
+      @d = @d.with_extend{def supports_regexp?; true end}
       @d.l{x !~ /blah/}.must_equal '(x !~ \'blah\')'
       @d.l{(x + y) !~ /blah/}.must_equal '((x + y) !~ \'blah\')'
     end
   end
   
   it "should support ~ via Hash and Regexp (if supported by database)" do
-    def @d.supports_regexp?; true end
+    @d = @d.with_extend{def supports_regexp?; true end}
     @d.l(:x => /blah/).must_equal '(x ~ \'blah\')'
   end
   
   it "should support !~ via inverted Hash and Regexp" do
-    def @d.supports_regexp?; true end
+    @d = @d.with_extend{def supports_regexp?; true end}
     @d.l(~Sequel.expr(:x => /blah/)).must_equal '(x !~ \'blah\')'
   end
   
@@ -265,7 +266,7 @@ describe "Blockless Ruby Filters" do
   end
   
   it "should emulate multiple column in if not supported" do
-    meta_def(@d, :supports_multiple_column_in?){false}
+    @d = @d.with_extend{def supports_multiple_column_in?; false end}
     @d.l([:x, :y]=>Sequel.value_list([[1,2], [3,4]])).must_equal '(((x = 1) AND (y = 2)) OR ((x = 3) AND (y = 4)))'
     @d.l([:x, :y, :z]=>[[1,2,5], [3,4,6]]).must_equal '(((x = 1) AND (y = 2) AND (z = 5)) OR ((x = 3) AND (y = 4) AND (z = 6)))'
   end
@@ -429,8 +430,11 @@ describe "Blockless Ruby Filters" do
   end
 
   it "should raise an error if trying to literalize an invalid complex expression" do
-    ce = Sequel.+(:x, 1)
-    ce.instance_variable_set(:@op, :BANG)
+    ce = Sequel::SQL::ComplexExpression.allocate
+    ce.instance_eval do
+      @op = :BANG
+      @args = [:x, 1]
+    end
     proc{@d.lit(ce)}.must_raise(Sequel::InvalidOperation)
   end
 
@@ -489,7 +493,9 @@ describe "Blockless Ruby Filters" do
   end
 
   it "should handled emulated function where only name is emulated" do
-    dsc = Class.new(Sequel::Dataset)
+    db = Sequel.mock
+    db.extend_datasets{}
+    dsc = db.dataset_class
     efm = dsc::EMULATED_FUNCTION_MAP.dup
     dsc::EMULATED_FUNCTION_MAP[:trim] = :foo
     dsc.new(@d.db).literal(Sequel.trim(:a)).must_equal 'foo(a)'
@@ -509,12 +515,11 @@ end
 
 describe Sequel::SQL::VirtualRow do
   before do
-    db = Sequel::Database.new
-    db.quote_identifiers = true
-    @d = db[:items]
-    meta_def(@d, :supports_window_functions?){true}
-    def @d.l(*args, &block)
-      literal(filter_expr(*args, &block))
+    @d = Sequel.mock[:items].with_quote_identifiers(true).with_extend do
+      def supports_window_functions?; true end
+      def l(*args, &block)
+        literal(filter_expr(*args, &block))
+      end
     end
   end
 
@@ -626,9 +631,7 @@ describe Sequel::SQL::VirtualRow do
   end
 
   it "should raise an error if window functions are not supported" do
-    class << @d; remove_method :supports_window_functions? end
-    meta_def(@d, :supports_window_functions?){false}
-    proc{@d.l{count(:over, :* =>true, :partition=>a, :order=>b, :window=>:win, :frame=>:rows){}}}.must_raise(Sequel::Error)
+    proc{@d.with_extend{def supports_window_functions?; false end}.l{count(:over, :* =>true, :partition=>a, :order=>b, :window=>:win, :frame=>:rows){}}}.must_raise(Sequel::Error)
     proc{Sequel.mock.dataset.filter{count(:over, :* =>true, :partition=>a, :order=>b, :window=>:win, :frame=>:rows){}}.sql}.must_raise(Sequel::Error)
   end
   
@@ -670,19 +673,19 @@ describe Sequel::SQL::VirtualRow do
   end
 
   it "should handle quoted function names" do
-    def @d.supports_quoted_function_names?; true; end
+    @d = @d.with_extend{def supports_quoted_function_names?; true end}
     @d.l{rank.function}.must_equal '"rank"()' 
     @d.l{sch__rank.function}.must_equal '"sch"."rank"()' 
   end
 
   it "should quote function names if a quoted function is used and database supports quoted function names" do
-    def @d.supports_quoted_function_names?; true; end
+    @d = @d.with_extend{def supports_quoted_function_names?; true end}
     @d.l{rank{}.quoted}.must_equal '"rank"()' 
     @d.l{sch__rank{}.quoted}.must_equal '"sch__rank"()' 
   end
 
   it "should not quote function names if an unquoted function is used" do
-    def @d.supports_quoted_function_names?; true; end
+    @d = @d.with_extend{def supports_quoted_function_names?; true end}
     @d.l{rank.function.unquoted}.must_equal 'rank()' 
     @d.l{sch__rank.function.unquoted}.must_equal 'sch.rank()' 
   end
@@ -734,9 +737,8 @@ end
 
 describe "Sequel core extension replacements" do
   before do
-    @db = Sequel::Database.new
-    @ds = @db.dataset 
-    def @ds.supports_regexp?; true end
+    @db = Sequel.mock
+    @ds = @db.dataset.with_extend{def supports_regexp?; true end}
     @o = Object.new
     def @o.sql_literal(ds) 'foo' end
   end
@@ -1242,7 +1244,7 @@ describe "Sequel.delay" do
 
   it "should delay calling the block until literalization" do
     ds = Sequel.mock[:b].where(:a=>Sequel.delay{@o.a})
-    @o._a.must_equal nil
+    @o._a.must_be_nil
     ds.sql.must_equal "SELECT * FROM b WHERE (a = 1)"
     @o._a.must_equal 1
     ds.sql.must_equal "SELECT * FROM b WHERE (a = 2)"

data/spec/core/mock_adapter_spec.rb

@@ -39,6 +39,7 @@ describe "Sequel Mock Adapter" do
   end
 
   it "should have constructor accept no arguments" do
+    Sequel.require 'adapters/mock'
     Sequel::Mock::Database.new.must_be_kind_of(Sequel::Mock::Database)
   end
 
@@ -56,8 +57,8 @@ describe "Sequel Mock Adapter" do
   end
 
   it "should return nil for insert/execute_insert by default" do
-    Sequel.mock[:t].insert(:a=>1).must_equal nil
-    Sequel.mock.execute_insert('INSERT INTO a () DEFAULT VALUES').must_equal nil
+    Sequel.mock[:t].insert(:a=>1).must_be_nil
+    Sequel.mock.execute_insert('INSERT INTO a () DEFAULT VALUES').must_be_nil
   end
 
   it "should be able to set the rows returned by each using :fetch option with a single hash" do
@@ -149,13 +150,13 @@ describe "Sequel Mock Adapter" do
     proc{db[:t].all}.must_raise(Sequel::DatabaseError)
   end
 
-  it "should be able to set the rows returned by each on a per dataset basis using _fetch" do
+  it "should be able to set the rows returned by each on a per dataset basis using with_fetch" do
     rs = []
     db = Sequel.mock(:fetch=>{:a=>1})
     ds = db[:t]
     ds.each{|r| rs << r}
     rs.must_equal [{:a=>1}]
-    ds._fetch = {:b=>2}
+    ds = ds.with_fetch(:b=>2)
     ds.each{|r| rs << r}
     rs.must_equal [{:a=>1}, {:b=>2}]
   end
@@ -222,7 +223,7 @@ describe "Sequel Mock Adapter" do
     ds = db[:t]
     ds.update(:a=>1).must_equal 2
     ds.delete.must_equal 2
-    ds.numrows = 3
+    ds = ds.with_numrows(3)
     ds.update(:a=>1).must_equal 3
     ds.delete.must_equal 3
   end
@@ -246,7 +247,7 @@ describe "Sequel Mock Adapter" do
     db[:t].insert(:a=>1).must_equal 1
     db[:t].insert(:a=>1).must_equal 3
     db[:t].insert(:a=>1).must_equal 5
-    db[:t].insert(:a=>1).must_equal nil
+    db[:t].insert(:a=>1).must_be_nil
   end
 
   it "should be able to set the autogenerated primary key returned by insert using :autoid option as a proc" do
@@ -272,7 +273,7 @@ describe "Sequel Mock Adapter" do
     db = Sequel.mock(:autoid=>[1, proc{|s| 2}, nil, ArgumentError])
     db[:t].insert.must_equal 1
     db[:t].insert.must_equal 2
-    db[:t].insert.must_equal nil
+    db[:t].insert.must_be_nil
     proc{db[:t].insert}.must_raise(Sequel::DatabaseError)
   end
 
@@ -288,7 +289,7 @@ describe "Sequel Mock Adapter" do
     db = Sequel.mock(:autoid=>1)
     ds = db[:t]
     ds.insert(:a=>1).must_equal 1
-    ds.autoid = 5
+    ds = ds.with_autoid(5)
     ds.insert(:a=>1).must_equal 5
     ds.insert(:a=>1).must_equal 6
     db[:t].insert(:a=>1).must_equal 2
@@ -335,14 +336,13 @@ describe "Sequel Mock Adapter" do
 
   it "should allow overriding of server_version" do
     db = Sequel.mock
-    db.server_version.must_equal nil
+    db.server_version.must_be_nil
     db.server_version = 80102
     db.server_version.must_equal 80102
   end
 
-  it "should not have identifier input/output methods by default" do
-    Sequel.mock.send(:identifier_input_method_default).must_equal nil
-    Sequel.mock.send(:identifier_output_method_default).must_equal nil
+  it "should not fold to uppercase by default" do
+    Sequel.mock.send(:folds_unquoted_identifiers_to_uppercase?).must_equal false
   end
 
   it "should keep a record of all executed SQL in #sqls" do
@@ -449,29 +449,21 @@ describe "Sequel Mock Adapter" do
   end
 
   it "should be able to load dialects based on the database name" do
-    begin
-      qi = class Sequel::Database; @quote_identifiers; end
-      ii = class Sequel::Database; @identifier_input_method; end
-      io = class Sequel::Database; @identifier_output_method; end
-      Sequel.quote_identifiers = nil
-      class Sequel::Database; @identifier_input_method=nil; end
-      class Sequel::Database; @identifier_output_method=nil; end
-      Sequel.mock(:host=>'access').select(Date.new(2011, 12, 13)).sql.must_equal 'SELECT #2011-12-13#'
-      Sequel.mock(:host=>'cubrid').from(:a).offset(1).sql.must_equal 'SELECT * FROM "a" LIMIT 1,4294967295'
-      Sequel.mock(:host=>'db2').select(1).sql.must_equal 'SELECT 1 FROM "SYSIBM"."SYSDUMMY1"'
-      Sequel.mock(:host=>'firebird')[:a].distinct.limit(1, 2).sql.must_equal 'SELECT DISTINCT FIRST 1 SKIP 2 * FROM "A"'
-      Sequel.mock(:host=>'informix')[:a].distinct.limit(1, 2).sql.must_equal 'SELECT SKIP 2 FIRST 1 DISTINCT * FROM A'
-      Sequel.mock(:host=>'mssql')[:a].full_text_search(:b, 'c').sql.must_equal "SELECT * FROM [A] WHERE (CONTAINS ([B], 'c'))"
-      Sequel.mock(:host=>'mysql')[:a].full_text_search(:b, 'c').sql.must_equal "SELECT * FROM `a` WHERE (MATCH (`b`) AGAINST ('c'))"
-      Sequel.mock(:host=>'oracle')[:a].limit(1).sql.must_equal 'SELECT * FROM (SELECT * FROM "A") "T1" WHERE (ROWNUM <= 1)'
-      Sequel.mock(:host=>'postgres')[:a].full_text_search(:b, 'c').sql.must_equal "SELECT * FROM \"a\" WHERE (to_tsvector(CAST('simple' AS regconfig), (COALESCE(\"b\", ''))) @@ to_tsquery(CAST('simple' AS regconfig), 'c'))"
-      Sequel.mock(:host=>'sqlanywhere').from(:a).offset(1).sql.must_equal 'SELECT TOP 2147483647 START AT (1 + 1) * FROM "A"'
-      Sequel.mock(:host=>'sqlite')[:a___b].sql.must_equal "SELECT * FROM `a` AS 'b'"
-    ensure
-      Sequel.quote_identifiers = qi
-      Sequel::Database.send(:instance_variable_set, :@identifier_input_method, ii)
-      Sequel::Database.send(:instance_variable_set, :@identifier_output_method, io)
-    end
+    Sequel.mock(:host=>'access').select(Date.new(2011, 12, 13)).sql.must_equal 'SELECT #2011-12-13#'
+    Sequel.mock(:host=>'cubrid').from(:a).offset(1).with_quote_identifiers(false).sql.must_equal 'SELECT * FROM a LIMIT 1,4294967295'
+    Sequel.mock(:host=>'db2').select(1).sql.must_equal 'SELECT 1 FROM "SYSIBM"."SYSDUMMY1"'
+    Sequel.mock(:host=>'firebird')[:A].distinct.limit(1, 2).with_quote_identifiers(false).sql.must_equal 'SELECT DISTINCT FIRST 1 SKIP 2 * FROM A'
+    Sequel.mock(:host=>'informix')[:a].distinct.limit(1, 2).sql.upcase.must_equal 'SELECT SKIP 2 FIRST 1 DISTINCT * FROM A'
+    Sequel.mock(:host=>'mssql', :identifier_mangling=>false)[:A].full_text_search(:B, 'C').with_quote_identifiers(false).sql.must_equal "SELECT * FROM A WHERE (CONTAINS (B, 'C'))"
+    Sequel.mock(:host=>'mysql')[:a].full_text_search(:b, 'c').with_quote_identifiers(false).sql.must_equal "SELECT * FROM a WHERE (MATCH (b) AGAINST ('c'))"
+    Sequel.mock(:host=>'oracle')[:a].limit(1).with_quote_identifiers(false).sql.upcase.must_equal 'SELECT * FROM (SELECT * FROM A) T1 WHERE (ROWNUM <= 1)'
+    Sequel.mock(:host=>'postgres')[:a].full_text_search(:b, 'c').with_quote_identifiers(false).sql.must_equal "SELECT * FROM a WHERE (to_tsvector(CAST('simple' AS regconfig), (COALESCE(b, ''))) @@ to_tsquery(CAST('simple' AS regconfig), 'c'))"
+    Sequel.mock(:host=>'sqlanywhere').from(:A).offset(1).with_quote_identifiers(false).sql.must_equal 'SELECT TOP 2147483647 START AT (1 + 1) * FROM A'
+    Sequel.mock(:host=>'sqlite')[:a___b].with_quote_identifiers(false).sql.must_equal "SELECT * FROM a AS 'b'"
+  end
+
+  it "should be able to mock schema calls" do
+    Sequel.mock(:host=>'mysql', :fetch=>{:Field=>'a'}).schema(:a).first.first.must_equal :a
   end
 
   it "should automatically set version for adapters needing versions" do

data/spec/core/placeholder_literalizer_spec.rb

@@ -87,7 +87,7 @@ describe "Dataset::PlaceholderLiteralizer" do
   end
   
   it "should handle dataset with row procs" do
-    @ds.row_proc = proc{|r| {:foo=>r[:id]+1}}
+    @ds = @ds.with_row_proc(proc{|r| {:foo=>r[:id]+1}})
     loader = @c.loader(@ds){|pl, ds| ds.where(:a=>pl.arg)}
     loader.first(1).must_equal(:foo=>2)
     @db.sqls.must_equal ["SELECT * FROM items WHERE (a = 1)"]
@@ -124,9 +124,7 @@ describe "Dataset::PlaceholderLiteralizer" do
   it "should support modifying dataset used on per-call basis with #run" do
     loader = @c.loader(@ds){|pl, ds| ds.where(:a=>pl.arg)}
     loader.with_dataset do |ds|
-      ds = ds.clone
-      ds.row_proc = lambda{|row| [row]}
-      ds
+      ds.with_row_proc(lambda{|row| [row]})
     end.all(1).must_equal [[@h]]
     @db.sqls.must_equal ["SELECT * FROM items WHERE (a = 1)"]
   end

data/spec/core/schema_generator_spec.rb

@@ -27,7 +27,7 @@ describe Sequel::Schema::Generator do
     @columns.first[:name].must_equal :id
     @columns.first[:primary_key].must_equal true
     @columns[3][:name].must_equal :parent_id
-    @columns[3][:primary_key].must_equal nil
+    @columns[3][:primary_key].must_be_nil
   end
   
   it "should respect existing column order if primary_key :keep_order is used" do
@@ -40,7 +40,7 @@ describe Sequel::Schema::Generator do
     columns.last[:name].must_equal :id
     columns.last[:primary_key].must_equal true
     columns.first[:name].must_equal :title
-    columns.first[:primary_key].must_equal nil
+    columns.first[:primary_key].must_be_nil
   end
   
   it "should handle SQL::Identifier and SQL::QualifiedIdentifier as foreign_key arguments" do
@@ -85,7 +85,7 @@ describe Sequel::Schema::Generator do
   end
   
   it "uses table for foreign key columns, if specified" do
-    @columns[3][:table].must_equal nil
+    @columns[3][:table].must_be_nil
     @columns[4][:table].must_equal :nodes
     @constraints[3][:table].must_equal :nodes_props
   end
@@ -98,7 +98,7 @@ describe Sequel::Schema::Generator do
   end
   
   it "creates constraints" do
-    @constraints[0][:name].must_equal nil
+    @constraints[0][:name].must_be_nil
     @constraints[0][:type].must_equal :check
     @constraints[0][:check].must_equal ['price > 100']
 

data/spec/core/schema_spec.rb

@@ -384,11 +384,10 @@ describe "DB#create_table" do
   end
 
   it "should accept collation" do
-    @db.quote_identifiers = true
     @db.create_table(:cats) do
       String :name, :collate => :utf8_bin
     end
-    @db.sqls.must_equal ['CREATE TABLE "cats" ("name" varchar(255) COLLATE utf8_bin)']
+    @db.sqls.must_equal ['CREATE TABLE cats (name varchar(255) COLLATE utf8_bin)']
   end
 
   it "should accept collation as a String, treated literally" do

data/spec/core_extensions_spec.rb

@@ -33,14 +33,15 @@ end
 
 describe "Core extensions" do
   before do
-    db = Sequel::Database.new
-    @d = db[:items]
-    def @d.supports_regexp?; true end
-    def @d.l(*args, &block)
-      literal(filter_expr(*args, &block))
-    end
-    def @d.lit(*args)
-      literal(*args)
+    db = Sequel.mock
+    @d = db[:items].with_extend do
+      def supports_regexp?; true end
+      def l(*args, &block)
+        literal(filter_expr(*args, &block))
+      end
+      def lit(*args)
+        literal(*args)
+      end
     end
   end
   
@@ -316,7 +317,7 @@ end
 
 describe "String#lit" do
   before do
-    @ds = Sequel::Database.new[:t]
+    @ds = Sequel.mock[:t]
   end
 
   it "should return an LiteralString object" do
@@ -332,16 +333,14 @@ describe "String#lit" do
     a = 'DISTINCT ?'.lit(:a)
     a.must_be_kind_of(Sequel::SQL::PlaceholderLiteralString)
     @ds.literal(a).must_equal 'DISTINCT a'
-    @ds.quote_identifiers = true
-    @ds.literal(a).must_equal 'DISTINCT "a"'
+    @ds.with_quote_identifiers(true).literal(a).must_equal 'DISTINCT "a"'
   end
   
   it "should handle named placeholders if given a single argument hash" do
     a = 'DISTINCT :b'.lit(:b=>:a)
     a.must_be_kind_of(Sequel::SQL::PlaceholderLiteralString)
     @ds.literal(a).must_equal 'DISTINCT a'
-    @ds.quote_identifiers = true
-    @ds.literal(a).must_equal 'DISTINCT "a"'
+    @ds.with_quote_identifiers(true).literal(a).must_equal 'DISTINCT "a"'
   end
 
   it "should treat placeholder literal strings as generic expressions" do
@@ -445,11 +444,7 @@ end
 
 describe "Column references" do
   before do
-    @ds = Sequel::Database.new.dataset
-    def @ds.quoted_identifier_append(sql, c)
-      sql << "`#{c}`"
-    end
-    @ds.quote_identifiers = true
+    @ds = Sequel.mock.dataset.with_quote_identifiers(true).with_extend{def quoted_identifier_append(sql, c) sql << "`#{c}`" end}
   end
   
   it "should be quoted properly" do
@@ -520,30 +515,28 @@ end
 
 describe "Symbol" do
   before do
-    @ds = Sequel.mock.dataset
-    @ds.quote_identifiers = true
-    @ds.identifier_input_method = :upcase
+    @ds = Sequel.mock.dataset.with_quote_identifiers(true)
   end
 
   it "#identifier should format an identifier" do
-    @ds.literal(:xyz__abc.identifier).must_equal '"XYZ__ABC"'
+    @ds.literal(:xyz__abc.identifier).must_equal '"xyz__abc"'
   end
 
   it "#qualify should format a qualified column" do
-    @ds.literal(:xyz.qualify(:abc)).must_equal '"ABC"."XYZ"'
+    @ds.literal(:xyz.qualify(:abc)).must_equal '"abc"."xyz"'
   end
 
   it "#qualify should work on QualifiedIdentifiers" do
-    @ds.literal(:xyz.qualify(:abc).qualify(:def)).must_equal '"DEF"."ABC"."XYZ"'
+    @ds.literal(:xyz.qualify(:abc).qualify(:def)).must_equal '"def"."abc"."xyz"'
   end
 
   it "should be able to qualify an identifier" do
-    @ds.literal(:xyz.identifier.qualify(:xyz__abc)).must_equal '"XYZ"."ABC"."XYZ"'
+    @ds.literal(:xyz.identifier.qualify(:xyz__abc)).must_equal '"xyz"."abc"."xyz"'
   end
 
   it "should be able to specify a schema.table.column" do
-    @ds.literal(:column.qualify(:table.qualify(:schema))).must_equal '"SCHEMA"."TABLE"."COLUMN"'
-    @ds.literal(:column.qualify(:table__name.identifier.qualify(:schema))).must_equal '"SCHEMA"."TABLE__NAME"."COLUMN"'
+    @ds.literal(:column.qualify(:table.qualify(:schema))).must_equal '"schema"."table"."column"'
+    @ds.literal(:column.qualify(:table__name.identifier.qualify(:schema))).must_equal '"schema"."table__name"."column"'
   end
 
   it "should be able to specify order" do
@@ -558,13 +551,13 @@ describe "Symbol" do
   it "should work correctly with objects" do
     o = Object.new
     def o.sql_literal(ds) "(foo)" end
-    @ds.literal(:column.qualify(o)).must_equal '(foo)."COLUMN"'
+    @ds.literal(:column.qualify(o)).must_equal '(foo)."column"'
   end
 end
 
 describe "Symbol" do
   before do
-    @ds = Sequel::Database.new.dataset
+    @ds = Sequel.mock.dataset
   end
   
   it "should support sql_function method" do