sequel 5.20.0 → 5.49.0

data/spec/extensions/pg_row_spec.rb

@@ -1,363 +0,0 @@
-require_relative "spec_helper"
-
-describe "pg_row extension" do
-  before do
-    @db = Sequel.connect('mock://postgres')
-    @db.extend_datasets{def quote_identifiers?; false end}
-    @db.extension(:pg_array, :pg_row)
-    @m = Sequel::Postgres::PGRow
-    @db.sqls
-  end
-
-  it "should parse record objects as arrays" do
-    a = @db.conversion_procs[2249].call("(a,b,c)")
-    a.class.must_equal(@m::ArrayRow)
-    a.to_a.must_be_kind_of(Array)
-    a[0].must_equal 'a'
-    a.must_equal %w'a b c'
-    a.db_type.must_be_nil
-    @db.literal(a).must_equal "ROW('a', 'b', 'c')"
-  end
-
-  it "should parse arrays of record objects as arrays of arrays" do
-    as = @db.conversion_procs[2287].call('{"(a,b,c)","(d,e,f)"}')
-    as.must_equal [%w'a b c', %w'd e f']
-    as.each do |a|
-      a.class.must_equal(@m::ArrayRow)
-      a.to_a.must_be_kind_of(Array)
-      a.db_type.must_be_nil
-    end
-    @db.literal(as).must_equal "ARRAY[ROW('a', 'b', 'c'),ROW('d', 'e', 'f')]::record[]"
-  end
-
-  it "should be able to register custom parsing of row types as array-like objects" do
-    klass = @m::ArrayRow.subclass(:foo)
-    parser = @m::Parser.new(:converter=>klass)
-    a = parser.call("(a,b,c)")
-    a.class.must_equal(klass)
-    a.to_a.must_be_kind_of(Array)
-    a[0].must_equal 'a'
-    a.must_equal %w'a b c'
-    a.db_type.must_equal :foo
-    @db.literal(a).must_equal "ROW('a', 'b', 'c')::foo"
-  end
-
-  it "should be able to register custom parsing of row types as hash-like objects" do
-    klass = @m::HashRow.subclass(:foo, [:a, :b, :c])
-    parser = @m::Parser.new(:converter=>klass, :columns=>[:a, :b, :c])
-    a = parser.call("(a,b,c)")
-    a.class.must_equal(klass)
-    a.to_hash.must_be_kind_of(Hash)
-    a[:a].must_equal 'a'
-    a.must_equal(:a=>'a', :b=>'b', :c=>'c')
-    a.db_type.must_equal :foo
-    a.columns.must_equal [:a, :b, :c]
-    @db.literal(a).must_equal "ROW('a', 'b', 'c')::foo"
-  end
-
-  it "should raise an error if attempting to literalize a HashRow without column information" do
-    h = @m::HashRow.call(:a=>'a', :b=>'b', :c=>'c')
-    proc{@db.literal(h)}.must_raise(Sequel::Error)
-  end
-
-  it "should be able to manually override db_type per ArrayRow instance" do
-    a = @m::ArrayRow.call(%w'a b c')
-    a.db_type = :foo
-    @db.literal(a).must_equal "ROW('a', 'b', 'c')::foo"
-  end
-
-  it "should be able to manually override db_type and columns per HashRow instance" do
-    h = @m::HashRow.call(:a=>'a', :c=>'c', :b=>'b')
-    h.db_type = :foo
-    h.columns = [:a, :b, :c]
-    @db.literal(h).must_equal "ROW('a', 'b', 'c')::foo"
-  end
-
-  it "should correctly split an empty row" do
-    @m::Splitter.new("()").parse.must_equal [nil]
-  end
-
-  it "should correctly split a row with a single value" do
-    @m::Splitter.new("(1)").parse.must_equal %w'1'
-  end
-
-  it "should correctly split a row with multiple values" do
-    @m::Splitter.new("(1,2)").parse.must_equal %w'1 2'
-  end
-
-  it "should correctly NULL values when splitting" do
-    @m::Splitter.new("(1,)").parse.must_equal ['1', nil]
-  end
-
-  it "should correctly empty string values when splitting" do
-    @m::Splitter.new('(1,"")').parse.must_equal ['1', '']
-  end
-
-  it "should handle quoted values when splitting" do
-    @m::Splitter.new('("1","2")').parse.must_equal %w'1 2'
-  end
-
-  it "should handle escaped backslashes in quoted values when splitting" do
-    @m::Splitter.new('("\\\\1","2\\\\")').parse.must_equal ['\\1', '2\\']
-  end
-
-  it "should handle doubled quotes in quoted values when splitting" do
-    @m::Splitter.new('("""1","2""")').parse.must_equal ['"1', '2"']
-  end
-
-  it "should correctly convert types when parsing into an array" do
-    @m::Parser.new(:column_converters=>[proc{|s| s*2}, proc{|s| s*3}, proc{|s| s*4}]).call("(a,b,c)").must_equal %w'aa bbb cccc'
-  end
-
-  it "should correctly convert types into hashes if columns are known" do
-    @m::Parser.new(:columns=>[:a, :b, :c]).call("(a,b,c)").must_equal(:a=>'a', :b=>'b', :c=>'c')
-  end
-
-  it "should correctly handle type conversion when converting into hashes" do
-    @m::Parser.new(:column_converters=>[proc{|s| s*2}, proc{|s| s*3}, proc{|s| s*4}], :columns=>[:a, :b, :c]).call("(a,b,c)").must_equal(:a=>'aa', :b=>'bbb', :c=>'cccc')
-  end
-
-  it "should correctly wrap arrays when converting" do
-    @m::Parser.new(:converter=>proc{|s| [:foo, s]}).call("(a,b,c)").must_equal [:foo, %w'a b c']
-  end
-
-  it "should correctly wrap hashes when converting" do
-    @m::Parser.new(:converter=>proc{|s| [:foo, s]}, :columns=>[:a, :b, :c]).call("(a,b,c)").must_equal [:foo, {:a=>'a', :b=>'b', :c=>'c'}]
-  end
-
-  it "should have parser store reflection information" do
-    p = @m::Parser.new(:oid=>1, :column_oids=>[2], :columns=>[:a], :converter=>Array, :typecaster=>Hash, :column_converters=>[Array])
-    p.oid.must_equal 1
-    p.column_oids.must_equal [2]
-    p.columns.must_equal [:a]
-    p.converter.must_equal Array
-    p.typecaster.must_equal Hash
-    p.column_converters.must_equal [Array]
-  end
-
-  it "should handle ArrayRows and HashRows in bound variables" do
-    @db.bound_variable_arg(1, nil).must_equal 1
-    @db.bound_variable_arg(@m::ArrayRow.call(["1", "abc\\'\","]), nil).must_equal '("1","abc\\\\\'\\",")'
-    @db.bound_variable_arg(@m::HashRow.subclass(nil, [:a, :b]).call(:a=>"1", :b=>"abc\\'\","), nil).must_equal '("1","abc\\\\\'\\",")'
-  end
-
-  it "should handle ArrayRows and HashRows in arrays in bound variables" do
-    @db.bound_variable_arg(1, nil).must_equal 1
-    @db.bound_variable_arg([@m::ArrayRow.call(["1", "abc\\'\","])], nil).must_equal '{"(\\"1\\",\\"abc\\\\\\\\\'\\\\\\",\\")"}'
-    @db.bound_variable_arg([@m::HashRow.subclass(nil, [:a, :b]).call(:a=>"1", :b=>"abc\\'\",")], nil).must_equal '{"(\\"1\\",\\"abc\\\\\\\\\'\\\\\\",\\")"}'
-  end
-
-  it "should handle nils in bound variables" do
-    @db.bound_variable_arg(@m::ArrayRow.call([nil, nil]), nil).must_equal '(,)'
-    @db.bound_variable_arg(@m::HashRow.subclass(nil, [:a, :b]).call(:a=>nil, :b=>nil), nil).must_equal '(,)'
-    @db.bound_variable_arg([@m::ArrayRow.call([nil, nil])], nil).must_equal '{"(,)"}'
-    @db.bound_variable_arg([@m::HashRow.subclass(nil, [:a, :b]).call(:a=>nil, :b=>nil)], nil).must_equal '{"(,)"}'
-  end
-  
-  it "should allow registering row type parsers by introspecting system tables" do
-    @db.conversion_procs[4] = p4 = proc{|s| s.to_i}
-    @db.conversion_procs[5] = p5 = proc{|s| s * 2}
-    @db.fetch = [[{:oid=>1, :typrelid=>2, :typarray=>3}], [{:attname=>'bar', :atttypid=>4}, {:attname=>'baz', :atttypid=>5}]]
-    @db.register_row_type(:foo)
-    @db.sqls.must_equal ["SELECT pg_type.oid, typrelid, typarray FROM pg_type WHERE ((typtype = 'c') AND (typname = 'foo')) LIMIT 1",
-      "SELECT attname, (CASE pg_type.typbasetype WHEN 0 THEN atttypid ELSE pg_type.typbasetype END) AS atttypid FROM pg_attribute INNER JOIN pg_type ON (pg_type.oid = pg_attribute.atttypid) WHERE ((attrelid = 2) AND (attnum > 0) AND NOT attisdropped) ORDER BY attnum"]
-    p1 = @db.conversion_procs[1]
-    p1.columns.must_equal [:bar, :baz]
-    p1.column_oids.must_equal [4, 5]
-    p1.column_converters.must_equal [p4, p5]
-    p1.oid.must_equal 1
-    @db.send(:schema_column_type, 'foo').must_equal :pg_row_foo
-    @db.send(:schema_column_type, 'integer').must_equal :integer
-
-    c = p1.converter
-    c.superclass.must_equal @m::HashRow
-    c.columns.must_equal [:bar, :baz]
-    c.db_type.must_equal :foo
-    p1.typecaster.must_equal c
-
-    p1.call('(1,b)').must_equal(:bar=>1, :baz=>'bb')
-    @db.typecast_value(:pg_row_foo, %w'1 b').class.must_be :<, @m::HashRow
-    @db.typecast_value(:pg_row_foo, %w'1 b').must_equal(:bar=>'1', :baz=>'b')
-    @db.typecast_value(:pg_row_foo, :bar=>'1', :baz=>'b').must_equal(:bar=>'1', :baz=>'b')
-    @db.literal(p1.call('(1,b)')).must_equal "ROW(1, 'bb')::foo"
-  end
-
-  it "should allow registering row type parsers for schema qualify types" do
-    @db.conversion_procs[4] = p4 = proc{|s| s.to_i}
-    @db.conversion_procs[5] = p5 = proc{|s| s * 2}
-    @db.fetch = [[{:oid=>1, :typrelid=>2, :typarray=>3}], [{:attname=>'bar', :atttypid=>4}, {:attname=>'baz', :atttypid=>5}]]
-    @db.register_row_type(Sequel[:foo][:bar])
-    @db.sqls.must_equal ["SELECT pg_type.oid, typrelid, typarray FROM pg_type INNER JOIN pg_namespace ON ((pg_namespace.oid = pg_type.typnamespace) AND (pg_namespace.nspname = 'foo')) WHERE ((typtype = 'c') AND (typname = 'bar')) LIMIT 1",
-      "SELECT attname, (CASE pg_type.typbasetype WHEN 0 THEN atttypid ELSE pg_type.typbasetype END) AS atttypid FROM pg_attribute INNER JOIN pg_type ON (pg_type.oid = pg_attribute.atttypid) WHERE ((attrelid = 2) AND (attnum > 0) AND NOT attisdropped) ORDER BY attnum"]
-    p1 = @db.conversion_procs[1]
-    p1.columns.must_equal [:bar, :baz]
-    p1.column_oids.must_equal [4, 5]
-    p1.column_converters.must_equal [p4, p5]
-    p1.oid.must_equal 1
-
-    c = p1.converter
-    c.superclass.must_equal @m::HashRow
-    c.columns.must_equal [:bar, :baz]
-    c.db_type.must_equal Sequel[:foo][:bar]
-    p1.typecaster.must_equal c
-
-    p1.call('(1,b)').must_equal(:bar=>1, :baz=>'bb')
-    @db.typecast_value(:pg_row_foo__bar, %w'1 b').must_equal(:bar=>'1', :baz=>'b')
-    @db.typecast_value(:pg_row_foo__bar, :bar=>'1', :baz=>'b').must_equal(:bar=>'1', :baz=>'b')
-    @db.literal(p1.call('(1,b)')).must_equal "ROW(1, 'bb')::foo.bar"
-  end
-
-  with_symbol_splitting "should allow registering row type parsers for schema qualify type symbols" do
-    @db.conversion_procs[4] = p4 = proc{|s| s.to_i}
-    @db.conversion_procs[5] = p5 = proc{|s| s * 2}
-    @db.fetch = [[{:oid=>1, :typrelid=>2, :typarray=>3}], [{:attname=>'bar', :atttypid=>4}, {:attname=>'baz', :atttypid=>5}]]
-    @db.register_row_type(:foo__bar)
-    @db.sqls.must_equal ["SELECT pg_type.oid, typrelid, typarray FROM pg_type INNER JOIN pg_namespace ON ((pg_namespace.oid = pg_type.typnamespace) AND (pg_namespace.nspname = 'foo')) WHERE ((typtype = 'c') AND (typname = 'bar')) LIMIT 1",
-      "SELECT attname, (CASE pg_type.typbasetype WHEN 0 THEN atttypid ELSE pg_type.typbasetype END) AS atttypid FROM pg_attribute INNER JOIN pg_type ON (pg_type.oid = pg_attribute.atttypid) WHERE ((attrelid = 2) AND (attnum > 0) AND NOT attisdropped) ORDER BY attnum"]
-    p1 = @db.conversion_procs[1]
-    p1.columns.must_equal [:bar, :baz]
-    p1.column_oids.must_equal [4, 5]
-    p1.column_converters.must_equal [p4, p5]
-    p1.oid.must_equal 1
-
-    c = p1.converter
-    c.superclass.must_equal @m::HashRow
-    c.columns.must_equal [:bar, :baz]
-    c.db_type.must_equal :foo__bar
-    p1.typecaster.must_equal c
-
-    p1.call('(1,b)').must_equal(:bar=>1, :baz=>'bb')
-    @db.typecast_value(:pg_row_foo__bar, %w'1 b').must_equal(:bar=>'1', :baz=>'b')
-    @db.typecast_value(:pg_row_foo__bar, :bar=>'1', :baz=>'b').must_equal(:bar=>'1', :baz=>'b')
-    @db.literal(p1.call('(1,b)')).must_equal "ROW(1, 'bb')::foo.bar"
-  end
-
-  it "should not allow registering on a frozen database" do
-    @db.conversion_procs[4] = proc{|s| s.to_i}
-    @db.conversion_procs[5] = proc{|s| s * 2}
-    @db.fetch = [[], [{:oid=>1, :typrelid=>2, :typarray=>3}], [{:attname=>'bar', :atttypid=>4}, {:attname=>'baz', :atttypid=>5}]]
-    c = proc{|h| [h]}
-    @db.freeze
-    proc{@db.register_row_type(:foo, :converter=>c)}.must_raise RuntimeError, TypeError
-  end
-
-  it "should allow registering with a custom converter" do
-    @db.conversion_procs[4] = proc{|s| s.to_i}
-    @db.conversion_procs[5] = proc{|s| s * 2}
-    @db.fetch = [[{:oid=>1, :typrelid=>2, :typarray=>3}], [{:attname=>'bar', :atttypid=>4}, {:attname=>'baz', :atttypid=>5}]]
-    c = proc{|h| [h]}
-    @db.register_row_type(:foo, :converter=>c)
-    o = @db.conversion_procs[1].call('(1,b)')
-    o.must_equal [{:bar=>1, :baz=>'bb'}]
-    o.first.must_be_kind_of(Hash)
-  end
-
-  it "should allow registering with a custom typecaster" do
-    @db.conversion_procs[4] = proc{|s| s.to_i}
-    @db.conversion_procs[5] = proc{|s| s * 2}
-    @db.fetch = [[{:oid=>1, :typrelid=>2, :typarray=>3}], [{:attname=>'bar', :atttypid=>4}, {:attname=>'baz', :atttypid=>5}]]
-    @db.register_row_type(:foo, :typecaster=>proc{|h| {:bar=>(h[:bar]||0).to_i, :baz=>(h[:baz] || 'a')*2}})
-    @db.typecast_value(:pg_row_foo, %w'1 b').must_be_kind_of(Hash)
-    @db.typecast_value(:pg_row_foo, %w'1 b').must_equal(:bar=>1, :baz=>'bb')
-    @db.typecast_value(:pg_row_foo, :bar=>'1', :baz=>'b').must_equal(:bar=>1, :baz=>'bb')
-    @db.typecast_value(:pg_row_foo, 'bar'=>'1', 'baz'=>'b').must_equal(:bar=>0, :baz=>'aa')
-    @db.fetch = [[{:oid=>1, :typrelid=>2, :typarray=>3}], [{:attname=>'bar', :atttypid=>4}, {:attname=>'baz', :atttypid=>5}]]
-    @db.register_row_type(:foo, :typecaster=>proc{|h| {:bar=>(h[:bar] || h['bar'] || 0).to_i, :baz=>(h[:baz] || h['baz'] || 'a')*2}})
-    @db.typecast_value(:pg_row_foo, %w'1 b').must_equal(:bar=>1, :baz=>'bb')
-    @db.typecast_value(:pg_row_foo, :bar=>'1', :baz=>'b').must_equal(:bar=>1, :baz=>'bb')
-    @db.typecast_value(:pg_row_foo, 'bar'=>'1', 'baz'=>'b').must_equal(:bar=>1, :baz=>'bb')
-  end
-
-  it "should handle nil values when converting columns" do
-    @db.conversion_procs[5] = proc{|s| s * 2}
-    @db.fetch = [[{:oid=>1, :typrelid=>2, :typarray=>3}], [{:attname=>'bar', :atttypid=>4}]]
-    called = false
-    @db.conversion_procs[4] = proc{|s| called = true; s}
-    @db.register_row_type(:foo)
-    @db.conversion_procs[1].call('()').must_equal(:bar=>nil)
-    called.must_equal false
-  end
-
-  it "should registering array type for row type if type has an array oid" do
-    @db.conversion_procs[4] = proc{|s| s.to_i}
-    @db.conversion_procs[5] = proc{|s| s * 2}
-    @db.fetch = [[{:oid=>1, :typrelid=>2, :typarray=>3}], [{:attname=>'bar', :atttypid=>4}, {:attname=>'baz', :atttypid=>5}]]
-    @db.register_row_type(:foo, :typecaster=>proc{|h| {:bar=>(h[:bar]||0).to_i, :baz=>(h[:baz] || 'a')*2}})
-    p3 = @db.conversion_procs[3]
-
-    p3.call('{"(1,b)"}').must_equal [{:bar=>1, :baz=>'bb'}]
-    @db.literal(p3.call('{"(1,b)"}')).must_equal "ARRAY[ROW(1, 'bb')::foo]::foo[]"
-    @db.typecast_value(:foo_array, [{:bar=>'1', :baz=>'b'}]).must_equal [{:bar=>1, :baz=>'bb'}]
-  end
-
-  it "should allow creating unregisted row types via Database#row_type" do
-    @db.literal(@db.row_type(:foo, [1, 2])).must_equal 'ROW(1, 2)::foo'
-  end
-
-  it "should allow typecasting of registered row types via Database#row_type" do
-    @db.conversion_procs[4] = proc{|s| s.to_i}
-    @db.conversion_procs[5] = proc{|s| s * 2}
-    @db.fetch = [[{:oid=>1, :typrelid=>2, :typarray=>3}], [{:attname=>'bar', :atttypid=>4}, {:attname=>'baz', :atttypid=>5}]]
-    @db.register_row_type(:foo, :typecaster=>proc{|h| @m::HashRow.subclass(:foo, [:bar, :baz]).new({:bar=>(h[:bar]||0).to_i, :baz=>(h[:baz] || 'a')*2})})
-    @db.literal(@db.row_type(:foo, ['1', 'b'])).must_equal "ROW(1, 'bb')::foo"
-    @db.literal(@db.row_type(:foo, {:bar=>'1', :baz=>'b'})).must_equal "ROW(1, 'bb')::foo"
-  end
-
-  it "should allow parsing when typecasting registered row types via Database#row_type" do
-    @db.conversion_procs[4] = proc{|s| s.to_i}
-    @db.conversion_procs[5] = proc{|s| s * 2}
-    @db.fetch = [[{:oid=>1, :typrelid=>2, :typarray=>3}], [{:attname=>'bar', :atttypid=>4}, {:attname=>'baz', :atttypid=>5}]]
-    @db.register_row_type(:foo, :typecaster=>proc{|h| @m::HashRow.subclass(:foo, [:bar, :baz]).new(:bar=>(h[:bar]||0).to_i, :baz=>(h[:baz] || 'a')*2)})
-    @db.literal(@db.row_type(:foo, ['1', 'b'])).must_equal "ROW(1, 'bb')::foo"
-  end
-
-  it "should raise an error if attempt to use Database#row_type with an unregistered type and hash" do
-    proc{@db.literal(@db.row_type(:foo, {:bar=>'1', :baz=>'b'}))}.must_raise(Sequel::InvalidValue)
-  end
-
-  it "should raise an error if attempt to use Database#row_type with an unhandled type" do
-    proc{@db.literal(@db.row_type(:foo, 1))}.must_raise(Sequel::InvalidValue)
-  end
-
-  it "should return ArrayRow and HashRow values as-is" do
-    h = @m::HashRow.call(:a=>1)
-    a = @m::ArrayRow.call([1])
-    @db.row_type(:foo, h).object_id.must_equal(h.object_id)
-    @db.row_type(:foo, a).object_id.must_equal(a.object_id)
-  end
-
-  it "should have Sequel.pg_row return a plain ArrayRow" do
-    @db.literal(Sequel.pg_row([1, 2, 3])).must_equal 'ROW(1, 2, 3)'
-  end
-
-  it "should raise an error if attempting to typecast a hash for a parser without columns" do
-    proc{@m::Parser.new.typecast(:a=>1)}.must_raise(Sequel::Error)
-  end
-
-  it "should raise an error if attempting to typecast a unhandled value for a parser" do
-    proc{@m::Parser.new.typecast(1)}.must_raise(Sequel::Error)
-  end
-
-  it "should handle typecasting for a parser without a typecaster" do
-    @m::Parser.new.typecast([1]).must_equal [1]
-  end
-
-  it "should raise an error if no columns are returned when registering a custom row type" do
-    @db.fetch = [[{:oid=>1, :typrelid=>2, :typarray=>3}]]
-    proc{@db.register_row_type(:foo)}.must_raise(Sequel::Error)
-  end
-
-  it "should raise an error when registering a custom row type if the type is found found" do
-    @db.fetch = []
-    proc{@db.register_row_type(:foo)}.must_raise(Sequel::Error)
-  end
-
-  it "should return correct results for Database#schema_type_class" do
-    @db.conversion_procs[4] = proc{|s| s.to_i}
-    @db.conversion_procs[5] = proc{|s| s * 2}
-    @db.fetch = [[{:oid=>1, :typrelid=>2, :typarray=>3}], [{:attname=>'bar', :atttypid=>4}, {:attname=>'baz', :atttypid=>5}]]
-    @db.register_row_type(:foo, :typecaster=>proc{|h| {:bar=>(h[:bar]||0).to_i, :baz=>(h[:baz] || 'a')*2}})
-    @db.schema_type_class(:pg_row_foo).must_equal [Sequel::Postgres::PGRow::HashRow, Sequel::Postgres::PGRow::ArrayRow]
-    @db.schema_type_class(:integer).must_equal Integer
-  end
-end

data/spec/extensions/pg_static_cache_updater_spec.rb

@@ -1,93 +0,0 @@
-require_relative "spec_helper"
-
-describe "pg_static_cache_updater extension" do
-  before do
-    @db = Sequel.connect('mock://postgres')
-    @db.extend_datasets{def quote_identifiers?; false end}
-    def @db.listen(chan, opts={})
-      execute("LISTEN #{chan}")
-      yield(*opts[:yield])
-    end
-    @db.extension(:pg_static_cache_updater)
-    @model = Class.new(Sequel::Model(@db[:table]))
-    @model.plugin :static_cache
-    @db.sqls
-  end
-
-  it "#create_static_cache_update_function should create a function in the database" do
-    @db.create_static_cache_update_function
-    @db.sqls.first.gsub(/\s+/, ' ').must_equal " CREATE FUNCTION sequel_static_cache_update() RETURNS trigger LANGUAGE plpgsql AS 'BEGIN PERFORM pg_notify(''sequel_static_cache_update'', TG_RELID::text); RETURN NULL; END ' "
-  end
-
-  it "#create_static_cache_update_function should support :channel_name and :function_name options" do
-    @db.create_static_cache_update_function(:channel_name=>'foo', :function_name=>'bar')
-    @db.sqls.first.gsub(/\s+/, ' ').must_equal " CREATE FUNCTION bar() RETURNS trigger LANGUAGE plpgsql AS 'BEGIN PERFORM pg_notify(''foo'', TG_RELID::text); RETURN NULL; END ' "
-  end
-
-  it "#create_static_cache_update_trigger should create a trigger for the database table" do
-    @db.create_static_cache_update_trigger(:tab)
-    @db.sqls.first.gsub(/\s+/, ' ').must_equal "CREATE TRIGGER sequel_static_cache_update AFTER INSERT OR UPDATE OR DELETE ON tab EXECUTE PROCEDURE sequel_static_cache_update()"
-  end
-
-  it "#create_static_cache_update_trigger should support :trigger_name and :function_name options" do
-    @db.create_static_cache_update_trigger(:tab, :trigger_name=>'foo', :function_name=>'bar')
-    @db.sqls.first.gsub(/\s+/, ' ').must_equal "CREATE TRIGGER foo AFTER INSERT OR UPDATE OR DELETE ON tab EXECUTE PROCEDURE bar()"
-  end
-
-  it "#default_static_cache_update_name should return the default name for function, trigger, and channel" do
-    @db.default_static_cache_update_name.must_equal :sequel_static_cache_update
-  end
-
-  it "#listen_for_static_cache_updates should listen for changes to model tables and reload model classes" do
-    @db.fetch = {:v=>1234}
-    @db.listen_for_static_cache_updates([@model], :yield=>[nil, nil, 1234]).join
-    @db.sqls.must_equal ["SELECT CAST(CAST('table' AS regclass) AS oid) AS v LIMIT 1", "LISTEN sequel_static_cache_update", "SELECT * FROM table"]
-  end
-
-  it "#listen_for_static_cache_updates should not reload model classes if oid doesn't match" do
-    @db.fetch = {:v=>1234}
-    @db.listen_for_static_cache_updates([@model], :yield=>[nil, nil, 12345]).join
-    @db.sqls.must_equal ["SELECT CAST(CAST('table' AS regclass) AS oid) AS v LIMIT 1", "LISTEN sequel_static_cache_update"]
-  end
-
-  it "#listen_for_static_cache_updates should support a single model argument" do
-    @db.fetch = {:v=>1234}
-    @db.listen_for_static_cache_updates(@model, :yield=>[nil, nil, 1234]).join
-    @db.sqls.must_equal ["SELECT CAST(CAST('table' AS regclass) AS oid) AS v LIMIT 1", "LISTEN sequel_static_cache_update", "SELECT * FROM table"]
-  end
-
-  it "#listen_for_static_cache_updates should support the :channel_name option" do
-    @db.fetch = {:v=>1234}
-    @db.listen_for_static_cache_updates([@model], :yield=>[nil, nil, 12345], :channel_name=>:foo).join
-    @db.sqls.must_equal ["SELECT CAST(CAST('table' AS regclass) AS oid) AS v LIMIT 1", "LISTEN foo"]
-  end
-
-  it "#listen_for_static_cache_updates should raise an error if given an empty array" do
-    @db.fetch = {:v=>1234}
-    proc{@db.listen_for_static_cache_updates([])}.must_raise(Sequel::Error)
-  end
-
-  it "#listen_for_static_cache_updates should raise an error if one of the models is not using the static cache plugin" do
-    @db.fetch = {:v=>1234}
-    proc{@db.listen_for_static_cache_updates(Class.new(Sequel::Model(@db[:table])))}.must_raise(Sequel::Error)
-  end
-
-  it "#listen_for_static_cache_updates should raise an error if the database doesn't respond to listen" do
-    @db = Sequel.mock(:host=>'postgres')
-    @db.extension(:pg_static_cache_updater)
-    @db.fetch = {:v=>1234}
-    proc{@db.listen_for_static_cache_updates(Class.new(Sequel::Model(@db[:table])))}.must_raise(Sequel::Error)
-  end
-
-  it "#listen_for_static_cache_updates should handle a :before_thread_exit option" do
-    a = []
-    @db.listen_for_static_cache_updates([@model], :yield=>[nil, nil, 12345], :before_thread_exit=>proc{a << 1}).join
-    a.must_equal [1]
-  end
-
-  it "#listen_for_static_cache_updates should call :before_thread_exit option even if listen raises an exception" do
-    a = []
-    @db.listen_for_static_cache_updates([@model], :yield=>[nil, nil, 12345], :after_listen=>proc{raise ArgumentError}, :before_thread_exit=>proc{a << 1}).join
-    a.must_equal [1]
-  end
-end

data/spec/extensions/pg_timestamptz_spec.rb

@@ -1,17 +0,0 @@
-require_relative "spec_helper"
-
-describe "pg_timestamptz extension" do
-  before do
-    @db = Sequel.mock(:host=>'postgres').extension :pg_timestamptz
-  end
-
-  it "should use timestamptz as default timestamp type" do
-    @db.create_table(:t){Time :t; DateTime :tz; Time :ot, :only_time=>true}
-    @db.sqls.must_equal ['CREATE TABLE "t" ("t" timestamptz, "tz" timestamptz, "ot" time)']
-  end
-
-  it "should use timestamptz when casting" do
-    @db.get(Sequel.cast('a', Time))
-    @db.sqls.must_equal ["SELECT CAST('a' AS timestamptz) AS \"v\" LIMIT 1"]
-  end
-end

data/spec/extensions/prepared_statements_safe_spec.rb

@@ -1,66 +0,0 @@
-require_relative "spec_helper"
-
-describe "prepared_statements_safe plugin" do
-  before do
-    @db = Sequel.mock(:fetch=>{:id=>1, :name=>'foo', :i=>2}, :autoid=>proc{|sql| 1}, :numrows=>1, :servers=>{:read_only=>{}})
-    @c = Class.new(Sequel::Model(@db[:people]))
-    @c.columns :id, :name, :i
-    @c.instance_variable_set(:@db_schema, {:i=>{}, :name=>{}, :id=>{:primary_key=>true}})
-    @c.plugin :prepared_statements_safe
-    @p = @c.load(:id=>1, :name=>'foo', :i=>2)
-    @db.sqls
-  end
-
-  it "should load the prepared_statements plugin" do
-    @c.plugins.must_include(Sequel::Plugins::PreparedStatements)
-  end
-
-  it "should set default values correctly" do
-    @c.prepared_statements_column_defaults.must_equal(:name=>nil, :i=>nil)
-    @c.instance_variable_set(:@db_schema, {:i=>{:default=>'f(x)'}, :name=>{:ruby_default=>'foo'}, :id=>{:primary_key=>true}, :bar=>{:ruby_default=>Sequel::CURRENT_TIMESTAMP}})
-    Class.new(@c).prepared_statements_column_defaults.must_equal(:name=>'foo')
-  end
-
-  it "should set default values when creating" do
-    @c.create
-    @db.sqls.must_equal ['INSERT INTO people (i, name) VALUES (NULL, NULL)', "SELECT * FROM people WHERE (id = 1) LIMIT 1"]
-    @c.create(:name=>'foo')
-    @db.sqls.must_equal ["INSERT INTO people (i, name) VALUES (NULL, 'foo')", "SELECT * FROM people WHERE (id = 1) LIMIT 1"]
-    @c.create(:name=>'foo', :i=>2)
-    @db.sqls.must_equal ["INSERT INTO people (i, name) VALUES (2, 'foo')", "SELECT * FROM people WHERE (id = 1) LIMIT 1"]
-  end 
-
-  it "should use database default values" do
-    @c.instance_variable_set(:@db_schema, {:i=>{:ruby_default=>2}, :name=>{:ruby_default=>'foo'}, :id=>{:primary_key=>true}})
-    c = Class.new(@c)
-    c.create
-    @db.sqls.must_equal ["INSERT INTO people (i, name) VALUES (2, 'foo')", "SELECT * FROM people WHERE (id = 1) LIMIT 1"]
-  end
-
-  it "should not set defaults for unparseable dataset default values" do
-    @c.instance_variable_set(:@db_schema, {:i=>{:default=>'f(x)'}, :name=>{:ruby_default=>'foo'}, :id=>{:primary_key=>true}})
-    c = Class.new(@c)
-    c.create
-    @db.sqls.must_equal ["INSERT INTO people (name) VALUES ('foo')", "SELECT * FROM people WHERE (id = 1) LIMIT 1"]
-  end
-
-  it "should save all fields when updating" do
-    @p.update(:i=>3)
-    @db.sqls.must_equal ["UPDATE people SET name = 'foo', i = 3 WHERE (id = 1)"]
-  end
-
-  it "should work with abstract classes" do
-    c = Class.new(Sequel::Model)
-    c.plugin :prepared_statements_safe
-    c1 = Class.new(c)
-    def c1.get_db_schema; @db_schema = {:i=>{:default=>'f(x)'}, :name=>{:ruby_default=>'foo'}, :id=>{:primary_key=>true}} end
-    c1.set_dataset(:people)
-    c1.prepared_statements_column_defaults.must_equal(:name=>'foo')
-    Class.new(c1).prepared_statements_column_defaults.must_equal(:name=>'foo')
-  end
-
-  it "should freeze prepared statement column defaults when freezing model class" do
-    @c.freeze
-    @c.prepared_statements_column_defaults.frozen?.must_equal true
-  end
-end