sequel 3.47.0 → 3.48.0

data/spec/extensions/core_refinements_spec.rb

@@ -134,7 +134,7 @@ end
 
 describe "Array#case and Hash#case" do
   before do
-    @d = Sequel::Dataset.new(nil)
+    @d = Sequel.mock.dataset
   end
 
   specify "should return SQL CASE expression" do
@@ -166,7 +166,7 @@ end
 
 describe "Array#sql_value_list and #sql_array" do
   before do
-    @d = Sequel::Dataset.new(nil)
+    @d = Sequel.mock.dataset
   end
 
   specify "should treat the array as an SQL value list instead of conditions when used as a placeholder value" do
@@ -231,7 +231,7 @@ end
 
 describe "#desc" do
   before do
-    @ds = Sequel::Dataset.new(nil)
+    @ds = Sequel.mock.dataset
   end
   
   specify "should format a DESC clause for a column ref" do
@@ -247,7 +247,7 @@ end
 
 describe "#asc" do
   before do
-    @ds = Sequel::Dataset.new(nil)
+    @ds = Sequel.mock.dataset
   end
   
   specify "should format a ASC clause for a column ref" do
@@ -263,7 +263,7 @@ end
 
 describe "#as" do
   before do
-    @ds = Sequel::Dataset.new(nil)
+    @ds = Sequel.mock.dataset
   end
   
   specify "should format a AS clause for a column ref" do
@@ -327,7 +327,7 @@ end
 
 describe "Symbol#*" do
   before do
-    @ds = Sequel::Dataset.new(nil)
+    @ds = Sequel.mock.dataset
   end
   
   specify "should format a qualified wildcard if no argument" do
@@ -347,7 +347,7 @@ end
 
 describe "Symbol" do
   before do
-    @ds = Sequel::Dataset.new(nil)
+    @ds = Sequel.mock.dataset
     @ds.quote_identifiers = true
     @ds.identifier_input_method = :upcase
   end

data/spec/extensions/dataset_associations_spec.rb

@@ -2,7 +2,7 @@ require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
 
 describe "Sequel::Plugins::DatasetAssociations" do
   before do
-    @db = Sequel::Database.new
+    @db = Sequel.mock
     @Base = Class.new(Sequel::Model)
     @Base.plugin :dataset_associations
 
@@ -140,7 +140,7 @@ end
 
 describe "Sequel::Plugins::DatasetAssociations with composite keys" do
   before do
-    @db = Sequel::Database.new
+    @db = Sequel.mock
     @Base = Class.new(Sequel::Model)
     @Base.plugin :dataset_associations
 

data/spec/extensions/date_arithmetic_spec.rb

@@ -142,7 +142,7 @@ describe "date_arithmetic extension" do
     db.literal(Sequel.date_add(:a, @h2)).should == "(CAST(a AS timestamp) + 1 years + 1 months + 1 days + 1 hours + 1 minutes + 1 seconds)"
   end
 
-  it "should raise error if literalizing on an unsupported database" do
+  qspecify "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))}.should raise_error(Sequel::NotImplemented)

data/spec/extensions/defaults_setter_spec.rb

@@ -2,7 +2,8 @@ require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
 
 describe "Sequel::Plugins::DefaultsSetter" do
   before do
-    @db = db = Sequel::Database.new
+    @db = db = Sequel.mock
+    def db.supports_schema_parsing?() true end
     @c = c = Class.new(Sequel::Model(db[:foo]))
     @c.instance_variable_set(:@db_schema, {:a=>{}})
     @c.plugin :defaults_setter

data/spec/extensions/empty_array_ignore_nulls_spec.rb

@@ -0,0 +1,24 @@
+require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
+
+describe "filter_having extension" do
+  before do
+    @dataset = Sequel.mock[:test].extension(:empty_array_ignore_nulls)
+  end
+
+  specify "should handle all types of IN/NOT IN queries with empty arrays" do
+    @dataset.filter(:id => []).sql.should == "SELECT * FROM test WHERE (1 = 0)"
+    @dataset.filter([:id1, :id2] => []).sql.should == "SELECT * FROM test WHERE (1 = 0)"
+    @dataset.exclude(:id => []).sql.should == "SELECT * FROM test WHERE (1 = 1)"
+    @dataset.exclude([:id1, :id2] => []).sql.should == "SELECT * FROM test WHERE (1 = 1)"
+  end
+
+  specify "should handle IN/NOT IN queries with multiple columns and an empty dataset where the database doesn't support it" do
+    @dataset.meta_def(:supports_multiple_column_in?){false}
+    db = Sequel.mock
+    d1 = db[:test].select(:id1, :id2).filter(:region=>'Asia').columns(:id1, :id2)
+    @dataset.filter([:id1, :id2] => d1).sql.should == "SELECT * FROM test WHERE (1 = 0)"
+    db.sqls.should == ["SELECT id1, id2 FROM test WHERE (region = 'Asia')"]
+    @dataset.exclude([:id1, :id2] => d1).sql.should == "SELECT * FROM test WHERE (1 = 1)"
+    db.sqls.should == ["SELECT id1, id2 FROM test WHERE (region = 'Asia')"]
+  end
+end

data/spec/extensions/filter_having_spec.rb

@@ -0,0 +1,40 @@
+require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
+
+describe "filter_having extension" do
+  before do
+    @ds = Sequel.mock[:t].extension(:filter_having)
+    @dsh = @ds.having(:a)
+  end
+
+  it "should make filter operate on HAVING clause if dataset has a HAVING clause" do
+    @dsh.filter(:b).sql.should == 'SELECT * FROM t HAVING (a AND b)'
+  end
+
+  it "should make filter operate on WHERE clause if dataset does not have a HAVING clause" do
+    @ds.filter(:b).sql.should == 'SELECT * FROM t WHERE b'
+  end
+
+  it "should make and operate on HAVING clause if dataset has a HAVING clause" do
+    @dsh.and(:b).sql.should == 'SELECT * FROM t HAVING (a AND b)'
+  end
+
+  it "should make and operate on WHERE clause if dataset does not have a HAVING clause" do
+    @ds.where(:a).and(:b).sql.should == 'SELECT * FROM t WHERE (a AND b)'
+  end
+
+  it "should make or operate on HAVING clause if dataset has a HAVING clause" do
+    @dsh.or(:b).sql.should == 'SELECT * FROM t HAVING (a OR b)'
+  end
+
+  it "should make or operate on WHERE clause if dataset does not have a HAVING clause" do
+    @ds.where(:a).or(:b).sql.should == 'SELECT * FROM t WHERE (a OR b)'
+  end
+
+  it "should make exclude operate on HAVING clause if dataset has a HAVING clause" do
+    @dsh.exclude(:b).sql.should == 'SELECT * FROM t HAVING (a AND NOT b)'
+  end
+
+  it "should make exclude operate on WHERE clause if dataset does not have a HAVING clause" do
+    @ds.exclude(:b).sql.should == 'SELECT * FROM t WHERE NOT b'
+  end
+end

data/spec/extensions/graph_each_spec.rb

@@ -0,0 +1,109 @@
+require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
+
+describe Sequel::Dataset, " graphing" do
+  before do
+    @db = Sequel.mock(:columns=>proc do |sql|
+      case sql
+      when /points/
+        [:id, :x, :y]
+      when /lines/
+        [:id, :x, :y, :graph_id]
+      else
+        [:id, :name, :x, :y, :lines_x]
+      end
+    end).extension(:graph_each)
+    @ds1 = @db.from(:points)
+    @ds2 = @db.from(:lines)
+    @ds3 = @db.from(:graphs)
+    [@ds1, @ds2, @ds3].each{|ds| ds.columns}
+    @db.sqls
+  end
+
+  it "#graph_each should handle graph using currently selected columns as the basis for the selected columns in a new graph" do
+    ds = @ds1.select(:id).graph(@ds2, :x=>:id)
+    ds._fetch = {:id=>1, :lines_id=>2, :x=>3, :y=>4, :graph_id=>5}
+    ds.all.should == [{:points=>{:id=>1}, :lines=>{:id=>2, :x=>3, :y=>4, :graph_id=>5}}]
+
+    ds = @ds1.select(:id, :x).graph(@ds2, :x=>:id)
+    ds._fetch = {:id=>1, :x=>-1, :lines_id=>2, :lines_x=>3, :y=>4, :graph_id=>5}
+    ds.all.should == [{:points=>{:id=>1, :x=>-1}, :lines=>{:id=>2, :x=>3, :y=>4, :graph_id=>5}}]
+
+    ds = @ds1.select(Sequel.identifier(:id), Sequel.qualify(:points, :x)).graph(@ds2, :x=>:id)
+    ds._fetch = {:id=>1, :x=>-1, :lines_id=>2, :lines_x=>3, :y=>4, :graph_id=>5}
+    ds.all.should == [{:points=>{:id=>1, :x=>-1}, :lines=>{:id=>2, :x=>3, :y=>4, :graph_id=>5}}]
+
+    ds = @ds1.select(Sequel.identifier(:id).qualify(:points), Sequel.identifier(:x).as(:y)).graph(@ds2, :x=>:id)
+    ds._fetch = {:id=>1, :y=>-1, :lines_id=>2, :x=>3, :lines_y=>4, :graph_id=>5}
+    ds.all.should == [{:points=>{:id=>1, :y=>-1}, :lines=>{:id=>2, :x=>3, :y=>4, :graph_id=>5}}]
+
+    ds = @ds1.select(:id, Sequel.identifier(:x).qualify(Sequel.identifier(:points)).as(Sequel.identifier(:y))).graph(@ds2, :x=>:id)
+    ds._fetch = {:id=>1, :y=>-1, :lines_id=>2, :x=>3, :lines_y=>4, :graph_id=>5}
+    ds.all.should == [{:points=>{:id=>1, :y=>-1}, :lines=>{:id=>2, :x=>3, :y=>4, :graph_id=>5}}]
+  end
+
+  it "#graph_each should split the result set into component tables" do
+    @db.fetch = [[{:id=>1,:x=>2,:y=>3,:lines_id=>4,:lines_x=>5,:lines_y=>6,:graph_id=>7}],
+      [{:id=>1,:x=>2,:y=>3,:lines_id=>4,:lines_x=>5,:lines_y=>6,:graph_id=>7, :graphs_id=>8, :name=>9, :graphs_x=>10, :graphs_y=>11, :graphs_lines_x=>12}],
+      [{:id=>1,:x=>2,:y=>3,:lines_id=>4,:lines_x=>5,:lines_y=>6,:graph_id=>7, :graph_id_0=>8, :graph_x=>9, :graph_y=>10, :graph_graph_id=>11}]]
+
+    @ds1.graph(@ds2, :x=>:id).all.should == [{:points=>{:id=>1, :x=>2, :y=>3}, :lines=>{:id=>4, :x=>5, :y=>6, :graph_id=>7}}]
+    @ds1.graph(@ds2, :x=>:id).graph(@ds3, :id=>:graph_id).all.should == [{:points=>{:id=>1, :x=>2, :y=>3}, :lines=>{:id=>4, :x=>5, :y=>6, :graph_id=>7}, :graphs=>{:id=>8, :name=>9, :x=>10, :y=>11, :lines_x=>12}}]
+    @ds1.graph(@ds2, :x=>:id).graph(@ds2, {:y=>:points__id}, :table_alias=>:graph).all.should == [{:points=>{:id=>1, :x=>2, :y=>3}, :lines=>{:id=>4, :x=>5, :y=>6, :graph_id=>7}, :graph=>{:id=>8, :x=>9, :y=>10, :graph_id=>11}}]
+  end
+
+  it "#graph_each should give a nil value instead of a hash when all values for a table are nil" do
+    @db.fetch = [[{:id=>1,:x=>2,:y=>3,:lines_id=>nil,:lines_x=>nil,:lines_y=>nil,:graph_id=>nil}],
+      [{:id=>1,:x=>2,:y=>3,:lines_id=>4,:lines_x=>5,:lines_y=>6,:graph_id=>7, :graphs_id=>nil, :name=>nil, :graphs_x=>nil, :graphs_y=>nil, :graphs_lines_x=>nil},
+      {:id=>2,:x=>4,:y=>5,:lines_id=>nil,:lines_x=>nil,:lines_y=>nil,:graph_id=>nil, :graphs_id=>nil, :name=>nil, :graphs_x=>nil, :graphs_y=>nil, :graphs_lines_x=>nil},
+      {:id=>3,:x=>5,:y=>6,:lines_id=>4,:lines_x=>5,:lines_y=>6,:graph_id=>7, :graphs_id=>7, :name=>8, :graphs_x=>9, :graphs_y=>10, :graphs_lines_x=>11},
+      {:id=>3,:x=>5,:y=>6,:lines_id=>7,:lines_x=>5,:lines_y=>8,:graph_id=>9, :graphs_id=>9, :name=>10, :graphs_x=>10, :graphs_y=>11, :graphs_lines_x=>12}]]
+
+    @ds1.graph(@ds2, :x=>:id).all.should == [{:points=>{:id=>1, :x=>2, :y=>3}, :lines=>nil}]
+    @ds1.graph(@ds2, :x=>:id).graph(@ds3, :id=>:graph_id).all.should == [{:points=>{:id=>1, :x=>2, :y=>3}, :lines=>{:id=>4, :x=>5, :y=>6, :graph_id=>7}, :graphs=>nil},
+      {:points=>{:id=>2, :x=>4, :y=>5}, :lines=>nil, :graphs=>nil},
+      {:points=>{:id=>3, :x=>5, :y=>6}, :lines=>{:id=>4, :x=>5, :y=>6, :graph_id=>7}, :graphs=>{:id=>7, :name=>8, :x=>9, :y=>10, :lines_x=>11}},
+      {:points=>{:id=>3, :x=>5, :y=>6}, :lines=>{:id=>7, :x=>5, :y=>8, :graph_id=>9}, :graphs=>{:id=>9, :name=>10, :x=>10, :y=>11, :lines_x=>12}}]
+  end
+
+  it "#graph_each should not give a nil value instead of a hash when any value for a table is false" do
+    @db.fetch = {:id=>1,:x=>2,:y=>3,:lines_id=>nil,:lines_x=>false,:lines_y=>nil,:graph_id=>nil}
+    @ds1.graph(@ds2, :x=>:id).all.should == [{:points=>{:id=>1, :x=>2, :y=>3}, :lines=>{:id=>nil, :x=>false, :y=>nil, :graph_id=>nil}}]
+  end
+
+  it "#graph_each should not included tables graphed with the :select => false option in the result set" do
+    @db.fetch = {:id=>1,:x=>2,:y=>3,:graphs_id=>8, :name=>9, :graphs_x=>10, :graphs_y=>11, :lines_x=>12}
+    @ds1.graph(:lines, {:x=>:id}, :select=>false).graph(:graphs, :id=>:graph_id).all.should == [{:points=>{:id=>1, :x=>2, :y=>3}, :graphs=>{:id=>8, :name=>9, :x=>10, :y=>11, :lines_x=>12}}]
+  end
+
+  it "#graph_each should only include the columns selected with #set_graph_aliases and #add_graph_aliases, if called" do
+    @db.fetch = [nil, [{:x=>2,:y=>3}], nil, [{:x=>2}], [{:x=>2, :q=>18}]]
+
+    @ds1.graph(:lines, :x=>:id).set_graph_aliases(:x=>[:points, :x], :y=>[:lines, :y]).all.should == [{:points=>{:x=>2}, :lines=>{:y=>3}}]
+    ds = @ds1.graph(:lines, :x=>:id).set_graph_aliases(:x=>[:points, :x])
+    ds.all.should == [{:points=>{:x=>2}, :lines=>nil}]
+    ds = ds.add_graph_aliases(:q=>[:points, :r, 18])
+    ds.all.should == [{:points=>{:x=>2, :r=>18}, :lines=>nil}]
+  end
+
+  it "#graph_each should correctly map values when #set_graph_aliases is used with a third argument for each entry" do
+    @db.fetch = [nil, {:x=>2,:y=>3}]
+    @ds1.graph(:lines, :x=>:id).set_graph_aliases(:x=>[:points, :z1, 2], :y=>[:lines, :z2, Sequel.function(:random)]).all.should == [{:points=>{:z1=>2}, :lines=>{:z2=>3}}]
+  end
+
+  it "#graph_each should correctly map values when #set_graph_aliases is used with a single argument for each entry" do
+    @db.fetch = [nil, {:x=>2,:y=>3}]
+    @ds1.graph(:lines, :x=>:id).set_graph_aliases(:x=>[:points], :y=>[:lines]).all.should == [{:points=>{:x=>2}, :lines=>{:y=>3}}]
+  end
+
+  it "#graph_each should correctly map values when #set_graph_aliases is used with a symbol for each entry" do
+    @db.fetch = [nil, {:x=>2,:y=>3}]
+    @ds1.graph(:lines, :x=>:id).set_graph_aliases(:x=>:points, :y=>:lines).all.should == [{:points=>{:x=>2}, :lines=>{:y=>3}}]
+  end
+
+  it "#graph_each should run the row_proc for graphed datasets" do
+    @ds1.row_proc = proc{|h| h.keys.each{|k| h[k] *= 2}; h}
+    @ds2.row_proc = proc{|h| h.keys.each{|k| h[k] *= 3}; h}
+    @db.fetch = {:id=>1,:x=>2,:y=>3,:lines_id=>4,:lines_x=>5,:lines_y=>6,:graph_id=>7}
+    @ds1.graph(@ds2, :x=>:id).all.should == [{:points=>{:id=>2, :x=>4, :y=>6}, :lines=>{:id=>12, :x=>15, :y=>18, :graph_id=>21}}]
+  end
+end

data/spec/extensions/hash_aliases_spec.rb

@@ -0,0 +1,16 @@
+require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
+
+describe "hash_aliases extension" do
+  before do
+    @ds = Sequel.mock.dataset.extension(:hash_aliases)
+  end
+
+  it "should make from treat hash arguments as alias specifiers" do
+    @ds.from(:a=>:b).sql.should == "SELECT * FROM a AS b"
+  end
+
+  it "should make select treat hash arguments as alias specifiers" do
+    @ds.select(:a=>:b).sql.should == "SELECT a AS b"
+    @ds.select{{:a=>:b}}.sql.should == "SELECT a AS b"
+  end
+end

data/spec/extensions/hook_class_methods_spec.rb

@@ -165,7 +165,7 @@ describe Sequel::Model, "hook_class_methods plugin" do
 end
 
 describe "Model#after_initialize" do
-  specify "should be called after initialization" do
+  qspecify "should be called after initialization" do
     values1 = nil
     reached_after_initialized = false
     
@@ -325,7 +325,7 @@ describe "Model#before_validation && Model#after_validation" do
       after_validation{MODEL_DB << "BLAH after"}
 
       def self.validate(o)
-        o.errors[:id] << 'not valid' unless o[:id] == 2233
+        o.errors.add(:id, 'not valid') unless o[:id] == 2233
       end
       columns :id
     end

data/spec/extensions/identity_map_spec.rb

@@ -282,8 +282,8 @@ describe "Sequel::Plugins::IdentityMap" do
   it "should work correctly when eagerly loading many_to_many associations with composite keys" do
     @c1.columns :id, :id2
     @c2.columns :id, :id2
-    @c1.set_primary_key :id, :id2
-    @c2.set_primary_key :id, :id2
+    @c1.set_primary_key [:id, :id2]
+    @c2.set_primary_key [:id, :id2]
     @c1.many_to_many :artists, :class=>@c2, :left_key=>[:album_id1, :album_id2], :right_key=>[:artist_id1, :artist_id2], :join_table=>:aa
     @c1.dataset._fetch = [{:id=>1, :id2=>4}, {:id=>2, :id2=>5}, {:id=>3, :id2=>6}]
     @c2.dataset._fetch = [ {:id=>1, :x_foreign_key_0_x=>1, :x_foreign_key_1_x=>4}, {:id=>1, :x_foreign_key_0_x=>2, :x_foreign_key_1_x=>5}, {:id=>2, :x_foreign_key_0_x=>1, :x_foreign_key_1_x=>4}, {:id=>2, :x_foreign_key_0_x=>2, :x_foreign_key_1_x=>5}, {:id=>3, :x_foreign_key_0_x=>1, :x_foreign_key_1_x=>4}, {:id=>3, :x_foreign_key_0_x=>1, :x_foreign_key_1_x=>4}]
@@ -319,7 +319,7 @@ describe "Sequel::Plugins::IdentityMap" do
   it "should work correctly when eagerly loading many_to_many associations with composite keys" do
     @c1.columns :id, :id2
     @c2.columns :id
-    @c1.set_primary_key :id, :id2
+    @c1.set_primary_key [:id, :id2]
     @c1.plugin :many_through_many
     @c1.many_through_many :artists, [[:aa, [:album_id1, :album_id2], :artist_id]], :class=>@c2
     @c1.dataset._fetch = [{:id=>1, :id2=>4}, {:id=>2, :id2=>5}, {:id=>3, :id2=>6}]

data/spec/extensions/json_serializer_spec.rb

@@ -4,7 +4,7 @@ describe "Sequel::Plugins::JsonSerializer" do
   before do
     class ::Artist < Sequel::Model
       unrestrict_primary_key
-      plugin :json_serializer
+      plugin :json_serializer, :naked=>true
       columns :id, :name
       def_column_accessor :id, :name
       @db_schema = {:id=>{:type=>:integer}}
@@ -13,7 +13,7 @@ describe "Sequel::Plugins::JsonSerializer" do
     class ::Album < Sequel::Model
       unrestrict_primary_key
       attr_accessor :blah
-      plugin :json_serializer
+      plugin :json_serializer, :naked=>true
       columns :id, :name, :artist_id
       def_column_accessor :id, :name, :artist_id
       many_to_one :artist
@@ -43,12 +43,12 @@ describe "Sequel::Plugins::JsonSerializer" do
     Artist.from_json(Artist.load(:name=>Date.today).to_json).should == Artist.load(:name=>Date.today)
   end
 
-  it "should have .json_create method for creating an instance from a hash parsed from JSON" do
-    JSON.parse(@artist.to_json, :create_additions=>true).should == @artist
-    JSON.parse(@artist.to_json(:include=>{:albums=>{:include=>{:artist=>{:include=>:albums}}}}), :create_additions=>true).albums.map{|a| a.artist.albums}.should == [[@album]]
+  qspecify "should have .json_create method for creating an instance from a hash parsed from JSON" do
+    JSON.parse(@artist.to_json(:naked=>false), :create_additions=>true).should == @artist
+    JSON.parse(@artist.to_json(:naked=>false, :include=>{:albums=>{:include=>{:artist=>{:include=>:albums}}}}), :create_additions=>true).albums.map{|a| a.artist.albums}.should == [[@album]]
   end
 
-  it "should have .json_create method raise error if not given a hash" do
+  qspecify "should have .json_create method raise error if not given a hash" do
     proc{Artist.json_create([])}.should raise_error(Sequel::Error)
   end
 
@@ -68,8 +68,8 @@ describe "Sequel::Plugins::JsonSerializer" do
   end
 
   it "should raise an error if attempting to parse json when providing array to non-array association or vice-versa" do
-    proc{Artist.from_json('{"albums":{"id":1,"name":"RF","artist_id":2,"json_class":"Album"},"id":2,"name":"YJM","json_class":"Artist"}', :associations=>:albums)}.should raise_error(Sequel::Error)
-    proc{Album.from_json('{"artist":[{"id":2,"name":"YJM","json_class":"Artist"}],"id":1,"name":"RF","json_class":"Album","artist_id":2}', :associations=>:artist)}.should raise_error(Sequel::Error)
+    proc{Artist.from_json('{"albums":{"id":1,"name":"RF","artist_id":2,"json_class":"Album"},"id":2,"name":"YJM"}', :associations=>:albums)}.should raise_error(Sequel::Error)
+    proc{Album.from_json('{"artist":[{"id":2,"name":"YJM","json_class":"Artist"}],"id":1,"name":"RF","artist_id":2}', :associations=>:artist)}.should raise_error(Sequel::Error)
   end
 
   it "should raise an error if attempting to parse an array containing non-hashes" do
@@ -129,7 +129,7 @@ describe "Sequel::Plugins::JsonSerializer" do
     Album.from_json(@album.to_json(:include=>{:artist=>{:include=>{:albums=>{:only=>:name}}}}), :associations=>{:artist=>{:associations=>:albums}}).artist.albums.should == [Album.load(:name=>@album.name)]
   end
 
-  it "should automatically cascade parsing for all associations if :all_associations is used" do
+  qspecify "should automatically cascade parsing for all associations if :all_associations is used" do
     Artist.from_json(@artist.to_json(:include=>{:albums=>{:include=>:artist}}), :all_associations=>true).albums.map{|a| a.artist}.should == [@artist]
   end
 
@@ -222,7 +222,7 @@ describe "Sequel::Plugins::JsonSerializer" do
   
   it "should handle the :root=>:both option to qualify a dataset of records" do
     Album.dataset._fetch = [{:id=>1, :name=>'RF'}, {:id=>1, :name=>'RF'}]
-    Album.dataset.to_json(:root=>true, :only => :id).to_s.should == '{"albums":[{"album":{"id":1}},{"album":{"id":1}}]}'
+    Album.dataset.to_json(:root=>:both, :only => :id).to_s.should == '{"albums":[{"album":{"id":1}},{"album":{"id":1}}]}'
   end
 
   it "should handle the :root=>:collection option to qualify just the collection" do
@@ -235,16 +235,16 @@ describe "Sequel::Plugins::JsonSerializer" do
     Album.dataset.to_json(:root=>:instance, :only => :id).to_s.should == '[{"album":{"id":1}},{"album":{"id":1}}]'
   end
 
-  it "should handle the :root=>true option be the same as :root=>:both for backwards compatibility" do
+  qspecify "should handle the :root=>true option be the same as :root=>:both for backwards compatibility" do
     Album.dataset._fetch = [{:id=>1, :name=>'RF'}, {:id=>1, :name=>'RF'}]
     Album.dataset.to_json(:root=>true, :only => :id).to_s.should == '{"albums":[{"album":{"id":1}},{"album":{"id":1}}]}'
   end
 
   it "should store the default options in json_serializer_opts" do
-    Album.json_serializer_opts.should == {}
+    Album.json_serializer_opts.should == {:naked=>true}
     c = Class.new(Album)
-    c.plugin :json_serializer, :naked=>true
-    c.json_serializer_opts.should == {:naked=>true}
+    c.plugin :json_serializer, :naked=>false
+    c.json_serializer_opts.should == {:naked=>false}
   end
 
   it "should work correctly when subclassing" do
@@ -260,26 +260,26 @@ describe "Sequel::Plugins::JsonSerializer" do
     Object.send(:remove_const, :Artist3)
   end
 
-  it "should have :associations option take precedence over :all_assocations" do
+  qspecify "should have :associations option take precedence over :all_assocations" do
     Artist.from_json(@artist.to_json(:include=>:albums), :associations=>[], :all_associations=>true, :fields=>[]).associations.should == {}
   end
 
-  it "should allow overriding of :all_columns options in associated objects" do
+  qspecify "should allow overriding of :all_columns options in associated objects" do
     Album.restrict_primary_key
     Artist.from_json(@artist.to_json(:include=>:albums), :associations=>{:albums=>{:fields=>[:id, :name, :artist_id], :missing=>:raise}}, :all_columns=>true).albums.should == [@album]
   end
 
-  it "should handle typecasting if setter columns exist when using :all_columns" do
+  qspecify "should handle typecasting if setter columns exist when using :all_columns" do
     Artist.restrict_primary_key
     Artist.from_json('{"id":"2","name":"YJM","json_class":"Artist"}', :all_columns=>true).should == @artist
   end
 
-  it "should allow setting columns that are restricted if :all_columns is used" do
+  qspecify "should allow setting columns that are restricted if :all_columns is used" do
     Artist.restrict_primary_key
     Artist.from_json(@artist.to_json, :all_columns=>true).should == @artist
   end
 
-  it "should raise an error if using :all_columns and non-column is in the JSON" do
+  qspecify "should raise an error if using :all_columns and non-column is in the JSON" do
     proc{Artist.from_json('{"foo":"bar"}', :all_columns=>true)}.should raise_error(Sequel::Error)
   end
 

data/spec/extensions/lazy_attributes_spec.rb

@@ -4,6 +4,7 @@ require 'yaml'
 describe "Sequel::Plugins::LazyAttributes" do
   before do
     @db = Sequel.mock
+    def @db.supports_schema_parsing?() true end
     @db.meta_def(:schema){|*a| [[:id, {:type=>:integer}], [:name,{:type=>:string}]]}
     class ::LazyAttributesModel < Sequel::Model(@db[:la])
       plugin :lazy_attributes