sequel 5.28.0 → 5.33.0

data/spec/extensions/dataset_source_alias_spec.rb

@@ -1,51 +0,0 @@
-require_relative "spec_helper"
-
-describe "dataset_source_alias extension" do
-  before do
-    @db = Sequel.mock
-    @db.extension(:dataset_source_alias)
-  end
-
-  it "should automatically alias datasets to their first source in #from" do
-    @db[@db[:a]].sql.must_equal 'SELECT * FROM (SELECT * FROM a) AS a'
-    @db[:a, @db[:b]].sql.must_equal 'SELECT * FROM a, (SELECT * FROM b) AS b'
-  end
-
-  it "should handle virtual row blocks in #from" do
-    @db.dataset.from{|_| @db[:a]}.sql.must_equal 'SELECT * FROM (SELECT * FROM a) AS a'
-    @db.dataset.from(:a){|_| @db[:b]}.sql.must_equal 'SELECT * FROM a, (SELECT * FROM b) AS b'
-  end
-
-  it "should automatically alias datasets to their first source in #join" do
-    @db[:a].cross_join(@db[:b]).sql.must_equal 'SELECT * FROM a CROSS JOIN (SELECT * FROM b) AS b'
-  end
-
-  it "should handle :table_alias option when joining" do
-    @db[:a].cross_join(@db[:b], :table_alias=>:c).sql.must_equal 'SELECT * FROM a CROSS JOIN (SELECT * FROM b) AS c'
-  end
-
-  it "should handle aliasing issues automatically" do
-    @db[:a, @db[:a]].sql.must_equal 'SELECT * FROM a, (SELECT * FROM a) AS a_0'
-    @db.dataset.from(:a, @db[:a]){|_| @db[:a]}.sql.must_equal 'SELECT * FROM a, (SELECT * FROM a) AS a_0, (SELECT * FROM a) AS a_1'
-    @db.dataset.from(:a, @db[:a]){|_| @db[:a]}.cross_join(@db[:a]).sql.must_equal 'SELECT * FROM a, (SELECT * FROM a) AS a_0, (SELECT * FROM a) AS a_1 CROSS JOIN (SELECT * FROM a) AS a_2'
-  end
-
-  it "should handle from_self" do
-    @db[:a].from_self.sql.must_equal 'SELECT * FROM (SELECT * FROM a) AS a'
-    @db[:a].from_self.from_self.sql.must_equal 'SELECT * FROM (SELECT * FROM (SELECT * FROM a) AS a) AS a'
-  end
-
-  it "should handle datasets without sources" do
-    @db[@db.select(1)].sql.must_equal 'SELECT * FROM (SELECT 1) AS t1'
-    @db[:t, @db.select(1)].sql.must_equal 'SELECT * FROM t, (SELECT 1) AS t1'
-    @db[:a].cross_join(@db.select(1)).sql.must_equal 'SELECT * FROM a CROSS JOIN (SELECT 1) AS t1'
-  end
-
-  it "should handle datasets selecting from functions" do
-    @db.dataset.from{|o| @db[o.f(:a)]}.sql.must_equal 'SELECT * FROM (SELECT * FROM f(a)) AS t1'
-  end
-
-  it "should handle datasets with literal SQL" do
-    @db.from(@db['SELECT c FROM d']).sql.must_equal 'SELECT * FROM (SELECT c FROM d) AS t1'
-  end
-end

data/spec/extensions/date_arithmetic_spec.rb

@@ -1,181 +0,0 @@
-require_relative "spec_helper"
-
-asd = begin
-  require 'active_support/duration'
-  true
-rescue LoadError
-  warn "Skipping some tests of date_arithmetic extension: can't load active_support/duration"
-  false
-end
-
-Sequel.extension :date_arithmetic
-
-describe "date_arithmetic extension" do
-  dbf = lambda do |db_type|
-    db = Sequel.connect("mock://#{db_type}")
-    db.extension :date_arithmetic
-    db
-  end
-
-  before do
-    @h0 = {:days=>0}
-    @h1 = {:days=>1, :years=>nil, :hours=>0}
-    @h2 = {:years=>1, :months=>1, :days=>1, :hours=>1, :minutes=>1, :seconds=>1}
-  end
-
-  it "should have Sequel.date_add with an interval hash return an appropriate Sequel::SQL::DateAdd expression" do
-    da = Sequel.date_add(:a, :days=>1)
-    da.must_be_kind_of(Sequel::SQL::DateAdd)
-    da.expr.must_equal :a
-    da.interval.must_equal(:days=>1)
-    Sequel.date_add(:a, :years=>1, :months=>2, :days=>3, :hours=>1, :minutes=>1, :seconds=>1).interval.must_equal(:years=>1, :months=>2, :days=>3, :hours=>1, :minutes=>1, :seconds=>1)
-  end
-
-  it "should have Sequel.date_sub with an interval hash return an appropriate Sequel::SQL::DateAdd expression" do
-    da = Sequel.date_sub(:a, :days=>1)
-    da.must_be_kind_of(Sequel::SQL::DateAdd)
-    da.expr.must_equal :a
-    da.interval.must_equal(:days=>-1)
-    Sequel.date_sub(:a, :years=>1, :months=>2, :days=>3, :hours=>1, :minutes=>1, :seconds=>1).interval.must_equal(:years=>-1, :months=>-2, :days=>-3, :hours=>-1, :minutes=>-1, :seconds=>-1)
-  end
-
-  it "should have Sequel.date_* with an interval hash handle nil values" do
-    Sequel.date_sub(:a, :days=>1, :hours=>nil).interval.must_equal(:days=>-1)
-  end
-
-  it "should raise an error if given string values in an interval hash" do
-    lambda{Sequel.date_add(:a, :days=>'1')}.must_raise(Sequel::InvalidValue)
-  end
-
-  if asd
-    it "should have Sequel.date_add with an ActiveSupport::Duration return an appropriate Sequel::SQL::DateAdd expression" do
-      da = Sequel.date_add(:a, ActiveSupport::Duration.new(1, [[:days, 1]]))
-      da.must_be_kind_of(Sequel::SQL::DateAdd)
-      da.expr.must_equal :a
-      da.interval.must_equal(:days=>1)
-      Sequel.date_add(:a, ActiveSupport::Duration.new(1, [[:years, 1], [:months, 1], [:days, 1], [:minutes, 61], [:seconds, 1]])).interval.must_equal(:years=>1, :months=>1, :days=>1, :minutes=>61, :seconds=>1)
-    end
-
-    it "should have Sequel.date_sub with an ActiveSupport::Duration return an appropriate Sequel::SQL::DateAdd expression" do
-      da = Sequel.date_sub(:a, ActiveSupport::Duration.new(1, [[:days, 1]]))
-      da.must_be_kind_of(Sequel::SQL::DateAdd)
-      da.expr.must_equal :a
-      da.interval.must_equal(:days=>-1)
-      Sequel.date_sub(:a, ActiveSupport::Duration.new(1, [[:years, 1], [:months, 1], [:days, 1], [:minutes, 61], [:seconds, 1]])).interval.must_equal(:years=>-1, :months=>-1, :days=>-1, :minutes=>-61, :seconds=>-1)
-    end
-  end
-
-  it "should use existing method" do
-    db = Sequel.mock
-    db.extend_datasets do
-      def date_add_sql_append(sql, da)
-        interval = String.new
-        each_valid_interval_unit(da.interval, Sequel::SQL::DateAdd::DatasetMethods::DEF_DURATION_UNITS) do |value, sql_unit|
-          interval << "#{value} #{sql_unit} "
-        end
-        literal_append(sql, Sequel.function(:da, da.expr, interval))
-      end
-    end
-    db.extension :date_arithmetic
-    db.literal(Sequel.date_add(:a, @h0)).must_equal "da(a, '')"
-    db.literal(Sequel.date_add(:a, @h1)).must_equal "da(a, '1 days ')"
-    db.literal(Sequel.date_add(:a, @h2)).must_equal "da(a, '1 years 1 months 1 days 1 hours 1 minutes 1 seconds ')"
-  end
-
-  it "should correctly literalize on Postgres" do
-    db = dbf.call(:postgres).dataset.with_quote_identifiers(false)
-    db.literal(Sequel.date_add(:a, @h0)).must_equal "CAST(a AS timestamp)"
-    db.literal(Sequel.date_add(:a, @h1)).must_equal "(CAST(a AS timestamp) + CAST('1 days ' AS interval))"
-    db.literal(Sequel.date_add(:a, @h2)).must_equal "(CAST(a AS timestamp) + CAST('1 years 1 months 1 days 1 hours 1 minutes 1 seconds ' AS interval))"
-
-    db.literal(Sequel.date_add(:a, @h0, :cast=>:timestamptz)).must_equal "CAST(a AS timestamptz)"
-    db.literal(Sequel.date_sub(:a, @h0, :cast=>:timestamptz)).must_equal "CAST(a AS timestamptz)"
-    db.literal(Sequel.date_add(:a, @h2, :cast=>:timestamptz)).must_equal "(CAST(a AS timestamptz) + CAST('1 years 1 months 1 days 1 hours 1 minutes 1 seconds ' AS interval))"
-  end
-
-  it "should correctly literalize on SQLite" do
-    db = dbf.call(:sqlite).dataset.with_quote_identifiers(false)
-    db.literal(Sequel.date_add(:a, @h0)).must_equal "datetime(a)"
-    db.literal(Sequel.date_add(:a, @h1)).must_equal "datetime(a, '1 days')"
-    db.literal(Sequel.date_add(:a, @h2)).must_equal "datetime(a, '1 years', '1 months', '1 days', '1 hours', '1 minutes', '1 seconds')"
-  end
-
-  it "should correctly literalize on MySQL" do
-    db = dbf.call(:mysql).dataset.with_quote_identifiers(false)
-    db.literal(Sequel.date_add(:a, @h0)).must_equal "CAST(a AS DATETIME)"
-    db.literal(Sequel.date_add(:a, @h1)).must_equal "DATE_ADD(a, INTERVAL 1 DAY)"
-    db.literal(Sequel.date_add(:a, @h2)).must_equal "DATE_ADD(DATE_ADD(DATE_ADD(DATE_ADD(DATE_ADD(DATE_ADD(a, INTERVAL 1 YEAR), INTERVAL 1 MONTH), INTERVAL 1 DAY), INTERVAL 1 HOUR), INTERVAL 1 MINUTE), INTERVAL 1 SECOND)"
-    db.literal(Sequel.date_add(:a, @h0, :cast=>:timestamp)).must_equal "CAST(a AS timestamp)"
-  end
-
-  it "should correctly literalize on HSQLDB" do
-    db = Sequel.mock
-    def db.database_type; :hsqldb end
-    db.extension :date_arithmetic
-    db.literal(Sequel.date_add(:a, @h0)).must_equal "CAST(CAST(a AS timestamp) AS timestamp)"
-    db.literal(Sequel.date_add(:a, @h1)).must_equal "DATE_ADD(CAST(a AS timestamp), INTERVAL 1 DAY)"
-    db.literal(Sequel.date_add(:a, @h2)).must_equal "DATE_ADD(DATE_ADD(DATE_ADD(DATE_ADD(DATE_ADD(DATE_ADD(CAST(a AS timestamp), INTERVAL 1 YEAR), INTERVAL 1 MONTH), INTERVAL 1 DAY), INTERVAL 1 HOUR), INTERVAL 1 MINUTE), INTERVAL 1 SECOND)"
-
-    db.literal(Sequel.date_add(:a, @h0, :cast=>:datetime)).must_equal "CAST(CAST(a AS datetime) AS datetime)"
-    db.literal(Sequel.date_add(:a, @h2, :cast=>:datetime)).must_equal "DATE_ADD(DATE_ADD(DATE_ADD(DATE_ADD(DATE_ADD(DATE_ADD(CAST(a AS datetime), INTERVAL 1 YEAR), INTERVAL 1 MONTH), INTERVAL 1 DAY), INTERVAL 1 HOUR), INTERVAL 1 MINUTE), INTERVAL 1 SECOND)"
-  end
-
-  it "should correctly literalize on MSSQL" do
-    db = dbf.call(:mssql).dataset.with_quote_identifiers(false)
-    db.literal(Sequel.date_add(:A, @h0)).must_equal "CAST(A AS datetime)"
-    db.literal(Sequel.date_add(:A, @h1)).must_equal "DATEADD(day, 1, A)"
-    db.literal(Sequel.date_add(:A, @h2)).must_equal "DATEADD(second, 1, DATEADD(minute, 1, DATEADD(hour, 1, DATEADD(day, 1, DATEADD(month, 1, DATEADD(year, 1, A))))))"
-    db.literal(Sequel.date_add(:A, @h0, :cast=>:timestamp)).must_equal "CAST(A AS timestamp)"
-  end
-
-  it "should correctly literalize on H2" do
-    db = Sequel.mock
-    def db.database_type; :h2 end
-    db.extension :date_arithmetic
-    db.literal(Sequel.date_add(:a, @h0)).must_equal "CAST(a AS timestamp)"
-    db.literal(Sequel.date_add(:a, @h1)).must_equal "DATEADD('day', 1, a)"
-    db.literal(Sequel.date_add(:a, @h2)).must_equal "DATEADD('second', 1, DATEADD('minute', 1, DATEADD('hour', 1, DATEADD('day', 1, DATEADD('month', 1, DATEADD('year', 1, a))))))"
-    db.literal(Sequel.date_add(:a, @h0, :cast=>:datetime)).must_equal "CAST(a AS datetime)"
-  end
-
-  it "should correctly literalize on access" do
-    db = dbf.call(:access).dataset.with_quote_identifiers(false)
-    db.literal(Sequel.date_add(:a, @h0)).must_equal "CDate(a)"
-    db.literal(Sequel.date_add(:a, @h1)).must_equal "DATEADD('d', 1, a)"
-    db.literal(Sequel.date_add(:a, @h2)).must_equal "DATEADD('s', 1, DATEADD('n', 1, DATEADD('h', 1, DATEADD('d', 1, DATEADD('m', 1, DATEADD('yyyy', 1, a))))))"
-  end
-
-  it "should correctly literalize on Derby" do
-    db = Sequel.mock
-    def db.database_type; :derby end
-    db.extension :date_arithmetic
-    db.literal(Sequel.date_add(:a, @h0)).must_equal "CAST(a AS timestamp)"
-    db.literal(Sequel.date_add(:a, @h1)).must_equal "{fn timestampadd(SQL_TSI_DAY, 1, timestamp(a))}"
-    db.literal(Sequel.date_add(:a, @h2)).must_equal "{fn timestampadd(SQL_TSI_SECOND, 1, timestamp({fn timestampadd(SQL_TSI_MINUTE, 1, timestamp({fn timestampadd(SQL_TSI_HOUR, 1, timestamp({fn timestampadd(SQL_TSI_DAY, 1, timestamp({fn timestampadd(SQL_TSI_MONTH, 1, timestamp({fn timestampadd(SQL_TSI_YEAR, 1, timestamp(a))}))}))}))}))}))}"
-    db.literal(Sequel.date_add(Date.civil(2012, 11, 12), @h1)).must_equal "{fn timestampadd(SQL_TSI_DAY, 1, timestamp((CAST('2012-11-12' AS varchar(255)) || ' 00:00:00')))}"
-    db.literal(Sequel.date_add(:a, @h0, :cast=>:datetime)).must_equal "CAST(a AS datetime)"
-  end
-
-  it "should correctly literalize on Oracle" do
-    db = dbf.call(:oracle).dataset.with_quote_identifiers(false)
-    db.literal(Sequel.date_add(:A, @h0)).must_equal "CAST(A AS timestamp)"
-    db.literal(Sequel.date_add(:A, @h1)).must_equal "(A + INTERVAL '1' DAY)"
-    db.literal(Sequel.date_add(:A, @h2)).must_equal "(A + INTERVAL '1' YEAR + INTERVAL '1' MONTH + INTERVAL '1' DAY + INTERVAL '1' HOUR + INTERVAL '1' MINUTE + INTERVAL '1' SECOND)"
-    db.literal(Sequel.date_add(:A, @h0, :cast=>:datetime)).must_equal "CAST(A AS datetime)"
-  end
-
-  it "should correctly literalize on DB2" do
-    db = dbf.call(:db2)
-    db.literal(Sequel.date_add(:A, @h0)).must_equal "CAST(A AS timestamp)"
-    db.literal(Sequel.date_add(:A, @h1)).must_equal "(CAST(A AS timestamp) + 1 days)"
-    db.literal(Sequel.date_add(:A, @h0)).must_equal "CAST(A AS timestamp)"
-    db.literal(Sequel.date_add(:A, @h1, :cast=>:datetime)).must_equal "(CAST(A AS datetime) + 1 days)"
-    db.literal(Sequel.date_add(:A, @h2, :cast=>:datetime)).must_equal "(CAST(A AS datetime) + 1 years + 1 months + 1 days + 1 hours + 1 minutes + 1 seconds)"
-  end
-
-  it "should raise error if literalizing on an unsupported database" do
-    db = Sequel.mock
-    db.extension :date_arithmetic
-    lambda{db.literal(Sequel.date_add(:a, @h0))}.must_raise(Sequel::Error)
-  end
-end

data/spec/extensions/datetime_parse_to_time_spec.rb

@@ -1,169 +0,0 @@
-require_relative "spec_helper"
-
-describe "datetime_parse_to_time extension" do
-  before(:all) do
-    Sequel.extension :datetime_parse_to_time
-  end
-  after(:all) do
-    # Can't undo the adding of the module to Sequel, so removing the
-    # method in the module is the only way to fix it.
-    Sequel::DateTimeParseToTime.send(:remove_method, :convert_input_timestamp)
-  end
-
-  before do
-    @db = Sequel::Database.new
-    @dataset = @db.dataset.with_extend do
-      def supports_timestamp_timezones?; true end
-      def supports_timestamp_usecs?; false end
-    end
-    @utc_time = Time.utc(2010, 1, 2, 3, 4, 5)
-    @local_time = Time.local(2010, 1, 2, 3, 4, 5)
-    @offset = sprintf("%+03i%02i", *(@local_time.utc_offset/60).divmod(60))
-    @dt_offset = @local_time.utc_offset/Rational(86400, 1)
-    @utc_datetime = DateTime.new(2010, 1, 2, 3, 4, 5)
-    @local_datetime = DateTime.new(2010, 1, 2, 3, 4, 5, @dt_offset)
-  end
-  after do
-    Sequel.default_timezone = nil
-    Sequel.datetime_class = Time
-  end
-  
-  it "should handle conversions during invalid localtimes" do
-    # This only checks of a couple of times that may be invalid.
-    # You can run with TZ=Europe/Berlin or TZ=US/Pacific
-    Sequel.database_timezone = :utc
-    Sequel.database_to_application_timestamp("2017-03-26 02:30:00").getutc.hour.must_equal 2
-    Sequel.database_to_application_timestamp("2017-03-12 02:30:00").getutc.hour.must_equal 2
-  end
-
-  it "should handle an database timezone of :utc when literalizing values" do
-    Sequel.database_timezone = :utc
-    @dataset.literal(Time.utc(2010, 1, 2, 3, 4, 5)).must_equal "'2010-01-02 03:04:05+0000'"
-    @dataset.literal(DateTime.new(2010, 1, 2, 3, 4, 5)).must_equal "'2010-01-02 03:04:05+0000'"
-  end
-  
-  it "should handle an database timezone of :local when literalizing values" do
-    Sequel.database_timezone = :local
-    @dataset.literal(Time.local(2010, 1, 2, 3, 4, 5)).must_equal "'2010-01-02 03:04:05#{@offset}'"
-    @dataset.literal(DateTime.new(2010, 1, 2, 3, 4, 5, @dt_offset)).must_equal "'2010-01-02 03:04:05#{@offset}'"
-  end
-  
-  it "should have Database#timezone override Sequel.database_timezone" do
-    Sequel.database_timezone = :local
-    @db.timezone = :utc
-    @dataset.literal(Time.utc(2010, 1, 2, 3, 4, 5)).must_equal "'2010-01-02 03:04:05+0000'"
-    @dataset.literal(DateTime.new(2010, 1, 2, 3, 4, 5)).must_equal "'2010-01-02 03:04:05+0000'"
-
-    Sequel.database_timezone = :utc
-    @db.timezone = :local
-    @dataset.literal(Time.local(2010, 1, 2, 3, 4, 5)).must_equal "'2010-01-02 03:04:05#{@offset}'"
-    @dataset.literal(DateTime.new(2010, 1, 2, 3, 4, 5, @dt_offset)).must_equal "'2010-01-02 03:04:05#{@offset}'"
-  end
-  
-  it "should handle converting database timestamps into application timestamps" do
-    Sequel.database_timezone = :utc
-    Sequel.application_timezone = :local
-    t = Time.now.utc
-    Sequel.database_to_application_timestamp(t).to_s.must_equal t.getlocal.to_s
-    Sequel.database_to_application_timestamp(t.to_s).to_s.must_equal t.getlocal.to_s
-    Sequel.database_to_application_timestamp(t.strftime('%Y-%m-%d %H:%M:%S')).to_s.must_equal t.getlocal.to_s
-    
-    Sequel.datetime_class = DateTime
-    dt = DateTime.now
-    dt2 = dt.new_offset(0)
-    Sequel.database_to_application_timestamp(dt2).to_s.must_equal dt.to_s
-    Sequel.database_to_application_timestamp(dt2.to_s).to_s.must_equal dt.to_s
-    Sequel.database_to_application_timestamp(dt2.strftime('%Y-%m-%d %H:%M:%S')).to_s.must_equal dt.to_s
-    
-    Sequel.datetime_class = Time
-    Sequel.database_timezone = :local
-    Sequel.application_timezone = :utc
-    Sequel.database_to_application_timestamp(t.getlocal).to_s.must_equal t.to_s
-    Sequel.database_to_application_timestamp(t.getlocal.to_s).to_s.must_equal t.to_s
-    Sequel.database_to_application_timestamp(t.getlocal.strftime('%Y-%m-%d %H:%M:%S')).to_s.must_equal t.to_s
-    
-    Sequel.datetime_class = DateTime
-    Sequel.database_to_application_timestamp(dt).to_s.must_equal dt2.to_s
-    Sequel.database_to_application_timestamp(dt.to_s).to_s.must_equal dt2.to_s
-    Sequel.database_to_application_timestamp(dt.strftime('%Y-%m-%d %H:%M:%S')).to_s.must_equal dt2.to_s
-  end
-  
-  it "should handle typecasting timestamp columns" do
-    Sequel.typecast_timezone = :utc
-    Sequel.application_timezone = :local
-    t = Time.now.utc
-    @db.typecast_value(:datetime, t).to_s.must_equal t.getlocal.to_s
-    @db.typecast_value(:datetime, t.to_s).to_s.must_equal t.getlocal.to_s
-    @db.typecast_value(:datetime, t.strftime('%Y-%m-%d %H:%M:%S')).to_s.must_equal t.getlocal.to_s
-    
-    Sequel.datetime_class = DateTime
-    dt = DateTime.now
-    dt2 = dt.new_offset(0)
-    @db.typecast_value(:datetime, dt2).to_s.must_equal dt.to_s
-    @db.typecast_value(:datetime, dt2.to_s).to_s.must_equal dt.to_s
-    @db.typecast_value(:datetime, dt2.strftime('%Y-%m-%d %H:%M:%S')).to_s.must_equal dt.to_s
-    
-    Sequel.datetime_class = Time
-    Sequel.typecast_timezone = :local
-    Sequel.application_timezone = :utc
-    @db.typecast_value(:datetime, t.getlocal).to_s.must_equal t.to_s
-    @db.typecast_value(:datetime, t.getlocal.to_s).to_s.must_equal t.to_s
-    @db.typecast_value(:datetime, t.getlocal.strftime('%Y-%m-%d %H:%M:%S')).to_s.must_equal t.to_s
-    
-    Sequel.datetime_class = DateTime
-    @db.typecast_value(:datetime, dt).to_s.must_equal dt2.to_s
-    @db.typecast_value(:datetime, dt.to_s).to_s.must_equal dt2.to_s
-    @db.typecast_value(:datetime, dt.strftime('%Y-%m-%d %H:%M:%S')).to_s.must_equal dt2.to_s
-  end
-  
-  it "should handle converting database timestamp columns from an array of values" do
-    Sequel.database_timezone = :utc
-    Sequel.application_timezone = :local
-    t = Time.now.utc
-    Sequel.database_to_application_timestamp([t.year, t.mon, t.day, t.hour, t.min, t.sec]).to_s.must_equal t.getlocal.to_s
-    
-    Sequel.datetime_class = DateTime
-    dt = DateTime.now
-    dt2 = dt.new_offset(0)
-    Sequel.database_to_application_timestamp([dt2.year, dt2.mon, dt2.day, dt2.hour, dt2.min, dt2.sec]).to_s.must_equal dt.to_s
-    
-    Sequel.datetime_class = Time
-    Sequel.database_timezone = :local
-    Sequel.application_timezone = :utc
-    t = t.getlocal
-    Sequel.database_to_application_timestamp([t.year, t.mon, t.day, t.hour, t.min, t.sec]).to_s.must_equal t.getutc.to_s
-    
-    Sequel.datetime_class = DateTime
-    Sequel.database_to_application_timestamp([dt.year, dt.mon, dt.day, dt.hour, dt.min, dt.sec]).to_s.must_equal dt2.to_s
-  end
-  
-  it "should raise an InvalidValue error when an error occurs while converting a timestamp" do
-    proc{Sequel.database_to_application_timestamp([0, 0, 0, 0, 0, 0])}.must_raise(Sequel::InvalidValue)
-  end
-  
-  it "should raise an error when attempting to typecast to a timestamp from an unsupported type" do
-    proc{Sequel.database_to_application_timestamp(Object.new)}.must_raise(Sequel::InvalidValue)
-  end
-
-  it "should raise an InvalidValue error when the DateTime class is used and when a bad application timezone is used when attempting to convert timestamps" do
-    Sequel.application_timezone = :blah
-    Sequel.datetime_class = DateTime
-    proc{Sequel.database_to_application_timestamp('2009-06-01 10:20:30')}.must_raise(Sequel::InvalidValue)
-  end
-  
-  it "should raise an InvalidValue error when the DateTime class is used and when a bad database timezone is used when attempting to convert timestamps" do
-    Sequel.database_timezone = :blah
-    Sequel.datetime_class = DateTime
-    proc{Sequel.database_to_application_timestamp('2009-06-01 10:20:30')}.must_raise(Sequel::InvalidValue)
-  end
-
-  it "should have Sequel.default_timezone= should set all other timezones" do
-    Sequel.database_timezone.must_be_nil
-    Sequel.application_timezone.must_be_nil
-    Sequel.typecast_timezone.must_be_nil
-    Sequel.default_timezone = :utc
-    Sequel.database_timezone.must_equal :utc
-    Sequel.application_timezone.must_equal :utc
-    Sequel.typecast_timezone.must_equal :utc
-  end
-end

data/spec/extensions/def_dataset_method_spec.rb

@@ -1,100 +0,0 @@
-require_relative "spec_helper"
-
-describe Sequel::Model, ".def_dataset_method" do
-  before do
-    @c = Class.new(Sequel::Model(:items))
-    @c.plugin :def_dataset_method
-  end
-  
-  it "should add a method to the dataset and model if called with a block argument" do
-    @c.def_dataset_method(:return_3){3}
-    @c.return_3.must_equal 3
-    @c.dataset.return_3.must_equal 3
-  end
-
-  it "should handle weird method names" do
-    @c.def_dataset_method(:"return 3"){3}
-    @c.send(:"return 3").must_equal 3
-    @c.dataset.send(:"return 3").must_equal 3
-  end
-
-  it "should not add a model method if the model already responds to the method" do
-    @c.instance_eval do
-      def foo
-        1
-      end
-
-      private
-
-      def bar
-        2
-      end
-
-      def_dataset_method(:foo){3}
-      def_dataset_method(:bar){4}
-    end
-    @c.foo.must_equal 1
-    @c.dataset.foo.must_equal 3
-    @c.send(:bar).must_equal 2
-    @c.dataset.bar.must_equal 4
-  end
-
-  it "should add all passed methods to the model if called without a block argument" do
-    @c.def_dataset_method(:return_3, :return_4)
-    proc{@c.return_3}.must_raise(NoMethodError)
-    proc{@c.return_4}.must_raise(NoMethodError)
-    @c.dataset = @c.dataset.with_extend do
-      def return_3; 3; end
-      def return_4; 4; end
-    end
-    @c.return_3.must_equal 3
-    @c.return_4.must_equal 4
-  end
-
-  it "should cache calls and readd methods if set_dataset is used" do
-    @c.def_dataset_method(:return_3){3}
-    @c.set_dataset :items
-    @c.return_3.must_equal 3
-    @c.dataset.return_3.must_equal 3
-  end
-
-  it "should readd methods to subclasses, if set_dataset is used in a subclass" do
-    @c.def_dataset_method(:return_3){3}
-    c = Class.new(@c)
-    c.set_dataset :items
-    c.return_3.must_equal 3
-    c.dataset.return_3.must_equal 3
-  end
-end
-
-describe Sequel::Model, ".subset" do
-  before do
-    @c = Class.new(Sequel::Model(:items))
-    @c.plugin :def_dataset_method
-    DB.reset
-  end
-
-  it "should create a filter on the underlying dataset" do
-    proc {@c.new_only}.must_raise(NoMethodError)
-    
-    @c.subset(:new_only){age < 'new'}
-    
-    @c.new_only.sql.must_equal "SELECT * FROM items WHERE (age < 'new')"
-    @c.dataset.new_only.sql.must_equal "SELECT * FROM items WHERE (age < 'new')"
-    
-    @c.subset(:pricey){price > 100}
-    
-    @c.pricey.sql.must_equal "SELECT * FROM items WHERE (price > 100)"
-    @c.dataset.pricey.sql.must_equal "SELECT * FROM items WHERE (price > 100)"
-    
-    @c.pricey.new_only.sql.must_equal "SELECT * FROM items WHERE ((price > 100) AND (age < 'new'))"
-    @c.new_only.pricey.sql.must_equal "SELECT * FROM items WHERE ((age < 'new') AND (price > 100))"
-  end
-
-  it "should not override existing model methods" do
-    def @c.active() true end
-    @c.subset(:active, :active)
-    @c.active.must_equal true
-  end
-end
-