sequel 4.49.0 → 5.3.0

data/spec/extensions/_deprecated_identifier_mangling_spec.rb

@@ -1,314 +0,0 @@
-require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
-
-describe "identifier_mangling extension" do
-  after do
-    deprecated do
-      Sequel.quote_identifiers = false
-      Sequel.identifier_input_method = nil
-      Sequel.identifier_output_method = nil
-    end
-  end
-  
-  deprecated "should respect the :quote_identifiers option" do
-    db = Sequel::Database.new(:quote_identifiers=>false, :identifier_mangling=>true)
-    db.quote_identifiers?.must_equal false
-    db = Sequel::Database.new(:quote_identifiers=>true, :identifier_mangling=>true)
-    db.quote_identifiers?.must_equal true
-  end
-
-  deprecated "should respect the :quote_identifiers setting" do
-    db = Sequel::Database.new(:identifier_mangling=>true)
-    db.quote_identifiers?.must_equal false
-    db.quote_identifiers = true
-    db.quote_identifiers?.must_equal true
-  end
-
-  deprecated "should upcase on input and downcase on output by default" do
-    db = Sequel::Database.new(:identifier_mangling=>true)
-    db.send(:identifier_input_method_default).must_equal :upcase
-    db.send(:identifier_output_method_default).must_equal :downcase
-  end
-
-  deprecated "should respect the :identifier_input_method option" do
-    Sequel.identifier_input_method = nil
-    Sequel::Database.identifier_input_method.must_equal false
-    db = Sequel::Database.new(:identifier_input_method=>nil, :identifier_mangling=>true)
-    db.identifier_input_method.must_be_nil
-    db.identifier_input_method = :downcase
-    db.identifier_input_method.must_equal :downcase
-    db = Sequel::Database.new(:identifier_input_method=>:upcase, :identifier_mangling=>true)
-    db.identifier_input_method.must_equal :upcase
-    db.identifier_input_method = nil
-    db.identifier_input_method.must_be_nil
-    Sequel.identifier_input_method = :downcase
-    Sequel::Database.identifier_input_method.must_equal :downcase
-    db = Sequel::Database.new(:identifier_input_method=>nil, :identifier_mangling=>true)
-    db.identifier_input_method.must_be_nil
-    db.identifier_input_method = :upcase
-    db.identifier_input_method.must_equal :upcase
-    db = Sequel::Database.new(:identifier_input_method=>:upcase, :identifier_mangling=>true)
-    db.identifier_input_method.must_equal :upcase
-    db.identifier_input_method = nil
-    db.identifier_input_method.must_be_nil
-  end
-  
-  deprecated "should respect the :identifier_output_method option" do
-    Sequel.identifier_output_method = nil
-    Sequel::Database.identifier_output_method.must_equal false
-    db = Sequel::Database.new(:identifier_output_method=>nil, :identifier_mangling=>true)
-    db.identifier_output_method.must_be_nil
-    db.identifier_output_method = :downcase
-    db.identifier_output_method.must_equal :downcase
-    db = Sequel::Database.new(:identifier_output_method=>:upcase, :identifier_mangling=>true)
-    db.identifier_output_method.must_equal :upcase
-    db.identifier_output_method = nil
-    db.identifier_output_method.must_be_nil
-    Sequel.identifier_output_method = :downcase
-    Sequel::Database.identifier_output_method.must_equal :downcase
-    db = Sequel::Database.new(:identifier_output_method=>nil, :identifier_mangling=>true)
-    db.identifier_output_method.must_be_nil
-    db.identifier_output_method = :upcase
-    db.identifier_output_method.must_equal :upcase
-    db = Sequel::Database.new(:identifier_output_method=>:upcase, :identifier_mangling=>true)
-    db.identifier_output_method.must_equal :upcase
-    db.identifier_output_method = nil
-    db.identifier_output_method.must_be_nil
-  end
-
-  deprecated "should use the default Sequel.quote_identifiers value" do
-    Sequel.quote_identifiers = true
-    Sequel::Database.new(:identifier_mangling=>true).quote_identifiers?.must_equal true
-    Sequel.quote_identifiers = false
-    Sequel::Database.new(:identifier_mangling=>true).quote_identifiers?.must_equal false
-    Sequel::Database.quote_identifiers = true
-    Sequel::Database.new(:identifier_mangling=>true).quote_identifiers?.must_equal true
-    Sequel::Database.quote_identifiers = false
-    Sequel::Database.new(:identifier_mangling=>true).quote_identifiers?.must_equal false
-  end
-
-  deprecated "should use the default Sequel.identifier_input_method value" do
-    Sequel.identifier_input_method = :downcase
-    Sequel::Database.new(:identifier_mangling=>true).identifier_input_method.must_equal :downcase
-    Sequel.identifier_input_method = :upcase
-    Sequel::Database.new(:identifier_mangling=>true).identifier_input_method.must_equal :upcase
-    Sequel::Database.identifier_input_method = :downcase
-    Sequel::Database.new(:identifier_mangling=>true).identifier_input_method.must_equal :downcase
-    Sequel::Database.identifier_input_method = :upcase
-    Sequel::Database.new(:identifier_mangling=>true).identifier_input_method.must_equal :upcase
-  end
-  
-  deprecated "should use the default Sequel.identifier_output_method value" do
-    Sequel.identifier_output_method = :downcase
-    Sequel::Database.new(:identifier_mangling=>true).identifier_output_method.must_equal :downcase
-    Sequel.identifier_output_method = :upcase
-    Sequel::Database.new(:identifier_mangling=>true).identifier_output_method.must_equal :upcase
-    Sequel::Database.identifier_output_method = :downcase
-    Sequel::Database.new(:identifier_mangling=>true).identifier_output_method.must_equal :downcase
-    Sequel::Database.identifier_output_method = :upcase
-    Sequel::Database.new(:identifier_mangling=>true).identifier_output_method.must_equal :upcase
-  end
-
-  deprecated "should respect the quote_indentifiers_default method if Sequel.quote_identifiers = nil" do
-    Sequel.quote_identifiers = nil
-    Sequel::Database.new(:identifier_mangling=>true).quote_identifiers?.must_equal true
-    x = Class.new(Sequel::Database){def dataset_class_default; Sequel::Dataset end; def quote_identifiers_default; false end}
-    x.new(:identifier_mangling=>true).quote_identifiers?.must_equal false
-    y = Class.new(Sequel::Database){def dataset_class_default; Sequel::Dataset end; def quote_identifiers_default; true end}
-    y.new(:identifier_mangling=>true).quote_identifiers?.must_equal true
-  end
-  
-  deprecated "should respect the identifier_input_method_default method if Sequel.identifier_input_method is not called" do
-    class Sequel::Database
-      @identifier_input_method = nil
-    end
-    x = Class.new(Sequel::Database){def dataset_class_default; Sequel::Dataset end; def identifier_input_method_default; :downcase end}
-    x.new(:identifier_mangling=>true).identifier_input_method.must_equal :downcase
-    y = Class.new(Sequel::Database){def dataset_class_default; Sequel::Dataset end; def identifier_input_method_default; :camelize end}
-    y.new(:identifier_mangling=>true).identifier_input_method.must_equal :camelize
-  end
-  
-  deprecated "should respect the identifier_output_method_default method if Sequel.identifier_output_method is not called" do
-    class Sequel::Database
-      @identifier_output_method = nil
-    end
-    x = Class.new(Sequel::Database){def dataset_class_default; Sequel::Dataset end; def identifier_output_method_default; :upcase end}
-    x.new(:identifier_mangling=>true).identifier_output_method.must_equal :upcase
-    y = Class.new(Sequel::Database){def dataset_class_default; Sequel::Dataset end; def identifier_output_method_default; :underscore end}
-    y.new(:identifier_mangling=>true).identifier_output_method.must_equal :underscore
-  end
-end
-
-describe "Database#input_identifier_meth" do
-  deprecated "should be the input_identifer method of a default dataset for this database" do
-    db = Sequel::Database.new(:identifier_mangling=>true)
-    db.send(:input_identifier_meth).call(:a).must_equal 'a'
-    db.identifier_input_method = :upcase
-    db.send(:input_identifier_meth).call(:a).must_equal 'A'
-  end
-end
-
-describe "Database#output_identifier_meth" do
-  deprecated "should be the output_identifer method of a default dataset for this database" do
-    db = Sequel::Database.new(:identifier_mangling=>true)
-    db.send(:output_identifier_meth).call('A').must_equal :A
-    db.identifier_output_method = :downcase
-    db.send(:output_identifier_meth).call('A').must_equal :a
-  end
-end
-
-describe "Database#metadata_dataset" do
-  deprecated "should be a dataset with the default settings for identifier_mangling" do
-    ds = Sequel::Database.new(:identifier_mangling=>true).send(:metadata_dataset)
-    ds.literal(:a).must_equal 'A'
-    ds.send(:output_identifier, 'A').must_equal :a
-  end
-end
-
-describe "Dataset" do
-  before do
-    @dataset = Sequel.mock(:identifier_mangling=>true).dataset
-  end
-  
-  deprecated "should get quote_identifiers default from database" do
-    db = Sequel::Database.new(:quote_identifiers=>true, :identifier_mangling=>true)
-    db[:a].quote_identifiers?.must_equal true
-    db = Sequel::Database.new(:quote_identifiers=>false, :identifier_mangling=>true)
-    db[:a].quote_identifiers?.must_equal false
-  end
-
-  deprecated "should get identifier_input_method default from database" do
-    db = Sequel::Database.new(:identifier_input_method=>:upcase, :identifier_mangling=>true)
-    db[:a].identifier_input_method.must_equal :upcase
-    db = Sequel::Database.new(:identifier_input_method=>:downcase, :identifier_mangling=>true)
-    db[:a].identifier_input_method.must_equal :downcase
-  end
-
-  deprecated "should get identifier_output_method default from database" do
-    db = Sequel::Database.new(:identifier_output_method=>:upcase, :identifier_mangling=>true)
-    db[:a].identifier_output_method.must_equal :upcase
-    db = Sequel::Database.new(:identifier_output_method=>:downcase, :identifier_mangling=>true)
-    db[:a].identifier_output_method.must_equal :downcase
-  end
-  
-  # SEQUEL5: Remove
-  unless Sequel.mock(:identifier_mangling=>true).dataset.frozen?
-    deprecated "should have quote_identifiers= method which changes literalization of identifiers" do
-      @dataset.quote_identifiers = true
-      @dataset.literal(:a).must_equal '"a"'
-      @dataset.quote_identifiers = false
-      @dataset.literal(:a).must_equal 'a'
-    end
-    
-    deprecated "should have identifier_input_method= method which changes literalization of identifiers" do
-      @dataset.identifier_input_method = :upcase
-      @dataset.literal(:a).must_equal 'A'
-      @dataset.identifier_input_method = :downcase
-      @dataset.literal(:A).must_equal 'a'
-      @dataset.identifier_input_method = :reverse
-      @dataset.literal(:at_b).must_equal 'b_ta'
-    end
-    
-    deprecated "should have identifier_output_method= method which changes identifiers returned from the database" do
-      @dataset.send(:output_identifier, "at_b_C").must_equal :at_b_C
-      @dataset.identifier_output_method = :upcase
-      @dataset.send(:output_identifier, "at_b_C").must_equal :AT_B_C
-      @dataset.identifier_output_method = :downcase
-      @dataset.send(:output_identifier, "at_b_C").must_equal :at_b_c
-      @dataset.identifier_output_method = :reverse
-      @dataset.send(:output_identifier, "at_b_C").must_equal :C_b_ta
-    end
-  end
-  
-  deprecated "should have with_quote_identifiers method which returns cloned dataset with changed literalization of identifiers" do
-    @dataset.with_quote_identifiers(true).literal(:a).must_equal '"a"'
-    @dataset.with_quote_identifiers(false).literal(:a).must_equal 'a'
-    ds = @dataset.freeze.with_quote_identifiers(false)
-    ds.literal(:a).must_equal 'a'
-    ds.frozen?.must_equal true
-  end
-  
-  deprecated "should have with_identifier_input_method method which returns cloned dataset with changed literalization of identifiers" do
-    @dataset.with_identifier_input_method(:upcase).literal(:a).must_equal 'A'
-    @dataset.with_identifier_input_method(:downcase).literal(:A).must_equal 'a'
-    @dataset.with_identifier_input_method(:reverse).literal(:at_b).must_equal 'b_ta'
-    ds = @dataset.freeze.with_identifier_input_method(:reverse)
-    ds.frozen?.must_equal true
-    ds.literal(:at_b).must_equal 'b_ta'
-  end
-  
-  deprecated "should have with_identifier_output_method method which returns cloned dataset with changed identifiers returned from the database" do
-    @dataset.send(:output_identifier, "at_b_C").must_equal :at_b_C
-    @dataset.with_identifier_output_method(:upcase).send(:output_identifier, "at_b_C").must_equal :AT_B_C
-    @dataset.with_identifier_output_method(:downcase).send(:output_identifier, "at_b_C").must_equal :at_b_c
-    @dataset.with_identifier_output_method(:reverse).send(:output_identifier, "at_b_C").must_equal :C_b_ta
-    ds = @dataset.freeze.with_identifier_output_method(:reverse)
-    ds.send(:output_identifier, "at_b_C").must_equal :C_b_ta
-    ds.frozen?.must_equal true
-  end
-  
-  deprecated "should have output_identifier handle empty identifiers" do
-    @dataset.send(:output_identifier, "").must_equal :untitled
-    @dataset.with_identifier_output_method(:upcase).send(:output_identifier, "").must_equal :UNTITLED
-    @dataset.with_identifier_output_method(:downcase).send(:output_identifier, "").must_equal :untitled
-    @dataset.with_identifier_output_method(:reverse).send(:output_identifier, "").must_equal :deltitnu
-  end
-end
-
-describe "Frozen Datasets" do
-  before do
-    @ds = Sequel.mock(:identifier_mangling=>true)[:test].freeze
-  end
-
-  deprecated "should raise an error when calling mutation methods" do
-    proc{@ds.identifier_input_method = :a}.must_raise RuntimeError
-    proc{@ds.identifier_output_method = :a}.must_raise RuntimeError
-    proc{@ds.quote_identifiers = false}.must_raise RuntimeError
-  end
-end
-
-describe "identifier_mangling extension" do
-  deprecated "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=>'db2').select(1).sql.must_equal 'SELECT 1 FROM "SYSIBM"."SYSDUMMY1"'
-      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
-  end
-end
-
-describe Sequel::Model, ".[] optimization" do
-  before do
-    @db = Sequel.mock(:identifier_mangling=>true, :quote_identifiers=>true)
-    def @db.schema(*) [[:id, {:primary_key=>true}]] end
-    def @db.supports_schema_parsing?() true end
-    @c = Class.new(Sequel::Model(@db))
-    @ds = @db.dataset.with_quote_identifiers(true)
-  end
-
-  deprecated "should have simple_pk and simple_table respect dataset's identifier input methods" do
-    ds = @db.from(:ab).with_identifier_input_method(:reverse)
-    @c.set_dataset ds
-    @c.simple_table.must_equal '"ba"'
-    @c.set_primary_key :cd
-    @c.simple_pk.must_equal '"dc"'
-
-    @c.set_dataset ds.from(:ef__gh)
-    @c.simple_table.must_equal '"fe"."hg"'
-  end
-end
-

data/spec/extensions/before_after_save_spec.rb

@@ -1,40 +0,0 @@
-require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
-
-describe "Sequel::Plugins::BeforeAfterSave" do
-  before do
-    @db = Sequel.mock(:numrows=>1, :fetch=>{:id=>1, :name=>'b'})
-    @c = Class.new(Sequel::Model(@db[:test]))
-    @ds = @c.dataset
-    @c.columns :id, :name
-    @c.plugin :before_after_save
-    @c.plugin :instance_hooks
-    @o = @c.new
-    @db.sqls
-  end
-
-  it "should reset modified flag before calling after hooks" do
-    a = []
-    @o.after_create_hook{@o.modified?.must_equal false; a << 1}
-    @o.after_save_hook{@o.modified?.must_equal false; a << 2}
-
-    @o.modified!
-    @o.save
-    a.must_equal [1, 2]
-
-    @o.after_save_hook{@o.modified?.must_equal false; a << 2}
-    @o.after_update_hook{@o.modified?.must_equal false; a << 3}
-    a = []
-    @o.modified!
-    @o.save
-    a.must_equal [3, 2]
-  end
-
-  it "should refresh the instance before calling after hooks" do
-    a = []
-    @o.after_create_hook{@o.values.must_equal(:id=>1, :name=>'b'); a << 1}
-    @o.after_save_hook{@o.values.must_equal(:id=>1, :name=>'b'); a << 2}
-
-    @o.save
-    a.must_equal [1, 2]
-  end
-end

data/spec/extensions/filter_having_spec.rb

@@ -1,42 +0,0 @@
-require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
-
-describe "filter_having extension" do
-  before do
-    deprecated do
-      @ds = Sequel.mock[:t].extension(:filter_having)
-    end
-    @dsh = @ds.having(:a)
-  end
-
-  it "should make filter operate on HAVING clause if dataset has a HAVING clause" do
-    @dsh.filter(:b).sql.must_equal 'SELECT * FROM t HAVING (a AND b)'
-  end
-
-  it "should make filter operate on WHERE clause if dataset does not have a HAVING clause" do
-    @ds.filter(:b).sql.must_equal 'SELECT * FROM t WHERE b'
-  end
-
-  deprecated "should make and operate on HAVING clause if dataset has a HAVING clause" do
-    @dsh.and(:b).sql.must_equal 'SELECT * FROM t HAVING (a AND b)'
-  end
-
-  deprecated "should make and operate on WHERE clause if dataset does not have a HAVING clause" do
-    @ds.where(:a).and(:b).sql.must_equal 'SELECT * FROM t WHERE (a AND b)'
-  end
-
-  it "should make or operate on HAVING clause if dataset has a HAVING clause" do
-    @dsh.or(:b).sql.must_equal 'SELECT * FROM t HAVING (a OR b)'
-  end
-
-  it "should make or operate on WHERE clause if dataset does not have a HAVING clause" do
-    @ds.where(:a).or(:b).sql.must_equal 'SELECT * FROM t WHERE (a OR b)'
-  end
-
-  it "should make exclude operate on HAVING clause if dataset has a HAVING clause" do
-    @dsh.exclude(:b).sql.must_equal 'SELECT * FROM t HAVING (a AND NOT b)'
-  end
-
-  it "should make exclude operate on WHERE clause if dataset does not have a HAVING clause" do
-    @ds.exclude(:b).sql.must_equal 'SELECT * FROM t WHERE NOT b'
-  end
-end

data/spec/extensions/from_block_spec.rb

@@ -1,21 +0,0 @@
-require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
-
-describe "from_block extension" do
-  before do
-    @db = Sequel.mock
-    @db.extension(:from_block)
-  end
-
-  it "should make Database#from blocks apply to FROM" do
-    @db.from{f}.sql.must_equal 'SELECT * FROM f'
-    @db.from{[f, g(f)]}.sql.must_equal 'SELECT * FROM f, g(f)'
-  end
-
-  it "should handle from blocks with method arguments" do
-    @db.from(:f){g(f)}.sql.must_equal 'SELECT * FROM f, g(f)'
-  end
-
-  it "should handle from without block" do
-    @db.from(:f).sql.must_equal 'SELECT * FROM f'
-  end
-end

data/spec/extensions/hash_aliases_spec.rb

@@ -1,26 +0,0 @@
-require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
-
-describe "hash_aliases extension" do
-  before do
-    deprecated do
-      @ds = Sequel.mock.dataset.extension(:hash_aliases)
-    end
-  end
-
-  it "should make from treat hash arguments as alias specifiers" do
-    @ds.from(:a=>:b).sql.must_equal "SELECT * FROM a AS b"
-  end
-
-  it "should not affect other arguments to from" do
-    @ds.from(:a, :b).sql.must_equal "SELECT * FROM a, b"
-  end
-
-  it "should make select treat hash arguments as alias specifiers" do
-    @ds.select(:a=>:b).sql.must_equal "SELECT a AS b"
-    @ds.select{{:a=>:b}}.sql.must_equal "SELECT a AS b"
-  end
-
-  it "should not affect other arguments to select" do
-    @ds.select(:a, :b).sql.must_equal "SELECT a, b"
-  end
-end

data/spec/extensions/identifier_columns_spec.rb

@@ -1,19 +0,0 @@
-require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
-
-describe "identifier_columns plugin" do
-  before do
-    @db = Sequel.mock(:numrows=>1, :fetch=>{:id=>1, :a__b=>2}, :autoid=>1)
-    @c = Class.new(Sequel::Model(@db[:test]))
-    @ds = @c.dataset
-    @c.columns :id, :a__b
-    deprecated do
-      @c.plugin :identifier_columns
-    end
-    @db.sqls
-  end
-
-  it "should not use qualification when updating or inserting values" do
-    @c.create(:a__b=>2).save
-    @db.sqls.must_equal ["INSERT INTO test (a__b) VALUES (2)", "SELECT * FROM test WHERE (id = 1) LIMIT 1", "UPDATE test SET a__b = 2 WHERE (id = 1)"]
-  end
-end

data/spec/extensions/meta_def_spec.rb

@@ -1,35 +0,0 @@
-require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
-
-describe "Sequel::Metaprogramming" do
-  before do
-    deprecated do
-      Sequel.extension :meta_def
-    end
-  end
-  after do
-    Sequel::Metaprogramming.send(:remove_method, :meta_def)
-  end
-
-  it "should add meta_def method to Database, Dataset, and Model classes and instances" do
-    Sequel::Database.meta_def(:foo){1}
-    Sequel::Database.foo.must_equal 1
-    Sequel::Dataset.meta_def(:foo){2}
-    Sequel::Dataset.foo.must_equal 2
-    Sequel::Model.meta_def(:foo){3}
-    Sequel::Model.foo.must_equal 3
-    o = Sequel::Database.new
-    o.meta_def(:foo){4}
-    o.foo.must_equal 4
-    
-    o = o[:a]
-    # SEQUEL5: Remove
-    unless o.frozen?
-      o.meta_def(:foo){5}
-      o.foo.must_equal 5
-    end
-
-    o = Sequel::Model.new
-    o.meta_def(:foo){6}
-    o.foo.must_equal 6
-  end
-end

data/spec/extensions/no_auto_literal_strings_spec.rb

@@ -1,69 +0,0 @@
-require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
-
-describe "no_auto_literal_strings extension" do
-  before do
-    @ds = Sequel.mock[:t].extension(:no_auto_literal_strings)
-  end
-
-  it "should raise exception for plain strings in filter methods" do
-    proc{@ds.where("a")}.must_raise Sequel::Error
-    proc{@ds.having("a")}.must_raise Sequel::Error
-    proc{@ds.filter("a")}.must_raise Sequel::Error
-    proc{@ds.exclude_having("a")}.must_raise Sequel::Error
-    deprecated do
-      proc{@ds.exclude_where("a")}.must_raise Sequel::Error
-      proc{@ds.and("a")}.must_raise Sequel::Error
-    end
-    proc{@ds.where(:a).or("a")}.must_raise Sequel::Error
-    proc{@ds.first("a")}.must_raise Sequel::Error
-    proc{@ds.order(:a).last("a")}.must_raise Sequel::Error
-    proc{@ds["a"]}.must_raise Sequel::Error
-  end
-  
-  it "should raise exception for plain strings arrays in filter methods" do
-    proc{@ds.where(["a"])}.must_raise Sequel::Error
-  end
-
-  it "should handle explicit literal strings in filter methods" do
-    @ds.where(Sequel.lit("a")).sql.must_equal 'SELECT * FROM t WHERE (a)'
-    @ds.having(Sequel.lit("a")).sql.must_equal 'SELECT * FROM t HAVING (a)'
-    @ds.filter(Sequel.lit("a")).sql.must_equal 'SELECT * FROM t WHERE (a)'
-    @ds.exclude_having(Sequel.lit("a")).sql.must_equal 'SELECT * FROM t HAVING NOT (a)'
-    deprecated do
-      @ds.exclude_where(Sequel.lit("a")).sql.must_equal 'SELECT * FROM t WHERE NOT (a)'
-      @ds.and(Sequel.lit("a")).sql.must_equal 'SELECT * FROM t WHERE (a)'
-    end
-    @ds.where(:a).or(Sequel.lit("a")).sql.must_equal 'SELECT * FROM t WHERE (a OR (a))'
-    @ds.first(Sequel.lit("a"))
-    @ds.order(:a).last(Sequel.lit("a"))
-    @ds[Sequel.lit("a")]
-    @ds.db.sqls.must_equal ["SELECT * FROM t WHERE (a) LIMIT 1",
-                            "SELECT * FROM t WHERE (a) ORDER BY a DESC LIMIT 1",
-                            "SELECT * FROM t WHERE (a) LIMIT 1"]
-  end
-  
-  deprecated "should handle literal strings in arrays in filter methods" do
-    @ds.where([Sequel.lit("a")]).sql.must_equal 'SELECT * FROM t WHERE (a)'
-  end
-
-  it "should handle other objects in filter methods" do
-    @ds.where(:a).sql.must_equal 'SELECT * FROM t WHERE a'
-  end
-  
-  it "should raise exception for plain strings in update methods" do
-    proc{@ds.update("a = a + 1")}.must_raise Sequel::Error
-    proc{@ds.update_sql("a = a + 1")}.must_raise Sequel::Error
-  end
-  
-  it "should handle explicit literal strings in update methods" do
-    @ds.update_sql(Sequel.lit("a = a + 1")).must_equal "UPDATE t SET a = a + 1"
-    @ds.update(Sequel.lit("a = a + 1"))
-    @ds.db.sqls.must_equal ["UPDATE t SET a = a + 1"]
-  end
-  
-  it "should handle other objects in update methods" do
-    @ds.update_sql(:a=>:a).must_equal "UPDATE t SET a = a"
-    @ds.update(:a=>:a)
-    @ds.db.sqls.must_equal ["UPDATE t SET a = a"]
-  end
-end

data/spec/extensions/pg_typecast_on_load_spec.rb

@@ -1,70 +0,0 @@
-require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
-
-describe Sequel::Model, "PgTypecastOnLoad plugin" do
-  before do
-    @db = Sequel.mock(:host=>'postgres', :fetch=>{:id=>1, :b=>"t", :y=>"0"}, :columns=>[:id, :b, :y], :numrows=>1)
-    def @db.schema(*args)
-      [[:id, {}], [:b, {:type=>:boolean, :oid=>16}], [:y, {:type=>:integer, :oid=>20}]]
-    end
-    @c = Class.new(Sequel::Model(@db[:items]))
-    deprecated do
-      @c.plugin :pg_typecast_on_load, :b, :y
-    end
-  end 
-
-  deprecated "should call the database conversion proc for all given columns" do
-    @c.first.values.must_equal(:id=>1, :b=>true, :y=>0)
-  end
-
-  deprecated "should call the database conversion proc with value when reloading the object, for all given columns" do
-    @c.first.refresh.values.must_equal(:id=>1, :b=>true, :y=>0)
-  end
-
-  deprecated "should not fail if schema oid does not have a related conversion proc" do
-    @c.db_schema[:b][:oid] = 0
-    @c.first.refresh.values.must_equal(:id=>1, :b=>"t", :y=>0)
-  end
-
-  deprecated "should call the database conversion proc with value when automatically reloading the object on creation via insert_select" do
-    @c.dataset = @c.dataset.with_extend{def insert_select(h) insert(h); first end}
-    @c.create.values.must_equal(:id=>1, :b=>true, :y=>0)
-  end
-
-  deprecated "should allowing setting columns separately via add_pg_typecast_on_load_columns" do
-    @c = Class.new(Sequel::Model(@db[:items]))
-    @c.plugin :pg_typecast_on_load
-    @c.first.values.must_equal(:id=>1, :b=>"t", :y=>"0")
-    @c.add_pg_typecast_on_load_columns :b
-    @c.first.values.must_equal(:id=>1, :b=>true, :y=>"0")
-    @c.add_pg_typecast_on_load_columns :y
-    @c.first.values.must_equal(:id=>1, :b=>true, :y=>0)
-  end
-
-  deprecated "should work with subclasses" do
-    @c = Class.new(Sequel::Model(@db[:items]))
-    @c.plugin :pg_typecast_on_load
-    @c.first.values.must_equal(:id=>1, :b=>"t", :y=>"0")
-
-    c1 = Class.new(@c)
-    @c.add_pg_typecast_on_load_columns :b
-    @c.first.values.must_equal(:id=>1, :b=>true, :y=>"0")
-    c1.first.values.must_equal(:id=>1, :b=>"t", :y=>"0")
-
-    c2 = Class.new(@c)
-    @c.add_pg_typecast_on_load_columns :y
-    @c.first.values.must_equal(:id=>1, :b=>true, :y=>0)
-    c2.first.values.must_equal(:id=>1, :b=>true, :y=>"0")
-    
-    c1.add_pg_typecast_on_load_columns :y
-    c1.first.values.must_equal(:id=>1, :b=>"t", :y=>0)
-  end
-
-  deprecated "should not mark the object as modified" do
-    @c.first.modified?.must_equal false
-  end
-
-  deprecated "should freeze pg_typecast_on_load_columns" do
-    @c.freeze
-    @c.pg_typecast_on_load_columns.frozen?.must_equal true
-  end
-end