sequel 4.26.0 → 5.37.0

data/spec/extensions/to_dot_spec.rb

@@ -1,154 +0,0 @@
-require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
-
-describe Sequel::Model, "to_dot extension" do
-  def dot(ds)
-    Sequel::ToDot.new(ds).instance_variable_get(:@dot)[4...-1]
-  end
-
-  before do
-    @db = DB
-    @ds = @db.dataset.extension(:to_dot)
-  end
-
-  it "should output a string suitable for input to the graphviz dot program" do
-    @ds.to_dot.must_equal((<<END).strip)
-digraph G {
-0 [label="self"];
-0 -> 1 [label=""];
-1 [label="Dataset"];
-}
-END
-  end
-
-  it "should handle an empty dataset" do
-    dot(@ds).must_equal []
-  end
-
-  it "should handle WITH" do
-    def @ds.supports_cte?(*) true end
-    a = dot(@ds.with(:a, @ds))
-    a[0..3].must_equal ["1 -> 2 [label=\"with\"];", "2 [label=\"Array\"];", "2 -> 3 [label=\"0\"];", "3 [label=\"Hash\"];"]
-    [["3 -> 4 [label=\"dataset\"];", "4 [label=\"Dataset\"];", "3 -> 5 [label=\"name\"];", "5 [label=\":a\"];"],
-     ["3 -> 4 [label=\"name\"];", "4 [label=\":a\"];", "3 -> 5 [label=\"dataset\"];", "5 [label=\"Dataset\"];"]].must_include(a[4..-1])
-  end
-
-  it "should handle DISTINCT" do
-    dot(@ds.distinct).must_equal ["1 -> 2 [label=\"distinct\"];", "2 [label=\"Array\"];"]
-  end
-
-  it "should handle FROM" do
-    dot(@ds.from(:a)).must_equal ["1 -> 2 [label=\"from\"];", "2 [label=\"Array\"];", "2 -> 3 [label=\"0\"];", "3 [label=\":a\"];"]
-  end
-
-  it "should handle JOIN" do
-    dot(@ds.join(:a)).must_equal ["1 -> 2 [label=\"join\"];", "2 [label=\"Array\"];", "2 -> 3 [label=\"0\"];", "3 [label=\"INNER JOIN\"];", "3 -> 4 [label=\"table\"];", "4 [label=\":a\"];"]
-  end
-
-  it "should handle WHERE" do
-    dot(@ds.filter(true)).must_equal ["1 -> 2 [label=\"where\"];", "2 [label=\"ComplexExpression: NOOP\"];", "2 -> 3 [label=\"0\"];", "3 [label=\"true\"];"]
-  end
-
-  it "should handle GROUP" do
-    dot(@ds.group(:a)).must_equal ["1 -> 2 [label=\"group\"];", "2 [label=\"Array\"];", "2 -> 3 [label=\"0\"];", "3 [label=\":a\"];"]
-  end
-
-  it "should handle HAVING" do
-    dot(@ds.having(:a)).must_equal ["1 -> 2 [label=\"having\"];", "2 [label=\":a\"];"]
-  end
-
-  it "should handle UNION" do
-    dot(@ds.union(@ds)).must_equal ["1 -> 2 [label=\"from\"];", "2 [label=\"Array\"];", "2 -> 3 [label=\"0\"];", "3 [label=\"AliasedExpression\"];", "3 -> 4 [label=\"expression\"];", "4 [label=\"Dataset\"];", "4 -> 5 [label=\"compounds\"];", "5 [label=\"Array\"];", "5 -> 6 [label=\"0\"];", "6 [label=\"Array\"];", "6 -> 7 [label=\"0\"];", "7 [label=\":union\"];", "6 -> 8 [label=\"1\"];", "8 [label=\"Dataset\"];", "6 -> 9 [label=\"2\"];", "9 [label=\"nil\"];", "3 -> 10 [label=\"alias\"];", "10 [label=\":t1\"];"]
-  end
-
-  it "should handle INTERSECT" do
-    dot(@ds.intersect(@ds)).must_equal ["1 -> 2 [label=\"from\"];", "2 [label=\"Array\"];", "2 -> 3 [label=\"0\"];", "3 [label=\"AliasedExpression\"];", "3 -> 4 [label=\"expression\"];", "4 [label=\"Dataset\"];", "4 -> 5 [label=\"compounds\"];", "5 [label=\"Array\"];", "5 -> 6 [label=\"0\"];", "6 [label=\"Array\"];", "6 -> 7 [label=\"0\"];", "7 [label=\":intersect\"];", "6 -> 8 [label=\"1\"];", "8 [label=\"Dataset\"];", "6 -> 9 [label=\"2\"];", "9 [label=\"nil\"];", "3 -> 10 [label=\"alias\"];", "10 [label=\":t1\"];"]
-  end
-
-  it "should handle EXCEPT" do
-    dot(@ds.except(@ds)).must_equal ["1 -> 2 [label=\"from\"];", "2 [label=\"Array\"];", "2 -> 3 [label=\"0\"];", "3 [label=\"AliasedExpression\"];", "3 -> 4 [label=\"expression\"];", "4 [label=\"Dataset\"];", "4 -> 5 [label=\"compounds\"];", "5 [label=\"Array\"];", "5 -> 6 [label=\"0\"];", "6 [label=\"Array\"];", "6 -> 7 [label=\"0\"];", "7 [label=\":except\"];", "6 -> 8 [label=\"1\"];", "8 [label=\"Dataset\"];", "6 -> 9 [label=\"2\"];", "9 [label=\"nil\"];", "3 -> 10 [label=\"alias\"];", "10 [label=\":t1\"];"]
-  end
-
-  it "should handle ORDER" do
-    dot(@ds.order(:a)).must_equal ["1 -> 2 [label=\"order\"];", "2 [label=\"Array\"];", "2 -> 3 [label=\"0\"];", "3 [label=\":a\"];"]
-  end
-
-  it "should handle LIMIT and OFFSET" do
-    dot(@ds.limit(1, 2)).must_equal ["1 -> 2 [label=\"limit\"];", "2 [label=\"1\"];", "1 -> 3 [label=\"offset\"];", "3 [label=\"2\"];"]
-  end
-
-  it "should handle FOR UPDATE" do
-    dot(@ds.for_update).must_equal ["1 -> 2 [label=\"lock\"];", "2 [label=\":update\"];"]
-  end
-
-  it "should handle LiteralStrings" do
-    dot(@ds.filter('a')).must_equal ["1 -> 2 [label=\"where\"];", "2 [label=\"\\\"(a)\\\".lit\"];"]
-  end
-
-  it "should handle true, false, nil" do
-    dot(@ds.select(true, false, nil)).must_equal ["1 -> 2 [label=\"select\"];", "2 [label=\"Array\"];", "2 -> 3 [label=\"0\"];", "3 [label=\"true\"];", "2 -> 4 [label=\"1\"];", "4 [label=\"false\"];", "2 -> 5 [label=\"2\"];", "5 [label=\"nil\"];"]
-  end
-
-  it "should handle SQL::ComplexExpressions" do
-    dot(@ds.filter(:a=>:b)).must_equal ["1 -> 2 [label=\"where\"];", "2 [label=\"ComplexExpression: =\"];", "2 -> 3 [label=\"0\"];", "3 [label=\":a\"];", "2 -> 4 [label=\"1\"];", "4 [label=\":b\"];"]
-  end
-
-  it "should handle SQL::Identifiers" do
-    dot(@ds.select{a}).must_equal ["1 -> 2 [label=\"select\"];", "2 [label=\"Array\"];", "2 -> 3 [label=\"0\"];", "3 [label=\"Identifier\"];", "3 -> 4 [label=\"value\"];", "4 [label=\":a\"];"]
-  end
-
-  it "should handle SQL::QualifiedIdentifiers" do
-    dot(@ds.select{a__b}).must_equal ["1 -> 2 [label=\"select\"];", "2 [label=\"Array\"];", "2 -> 3 [label=\"0\"];", "3 [label=\"QualifiedIdentifier\"];", "3 -> 4 [label=\"table\"];", "4 [label=\"\\\"a\\\"\"];", "3 -> 5 [label=\"column\"];", "5 [label=\"\\\"b\\\"\"];"]
-  end
-
-  it "should handle SQL::OrderedExpressions" do
-    dot(@ds.order(Sequel.desc(:a, :nulls=>:last))).must_equal ["1 -> 2 [label=\"order\"];", "2 [label=\"Array\"];", "2 -> 3 [label=\"0\"];", "3 [label=\"OrderedExpression: DESC NULLS LAST\"];", "3 -> 4 [label=\"expression\"];", "4 [label=\":a\"];"]
-  end
-
-  it "should handle SQL::AliasedExpressions" do
-    dot(@ds.from(Sequel.as(:a, :b))).must_equal ["1 -> 2 [label=\"from\"];", "2 [label=\"Array\"];", "2 -> 3 [label=\"0\"];", "3 [label=\"AliasedExpression\"];", "3 -> 4 [label=\"expression\"];", "4 [label=\":a\"];", "3 -> 5 [label=\"alias\"];", "5 [label=\":b\"];"]
-  end
-
-  it "should handle SQL::AliasedExpressions with column aliases" do
-    dot(@ds.from(Sequel.as(:a, :b, [:c, :d]))).must_equal ["1 -> 2 [label=\"from\"];", "2 [label=\"Array\"];", "2 -> 3 [label=\"0\"];", "3 [label=\"AliasedExpression\"];", "3 -> 4 [label=\"expression\"];", "4 [label=\":a\"];", "3 -> 5 [label=\"alias\"];", "5 [label=\":b\"];", "3 -> 6 [label=\"columns\"];", "6 [label=\"Array\"];", "6 -> 7 [label=\"0\"];", "7 [label=\":c\"];", "6 -> 8 [label=\"1\"];", "8 [label=\":d\"];"]
-  end
-
-  it "should handle SQL::CaseExpressions" do
-    dot(@ds.select(Sequel.case({:a=>:b}, :c, :d))).must_equal ["1 -> 2 [label=\"select\"];", "2 [label=\"Array\"];", "2 -> 3 [label=\"0\"];", "3 [label=\"CaseExpression\"];", "3 -> 4 [label=\"expression\"];", "4 [label=\":d\"];", "3 -> 5 [label=\"conditions\"];", "5 [label=\"Array\"];", "5 -> 6 [label=\"0\"];", "6 [label=\"Array\"];", "6 -> 7 [label=\"0\"];", "7 [label=\":a\"];", "6 -> 8 [label=\"1\"];", "8 [label=\":b\"];", "3 -> 9 [label=\"default\"];", "9 [label=\":c\"];"]
-  end
-
-  it "should handle SQL::Cast" do
-    dot(@ds.select(Sequel.cast(:a, Integer))).must_equal  ["1 -> 2 [label=\"select\"];", "2 [label=\"Array\"];", "2 -> 3 [label=\"0\"];", "3 [label=\"Cast\"];", "3 -> 4 [label=\"expr\"];", "4 [label=\":a\"];", "3 -> 5 [label=\"type\"];", "5 [label=\"Integer\"];"]
-  end
-
-  it "should handle SQL::Function" do
-    dot(@ds.select{a(b)}).must_equal ["1 -> 2 [label=\"select\"];", "2 [label=\"Array\"];", "2 -> 3 [label=\"0\"];", "3 [label=\"Function: a\"];", "3 -> 4 [label=\"0\"];", "4 [label=\"Identifier\"];", "4 -> 5 [label=\"value\"];", "5 [label=\":b\"];", "3 -> 6 [label=\"args\"];", "6 [label=\"Array\"];", "6 -> 7 [label=\"0\"];", "7 [label=\"Identifier\"];", "7 -> 8 [label=\"value\"];", "8 [label=\":b\"];", "3 -> 9 [label=\"opts\"];", "9 [label=\"Hash\"];"]
-  end
-
-  it "should handle SQL::Subscript" do
-    dot(@ds.select(Sequel.subscript(:a, 1))).must_equal ["1 -> 2 [label=\"select\"];", "2 [label=\"Array\"];", "2 -> 3 [label=\"0\"];", "3 [label=\"Subscript\"];", "3 -> 4 [label=\"f\"];", "4 [label=\":a\"];", "3 -> 5 [label=\"sub\"];", "5 [label=\"Array\"];", "5 -> 6 [label=\"0\"];", "6 [label=\"1\"];"]
-  end
-
-  it "should handle SQL::Function with a window" do
-    dot(@ds.select{sum{}.over(:partition=>:a)}).must_equal ["1 -> 2 [label=\"select\"];", "2 [label=\"Array\"];", "2 -> 3 [label=\"0\"];", "3 [label=\"Function: sum\"];", "3 -> 4 [label=\"args\"];", "4 [label=\"Array\"];", "3 -> 5 [label=\"opts\"];", "5 [label=\"Hash\"];", "5 -> 6 [label=\"over\"];", "6 [label=\"Window\"];", "6 -> 7 [label=\"opts\"];", "7 [label=\"Hash\"];", "7 -> 8 [label=\"partition\"];", "8 [label=\":a\"];"]
-  end
-
-  it "should handle SQL::PlaceholderLiteralString" do
-    dot(@ds.where("?", true)).must_equal ["1 -> 2 [label=\"where\"];", "2 [label=\"PlaceholderLiteralString: \\\"(?)\\\"\"];", "2 -> 3 [label=\"args\"];", "3 [label=\"Array\"];", "3 -> 4 [label=\"0\"];", "4 [label=\"true\"];"]
-  end
-
-  it "should handle JOIN ON" do
-    dot(@ds.from(:a).join(:d, :b=>:c)).must_equal ["1 -> 2 [label=\"from\"];", "2 [label=\"Array\"];", "2 -> 3 [label=\"0\"];", "3 [label=\":a\"];", "1 -> 4 [label=\"join\"];", "4 [label=\"Array\"];", "4 -> 5 [label=\"0\"];", "5 [label=\"INNER JOIN ON\"];", "5 -> 6 [label=\"table\"];", "6 [label=\":d\"];", "5 -> 7 [label=\"on\"];", "7 [label=\"ComplexExpression: =\"];", "7 -> 8 [label=\"0\"];", "8 [label=\"QualifiedIdentifier\"];", "8 -> 9 [label=\"table\"];", "9 [label=\"\\\"d\\\"\"];", "8 -> 10 [label=\"column\"];", "10 [label=\"\\\"b\\\"\"];", "7 -> 11 [label=\"1\"];", "11 [label=\"QualifiedIdentifier\"];", "11 -> 12 [label=\"table\"];", "12 [label=\"\\\"a\\\"\"];", "11 -> 13 [label=\"column\"];", "13 [label=\"\\\"c\\\"\"];"]
-  end
-
-  it "should handle JOIN USING" do
-    dot(@ds.from(:a).join(:d, [:c], :table_alias=>:c)).must_equal ["1 -> 2 [label=\"from\"];", "2 [label=\"Array\"];", "2 -> 3 [label=\"0\"];", "3 [label=\":a\"];", "1 -> 4 [label=\"join\"];", "4 [label=\"Array\"];", "4 -> 5 [label=\"0\"];", "5 [label=\"INNER JOIN USING\"];", "5 -> 6 [label=\"table\"];", "6 [label=\"AliasedExpression\"];", "6 -> 7 [label=\"expression\"];", "7 [label=\":d\"];", "6 -> 8 [label=\"alias\"];", "8 [label=\":c\"];", "5 -> 9 [label=\"using\"];", "9 [label=\"Array\"];", "9 -> 10 [label=\"0\"];", "10 [label=\":c\"];"]
-  end
-
-  it "should handle other types" do
-    o = Object.new
-    def o.inspect
-      "blah"
-    end
-    dot(@ds.select(o)).must_equal ["1 -> 2 [label=\"select\"];", "2 [label=\"Array\"];", "2 -> 3 [label=\"0\"];", "3 [label=\"Unhandled: blah\"];"]
-  end
-end

data/spec/extensions/touch_spec.rb

@@ -1,203 +0,0 @@
-require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
-
-describe "Touch plugin" do
-  before do
-    @c = Class.new(Sequel::Model)
-    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)
-    DB.reset
-  end
-
-  it "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
-    DB.sqls.first.must_match(/UPDATE a SET updated_at = '[-0-9 :.]+' WHERE \(id = 1\)/)
-  end
-
-  it "should work with current_datetime_timestamp extension" do
-    c = Class.new(Sequel::Model).set_dataset(:a)
-    c.dataset = c.dataset.extension(:current_datetime_timestamp)
-    c.plugin :touch
-    c.columns :id, :updated_at
-    c.load(:id=>1).touch
-    DB.sqls.must_equal ["UPDATE a SET updated_at = CURRENT_TIMESTAMP WHERE (id = 1)"]
-  end
-
-  it "should allow #touch instance method for updating the updated_at column" do
-    @Artist.plugin :touch
-    @a.touch
-    DB.sqls.must_equal ["UPDATE artists SET updated_at = CURRENT_TIMESTAMP WHERE (id = 1)"]
-  end
-
-  it "should have #touch take an argument for the column to touch" do
-    @Artist.plugin :touch
-    @a.touch(:modified_on)
-    DB.sqls.must_equal ["UPDATE artists SET modified_on = CURRENT_TIMESTAMP WHERE (id = 1)"]
-  end
-
-  it "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
-    DB.sqls.must_equal ["UPDATE artists SET modified_on = CURRENT_TIMESTAMP WHERE (id = 1)"]
-  end
-
-  it "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
-    DB.sqls.must_equal ["UPDATE artists SET modified_on = CURRENT_TIMESTAMP WHERE (id = 1)"]
-  end
-
-  it "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
-    DB.sqls.must_equal ["UPDATE artists SET updated_at = CURRENT_TIMESTAMP WHERE (id = 1)",
-      "UPDATE albums SET updated_at = CURRENT_TIMESTAMP WHERE (albums.artist_id = 1)"]
-  end
-
-  it "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
-    sqls = DB.sqls
-    sqls.shift.must_equal "UPDATE albums SET updated_at = CURRENT_TIMESTAMP WHERE (id = 4)"
-    sqls.sort.must_equal ["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
-
-  it "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
-    DB.sqls.must_equal ["UPDATE artists SET updated_at = CURRENT_TIMESTAMP WHERE (id = 1)",
-      "UPDATE albums SET modified_on = CURRENT_TIMESTAMP WHERE (albums.artist_id = 1)"]
-  end
-
-  it "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
-    DB.sqls.must_equal ["UPDATE artists SET modified_on = CURRENT_TIMESTAMP WHERE (id = 1)",
-      "UPDATE albums SET modified_on = CURRENT_TIMESTAMP WHERE (albums.artist_id = 1)"]
-  end
-
-  it "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
-    sqls = DB.sqls
-    sqls.shift.must_equal "UPDATE albums SET updated_at = CURRENT_TIMESTAMP WHERE (id = 4)"
-    sqls.sort.must_equal ["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
-
-  it "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
-    sqls = DB.sqls
-    sqls.shift.must_equal "UPDATE albums SET updated_at = CURRENT_TIMESTAMP WHERE (id = 4)"
-    sqls.sort.must_equal ["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
-
-  it "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
-    sqls = DB.sqls
-    sqls.shift.must_equal "DELETE FROM albums WHERE id = 4"
-    sqls.sort.must_equal ["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
-
-  it "should be able to touch many_to_one associations" do
-    @Album.plugin :touch, :associations=>:artist
-    @Album.load(:id=>3, :artist_id=>4).touch
-    DB.sqls.must_equal ["UPDATE albums SET updated_at = CURRENT_TIMESTAMP WHERE (id = 3)",
-      "UPDATE artists SET updated_at = CURRENT_TIMESTAMP WHERE (artists.id = 4)"]
-  end
-
-  it "should be able to touch many_to_one associations" do
-    @Artist.one_to_one :album, :class=>@Album, :key=>:artist_id
-    @Artist.plugin :touch, :associations=>:album
-    @a.touch
-    DB.sqls.must_equal ["UPDATE artists SET updated_at = CURRENT_TIMESTAMP WHERE (id = 1)",
-      "UPDATE albums SET updated_at = CURRENT_TIMESTAMP WHERE (albums.artist_id = 1)"]
-  end
-
-  it "should be able to touch many_to_many associations" do
-    @Artist.many_to_many :albums, :class=>@Album, :left_key=>:artist_id, :join_table=>:aa
-    @Artist.plugin :touch, :associations=>:albums
-    @a.touch
-    DB.sqls.must_equal ["UPDATE artists SET updated_at = CURRENT_TIMESTAMP WHERE (id = 1)",
-      "SELECT albums.* FROM albums INNER JOIN aa ON (aa.album_id = albums.id) WHERE (aa.artist_id = 1)",
-      "UPDATE albums SET updated_at = CURRENT_TIMESTAMP WHERE (id = 1)"]
-  end
-
-  it "should be able to touch many_through_many associations" do
-    @Artist.plugin :many_through_many
-    @Artist.many_through_many :albums, [[:aa, :artist_id, :album_id]], :class=>@Album
-    @Artist.plugin :touch, :associations=>:albums
-    @a.touch
-    DB.sqls.must_equal ["UPDATE artists SET updated_at = CURRENT_TIMESTAMP WHERE (id = 1)",
-      "SELECT albums.* FROM albums INNER JOIN aa ON (aa.album_id = albums.id) WHERE (aa.artist_id = 1)",
-      "UPDATE albums SET updated_at = CURRENT_TIMESTAMP WHERE (id = 1)"]
-  end
-
-  it "should handle touching many_to_one associations with no associated object" do
-    @Album.plugin :touch, :associations=>:artist
-    @Album.load(:id=>3, :artist_id=>nil).touch
-    DB.sqls.must_equal ["UPDATE albums SET updated_at = CURRENT_TIMESTAMP WHERE (id = 3)"]
-  end
-
-  it "should not update a column that doesn't exist" do
-    @Album.plugin :touch, :column=>:x
-    a = @Album.load(:id=>1)
-    a.touch
-    DB.sqls.must_equal []
-    a.artist_id = 1
-    a.touch
-    DB.sqls.must_equal ['UPDATE albums SET artist_id = 1 WHERE (id = 1)']
-  end
-
-  it "should raise an error if given a column argument in touch that doesn't exist" do
-    @Artist.plugin :touch
-    proc{@a.touch(:x)}.must_raise(Sequel::MassAssignmentRestriction)
-  end
-
-  it "should raise an Error when a nonexistent association is given" do
-    @Artist.plugin :touch
-    proc{@Artist.plugin :touch, :associations=>:blah}.must_raise(Sequel::Error)
-  end
-
-  it "should work correctly in subclasses" do
-    @Artist.plugin :touch
-    c1 = Class.new(@Artist)
-    c1.load(:id=>4).touch
-    DB.sqls.must_equal ["UPDATE artists SET updated_at = CURRENT_TIMESTAMP WHERE (id = 4)"]
-
-    c1.touch_column = :modified_on
-    c1.touch_associations :albums
-    c1.load(:id=>1).touch
-    DB.sqls.must_equal ["UPDATE artists SET modified_on = CURRENT_TIMESTAMP WHERE (id = 1)",
-      "UPDATE albums SET modified_on = CURRENT_TIMESTAMP WHERE (albums.artist_id = 1)"]
-
-    @a.touch
-    DB.sqls.must_equal ["UPDATE artists SET updated_at = CURRENT_TIMESTAMP WHERE (id = 1)"]
-
-    @Artist.plugin :touch, :column=>:modified_on, :associations=>:albums
-    c2 = Class.new(@Artist)
-    c2.load(:id=>4).touch
-    DB.sqls.must_equal ["UPDATE artists SET modified_on = CURRENT_TIMESTAMP WHERE (id = 4)",
-      "UPDATE albums SET modified_on = CURRENT_TIMESTAMP WHERE (albums.artist_id = 4)"]
-  end
-end

data/spec/extensions/tree_spec.rb

@@ -1,274 +0,0 @@
-require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
-
-describe Sequel::Model, "tree plugin" do
-  def klass(opts={})
-    @db = DB
-    c = Class.new(Sequel::Model(@db[:nodes]))
-    c.class_eval do
-      def self.name; 'Node'; end
-      columns :id, :name, :parent_id, :i, :pi
-      plugin :tree, opts
-    end
-    c
-  end
-
-  before do
-    @c = klass
-    @ds = @c.dataset
-    @o = @c.load(:id=>2, :parent_id=>1, :name=>'AA', :i=>3, :pi=>4)
-    @db.reset
-  end
-
-  it "should define the correct associations" do
-    @c.associations.sort_by{|x| x.to_s}.must_equal [:children, :parent]
-  end
-  
-  it "should define the correct reciprocals" do
-    @c.associations.sort_by{|x| x.to_s}.map{|x| @c.association_reflection(x).reciprocal}.must_equal [:parent, :children]
-  end
-  
-  it "should define the correct associations when giving options" do
-    klass(:children=>{:name=>:cs}, :parent=>{:name=>:p}).associations.sort_by{|x| x.to_s}.must_equal [:cs, :p]
-  end
-
-  it "should use the correct SQL for lazy associations" do
-    @o.parent_dataset.sql.must_equal 'SELECT * FROM nodes WHERE (nodes.id = 1) LIMIT 1'
-    @o.children_dataset.sql.must_equal 'SELECT * FROM nodes WHERE (nodes.parent_id = 2)'
-  end
-  
-  it "should use the correct SQL for lazy associations when giving options" do
-    o = klass(:primary_key=>:i, :key=>:pi, :order=>:name, :children=>{:name=>:cs}, :parent=>{:name=>:p}).load(:id=>2, :parent_id=>1, :name=>'AA', :i=>3, :pi=>4)
-    o.p_dataset.sql.must_equal 'SELECT * FROM nodes WHERE (nodes.i = 4) ORDER BY name LIMIT 1'
-    o.cs_dataset.sql.must_equal 'SELECT * FROM nodes WHERE (nodes.pi = 3) ORDER BY name'
-  end
-
-  it "should have parent_column give the symbol of the parent column" do
-    @c.parent_column.must_equal :parent_id
-    klass(:key=>:p_id).parent_column.must_equal :p_id
-  end
-
-  it "should have tree_order give the order of the association" do
-    @c.tree_order.must_equal nil
-    klass(:order=>:name).tree_order.must_equal :name
-    klass(:order=>[:parent_id, :name]).tree_order.must_equal [:parent_id, :name]
-  end
-
-  it "should work correctly in subclasses" do
-    o = Class.new(klass(:primary_key=>:i, :key=>:pi, :order=>:name, :children=>{:name=>:cs}, :parent=>{:name=>:p})).load(:id=>2, :parent_id=>1, :name=>'AA', :i=>3, :pi=>4)
-    o.p_dataset.sql.must_equal 'SELECT * FROM nodes WHERE (nodes.i = 4) ORDER BY name LIMIT 1'
-    o.cs_dataset.sql.must_equal 'SELECT * FROM nodes WHERE (nodes.pi = 3) ORDER BY name'
-  end
-
-  it "should have roots return an array of the tree's roots" do
-    @ds._fetch = [{:id=>1, :parent_id=>nil, :name=>'r'}]
-    @c.roots.must_equal [@c.load(:id=>1, :parent_id=>nil, :name=>'r')]
-    @db.sqls.must_equal ["SELECT * FROM nodes WHERE (parent_id IS NULL)"]
-  end
-
-  it "should have roots_dataset be a dataset representing the tree's roots" do
-    @c.roots_dataset.sql.must_equal "SELECT * FROM nodes WHERE (parent_id IS NULL)"
-  end
-
-  it "should have ancestors return the ancestors of the current node" do
-    @ds._fetch = [[{:id=>1, :parent_id=>5, :name=>'r'}], [{:id=>5, :parent_id=>nil, :name=>'r2'}]]
-    @o.ancestors.must_equal [@c.load(:id=>1, :parent_id=>5, :name=>'r'), @c.load(:id=>5, :parent_id=>nil, :name=>'r2')]
-    @db.sqls.must_equal ["SELECT * FROM nodes WHERE id = 1",
-      "SELECT * FROM nodes WHERE id = 5"]
-  end
-
-  it "should have descendants return the descendants of the current node" do
-    @ds._fetch = [[{:id=>3, :parent_id=>2, :name=>'r'}, {:id=>4, :parent_id=>2, :name=>'r2'}], [{:id=>5, :parent_id=>4, :name=>'r3'}], []]
-    @o.descendants.must_equal [@c.load(:id=>3, :parent_id=>2, :name=>'r'), @c.load(:id=>4, :parent_id=>2, :name=>'r2'), @c.load(:id=>5, :parent_id=>4, :name=>'r3')] 
-    @db.sqls.must_equal ["SELECT * FROM nodes WHERE (nodes.parent_id = 2)",
-      "SELECT * FROM nodes WHERE (nodes.parent_id = 3)",
-      "SELECT * FROM nodes WHERE (nodes.parent_id = 5)",
-      "SELECT * FROM nodes WHERE (nodes.parent_id = 4)"]
-  end
-
-  it "should have root return the root of the current node" do
-    @ds._fetch = [[{:id=>1, :parent_id=>5, :name=>'r'}], [{:id=>5, :parent_id=>nil, :name=>'r2'}]]
-    @o.root.must_equal @c.load(:id=>5, :parent_id=>nil, :name=>'r2')
-    @db.sqls.must_equal ["SELECT * FROM nodes WHERE id = 1",
-      "SELECT * FROM nodes WHERE id = 5"]
-  end
-
-  it "should have root? return true for a root node and false for a child node" do
-    @c.load(:parent_id => nil).root?.must_equal true
-    @c.load(:parent_id => 1).root?.must_equal false
-  end
-
-  it "should have root? return false for an new node" do
-    @c.new.root?.must_equal false
-  end
-
-  it "should have self_and_siblings return the children of the current node's parent" do
-    @ds._fetch = [[{:id=>1, :parent_id=>3, :name=>'r'}], [{:id=>7, :parent_id=>1, :name=>'r2'}, @o.values.dup]]
-    @o.self_and_siblings.must_equal [@c.load(:id=>7, :parent_id=>1, :name=>'r2'), @o] 
-    @db.sqls.must_equal ["SELECT * FROM nodes WHERE id = 1",
-      "SELECT * FROM nodes WHERE (nodes.parent_id = 1)"]
-  end
-
-  it "should have siblings return the children of the current node's parent, except for the current node" do
-    @ds._fetch = [[{:id=>1, :parent_id=>3, :name=>'r'}], [{:id=>7, :parent_id=>1, :name=>'r2'}, @o.values.dup]]
-    @o.siblings.must_equal [@c.load(:id=>7, :parent_id=>1, :name=>'r2')] 
-    @db.sqls.must_equal ["SELECT * FROM nodes WHERE id = 1",
-      "SELECT * FROM nodes WHERE (nodes.parent_id = 1)"]
-  end
-
-  describe ":single_root option" do
-    before do
-      @c = klass(:single_root => true)
-    end
-
-    it "should have root class method return the root" do
-      @c.dataset._fetch = [{:id=>1, :parent_id=>nil, :name=>'r'}]
-      @c.root.must_equal @c.load(:id=>1, :parent_id=>nil, :name=>'r')
-    end
-
-    it "prevents creating a second root" do
-      @c.dataset._fetch = [{:id=>1, :parent_id=>nil, :name=>'r'}]
-      lambda { @c.create }.must_raise(Sequel::Plugins::Tree::TreeMultipleRootError)
-    end
-
-    it "errors when promoting an existing record to a second root" do
-      @c.dataset._fetch = [{:id=>1, :parent_id=>nil, :name=>'r'}]
-      n = @c.load(:id => 2, :parent_id => 1)
-      lambda { n.update(:parent_id => nil) }.must_raise(Sequel::Plugins::Tree::TreeMultipleRootError)
-    end
-
-    it "allows updating existing root" do
-      @c.dataset._fetch = [{:id=>1, :parent_id=>nil, :name=>'r'}]
-       @c.root.update(:name => 'fdsa') 
-    end
-  end
-end
-
-describe Sequel::Model, "tree plugin with composite keys" do
-  def klass(opts={})
-    @db = DB
-    c = Class.new(Sequel::Model(@db[:nodes]))
-    c.class_eval do
-      def self.name; 'Node'; end
-      columns :id, :id2, :name, :parent_id, :parent_id2, :i, :pi
-      set_primary_key [:id, :id2]
-      plugin :tree, opts.merge(:key=>[:parent_id, :parent_id2])
-    end
-    c
-  end
-
-  before do
-    @c = klass
-    @ds = @c.dataset
-    @o = @c.load(:id=>2, :id2=>5, :parent_id=>1, :parent_id2=>6, :name=>'AA', :i=>3, :pi=>4)
-    @db.reset
-  end
-
-  
-  it "should use the correct SQL for lazy associations" do
-    @o.parent_dataset.sql.must_equal 'SELECT * FROM nodes WHERE ((nodes.id = 1) AND (nodes.id2 = 6)) LIMIT 1'
-    @o.children_dataset.sql.must_equal 'SELECT * FROM nodes WHERE ((nodes.parent_id = 2) AND (nodes.parent_id2 = 5))'
-  end
-  
-  it "should have parent_column give an array of symbols of the parent column" do
-    @c.parent_column.must_equal [:parent_id, :parent_id2]
-  end
-
-  it "should have roots return an array of the tree's roots" do
-    @ds._fetch = [{:id=>1, :parent_id=>nil, :parent_id2=>nil, :name=>'r'}]
-    @c.roots.must_equal [@c.load(:id=>1, :parent_id=>nil, :parent_id2=>nil, :name=>'r')]
-    @db.sqls.must_equal ["SELECT * FROM nodes WHERE ((parent_id IS NULL) OR (parent_id2 IS NULL))"]
-  end
-
-  it "should have roots_dataset be a dataset representing the tree's roots" do
-    @c.roots_dataset.sql.must_equal "SELECT * FROM nodes WHERE ((parent_id IS NULL) OR (parent_id2 IS NULL))"
-  end
-
-  it "should have ancestors return the ancestors of the current node" do
-    @ds._fetch = [[{:id=>1, :id2=>6, :parent_id=>5, :parent_id2=>7, :name=>'r'}], [{:id=>5, :id2=>7, :parent_id=>nil, :parent_id2=>nil, :name=>'r2'}]]
-    @o.ancestors.must_equal [@c.load(:id=>1, :id2=>6, :parent_id=>5, :parent_id2=>7, :name=>'r'), @c.load(:id=>5, :id2=>7, :parent_id=>nil, :parent_id2=>nil, :name=>'r2')]
-    sqls = @db.sqls
-    sqls.length.must_equal 2
-    ["SELECT * FROM nodes WHERE ((id = 1) AND (id2 = 6)) LIMIT 1", "SELECT * FROM nodes WHERE ((id2 = 6) AND (id = 1)) LIMIT 1"].must_include(sqls[0])
-    ["SELECT * FROM nodes WHERE ((id = 5) AND (id2 = 7)) LIMIT 1", "SELECT * FROM nodes WHERE ((id2 = 7) AND (id = 5)) LIMIT 1"].must_include(sqls[1])
-  end
-
-  it "should have descendants return the descendants of the current node" do
-    @ds._fetch = [[{:id=>3, :id2=>7, :parent_id=>2, :parent_id2=>5, :name=>'r'}, {:id=>4, :id2=>8, :parent_id=>2, :parent_id2=>5, :name=>'r2'}], [{:id=>5, :id2=>9, :parent_id=>4, :parent_id2=>8, :name=>'r3'}], []]
-    @o.descendants.must_equal [@c.load(:id=>3, :id2=>7, :parent_id=>2, :parent_id2=>5, :name=>'r'), @c.load(:id=>4, :id2=>8, :parent_id=>2, :parent_id2=>5, :name=>'r2'), @c.load(:id=>5, :id2=>9, :parent_id=>4, :parent_id2=>8, :name=>'r3')] 
-    @db.sqls.must_equal ["SELECT * FROM nodes WHERE ((nodes.parent_id = 2) AND (nodes.parent_id2 = 5))",
-      "SELECT * FROM nodes WHERE ((nodes.parent_id = 3) AND (nodes.parent_id2 = 7))",
-      "SELECT * FROM nodes WHERE ((nodes.parent_id = 5) AND (nodes.parent_id2 = 9))",
-      "SELECT * FROM nodes WHERE ((nodes.parent_id = 4) AND (nodes.parent_id2 = 8))"]
-  end
-
-  it "should have root return the root of the current node" do
-    @ds._fetch = [[{:id=>1, :id2=>6, :parent_id=>5, :parent_id2=>7, :name=>'r'}], [{:id=>5, :id2=>7, :parent_id=>nil, :parent_id2=>nil, :name=>'r2'}]]
-    @o.root.must_equal @c.load(:id=>5, :id2=>7, :parent_id=>nil, :parent_id2=>nil, :name=>'r2')
-    sqls = @db.sqls
-    sqls.length.must_equal 2
-    ["SELECT * FROM nodes WHERE ((id = 1) AND (id2 = 6)) LIMIT 1", "SELECT * FROM nodes WHERE ((id2 = 6) AND (id = 1)) LIMIT 1"].must_include(sqls[0])
-    ["SELECT * FROM nodes WHERE ((id = 5) AND (id2 = 7)) LIMIT 1", "SELECT * FROM nodes WHERE ((id2 = 7) AND (id = 5)) LIMIT 1"].must_include(sqls[1])
-  end
-
-  it "should have root? return true for a root node and false for a child node" do
-    @c.load(:parent_id => nil, :parent_id2=>nil).root?.must_equal true
-    @c.load(:parent_id => 1, :parent_id2=>nil).root?.must_equal true
-    @c.load(:parent_id => nil, :parent_id2=>2).root?.must_equal true
-    @c.load(:parent_id => 1, :parent_id2=>2).root?.must_equal false
-  end
-
-  it "should have root? return false for an new node" do
-    @c.new.root?.must_equal false
-  end
-
-  it "should have self_and_siblings return the children of the current node's parent" do
-    @ds._fetch = [[{:id=>1, :id2=>6, :parent_id=>3, :parent_id2=>7, :name=>'r'}], [{:id=>7, :id2=>9, :parent_id=>1, :parent_id2=>6, :name=>'r2'}, @o.values.dup]]
-    @o.self_and_siblings.must_equal [@c.load(:id=>7, :id2=>9, :parent_id=>1, :parent_id2=>6, :name=>'r2'), @o] 
-    sqls = @db.sqls
-    sqls.length.must_equal 2
-    ["SELECT * FROM nodes WHERE ((id = 1) AND (id2 = 6)) LIMIT 1", "SELECT * FROM nodes WHERE ((id2 = 6) AND (id = 1)) LIMIT 1"].must_include(sqls[0])
-    sqls[1].must_equal "SELECT * FROM nodes WHERE ((nodes.parent_id = 1) AND (nodes.parent_id2 = 6))"
-  end
-
-  it "should have siblings return the children of the current node's parent, except for the current node" do
-    @ds._fetch = [[{:id=>1, :id2=>6, :parent_id=>3, :parent_id2=>7, :name=>'r'}], [{:id=>7, :id2=>9, :parent_id=>1, :parent_id2=>6, :name=>'r2'}, @o.values.dup]]
-    @o.siblings.must_equal [@c.load(:id=>7, :id2=>9, :parent_id=>1, :parent_id2=>6, :name=>'r2')] 
-    sqls = @db.sqls
-    sqls.length.must_equal 2
-    ["SELECT * FROM nodes WHERE ((id = 1) AND (id2 = 6)) LIMIT 1", "SELECT * FROM nodes WHERE ((id2 = 6) AND (id = 1)) LIMIT 1"].must_include(sqls[0])
-    sqls[1].must_equal "SELECT * FROM nodes WHERE ((nodes.parent_id = 1) AND (nodes.parent_id2 = 6))"
-  end
-
-  describe ":single_root option" do
-    before do
-      @c = klass(:single_root => true)
-    end
-
-    it "prevents creating a second root" do
-      @c.dataset._fetch = [{:id=>1, :id2=>6, :parent_id=>nil, :parent_id2=>nil, :name=>'r'}]
-      lambda { @c.create }.must_raise(Sequel::Plugins::Tree::TreeMultipleRootError)
-      @c.dataset._fetch = [{:id=>1, :id2=>6, :parent_id=>1, :parent_id2=>nil, :name=>'r'}]
-      lambda { @c.create(:parent_id2=>1) }.must_raise(Sequel::Plugins::Tree::TreeMultipleRootError)
-      @c.dataset._fetch = [{:id=>1, :id2=>6, :parent_id=>nil, :parent_id2=>2, :name=>'r'}]
-      lambda { @c.create(:parent_id=>2) }.must_raise(Sequel::Plugins::Tree::TreeMultipleRootError)
-    end
-
-    it "errors when promoting an existing record to a second root" do
-      @c.dataset._fetch = [{:id=>1, :id2=>6, :parent_id=>nil, :parent_id2=>nil, :name=>'r'}]
-      lambda { @c.load(:id => 2, :id2=>7, :parent_id => 1, :parent_id2=>2).update(:parent_id => nil, :parent_id2=>nil) }.must_raise(Sequel::Plugins::Tree::TreeMultipleRootError)
-      @c.dataset._fetch = [{:id=>1, :id2=>6, :parent_id=>1, :parent_id2=>nil, :name=>'r'}]
-      lambda { @c.load(:id => 2, :id2=>7, :parent_id => 1, :parent_id2=>2).update(:parent_id => nil) }.must_raise(Sequel::Plugins::Tree::TreeMultipleRootError)
-      @c.dataset._fetch = [{:id=>1, :id2=>6, :parent_id=>nil, :parent_id2=>2, :name=>'r'}]
-      lambda { @c.load(:id => 2, :id2=>7, :parent_id => 1, :parent_id2=>2).update(:parent_id2 => nil) }.must_raise(Sequel::Plugins::Tree::TreeMultipleRootError)
-    end
-
-    it "allows updating existing root" do
-      @c.dataset._fetch = {:id=>1, :id2=>6, :parent_id=>nil, :parent_id2=>nil, :name=>'r'}
-       @c.root.update(:name => 'fdsa') 
-      @c.dataset._fetch = {:id=>1, :id2=>6, :parent_id=>1, :parent_id2=>nil, :name=>'r'}
-       @c.root.update(:name => 'fdsa') 
-      @c.dataset._fetch = {:id=>1, :id2=>6, :parent_id=>nil, :parent_id2=>2, :name=>'r'}
-       @c.root.update(:name => 'fdsa') 
-    end
-  end
-end