viking-sequel 3.10.0

data/spec/extensions/string_date_time_spec.rb

@@ -0,0 +1,93 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+
+context "String#to_time" do
+  specify "should convert the string into a Time object" do
+    "2007-07-11".to_time.should == Time.parse("2007-07-11")
+    "06:30".to_time.should == Time.parse("06:30")
+  end
+  
+  specify "should raise InvalidValue for an invalid time" do
+    proc {'0000-00-00'.to_time}.should raise_error(Sequel::InvalidValue)
+  end
+end
+
+context "String#to_date" do
+  after do
+    Sequel.convert_two_digit_years = true
+  end
+
+  specify "should convert the string into a Date object" do
+    "2007-07-11".to_date.should == Date.parse("2007-07-11")
+  end
+  
+  specify "should convert 2 digit years by default" do
+    "July 11, 07".to_date.should == Date.parse("2007-07-11")
+  end
+
+  specify "should not convert 2 digit years if set not to" do
+    Sequel.convert_two_digit_years = false
+    "July 11, 07".to_date.should == Date.parse("0007-07-11")
+  end
+
+  specify "should raise InvalidValue for an invalid date" do
+    proc {'0000-00-00'.to_date}.should raise_error(Sequel::InvalidValue)
+  end
+end
+
+context "String#to_datetime" do
+  after do
+    Sequel.convert_two_digit_years = true
+  end
+
+  specify "should convert the string into a DateTime object" do
+    "2007-07-11 10:11:12a".to_datetime.should == DateTime.parse("2007-07-11 10:11:12a")
+  end
+  
+  specify "should convert 2 digit years by default" do
+    "July 11, 07 10:11:12a".to_datetime.should == DateTime.parse("2007-07-11 10:11:12a")
+  end
+
+  specify "should not convert 2 digit years if set not to" do
+    Sequel.convert_two_digit_years = false
+    "July 11, 07 10:11:12a".to_datetime.should == DateTime.parse("0007-07-11 10:11:12a")
+  end
+
+  specify "should raise InvalidValue for an invalid date" do
+    proc {'0000-00-00'.to_datetime}.should raise_error(Sequel::InvalidValue)
+  end
+end
+
+context "String#to_sequel_time" do
+  after do
+    Sequel.datetime_class = Time
+    Sequel.convert_two_digit_years = true
+  end
+
+  specify "should convert the string into a Time object by default" do
+    "2007-07-11 10:11:12a".to_sequel_time.class.should == Time
+    "2007-07-11 10:11:12a".to_sequel_time.should == Time.parse("2007-07-11 10:11:12a")
+  end
+  
+  specify "should convert the string into a DateTime object if that is set" do
+    Sequel.datetime_class = DateTime
+    "2007-07-11 10:11:12a".to_sequel_time.class.should == DateTime
+    "2007-07-11 10:11:12a".to_sequel_time.should == DateTime.parse("2007-07-11 10:11:12a")
+  end
+  
+  specify "should convert 2 digit years by default if using DateTime class" do
+    Sequel.datetime_class = DateTime
+    "July 11, 07 10:11:12a".to_sequel_time.should == DateTime.parse("2007-07-11 10:11:12a")
+  end
+
+  specify "should not convert 2 digit years if set not to when using DateTime class" do
+    Sequel.datetime_class = DateTime
+    Sequel.convert_two_digit_years = false
+    "July 11, 07 10:11:12a".to_sequel_time.should == DateTime.parse("0007-07-11 10:11:12a")
+  end
+
+  specify "should raise InvalidValue for an invalid time" do
+    proc {'0000-00-00'.to_sequel_time}.should raise_error(Sequel::InvalidValue)
+    Sequel.datetime_class = DateTime
+    proc {'0000-00-00'.to_sequel_time}.should raise_error(Sequel::InvalidValue)
+  end
+end

data/spec/extensions/subclasses_spec.rb

@@ -0,0 +1,52 @@
+require File.join(File.dirname(__FILE__), "spec_helper")
+
+describe Sequel::Model, "Subclasses plugin" do
+  before do
+    @c = Class.new(Sequel::Model)
+    @c.plugin :subclasses
+  end
+
+  specify "#subclasses should record direct subclasses of the given model" do
+    @c.subclasses.should == []
+
+    sc1 = Class.new(@c)
+    @c.subclasses.should == [sc1]
+    sc1.subclasses.should == []
+
+    sc2 = Class.new(@c)
+    @c.subclasses.should == [sc1, sc2]
+    sc1.subclasses.should == []
+    sc2.subclasses.should == []
+
+    ssc1 = Class.new(sc1)
+    @c.subclasses.should == [sc1, sc2]
+    sc1.subclasses.should == [ssc1]
+    sc2.subclasses.should == []
+  end
+
+  specify "#descendents should record all descendent subclasses of the given model" do
+    @c.descendents.should == []
+
+    sc1 = Class.new(@c)
+    @c.descendents.should == [sc1]
+    sc1.descendents.should == []
+
+    sc2 = Class.new(@c)
+    @c.descendents.should == [sc1, sc2]
+    sc1.descendents.should == []
+    sc2.descendents.should == []
+
+    ssc1 = Class.new(sc1)
+    @c.descendents.should == [sc1, ssc1, sc2]
+    sc1.descendents.should == [ssc1]
+    sc2.descendents.should == []
+    ssc1.descendents.should == []
+
+    sssc1 = Class.new(ssc1)
+    @c.descendents.should == [sc1, ssc1, sssc1, sc2]
+    sc1.descendents.should == [ssc1, sssc1]
+    sc2.descendents.should == []
+    ssc1.descendents.should == [sssc1]
+    sssc1.descendents.should == []
+  end
+end

data/spec/extensions/tactical_eager_loading_spec.rb

@@ -0,0 +1,65 @@
+require File.join(File.dirname(__FILE__), "spec_helper")
+
+describe "Sequel::Plugins::TacticalEagerLoading" do
+  before do
+    class ::TaticalEagerLoadingModel < Sequel::Model
+      plugin :tactical_eager_loading
+      columns :id, :parent_id
+      many_to_one :parent, :class=>self
+      one_to_many :children, :class=>self, :key=>:parent_id
+      ds = dataset
+      def ds.fetch_rows(sql)
+        execute(sql)
+        where = @opts[:where]
+        if !where
+          yield(:id=>1, :parent_id=>101)
+          yield(:id=>2, :parent_id=>102)
+          yield(:id=>101, :parent_id=>nil)
+          yield(:id=>102, :parent_id=>nil)
+        elsif where.args.first.column == :id
+          Array(where.args.last).each do |x|
+            yield(:id=>x, :parent_id=>nil)
+          end
+        elsif where.args.first.column == :parent_id
+          Array(where.args.last).each do |x|
+            yield(:id=>x-100, :parent_id=>x) if x > 100
+          end
+        end
+      end
+    end
+    @c = ::TaticalEagerLoadingModel
+    @ds = TaticalEagerLoadingModel.dataset
+    MODEL_DB.reset
+  end
+  after do
+    Object.send(:remove_const, :TaticalEagerLoadingModel)
+  end
+
+  it "Dataset#all should set the retrieved_by and reteived_with attributes" do
+    ts = @c.all
+    ts.map{|x| [x.retrieved_by, x.retrieved_with]}.should == [[@ds,ts], [@ds,ts], [@ds,ts], [@ds,ts]]
+  end
+
+  it "Dataset#all shouldn't raise an error if a Sequel::Model instance is not returned" do
+    proc{@c.naked.all}.should_not raise_error
+  end
+
+  it "association getter methods should eagerly load the association if the association isn't cached" do
+    MODEL_DB.sqls.length.should == 0
+    ts = @c.all
+    MODEL_DB.sqls.length.should == 1
+    ts.map{|x| x.parent}.should == [ts[2], ts[3], nil, nil]
+    MODEL_DB.sqls.length.should == 2
+    ts.map{|x| x.children}.should == [[], [], [ts[0]], [ts[1]]]
+    MODEL_DB.sqls.length.should == 3
+  end
+
+  it "association getter methods should not eagerly load the association if the association is cached" do
+    MODEL_DB.sqls.length.should == 0
+    ts = @c.all
+    MODEL_DB.sqls.length.should == 1
+    ts.map{|x| x.parent}.should == [ts[2], ts[3], nil, nil]
+    @ds.should_not_receive(:eager_load)
+    ts.map{|x| x.parent}.should == [ts[2], ts[3], nil, nil]
+  end
+end

data/spec/extensions/thread_local_timezones_spec.rb

@@ -0,0 +1,45 @@
+require File.join(File.dirname(__FILE__), "spec_helper")
+
+describe "Sequel thread_local_timezones extension" do
+  after do
+    Sequel.default_timezone = nil
+    Sequel.thread_application_timezone = nil
+    Sequel.thread_database_timezone = nil
+    Sequel.thread_typecast_timezone = nil
+  end
+  
+  it "should allow specifying thread local timezones via thread_*_timezone=" do
+    proc{Sequel.thread_application_timezone = :local}.should_not raise_error
+    proc{Sequel.thread_database_timezone = :utc}.should_not raise_error
+    proc{Sequel.thread_typecast_timezone = nil}.should_not raise_error
+  end
+    
+  it "should use thread local timezone if available" do
+    Sequel.thread_application_timezone = :local
+    Sequel.application_timezone.should == :local
+    Sequel.thread_database_timezone = :utc
+    Sequel.database_timezone.should == :utc
+    Sequel.thread_typecast_timezone = nil
+    Sequel.typecast_timezone.should == nil
+  end
+  
+  it "should fallback to default timezone if no thread_local timezone" do
+    Sequel.default_timezone = :utc
+    Sequel.application_timezone.should == :utc
+    Sequel.database_timezone.should == :utc
+    Sequel.typecast_timezone.should == :utc
+  end
+  
+  it "should use a nil thread_local_timezone if set instead of falling back to the default timezone if thread_local_timezone is set to :nil" do
+    Sequel.typecast_timezone = :utc
+    Sequel.thread_typecast_timezone = nil
+    Sequel.typecast_timezone.should == :utc
+    Sequel.thread_typecast_timezone = :nil
+    Sequel.typecast_timezone.should == nil
+  end
+    
+  it "should be thread safe" do
+    [Thread.new{Sequel.thread_application_timezone = :utc; sleep 0.03; Sequel.application_timezone.should == :utc},
+     Thread.new{sleep 0.01; Sequel.thread_application_timezone = :local; sleep 0.01; Sequel.application_timezone.should == :local}].each{|x| x.join}
+  end
+end

data/spec/extensions/timestamps_spec.rb

@@ -0,0 +1,150 @@
+require File.join(File.dirname(__FILE__), "spec_helper")
+
+describe "Sequel::Plugins::Timestamps" do
+  before do
+    dc = Object.new
+    dc.instance_eval do
+      def now
+        '2009-08-01'
+      end
+    end
+    Sequel.datetime_class = dc
+    @c = Class.new(Sequel::Model(:t))
+    @c.class_eval do
+      columns :id, :created_at, :updated_at
+      plugin :timestamps
+      db.reset
+      def _refresh(ds); self end
+    end
+  end 
+  after do
+    Sequel.datetime_class = Time
+  end
+  
+  it "should set the create timestamp field on creation" do
+    o = @c.create
+    @c.db.sqls.should == ["INSERT INTO t (created_at) VALUES ('2009-08-01')"]
+    o.created_at.should == '2009-08-01'
+  end
+
+  it "should set the update timestamp field on update" do
+    o = @c.load(:id=>1).save
+    @c.db.sqls.should == ["UPDATE t SET updated_at = '2009-08-01' WHERE (id = 1)"]
+    o.updated_at.should == '2009-08-01'
+  end
+
+  it "should not update the update timestamp on creation" do
+    @c.create.updated_at.should == nil
+  end
+
+  it "should use the same value for the creation and update timestamps when creating if the :update_on_create option is given" do
+    @c.plugin :timestamps, :update_on_create=>true
+    o = @c.create
+    @c.db.sqls.length.should == 1
+    @c.db.sqls.first.should =~ /INSERT INTO t \((creat|updat)ed_at, (creat|updat)ed_at\) VALUES \('2009-08-01', '2009-08-01'\)/
+    o.created_at.should === o.updated_at
+  end
+
+  it "should allow specifying the create timestamp field via the :create option" do
+    c = Class.new(Sequel::Model(:t))
+    c.class_eval do
+      columns :id, :c
+      plugin :timestamps, :create=>:c
+      db.reset
+      def _refresh(ds); self end
+    end
+    o = c.create
+    c.db.sqls.should == ["INSERT INTO t (c) VALUES ('2009-08-01')"]
+    o.c.should == '2009-08-01'
+  end
+
+  it "should allow specifying the update timestamp field via the :update option" do
+    c = Class.new(Sequel::Model(:t))
+    c.class_eval do
+      columns :id, :u
+      plugin :timestamps, :update=>:u
+      db.reset
+      def _refresh(ds); self end
+    end
+    o = c.load(:id=>1).save
+    c.db.sqls.should == ["UPDATE t SET u = '2009-08-01' WHERE (id = 1)"]
+    o.u.should == '2009-08-01'
+  end
+
+  it "should not raise an error if the model doesn't have the timestamp columns" do
+    c = Class.new(Sequel::Model(:t))
+    c.class_eval do
+      columns :id, :x
+      plugin :timestamps
+      db.reset
+      def _refresh(ds); self end
+    end
+    c.create(:x=>2)
+    c.load(:id=>1, :x=>2).save
+    c.db.sqls.should == ["INSERT INTO t (x) VALUES (2)", "UPDATE t SET x = 2 WHERE (id = 1)"] 
+  end
+
+  it "should not overwrite an existing create timestamp" do
+    o = @c.create(:created_at=>'2009-08-03')
+    @c.db.sqls.should == ["INSERT INTO t (created_at) VALUES ('2009-08-03')"]
+    o.created_at.should == '2009-08-03'
+  end
+
+  it "should overwrite an existing create timestamp if the :force option is used" do
+    @c.plugin :timestamps, :force=>true
+    o = @c.create(:created_at=>'2009-08-03')
+    @c.db.sqls.should == ["INSERT INTO t (created_at) VALUES ('2009-08-01')"]
+    o.created_at.should == '2009-08-01'
+  end
+
+  it "should have create_timestamp_field give the create timestamp field" do
+    @c.create_timestamp_field.should == :created_at
+    @c.plugin :timestamps, :create=>:c
+    @c.create_timestamp_field.should == :c
+  end
+
+  it "should have update_timestamp_field give the update timestamp field" do
+    @c.update_timestamp_field.should == :updated_at
+    @c.plugin :timestamps, :update=>:u
+    @c.update_timestamp_field.should == :u
+  end
+
+  it "should have create_timestamp_overwrite? give the whether to overwrite an existing create timestamp" do
+    @c.create_timestamp_overwrite?.should == false
+    @c.plugin :timestamps, :force=>true
+    @c.create_timestamp_overwrite?.should == true
+  end
+
+  it "should have set_update_timestamp_on_create? give whether to set the update timestamp on create" do
+    @c.set_update_timestamp_on_create?.should == false
+    @c.plugin :timestamps, :update_on_create=>true
+    @c.set_update_timestamp_on_create?.should == true
+  end
+
+  it "should work with subclasses" do
+    c = Class.new(@c)
+    o = c.create
+    o.created_at.should == '2009-08-01'
+    o.updated_at.should == nil
+    o = c.load(:id=>1).save
+    o.updated_at.should == '2009-08-01'
+    c.db.sqls.should == ["INSERT INTO t (created_at) VALUES ('2009-08-01')", "UPDATE t SET updated_at = '2009-08-01' WHERE (id = 1)"]
+    c.create(:created_at=>'2009-08-03').created_at.should == '2009-08-03'
+
+    c.class_eval do
+      columns :id, :c, :u
+      plugin :timestamps, :create=>:c, :update=>:u, :force=>true, :update_on_create=>true
+    end
+    c2 = Class.new(c)
+    c2.db.reset
+    o = c2.create
+    o.c.should == '2009-08-01'
+    o.u.should === o.c 
+    c2.db.sqls.first.should =~ /INSERT INTO t \([cu], [cu]\) VALUES \('2009-08-01', '2009-08-01'\)/
+    c2.db.reset
+    o = c2.load(:id=>1).save
+    o.u.should == '2009-08-01'
+    c2.db.sqls.should == ["UPDATE t SET u = '2009-08-01' WHERE (id = 1)"]
+    c2.create(:c=>'2009-08-03').c.should == '2009-08-01'
+  end
+end

data/spec/extensions/touch_spec.rb

@@ -0,0 +1,155 @@
+require File.join(File.dirname(__FILE__), "spec_helper")
+
+describe "Touch plugin" do
+  before do
+    @c = Class.new(Sequel::Model) do
+      def _refresh(*); end 
+    end
+    p = proc{def touch_instance_value; touch_association_value; end}
+    @Artist = Class.new(@c, &p).set_dataset(:artists)
+    @Album = Class.new(@c, &p).set_dataset(:albums)
+
+    @Artist.columns :id, :updated_at, :modified_on
+    @Artist.one_to_many :albums, :class=>@Album, :key=>:artist_id
+
+    @Album.columns :id, :updated_at, :modified_on, :artist_id, :original_album_id
+    @Album.one_to_many :followup_albums, :class=>@Album, :key=>:original_album_id
+    @Album.many_to_one :artist, :class=>@Artist
+
+    @a = @Artist.load(:id=>1)
+    MODEL_DB.reset
+  end
+
+  specify "should default to using Time.now when setting the column values for model instances" do
+    c = Class.new(Sequel::Model).set_dataset(:a)
+    c.plugin :touch
+    c.columns :id, :updated_at
+    c.load(:id=>1).touch
+    MODEL_DB.sqls.first.should =~ /UPDATE a SET updated_at = '[-0-9 :.]+' WHERE \(id = 1\)/
+  end
+
+  specify "should allow #touch instance method for updating the updated_at column" do
+    @Artist.plugin :touch
+    @a.touch
+    MODEL_DB.sqls.should == ["UPDATE artists SET updated_at = CURRENT_TIMESTAMP WHERE (id = 1)"]
+  end
+
+  specify "should have #touch take an argument for the column to touch" do
+    @Artist.plugin :touch
+    @a.touch(:modified_on)
+    MODEL_DB.sqls.should == ["UPDATE artists SET modified_on = CURRENT_TIMESTAMP WHERE (id = 1)"]
+  end
+
+  specify "should be able to specify the default column to touch in the plugin call using the :column option" do
+    @Artist.plugin :touch, :column=>:modified_on
+    @a.touch
+    MODEL_DB.sqls.should == ["UPDATE artists SET modified_on = CURRENT_TIMESTAMP WHERE (id = 1)"]
+  end
+
+  specify "should be able to specify the default column to touch using the touch_column model accessor" do
+    @Artist.plugin :touch
+    @Artist.touch_column = :modified_on
+    @a.touch
+    MODEL_DB.sqls.should == ["UPDATE artists SET modified_on = CURRENT_TIMESTAMP WHERE (id = 1)"]
+  end
+
+  specify "should be able to specify the associations to touch in the plugin call using the :associations option" do
+    @Artist.plugin :touch, :associations=>:albums
+    @a.touch
+    MODEL_DB.sqls.should == ["UPDATE artists SET updated_at = CURRENT_TIMESTAMP WHERE (id = 1)",
+      "UPDATE albums SET updated_at = CURRENT_TIMESTAMP WHERE (albums.artist_id = 1)"]
+  end
+
+  specify "should be able to give an array to the :associations option specifying multiple associations" do
+    @Album.plugin :touch, :associations=>[:artist, :followup_albums]
+    @Album.load(:id=>4, :artist_id=>1).touch
+    MODEL_DB.sqls.shift.should == "UPDATE albums SET updated_at = CURRENT_TIMESTAMP WHERE (id = 4)"
+    MODEL_DB.sqls.sort.should == ["UPDATE albums SET updated_at = CURRENT_TIMESTAMP WHERE (albums.original_album_id = 4)",
+      "UPDATE artists SET updated_at = CURRENT_TIMESTAMP WHERE (artists.id = 1)"]
+  end
+
+  specify "should be able to give a hash to the :associations option specifying the column to use for each association" do
+    @Artist.plugin :touch, :associations=>{:albums=>:modified_on}
+    @a.touch
+    MODEL_DB.sqls.should == ["UPDATE artists SET updated_at = CURRENT_TIMESTAMP WHERE (id = 1)",
+      "UPDATE albums SET modified_on = CURRENT_TIMESTAMP WHERE (albums.artist_id = 1)"]
+  end
+
+  specify "should default to using the touch_column as the default touch column for associations" do
+    @Artist.plugin :touch, :column=>:modified_on, :associations=>:albums
+    @a.touch
+    MODEL_DB.sqls.should == ["UPDATE artists SET modified_on = CURRENT_TIMESTAMP WHERE (id = 1)",
+      "UPDATE albums SET modified_on = CURRENT_TIMESTAMP WHERE (albums.artist_id = 1)"]
+  end
+
+  specify "should allow the mixed use of symbols and hashes inside an array for the :associations option" do
+    @Album.plugin :touch, :associations=>[:artist, {:followup_albums=>:modified_on}]
+    @Album.load(:id=>4, :artist_id=>1).touch
+    MODEL_DB.sqls.shift.should == "UPDATE albums SET updated_at = CURRENT_TIMESTAMP WHERE (id = 4)"
+    MODEL_DB.sqls.sort.should == ["UPDATE albums SET modified_on = CURRENT_TIMESTAMP WHERE (albums.original_album_id = 4)",
+      "UPDATE artists SET updated_at = CURRENT_TIMESTAMP WHERE (artists.id = 1)"]
+  end
+
+  specify "should be able to specify the associations to touch via a touch_associations_method" do
+    @Album.plugin :touch
+    @Album.touch_associations(:artist, {:followup_albums=>:modified_on})
+    @Album.load(:id=>4, :artist_id=>1).touch
+    MODEL_DB.sqls.shift.should == "UPDATE albums SET updated_at = CURRENT_TIMESTAMP WHERE (id = 4)"
+    MODEL_DB.sqls.sort.should == ["UPDATE albums SET modified_on = CURRENT_TIMESTAMP WHERE (albums.original_album_id = 4)",
+      "UPDATE artists SET updated_at = CURRENT_TIMESTAMP WHERE (artists.id = 1)"]
+  end
+
+  specify "should touch associated objects when destroying an object" do
+    @Album.plugin :touch
+    @Album.touch_associations(:artist, {:followup_albums=>:modified_on})
+    @Album.load(:id=>4, :artist_id=>1).destroy
+    MODEL_DB.sqls.shift.should == "DELETE FROM albums WHERE (id = 4)"
+    MODEL_DB.sqls.sort.should == ["UPDATE albums SET modified_on = CURRENT_TIMESTAMP WHERE (albums.original_album_id = 4)",
+      "UPDATE artists SET updated_at = CURRENT_TIMESTAMP WHERE (artists.id = 1)"]
+  end
+
+  specify "should not update a column that doesn't exist" do
+    @Album.plugin :touch, :column=>:x
+    a = @Album.load(:id=>1)
+    a.touch
+    MODEL_DB.sqls.should == []
+    a.artist_id = 1
+    a.touch
+    MODEL_DB.sqls.should == ['UPDATE albums SET artist_id = 1 WHERE (id = 1)']
+  end
+
+  specify "should raise an error if given a column argument in touch that doesn't exist" do
+    @Artist.plugin :touch
+    proc{@a.touch(:x)}.should raise_error(Sequel::Error)
+  end
+
+  specify "should raise an Error when a nonexistent association is given" do
+    @Artist.plugin :touch
+    proc{@Artist.plugin :touch, :associations=>:blah}.should raise_error(Sequel::Error)
+  end
+
+  specify "should work correctly in subclasses" do
+    @Artist.plugin :touch
+    c1 = Class.new(@Artist)
+    c1.load(:id=>4).touch
+    MODEL_DB.sqls.should == ["UPDATE artists SET updated_at = CURRENT_TIMESTAMP WHERE (id = 4)"]
+    MODEL_DB.reset
+
+    c1.touch_column = :modified_on
+    c1.touch_associations :albums
+    c1.load(:id=>1).touch
+    MODEL_DB.sqls.should == ["UPDATE artists SET modified_on = CURRENT_TIMESTAMP WHERE (id = 1)",
+      "UPDATE albums SET modified_on = CURRENT_TIMESTAMP WHERE (albums.artist_id = 1)"]
+    MODEL_DB.reset
+
+    @a.touch
+    MODEL_DB.sqls.should == ["UPDATE artists SET updated_at = CURRENT_TIMESTAMP WHERE (id = 1)"]
+    MODEL_DB.reset
+
+    @Artist.plugin :touch, :column=>:modified_on, :associations=>:albums
+    c2 = Class.new(@Artist)
+    c2.load(:id=>4).touch
+    MODEL_DB.sqls.should == ["UPDATE artists SET modified_on = CURRENT_TIMESTAMP WHERE (id = 4)",
+      "UPDATE albums SET modified_on = CURRENT_TIMESTAMP WHERE (albums.artist_id = 4)"]
+  end
+end