sequel 3.35.0 → 3.36.0

data/spec/extensions/eager_each_spec.rb

@@ -0,0 +1,34 @@
+require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
+
+describe "Sequel::Plugins::EagerEach" do
+  before do
+    @c = Class.new(Sequel::Model(:items))
+    @c.columns :id, :parent_id
+    @c.plugin :eager_each
+    @c.one_to_many :children, :class=>@c, :key=>:parent_id
+    @c.db.sqls
+  end
+
+  it "should make #each on an eager dataset do eager loading" do
+    a = []
+    ds = @c.eager(:children)
+    ds._fetch = [{:id=>1, :parent_id=>nil}, {:id=>2, :parent_id=>nil}]
+    @c.dataset._fetch = [{:id=>3, :parent_id=>1}, {:id=>4, :parent_id=>1}, {:id=>5, :parent_id=>2}, {:id=>6, :parent_id=>2}]
+    ds.each{|c| a << c}
+    a.should == [@c.load(:id=>1, :parent_id=>nil), @c.load(:id=>2, :parent_id=>nil)]
+    a.map{|c| c.associations[:children]}.should == [[@c.load(:id=>3, :parent_id=>1), @c.load(:id=>4, :parent_id=>1)], [@c.load(:id=>5, :parent_id=>2), @c.load(:id=>6, :parent_id=>2)]]
+    @c.db.sqls.should == ['SELECT * FROM items', 'SELECT * FROM items WHERE (items.parent_id IN (1, 2))']
+  end
+
+  it "should make #each on an eager_graph dataset do eager loading" do
+    a = []
+    ds = @c.eager_graph(:children)
+    ds._fetch = []
+    ds._fetch = [{:id=>1, :parent_id=>nil, :children_id=>3, :children_parent_id=>1}, {:id=>1, :parent_id=>nil, :children_id=>4, :children_parent_id=>1}, {:id=>2, :parent_id=>nil, :children_id=>5, :children_parent_id=>2}, {:id=>2, :parent_id=>nil, :children_id=>6, :children_parent_id=>2}]
+    ds.each{|c| a << c}
+    a.should == [@c.load(:id=>1, :parent_id=>nil), @c.load(:id=>2, :parent_id=>nil)]
+    a.map{|c| c.associations[:children]}.should == [[@c.load(:id=>3, :parent_id=>1), @c.load(:id=>4, :parent_id=>1)], [@c.load(:id=>5, :parent_id=>2), @c.load(:id=>6, :parent_id=>2)]]
+    @c.db.sqls.should == ['SELECT items.id, items.parent_id, children.id AS children_id, children.parent_id AS children_parent_id FROM items LEFT OUTER JOIN items AS children ON (children.parent_id = items.id)']
+  end
+
+end

data/spec/extensions/inflector_spec.rb

@@ -1,8 +1,5 @@
 require File.join(File.dirname(File.expand_path(__FILE__)), 'spec_helper')
 
-if defined?(ActiveSupport::Inflector)
-  skip_warn "inflector extension: active_support inflector loaded"
-else
 describe String do
   it "#camelize and #camelcase should transform the word to CamelCase" do
     "egg_and_hams".camelize.should == "EggAndHams"
@@ -182,4 +179,3 @@ describe 'Default inflections' do
     end
   end
 end
-end

data/spec/extensions/json_serializer_spec.rb

@@ -96,6 +96,22 @@ describe "Sequel::Plugins::JsonSerializer" do
     @artist.id.should == 2
   end
 
+  it "should support #from_json to support specific :fields" do
+    @album.from_json('{"name": "AS", "artist_id": 3}', :fields=>['name'])
+    @album.name.should == 'AS'
+    @album.artist_id.should == 2
+  end
+
+  it "should support #from_json to support :missing=>:skip option" do
+    @album.from_json('{"artist_id": 3}', :fields=>['name'], :missing=>:skip)
+    @album.name.should == 'RF'
+    @album.artist_id.should == 2
+  end
+
+  it "should support #from_json to support :missing=>:raise option" do
+    proc{@album.from_json('{"artist_id": 3}', :fields=>['name'], :missing=>:raise)}.should raise_error(Sequel::Error)
+  end
+
   it "should raise an exception for json keys that aren't associations, columns, or setter methods" do
     Album.send(:undef_method, :blah=)
     proc{JSON.parse(@album.to_json(:include=>:blah))}.should raise_error(Sequel::Error)
@@ -149,7 +165,22 @@ describe "Sequel::Plugins::JsonSerializer" do
     @album.to_json(:root=>true, :only => :name).to_s.should == '{"album":{"name":"RF"}}'
   end
   
-  it "should handle the :root option to qualify a dataset of records" 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}}]}'
+  end
+
+  it "should handle the :root=>:collection option to qualify just the collection" do
+    Album.dataset._fetch = [{:id=>1, :name=>'RF'}, {:id=>1, :name=>'RF'}]
+    Album.dataset.to_json(:root=>:collection, :only => :id).to_s.should == '{"albums":[{"id":1},{"id":1}]}'
+  end
+
+  it "should handle the :root=>:instance option to qualify just the instances" do
+    Album.dataset._fetch = [{:id=>1, :name=>'RF'}, {:id=>1, :name=>'RF'}]
+    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
     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

data/spec/extensions/migration_spec.rb

@@ -277,8 +277,20 @@ describe "Sequel::IntegerMigrator" do
     @db.creates.should == [1111, 2222, 3333]
     @db.version.should == 3
     @db.sqls.map{|x| x =~ /\AUPDATE.*(\d+)/ ? $1.to_i : nil}.compact.should == [1, 2, 3]
+  end
+  
+  specify "should be able to tell whether there are outstanding migrations" do
+    Sequel::Migrator.is_current?(@db, @dirname).should be_false
+    Sequel::Migrator.apply(@db, @dirname)
+    Sequel::Migrator.is_current?(@db, @dirname).should be_true
   end 
 
+  specify "should have #check_current raise an exception if the migrator is not current" do
+    proc{Sequel::Migrator.check_current(@db, @dirname)}.should raise_error(Sequel::Migrator::NotCurrentError)
+    Sequel::Migrator.apply(@db, @dirname)
+    proc{Sequel::Migrator.check_current(@db, @dirname)}.should_not raise_error
+  end
+
   specify "should apply migrations correctly in the up direction with target" do
     Sequel::Migrator.apply(@db, @dirname, 2)
     @db.creates.should == [1111, 2222]
@@ -448,6 +460,22 @@ describe "Sequel::TimestampMigrator" do
     @db[:schema_migrations].select_order_map(:filename).should == %w'1273253849_create_sessions.rb'
   end
 
+  specify "should not be current when there are migrations to apply" do
+    @dir = 'spec/files/timestamped_migrations'
+    @m.apply(@db, @dir)
+    @m.is_current?(@db, @dir).should be_true
+    @dir = 'spec/files/interleaved_timestamped_migrations'
+    @m.is_current?(@db, @dir).should be_false
+  end
+
+  specify "should raise an exception if the migrator is not current" do
+    @dir = 'spec/files/timestamped_migrations'
+    @m.apply(@db, @dir)
+    proc{@m.check_current(@db, @dir)}.should_not raise_error
+    @dir = 'spec/files/interleaved_timestamped_migrations'
+    proc{@m.check_current(@db, @dir)}.should raise_error(Sequel::Migrator::NotCurrentError)
+  end
+
   specify "should apply all missing files when migrating up" do
     @dir = 'spec/files/timestamped_migrations'
     @m.apply(@db, @dir)

data/spec/extensions/nested_attributes_spec.rb

@@ -22,17 +22,24 @@ describe "NestedAttributes plugin" do
     @Artist = Class.new(@c).set_dataset(:artists)
     @Album = Class.new(@c).set_dataset(:albums)
     @Tag = Class.new(@c).set_dataset(:tags)
+    @Concert = Class.new(@c).set_dataset(:concerts)
     @Artist.plugin :skip_create_refresh
     @Album.plugin :skip_create_refresh
     @Tag.plugin :skip_create_refresh
+    @Concert.plugin :skip_create_refresh
     @Artist.columns :id, :name
     @Album.columns :id, :name, :artist_id
     @Tag.columns :id, :name
+    @Concert.columns :tour, :date, :artist_id, :playlist
+    @Concert.set_primary_key([:tour, :date])
+    @Concert.unrestrict_primary_key
     @Artist.one_to_many :albums, :class=>@Album, :key=>:artist_id
+    @Artist.one_to_many :concerts, :class=>@Concert, :key=>:artist_id
     @Artist.one_to_one :first_album, :class=>@Album, :key=>:artist_id
     @Album.many_to_one :artist, :class=>@Artist
     @Album.many_to_many :tags, :class=>@Tag, :left_key=>:album_id, :right_key=>:tag_id, :join_table=>:at
     @Artist.nested_attributes :albums, :first_album, :destroy=>true, :remove=>true
+    @Artist.nested_attributes :concerts, :destroy=>true, :remove=>true
     @Album.nested_attributes :artist, :tags, :destroy=>true, :remove=>true
     @db.sqls
   end
@@ -80,6 +87,56 @@ describe "NestedAttributes plugin" do
     a.albums.first.tags.should == [@Tag.new(:name=>'T')]
   end
   
+  it "should support creating new objects with composite primary keys" do
+    insert = nil
+    @Concert.class_eval do
+      define_method :_insert do
+        insert = values
+      end
+      def before_create # Have to define the CPK somehow.
+        self.tour = 'To'
+        self.date = '2004-04-05'
+        super
+      end
+    end
+    a = @Artist.new({:name=>'Ar', :concerts_attributes=>[{:playlist=>'Pl'}]})
+    @db.sqls.should == []
+    a.save
+    @db.sqls.should == ["INSERT INTO artists (name) VALUES ('Ar')"]
+    insert.should == {:tour=>'To', :date=>'2004-04-05', :artist_id=>1, :playlist=>'Pl'}
+  end
+
+  it "should support creating new objects with specific primary keys if :unmatched_pk => :create is set" do
+    @Artist.nested_attributes :albums, :unmatched_pk=>:create
+    insert = nil
+    @Album.class_eval do
+      unrestrict_primary_key
+      define_method :_insert do
+        insert = values
+      end
+    end
+    a = @Artist.new({:name=>'Ar', :albums_attributes=>[{:id=>7, :name=>'Al'}]})
+    @db.sqls.should == []
+    a.save
+    @db.sqls.should == ["INSERT INTO artists (name) VALUES ('Ar')"]
+    insert.should == {:artist_id=>1, :name=>'Al', :id=>7}
+  end
+
+  it "should support creating new objects with specific composite primary keys if :unmatched_pk => :create is set" do
+    insert = nil
+    @Artist.nested_attributes :concerts, :unmatched_pk=>:create
+    @Concert.class_eval do
+      define_method :_insert do
+        insert = values
+      end
+    end
+    a = @Artist.new({:name=>'Ar', :concerts_attributes=>[{:tour=>'To', :date=>'2004-04-05', :playlist=>'Pl'}]})
+    @db.sqls.should == []
+    a.save
+    @db.sqls.should == ["INSERT INTO artists (name) VALUES ('Ar')"]
+    insert.should == {:tour=>'To', :date=>'2004-04-05', :artist_id=>1, :playlist=>'Pl'}
+  end
+
   it "should support updating many_to_one objects" do
     al = @Album.load(:id=>10, :name=>'Al')
     ar = @Artist.load(:id=>20, :name=>'Ar')
@@ -140,6 +197,16 @@ describe "NestedAttributes plugin" do
     @db.sqls.should == ["UPDATE albums SET name = 'Al' WHERE (id = 10)", "UPDATE tags SET name = 'T2' WHERE (id = 20)"]
   end
   
+  it "should support updating objects with composite primary keys" do
+    ar = @Artist.load(:id=>10, :name=>'Ar')
+    co = @Concert.load(:tour=>'To', :date=>'2004-04-05', :playlist=>'Pl')
+    ar.associations[:concerts] = [co]
+    ar.set(:concerts_attributes=>[{:tour=>'To', :date=>'2004-04-05', :playlist=>'Pl2'}])
+    @db.sqls.should == []
+    ar.save
+    check_sql_array("UPDATE artists SET name = 'Ar' WHERE (id = 10)", ["UPDATE concerts SET playlist = 'Pl2' WHERE ((tour = 'To') AND (date = '2004-04-05'))", "UPDATE concerts SET playlist = 'Pl2' WHERE ((date = '2004-04-05') AND (tour = 'To'))"])
+  end
+
   it "should support removing many_to_one objects" do
     al = @Album.load(:id=>10, :name=>'Al')
     ar = @Artist.load(:id=>20, :name=>'Ar')
@@ -183,6 +250,19 @@ describe "NestedAttributes plugin" do
     @db.sqls.should == ["DELETE FROM at WHERE ((album_id = 10) AND (tag_id = 20))", "UPDATE albums SET name = 'Al' WHERE (id = 10)"]
   end
   
+  it "should support removing objects with composite primary keys" do
+    ar = @Artist.load(:id=>10, :name=>'Ar')
+    co = @Concert.load(:tour=>'To', :date=>'2004-04-05', :playlist=>'Pl')
+    ar.associations[:concerts] = [co]
+    ar.set(:concerts_attributes=>[{:tour=>'To', :date=>'2004-04-05', :_remove=>'t'}])
+    @db.sqls.should == []
+    @Concert.dataset._fetch = {:id=>1}
+    ar.save
+    check_sql_array(["SELECT 1 AS one FROM concerts WHERE ((concerts.artist_id = 10) AND (tour = 'To') AND (date = '2004-04-05')) LIMIT 1", "SELECT 1 AS one FROM concerts WHERE ((concerts.artist_id = 10) AND (date = '2004-04-05') AND (tour = 'To')) LIMIT 1"],
+      ["UPDATE concerts SET artist_id = NULL, playlist = 'Pl' WHERE ((tour = 'To') AND (date = '2004-04-05'))", "UPDATE concerts SET playlist = 'Pl', artist_id = NULL WHERE ((tour = 'To') AND (date = '2004-04-05'))", "UPDATE concerts SET artist_id = NULL, playlist = 'Pl' WHERE ((date = '2004-04-05') AND (tour = 'To'))", "UPDATE concerts SET playlist = 'Pl', artist_id = NULL WHERE ((date = '2004-04-05') AND (tour = 'To'))"],
+      "UPDATE artists SET name = 'Ar' WHERE (id = 10)")
+  end
+
   it "should support destroying many_to_one objects" do
     al = @Album.load(:id=>10, :name=>'Al')
     ar = @Artist.load(:id=>20, :name=>'Ar')
@@ -224,6 +304,16 @@ describe "NestedAttributes plugin" do
     @db.sqls.should == ["DELETE FROM at WHERE ((album_id = 10) AND (tag_id = 20))", "UPDATE albums SET name = 'Al' WHERE (id = 10)", "DELETE FROM tags WHERE (id = 20)"]
   end
   
+  it "should support destroying objects with composite primary keys" do
+    ar = @Artist.load(:id=>10, :name=>'Ar')
+    co = @Concert.load(:tour=>'To', :date=>'2004-04-05', :playlist=>'Pl')
+    ar.associations[:concerts] = [co]
+    ar.set(:concerts_attributes=>[{:tour=>'To', :date=>'2004-04-05', :_delete=>'t'}])
+    @db.sqls.should == []
+    ar.save
+    check_sql_array("UPDATE artists SET name = 'Ar' WHERE (id = 10)", ["DELETE FROM concerts WHERE ((tour = 'To') AND (date = '2004-04-05'))", "DELETE FROM concerts WHERE ((date = '2004-04-05') AND (tour = 'To'))"])
+  end
+
   it "should support both string and symbol keys in nested attribute hashes" do
     a = @Album.load(:id=>10, :name=>'Al')
     t = @Tag.load(:id=>20, :name=>'T')
@@ -283,6 +373,36 @@ describe "NestedAttributes plugin" do
     @db.sqls.should == ["UPDATE artists SET name = 'Ar' WHERE (id = 20)"]
   end
   
+  it "should not raise an Error if an unmatched primary key is given, if the :unmatched_pk=>:ignore option is used" do
+    @Artist.nested_attributes :albums, :unmatched_pk=>:ignore
+    al = @Album.load(:id=>10, :name=>'Al')
+    ar = @Artist.load(:id=>20, :name=>'Ar')
+    ar.associations[:albums] = [al]
+    ar.set(:albums_attributes=>[{:id=>30, :_delete=>'t'}])
+    @db.sqls.should == []
+    ar.save
+    @db.sqls.should == ["UPDATE artists SET name = 'Ar' WHERE (id = 20)"]
+  end
+
+  it "should raise an Error if a composite primary key is given in a nested attribute hash, but no matching associated object exists" do
+    ar = @Artist.load(:id=>10, :name=>'Ar')
+    co = @Concert.load(:tour=>'To', :date=>'2004-04-05', :playlist=>'Pl')
+    ar.associations[:concerts] = [co]
+    proc{ar.set(:concerts_attributes=>[{:tour=>'To', :date=>'2004-04-04', :_delete=>'t'}])}.should raise_error(Sequel::Error)
+    proc{ar.set(:concerts_attributes=>[{:tour=>'To', :date=>'2004-04-05', :_delete=>'t'}])}.should_not raise_error(Sequel::Error)
+  end
+
+  it "should not raise an Error if an unmatched composite primary key is given, if the :strict=>false option is used" do
+    @Artist.nested_attributes :concerts, :strict=>false
+    ar = @Artist.load(:id=>10, :name=>'Ar')
+    co = @Concert.load(:tour=>'To', :date=>'2004-04-05', :playlist=>'Pl')
+    ar.associations[:concerts] = [co]
+    ar.set(:concerts_attributes=>[{:tour=>'To', :date=>'2004-04-06', :_delete=>'t'}])
+    @db.sqls.should == []
+    ar.save
+    @db.sqls.should == ["UPDATE artists SET name = 'Ar' WHERE (id = 10)"]
+  end
+
   it "should not save if nested attribute is not valid and should include nested attribute validation errors in the main object's validation errors" do
     @Artist.class_eval do
       def validate
@@ -370,6 +490,19 @@ describe "NestedAttributes plugin" do
       ["INSERT INTO at (album_id, tag_id) VALUES (1, 4)", "INSERT INTO at (tag_id, album_id) VALUES (4, 1)"])
   end
   
+  it "should accept a :transform block that returns a changed attributes hash" do
+    @Album.nested_attributes :tags, :transform=>proc{|parent, hash| hash[:name] << parent.name; hash }
+    a = @Album.new(:name => 'Al')
+    a.set(:tags_attributes=>[{:name=>'T'}, {:name=>'T2'}])
+    @db.sqls.should == []
+    a.save
+    check_sql_array("INSERT INTO albums (name) VALUES ('Al')",
+      "INSERT INTO tags (name) VALUES ('TAl')",
+      ["INSERT INTO at (album_id, tag_id) VALUES (1, 2)", "INSERT INTO at (tag_id, album_id) VALUES (2, 1)"],
+      "INSERT INTO tags (name) VALUES ('T2Al')",
+      ["INSERT INTO at (album_id, tag_id) VALUES (1, 4)", "INSERT INTO at (tag_id, album_id) VALUES (4, 1)"])
+  end
+
   it "should return objects created/modified in the internal methods" do
     @Album.nested_attributes :tags, :remove=>true, :strict=>false
     objs = []
@@ -381,7 +514,7 @@ describe "NestedAttributes plugin" do
     a = @Album.new(:name=>'Al')
     a.associations[:tags] = [@Tag.load(:id=>6, :name=>'A'), @Tag.load(:id=>7, :name=>'A2')] 
     a.tags_attributes = [{:id=>6, :name=>'T'}, {:id=>7, :name=>'T2', :_remove=>true}, {:name=>'T3'}, {:id=>8, :name=>'T4'}, {:id=>9, :name=>'T5', :_remove=>true}]
-    objs.should == [[@Tag.load(:id=>6, :name=>'T'), :update], [@Tag.load(:id=>7, :name=>'A2'), :remove], [@Tag.new(:name=>'T3'), :create], [nil, :update], [nil, :remove]]
+    objs.should == [[@Tag.load(:id=>6, :name=>'T'), :update], [@Tag.load(:id=>7, :name=>'A2'), :remove], [@Tag.new(:name=>'T3'), :create]]
   end
 
   it "should raise an error if updating modifies the associated objects keys" do

data/spec/extensions/optimistic_locking_spec.rb

@@ -37,7 +37,7 @@ describe "optimistic_locking plugin" do
         puts sql
       end
     end
-    @c.dataset._fetch = proc do |sql|
+    @c.instance_dataset._fetch = @c.dataset._fetch = proc do |sql|
       m = h[1].dup
       v = m.delete(:lock_version)
       m[lv.to_sym] = v
@@ -95,6 +95,20 @@ describe "optimistic_locking plugin" do
     proc{p2.update(:name=>'Bob')}.should raise_error(Sequel::Plugins::OptimisticLocking::Error)
   end
 
+  specify "should work correctly if attempting to refresh and save again after a failed save" do
+    p1 = @c[1]
+    p2 = @c[1]
+    p1.update(:name=>'Jim')
+    begin
+      p2.update(:name=>'Bob')
+    rescue Sequel::Plugins::OptimisticLocking::Error
+      p2.refresh
+      @c.db.sqls
+      proc{p2.update(:name=>'Bob')}.should_not raise_error
+    end
+    @c.db.sqls.first.should =~ /UPDATE people SET (name = 'Bob', lock_version = 4|lock_version = 4, name = 'Bob') WHERE \(\(id = 1\) AND \(lock_version = 3\)\)/
+  end
+
   specify "should increment the lock column when #modified! even if no columns are changed" do
     p1 = @c[1]
     p1.modified!

data/spec/extensions/pg_hstore_spec.rb

@@ -180,7 +180,7 @@ describe "pg_hstore extension" do
     @db.schema(:items).map{|e| e[1][:type]}.should == [:integer, :hstore]
   end
 
-  it "should support typecasting of the various array types" do
+  it "should support typecasting for the hstore type" do
     @db.extend @c::DatabaseMethods
     h = {1=>2}.hstore
     @db.typecast_value(:hstore, h).should equal(h)

data/spec/extensions/pg_inet_spec.rb

@@ -0,0 +1,44 @@
+require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
+
+describe "pg_inet extension" do
+  ipv6_broken = (IPAddr.new('::1'); false) rescue true
+  before do
+    @db = Sequel.connect('mock://postgres', :quote_identifiers=>false)
+    @db.extend(Module.new{def bound_variable_arg(arg, conn) arg end})
+    @db.extend(Sequel::Postgres::InetDatabaseMethods)
+  end
+
+  it "should literalize IPAddr v4 instances to strings correctly" do
+    @db.literal(IPAddr.new('127.0.0.1')).should == "'127.0.0.1/32'"
+    @db.literal(IPAddr.new('127.0.0.0/8')).should == "'127.0.0.0/8'"
+  end
+
+  it "should literalize IPAddr v6 instances to strings correctly" do
+    @db.literal(IPAddr.new('2001:4f8:3:ba::/64')).should == "'2001:4f8:3:ba::/64'"
+    @db.literal(IPAddr.new('2001:4f8:3:ba:2e0:81ff:fe22:d1f1')).should == "'2001:4f8:3:ba:2e0:81ff:fe22:d1f1/128'"
+  end unless ipv6_broken
+
+  it "should not affect literalization of custom objects" do
+    o = Object.new
+    def o.sql_literal(ds) 'v' end
+    @db.literal(o).should == 'v'
+  end
+
+  it "should support using IPAddr as bound variables" do
+    @db.bound_variable_arg(1, nil).should == 1
+    @db.bound_variable_arg(IPAddr.new('127.0.0.1'), nil).should == '127.0.0.1/32'
+  end
+
+  it "should parse inet/cidr type from the schema correctly" do
+    @db.fetch = [{:name=>'id', :db_type=>'integer'}, {:name=>'i', :db_type=>'inet'}, {:name=>'c', :db_type=>'cidr'}]
+    @db.schema(:items).map{|e| e[1][:type]}.should == [:integer, :ipaddr, :ipaddr]
+  end
+
+  it "should support typecasting for the ipaddr type" do
+    ip = IPAddr.new('127.0.0.1')
+    @db.typecast_value(:ipaddr, ip).should equal(ip)
+    @db.typecast_value(:ipaddr, ip.to_s).should == ip
+    proc{@db.typecast_value(:ipaddr, '')}.should raise_error(Sequel::InvalidValue)
+    proc{@db.typecast_value(:ipaddr, 1)}.should raise_error(Sequel::InvalidValue)
+  end
+end

data/spec/extensions/pg_json_spec.rb

@@ -0,0 +1,101 @@
+require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
+
+begin
+  Sequel.extension :pg_json
+rescue LoadError => e
+  skip_warn "can't load pg_json extension (#{e.class}: #{e})"
+else
+describe "pg_json extension" do
+  before(:all) do
+    m = Sequel::Postgres
+    @m = m::JSONDatabaseMethods
+    @hc = m::JSONHash
+    @ac = m::JSONArray
+
+    # Create subclass in correct namespace for easily overriding methods
+    j = m::JSON = JSON.dup
+    j.instance_eval do
+      Parser = JSON::Parser
+      alias old_parse parse
+      def parse(s)
+        return 1 if s == '1'
+        old_parse(s) 
+      end
+    end
+  end
+  before do
+    @db = Sequel.connect('mock://postgres', :quote_identifiers=>false)
+    @db.extend(Module.new{def bound_variable_arg(arg, conn) arg end})
+  end
+
+  it "should parse json strings correctly" do
+    @m.parse_json('[]').should be_a_kind_of(@ac)
+    @m.parse_json('[]').to_a.should == []
+    @m.parse_json('[1]').to_a.should == [1]
+    @m.parse_json('[1, 2]').to_a.should == [1, 2]
+    @m.parse_json('[1, [2], {"a": "b"}]').to_a.should == [1, [2], {'a'=>'b'}]
+    @m.parse_json('{}').should be_a_kind_of(@hc)
+    @m.parse_json('{}').to_hash.should == {}
+    @m.parse_json('{"a": "b"}').to_hash.should == {'a'=>'b'}
+    @m.parse_json('{"a": "b", "c": [1, 2, 3]}').to_hash.should == {'a'=>'b', 'c'=>[1, 2, 3]}
+    @m.parse_json('{"a": "b", "c": {"d": "e"}}').to_hash.should == {'a'=>'b', 'c'=>{'d'=>'e'}}
+  end
+
+  it "should raise an error when attempting to parse invalid json" do
+    proc{@m.parse_json('')}.should raise_error(Sequel::InvalidValue)
+    proc{@m.parse_json('1')}.should raise_error(Sequel::InvalidValue)
+  end
+
+  it "should literalize HStores to strings correctly" do
+    @db.literal([].pg_json).should == "'[]'::json"
+    @db.literal([1, [2], {'a'=>'b'}].pg_json).should == "'[1,[2],{\"a\":\"b\"}]'::json"
+    @db.literal({}.pg_json).should == "'{}'::json"
+    @db.literal({'a'=>'b'}.pg_json).should == "'{\"a\":\"b\"}'::json"
+  end
+
+  it "should have Hash#pg_json method for creating JSONHash instances" do
+    {}.pg_json.should be_a_kind_of(@hc)
+  end
+
+  it "should have Array#pg_json method for creating JSONArray instances" do
+    [].pg_json.should be_a_kind_of(@ac)
+  end
+
+  it "should have JSONHash#to_hash method for getting underlying hash" do
+    {}.pg_json.to_hash.should be_a_kind_of(Hash)
+  end
+
+  it "should have JSONArray#to_a method for getting underlying array" do
+    [].pg_json.to_a.should be_a_kind_of(Array)
+  end
+
+  it "should support using JSONHash and JSONArray as bound variables" do
+    @db.extend @m
+    @db.bound_variable_arg(1, nil).should == 1
+    @db.bound_variable_arg([1].pg_json, nil).should == '[1]'
+    @db.bound_variable_arg({'a'=>'b'}.pg_json, nil).should == '{"a":"b"}'
+  end
+
+  it "should parse json type from the schema correctly" do
+    @db.extend @m
+    @db.fetch = [{:name=>'id', :db_type=>'integer'}, {:name=>'i', :db_type=>'json'}]
+    @db.schema(:items).map{|e| e[1][:type]}.should == [:integer, :json]
+  end
+
+  it "should support typecasting for the json type" do
+    @db.extend @m
+    h = {1=>2}.pg_json
+    a = [1].pg_json
+    @db.typecast_value(:json, h).should equal(h)
+    @db.typecast_value(:json, h.to_hash).should == h
+    @db.typecast_value(:json, h.to_hash).should be_a_kind_of(@hc)
+    @db.typecast_value(:json, a).should equal(a)
+    @db.typecast_value(:json, a.to_a).should == a
+    @db.typecast_value(:json, a.to_a).should be_a_kind_of(@ac)
+    @db.typecast_value(:json, '[]').should == [].pg_json
+    @db.typecast_value(:json, '{"a": "b"}').should == {"a"=>"b"}.pg_json
+    proc{@db.typecast_value(:json, '')}.should raise_error(Sequel::InvalidValue)
+    proc{@db.typecast_value(:json, 1)}.should raise_error(Sequel::InvalidValue)
+  end
+end
+end