sequel 4.36.0 → 5.61.0

data/spec/extensions/singular_table_names_spec.rb

@@ -1,22 +0,0 @@
-require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
-
-describe "Sequel::Plugins::SingularTableNames" do
-  before do
-    @c = Class.new(Sequel::Model)
-    @c.plugin :singular_table_names
-  end
-  after do
-    Object.send(:remove_const, :Foo)
-  end
-
-  it "should not used the pluralized table name" do
-    class ::Foo < @c; end
-    Foo.table_name.must_equal :foo
-  end
-
-  it "should handle nested moedls name" do
-    module ::Foo; end
-    class Foo::Bar < @c; end
-    Foo::Bar.table_name.must_equal :bar
-  end
-end

data/spec/extensions/skip_create_refresh_spec.rb

@@ -1,17 +0,0 @@
-require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
-
-describe "Sequel::Plugins::SkipCreateRefresh" do
-  it "should skip the refresh after saving a new object" do
-    c = Class.new(Sequel::Model(:a))
-    c.columns :id, :x
-    c.db.reset
-    c.instance_dataset.meta_def(:insert){|*a| super(*a); 2}
-    c.create(:x=>1)
-    c.db.sqls.must_equal ['INSERT INTO a (x) VALUES (1)', 'SELECT * FROM a WHERE (id = 2) LIMIT 1']
-
-    c.plugin :skip_create_refresh
-    c.db.reset
-    c.create(:x=>3).values.must_equal(:id=>2, :x=>3)
-    c.db.sqls.must_equal ['INSERT INTO a (x) VALUES (3)']
-  end
-end

data/spec/extensions/spec_helper.rb

@@ -1,71 +0,0 @@
-require 'rubygems'
-
-if ENV['COVERAGE']
-  require File.join(File.dirname(File.expand_path(__FILE__)), "../sequel_coverage")
-  SimpleCov.sequel_coverage(:filter=>%r{lib/sequel/(extensions|plugins)/\w+\.rb\z})
-end
-
-gem 'minitest'
-require 'minitest/autorun'
-require 'minitest/hooks/default'
-require 'minitest/shared_description'
-
-unless Object.const_defined?('Sequel') && Sequel.const_defined?('Model')
-  $:.unshift(File.join(File.dirname(File.expand_path(__FILE__)), "../../lib/"))
-  require 'sequel'
-end
-Sequel::Deprecation.backtrace_filter = lambda{|line, lineno| lineno < 4 || line =~ /_spec\.rb/}
-SEQUEL_EXTENSIONS_NO_DEPRECATION_WARNING = true
-
-begin
-  # Attempt to load ActiveSupport blank extension and inflector first, so Sequel
-  # can override them.
-  require 'active_support/core_ext/object/blank'
-  require 'active_support/inflector'
-  require 'active_support/core_ext/string/inflections'
-rescue LoadError
-  nil
-end
-
-Sequel.extension :meta_def
-Sequel.extension :core_refinements if RUBY_VERSION >= '2.0.0' && RUBY_ENGINE == 'ruby'
-
-def skip_warn(s)
-  warn "Skipping test of #{s}" if ENV["SKIPPED_TEST_WARN"]
-end
-
-Sequel.quote_identifiers = false
-Sequel.identifier_input_method = nil
-Sequel.identifier_output_method = nil
-
-class << Sequel::Model
-  attr_writer :db_schema
-  alias orig_columns columns
-  def columns(*cols)
-    return super if cols.empty?
-    define_method(:columns){cols}
-    @dataset.instance_variable_set(:@columns, cols) if @dataset
-    def_column_accessor(*cols)
-    @columns = cols
-    @db_schema = {}
-    cols.each{|c| @db_schema[c] = {}}
-  end
-end
-
-Sequel::Model.use_transactions = false
-Sequel.cache_anonymous_models = false
-
-db = Sequel.mock(:fetch=>{:id => 1, :x => 1}, :numrows=>1, :autoid=>proc{|sql| 10})
-def db.schema(*) [[:id, {:primary_key=>true}]] end
-def db.reset() sqls end
-def db.supports_schema_parsing?() true end
-Sequel::Model.db = DB = db
-
-if ENV['SEQUEL_COLUMNS_INTROSPECTION']
-  Sequel.extension :columns_introspection
-  Sequel::Database.extension :columns_introspection
-  Sequel::Mock::Dataset.send(:include, Sequel::ColumnsIntrospection)
-end
-if ENV['SEQUEL_NO_CACHE_ASSOCIATIONS']
-  Sequel::Model.cache_associations = false
-end

data/spec/extensions/split_array_nil_spec.rb

@@ -1,24 +0,0 @@
-require File.join(File.dirname(File.expand_path(__FILE__)), 'spec_helper')
-
-describe "split_array_nil extension" do
-  before do
-    @ds = Sequel.mock[:table].extension(:split_array_nil)
-  end
-
-  it "should split IN with nil in array into separate OR IS NULL clause" do
-    @ds.filter(:a=>[1, nil]).sql.must_equal "SELECT * FROM table WHERE ((a IN (1)) OR (a IS NULL))"
-  end
-
-  it "should split NOT IN with nil in array into separate AND IS NOT NULL clause" do
-    @ds.exclude(:a=>[1, nil]).sql.must_equal "SELECT * FROM table WHERE ((a NOT IN (1)) AND (a IS NOT NULL))"
-  end
-
-  it "should not affect other IN/NOT in clauses" do
-    @ds.filter(:a=>[1, 2]).sql.must_equal "SELECT * FROM table WHERE (a IN (1, 2))"
-    @ds.exclude(:a=>[1, 2]).sql.must_equal "SELECT * FROM table WHERE (a NOT IN (1, 2))"
-  end
-
-  it "should not affect other types of filters clauses" do
-    @ds.filter(:a=>1).sql.must_equal "SELECT * FROM table WHERE (a = 1)"
-  end
-end

data/spec/extensions/split_values_spec.rb

@@ -1,22 +0,0 @@
-require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
-
-describe "Sequel::Plugins::SplitValues" do
-  it "should skip the refresh after saving a new object" do
-    c = Class.new(Sequel::Model(:a))
-    c.columns :id, :x
-    c.plugin :split_values
-    c.dataset._fetch = {:id=>1, :x=>2, :y=>3}
-    o = c.first
-    c.db.reset
-
-    o.must_equal c.load(:id=>1, :x=>2)
-    o[:id].must_equal 1
-    o[:x].must_equal 2
-    o[:y].must_equal 3
-    {c.load(:id=>1, :x=>2)=>4}[o].must_equal 4
-    o.values.must_equal(:id=>1, :x=>2)
-
-    o.save
-    c.db.sqls.must_equal ["UPDATE a SET x = 2 WHERE (id = 1)"]
-  end
-end

data/spec/extensions/sql_comments_spec.rb

@@ -1,27 +0,0 @@
-require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
-
-describe "sql_comments extension" do
-  before do
-    @ds = Sequel.mock[:t].extension(:sql_comments)
-  end
-
-  it "should not add a comment if one is not set for the dataset" do
-    @ds.select_sql.must_equal 'SELECT * FROM t'
-    @ds.insert_sql(:a=>1).must_equal 'INSERT INTO t (a) VALUES (1)'
-    @ds.delete_sql.must_equal 'DELETE FROM t'
-    @ds.update_sql(:a=>1).must_equal 'UPDATE t SET a = 1'
-  end
-
-  it "should add a comment if one is set for the dataset" do
-    ds = @ds.comment("Some\nComment\r\n Here")
-    ds.select_sql.must_equal "SELECT * FROM t -- Some Comment Here\n"
-    ds.insert_sql(:a=>1).must_equal "INSERT INTO t (a) VALUES (1) -- Some Comment Here\n"
-    ds.delete_sql.must_equal "DELETE FROM t -- Some Comment Here\n"
-    ds.update_sql(:a=>1).must_equal "UPDATE t SET a = 1 -- Some Comment Here\n"
-  end
-
-  it "should handle comments used in nested datasets" do
-    ds = @ds.comment("Some\nComment\r\n Here")
-    ds.where(:id=>ds).select_sql.must_equal "SELECT * FROM t WHERE (id IN (SELECT * FROM t -- Some Comment Here\n)) -- Some Comment Here\n"
-  end
-end

data/spec/extensions/sql_expr_spec.rb

@@ -1,60 +0,0 @@
-require File.join(File.dirname(File.expand_path(__FILE__)), 'spec_helper')
-
-Sequel.extension :sql_expr
-
-describe "Sequel sql_expr extension" do
-  before do
-    @ds = Sequel.mock.dataset
-  end
-
-  it "Object#sql_expr should wrap the object in a GenericComplexExpression" do
-    o = Object.new
-    def o.sql_literal(ds) 'foo' end
-    s = o.sql_expr
-    @ds.literal(s).must_equal "foo"
-    @ds.literal(s+1).must_equal "(foo + 1)"
-    @ds.literal(s & true).must_equal "(foo AND 't')"
-    @ds.literal(s < 1).must_equal "(foo < 1)"
-    @ds.literal(s.sql_subscript(1)).must_equal "foo[1]"
-    @ds.literal(s.like('a')).must_equal "(foo LIKE 'a' ESCAPE '\\')"
-    @ds.literal(s.as(:a)).must_equal "foo AS a"
-    @ds.literal(s.cast(Integer)).must_equal "CAST(foo AS integer)"
-    @ds.literal(s.desc).must_equal "foo DESC"
-    @ds.literal(s.sql_string + '1').must_equal "(foo || '1')"
-  end
-
-  it "Numeric#sql_expr should wrap the object in a NumericExpression" do
-    [1, 2.0, 2^70, BigDecimal.new('1.0')].each do |o|
-      @ds.literal(o.sql_expr).must_equal @ds.literal(o)
-      @ds.literal(o.sql_expr + 1).must_equal "(#{@ds.literal(o)} + 1)"
-    end
-  end
-
-  it "String#sql_expr should wrap the object in a StringExpression" do
-    @ds.literal("".sql_expr).must_equal "''"
-    @ds.literal("".sql_expr + :a).must_equal "('' || a)"
-  end
-
-  it "NilClass, TrueClass, and FalseClass#sql_expr should wrap the object in a BooleanExpression" do
-    [nil, true, false].each do |o|
-      @ds.literal(o.sql_expr).must_equal @ds.literal(o)
-      @ds.literal(o.sql_expr & :a).must_equal "(#{@ds.literal(o)} AND a)"
-    end
-  end
-
-  it "Proc#sql_expr should should treat the object as a virtual row block" do
-    @ds.literal(proc{a}.sql_expr).must_equal "a"
-    @ds.literal(proc{a__b}.sql_expr).must_equal "a.b"
-    @ds.literal(proc{a(b)}.sql_expr).must_equal "a(b)"
-  end
-
-  it "Proc#sql_expr should should wrap the object in a GenericComplexExpression if the object is not already an expression" do
-    @ds.literal(proc{1}.sql_expr).must_equal "1"
-    @ds.literal(proc{1}.sql_expr + 2).must_equal "(1 + 2)"
-  end
-
-  it "Proc#sql_expr should should convert a hash or array of two element arrays to a BooleanExpression" do
-    @ds.literal(proc{{a=>b}}.sql_expr).must_equal "(a = b)"
-    @ds.literal(proc{[[a, b]]}.sql_expr & :a).must_equal "((a = b) AND a)"
-  end
-end

data/spec/extensions/static_cache_spec.rb

@@ -1,361 +0,0 @@
-require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
-
-describe "Sequel::Plugins::StaticCache" do
-  before do
-    @db = Sequel.mock
-    @db.fetch = [{:id=>1}, {:id=>2}]
-    @db.numrows = 1
-    @c = Class.new(Sequel::Model(@db[:t]))
-    @c.columns :id, :name
-  end
-
-  it "should not attempt to validate objects" do
-    @c.send(:define_method, :validate){errors.add(:name, 'bad')}
-    @c.plugin(:static_cache)
-    @c.map{|o| o.valid?}.must_equal [true, true]
-  end
-
-  static_cache_specs = shared_description do
-    it "should use a ruby hash as a cache of all model instances" do
-      @c.cache.must_equal(1=>@c.load(:id=>1), 2=>@c.load(:id=>2))
-      @c.cache[1].must_be_same_as(@c1)
-      @c.cache[2].must_be_same_as(@c2)
-    end
-
-    it "should make .[] method with primary key use the cache" do
-      @c[1].must_equal @c1
-      @c[2].must_equal @c2
-      @c[3].must_equal nil
-      @c[[1, 2]].must_equal nil
-      @c[nil].must_equal nil
-      @c[].must_equal nil
-      @db.sqls.must_equal []
-    end
-
-    it "should have .[] with a hash not use the cache" do
-      @db.fetch = {:id=>2}
-      @c[:id=>2].must_equal @c2
-      @db.sqls.must_equal ['SELECT * FROM t WHERE (id = 2) LIMIT 1']
-    end
-
-    it "should support cache_get_pk" do
-      @c.cache_get_pk(1).must_equal @c1
-      @c.cache_get_pk(2).must_equal @c2
-      @c.cache_get_pk(3).must_equal nil
-      @db.sqls.must_equal []
-    end
-
-    it "should have each just iterate over the hash's values without sending a query" do
-      a = []
-      @c.each{|o| a << o}
-      a = a.sort_by{|o| o.id}
-      a.first.must_equal @c1
-      a.last.must_equal @c2
-      @db.sqls.must_equal []
-    end
-
-    it "should have map just iterate over the hash's values without sending a query if no argument is given" do
-      @c.map{|v| v.id}.sort.must_equal [1, 2]
-      @db.sqls.must_equal []
-    end
-
-    it "should have count with no argument or block not issue a query" do
-      @c.count.must_equal 2
-      @db.sqls.must_equal []
-    end
-
-    it "should have count with argument or block not issue a query" do
-      @db.fetch = [[{:count=>1}], [{:count=>2}]]
-      @c.count(:a).must_equal 1
-      @c.count{b}.must_equal 2
-      @db.sqls.must_equal ["SELECT count(a) AS count FROM t LIMIT 1", "SELECT count(b) AS count FROM t LIMIT 1"]
-    end
-
-    it "should have map not send a query if given an argument" do
-      @c.map(:id).sort.must_equal [1, 2]
-      @db.sqls.must_equal []
-      @c.map([:id,:id]).sort.must_equal [[1,1], [2,2]]
-      @db.sqls.must_equal []
-    end
-
-    it "should have map without a block or argument not raise an exception or issue a query" do
-      @c.map.to_a.must_equal @c.all
-      @db.sqls.must_equal []
-    end
-
-    it "should have map without a block not return a frozen object" do
-      @c.map.frozen?.must_equal false
-    end
-
-    it "should have map with a block and argument raise" do
-      proc{@c.map(:id){}}.must_raise(Sequel::Error)
-    end
-
-    it "should have other enumerable methods work without sending a query" do
-      a = @c.sort_by{|o| o.id}
-      a.first.must_equal @c1
-      a.last.must_equal @c2
-      @db.sqls.must_equal []
-    end
-
-    it "should have all return all objects" do
-      a = @c.all.sort_by{|o| o.id}
-      a.first.must_equal @c1
-      a.last.must_equal @c2
-      @db.sqls.must_equal []
-    end
-
-    it "should have all not return a frozen object" do
-      @c.all.frozen?.must_equal false
-    end
-
-    it "should have all return things in dataset order" do
-      @c.all.must_equal [@c1, @c2]
-    end
-
-    it "should have to_hash without arguments run without a query" do
-      a = @c.to_hash
-      a.must_equal(1=>@c1, 2=>@c2)
-      a[1].must_equal @c1
-      a[2].must_equal @c2
-      @db.sqls.must_equal []
-    end
-
-    it "should have to_hash with arguments return results without a query" do
-      a = @c.to_hash(:id)
-      a.must_equal(1=>@c1, 2=>@c2)
-      a[1].must_equal @c1
-      a[2].must_equal @c2
-
-      a = @c.to_hash([:id])
-      a.must_equal([1]=>@c1, [2]=>@c2)
-      a[[1]].must_equal @c1
-      a[[2]].must_equal @c2
-
-      @c.to_hash(:id, :id).must_equal(1=>1, 2=>2)
-      @c.to_hash([:id], :id).must_equal([1]=>1, [2]=>2)
-      @c.to_hash(:id, [:id]).must_equal(1=>[1], 2=>[2])
-      @c.to_hash([:id], [:id]).must_equal([1]=>[1], [2]=>[2])
-
-      @db.sqls.must_equal []
-    end
-
-    it "should have to_hash not return a frozen object" do
-      @c.to_hash.frozen?.must_equal false
-    end
-
-    it "should have to_hash_groups without arguments return the cached objects without a query" do
-      a = @c.to_hash_groups(:id)
-      a.must_equal(1=>[@c1], 2=>[@c2])
-      a[1].first.must_equal @c1
-      a[2].first.must_equal @c2
-
-      a = @c.to_hash_groups([:id])
-      a.must_equal([1]=>[@c1], [2]=>[@c2])
-      a[[1]].first.must_equal @c1
-      a[[2]].first.must_equal @c2
-
-      @c.to_hash_groups(:id, :id).must_equal(1=>[1], 2=>[2])
-      @c.to_hash_groups([:id], :id).must_equal([1]=>[1], [2]=>[2])
-      @c.to_hash_groups(:id, [:id]).must_equal(1=>[[1]], 2=>[[2]])
-      @c.to_hash_groups([:id], [:id]).must_equal([1]=>[[1]], [2]=>[[2]])
-
-      @db.sqls.must_equal []
-    end
-
-    it "subclasses should work correctly" do
-      c = Class.new(@c)
-      c.all.must_equal [c.load(:id=>1), c.load(:id=>2)]
-      c.to_hash.must_equal(1=>c.load(:id=>1), 2=>c.load(:id=>2))
-      @db.sqls.must_equal ['SELECT * FROM t']
-    end
-
-    it "set_dataset should work correctly" do
-      ds = @c.dataset.from(:t2)
-      ds.instance_variable_set(:@columns, [:id])
-      ds._fetch = {:id=>3}
-      @c.dataset = ds
-      @c.all.must_equal [@c.load(:id=>3)]
-      @c.to_hash.must_equal(3=>@c.load(:id=>3))
-      @c.to_hash[3].must_equal @c.all.first
-      @db.sqls.must_equal ['SELECT * FROM t2']
-    end
-  end
-
-  describe "without options" do
-    before do
-      @c.plugin :static_cache
-      @c1 = @c.cache[1]
-      @c2 = @c.cache[2]
-      @db.sqls
-    end
-
-    include static_cache_specs
-
-    it "should work correctly with composite keys" do
-      @db.fetch = [{:id=>1, :id2=>1}, {:id=>2, :id2=>1}]
-      @c = Class.new(Sequel::Model(@db[:t]))
-      @c.columns :id, :id2
-      @c.set_primary_key([:id, :id2])
-      @c.plugin :static_cache
-      @db.sqls
-      @c1 = @c.cache[[1, 2]]
-      @c2 = @c.cache[[2, 1]]
-      @c[[1, 2]].must_be_same_as(@c1)
-      @c[[2, 1]].must_be_same_as(@c2)
-      @db.sqls.must_equal []
-    end
-
-    it "all of the static cache values (model instances) should be frozen" do
-      @c.all.all?{|o| o.frozen?}.must_equal true
-    end
-
-    it "should make .[] method with primary key return cached instances" do
-      @c[1].must_be_same_as(@c1)
-      @c[2].must_be_same_as(@c2)
-    end
-
-    it "should have cache_get_pk return cached instances" do
-      @c.cache_get_pk(1).must_be_same_as(@c1)
-      @c.cache_get_pk(2).must_be_same_as(@c2)
-    end
-
-    it "should have each yield cached objects" do
-      a = []
-      @c.each{|o| a << o}
-      a = a.sort_by{|o| o.id}
-      a.first.must_be_same_as(@c1)
-      a.last.must_be_same_as(@c2)
-    end
-
-    it "should have other enumerable methods work yield cached objects" do
-      a = @c.sort_by{|o| o.id}
-      a.first.must_be_same_as(@c1)
-      a.last.must_be_same_as(@c2)
-    end
-
-    it "should have all return cached instances" do
-      a = @c.all.sort_by{|o| o.id}
-      a.first.must_be_same_as(@c1)
-      a.last.must_be_same_as(@c2)
-    end
-
-    it "should have to_hash without arguments use cached instances" do
-      a = @c.to_hash
-      a[1].must_be_same_as(@c1)
-      a[2].must_be_same_as(@c2)
-    end
-
-    it "should have to_hash with arguments return cached instances" do
-      a = @c.to_hash(:id)
-      a[1].must_be_same_as(@c1)
-      a[2].must_be_same_as(@c2)
-
-      a = @c.to_hash([:id])
-      a[[1]].must_be_same_as(@c1)
-      a[[2]].must_be_same_as(@c2)
-    end
-
-    it "should have to_hash_groups without single argument return the cached instances" do
-      a = @c.to_hash_groups(:id)
-      a[1].first.must_be_same_as(@c1)
-      a[2].first.must_be_same_as(@c2)
-
-      a = @c.to_hash_groups([:id])
-      a[[1]].first.must_be_same_as(@c1)
-      a[[2]].first.must_be_same_as(@c2)
-    end
-
-    it "should not allow the saving of new objects" do
-      proc{@c.create}.must_raise(Sequel::HookFailed)
-    end
-
-    it "should not allow the saving of existing objects" do
-      @db.fetch = {:id=>1}
-      proc{@c.first(:id=>1).save}.must_raise(Sequel::HookFailed)
-    end
-
-    it "should not allow the destroying of existing objects" do
-      @db.fetch = {:id=>1}
-      proc{@c.first(:id=>1).destroy}.must_raise(Sequel::HookFailed)
-    end
-  end
-
-  describe "with :frozen=>false option" do
-    before do
-      @c.plugin :static_cache, :frozen=>false
-      @c1 = @c.cache[1]
-      @c2 = @c.cache[2]
-      @db.sqls
-    end
-
-    include static_cache_specs
-
-    it "record retrieved by primary key should not be frozen" do
-      @c[1].frozen?.must_equal false
-      @c.cache_get_pk(1).frozen?.must_equal false
-    end
-
-    it "none of values returned in #all should be frozen" do
-      @c.all.all?{|o| !o.frozen?}.must_equal true
-    end
-
-    it "none of values yielded by each should be frozen" do
-      a = []
-      @c.each{|o| a << o}
-      a.all?{|o| !o.frozen?}.must_equal true
-    end
-
-    it "none of values yielded by Enumerable method should be frozen" do
-      @c.sort_by{|o| o.id}.all?{|o| !o.frozen?}.must_equal true
-    end
-
-    it "none of values returned by map without an argument or block should be frozen" do
-      @c.map{|o| o}.all?{|o| !o.frozen?}.must_equal true
-      @c.map.all?{|o| !o.frozen?}.must_equal true
-    end
-
-    it "none of values in the hash returned by to_hash without an argument should be frozen" do
-      @c.to_hash.values.all?{|o| !o.frozen?}.must_equal true
-    end
-
-    it "none of values in the hash returned by to_hash with a single argument should be frozen" do
-      @c.to_hash(:id).values.all?{|o| !o.frozen?}.must_equal true
-    end
-
-    it "none of values in the hash returned by to_hash with a single array argument should be frozen" do
-      @c.to_hash([:id, :id]).values.all?{|o| !o.frozen?}.must_equal true
-    end
-
-    it "none of values in the hash returned by to_hash_groups with a single argument should be frozen" do
-      @c.to_hash_groups(:id).values.flatten.all?{|o| !o.frozen?}.must_equal true
-    end
-
-    it "none of values in the hash returned by to_hash_groups with a single array argument should be frozen" do
-      @c.to_hash_groups([:id, :id]).values.flatten.all?{|o| !o.frozen?}.must_equal true
-    end
-
-    it "should not automatically update the cache when creating new model objects" do
-      o = @c.new
-      o.id = 3
-      @db.autoid = 3
-      @db.fetch = [[{:id=>1}, {:id=>2}, {:id=>3}], [{:id=>3}]]
-      o.save
-      @c[3].must_equal nil
-    end
-
-    it "should not automatically update the cache when updating model objects" do
-      o = @c[2]
-      @db.fetch = [[{:id=>1}, {:id=>2, :name=>'a'}]]
-      o.update(:name=>'a')
-      @c[2].values.must_equal(:id=>2)
-    end
-
-    it "should not automatically update the cache when updating model objects" do
-      o = @c[2]
-      @db.fetch = [[{:id=>1}]]
-      o.destroy
-      @c[2].must_equal @c2
-    end
-  end
-end

data/spec/extensions/string_agg_spec.rb

@@ -1,85 +0,0 @@
-require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
-
-
-describe "string_agg extension" do
-  dbf = lambda do |db_type|
-    db = Sequel.connect("mock://#{db_type}")
-    db.extension :string_agg
-    db
-  end
-
-  before(:all) do
-    Sequel.extension :string_agg
-  end
-  before do
-    @sa1 = Sequel.string_agg(:c)
-    @sa2 = Sequel.string_agg(:c, '-')
-    @sa3 = Sequel.string_agg(:c, '-').order(:o)
-    @sa4 = Sequel.string_agg(:c).order(:o).distinct
-  end
-
-  it "should use existing method" do
-    db = Sequel.mock
-    db.extend_datasets do
-      def string_agg_sql_append(sql, sa)
-        sql << "sa(#{sa.expr})"
-      end
-    end
-    db.extension :string_agg
-    db.literal(Sequel.string_agg(:c)).must_equal "sa(c)"
-  end
-
-  it "should correctly literalize on Postgres" do
-    db = dbf.call(:postgres)
-    db.literal(@sa1).must_equal "string_agg(c, ',')"
-    db.literal(@sa2).must_equal "string_agg(c, '-')"
-    db.literal(@sa3).must_equal "string_agg(c, '-' ORDER BY o)"
-    db.literal(@sa4).must_equal "string_agg(DISTINCT c, ',' ORDER BY o)"
-  end
-
-  it "should correctly literalize on SQLAnywhere" do
-    db = dbf.call(:sqlanywhere)
-    db.literal(@sa1).must_equal "list(c, ',')"
-    db.literal(@sa2).must_equal "list(c, '-')"
-    db.literal(@sa3).must_equal "list(c, '-' ORDER BY o)"
-    db.literal(@sa4).must_equal "list(DISTINCT c, ',' ORDER BY o)"
-  end
-
-  it "should correctly literalize on MySQL, H2, HSQLDB, CUBRID" do
-    [:mysql, :h2, :hsqldb, :cubrid].each do |type|
-      db = dbf.call(type)
-      db.meta_def(:database_type){type}
-      db.literal(@sa1).must_equal "GROUP_CONCAT(c SEPARATOR ',')"
-      db.literal(@sa2).must_equal "GROUP_CONCAT(c SEPARATOR '-')"
-      db.literal(@sa3).must_equal "GROUP_CONCAT(c ORDER BY o SEPARATOR '-')"
-      db.literal(@sa4).must_equal "GROUP_CONCAT(DISTINCT c ORDER BY o SEPARATOR ',')"
-    end
-  end
-
-  it "should correctly literalize on Oracle and DB2" do
-    [:oracle, :db2].each do |type|
-      db = dbf.call(type)
-      db.literal(@sa1).must_equal "listagg(c, ',') WITHIN GROUP (ORDER BY 1)"
-      db.literal(@sa2).must_equal "listagg(c, '-') WITHIN GROUP (ORDER BY 1)"
-      db.literal(@sa3).must_equal "listagg(c, '-') WITHIN GROUP (ORDER BY o)"
-      proc{db.literal(@sa4)}.must_raise Sequel::Error
-    end
-  end
-
-  it "should handle order without arguments" do
-    db = dbf.call(:postgres)
-    db.literal(@sa1.order).must_equal "string_agg(c, ',')"
-  end
-
-  it "should handle operations on object" do
-    db = dbf.call(:postgres)
-    db.literal(@sa1 + 'b').must_equal "(string_agg(c, ',') || 'b')"
-    db.literal(@sa1.like('b')).must_equal "(string_agg(c, ',') LIKE 'b' ESCAPE '\\')"
-    db.literal(@sa1 < 'b').must_equal "(string_agg(c, ',') < 'b')"
-    db.literal(@sa1.as(:b)).must_equal "string_agg(c, ',') AS b"
-    db.literal(@sa1.cast(:b)).must_equal "CAST(string_agg(c, ',') AS b)"
-    db.literal(@sa1.desc).must_equal "string_agg(c, ',') DESC"
-    db.literal(@sa1 =~ /a/).must_equal "(string_agg(c, ',') ~ 'a')"
-    db.literal(@sa1.sql_subscript(1)).must_equal "string_agg(c, ',')[1]"
-  end
-end