sequel 1.4.0 → 1.5.0

data/spec/eager_loading_spec.rb

@@ -1,34 +1,34 @@
 require File.join(File.dirname(__FILE__), "spec_helper")
 
-describe Sequel::Model, "eager" do
+describe Sequel::Model, "#eager" do
   before(:each) do
     MODEL_DB.reset
     
     class EagerAlbum < Sequel::Model(:albums)
-      def columns; [:id, :band_id]; end
+      columns :id, :band_id
       many_to_one :band, :class=>'EagerBand', :key=>:band_id
       one_to_many :tracks, :class=>'EagerTrack', :key=>:album_id
       many_to_many :genres, :class=>'EagerGenre', :left_key=>:album_id, :right_key=>:genre_id, :join_table=>:ag
     end
 
     class EagerBand < Sequel::Model(:bands)
-      def columns; [:id]; end
+      columns :id
       one_to_many :albums, :class=>'EagerAlbum', :key=>:band_id, :eager=>:tracks
       many_to_many :members, :class=>'EagerBandMember', :left_key=>:band_id, :right_key=>:member_id, :join_table=>:bm
     end
     
     class EagerTrack < Sequel::Model(:tracks)
-      def columns; [:id, :album_id]; end
+      columns :id, :album_id
       many_to_one :album, :class=>'EagerAlbum', :key=>:album_id
     end
     
     class EagerGenre < Sequel::Model(:genres)
-      def columns; [:id]; end
+      columns :id
       many_to_many :albums, :class=>'EagerAlbum', :left_key=>:genre_id, :right_key=>:album_id, :join_table=>:ag
     end
     
     class EagerBandMember < Sequel::Model(:members)
-      def columns; [:id]; end
+      columns :id
       many_to_many :bands, :class=>'EagerBand', :left_key=>:member_id, :right_key=>:band_id, :join_table=>:bm, :order =>:id
     end
     
@@ -206,7 +206,7 @@ describe Sequel::Model, "eager" do
     a.first.values.should == {:id => 2}
     MODEL_DB.sqls.should == ['SELECT * FROM bands']
     a = a.first
-    a.albums.all
+    a.albums
     MODEL_DB.sqls.should == ['SELECT * FROM bands', 
                              'SELECT * FROM albums WHERE (band_id = 2)',
                              'SELECT * FROM tracks WHERE (album_id IN (1))']
@@ -258,3 +258,291 @@ describe Sequel::Model, "eager" do
     MODEL_DB.sqls.length.should == 2
   end
 end
+
+describe Sequel::Model, "#eager_graph" do
+  after(:all) do
+    class MockDataset
+      alias clone orig_clone
+    end
+  end
+
+  before(:all) do
+    class MockDataset
+      alias orig_clone clone
+      def clone(opts = {})
+        c = super()
+        c.opts = @opts.merge(opts)
+        c.instance_variable_set(:@columns, (@columns.dup if @columns))
+        c
+      end
+    end
+
+    class GraphAlbum < Sequel::Model(:albums)
+      dataset.opts[:from] = [:albums]
+      columns :id, :band_id
+      many_to_one :band, :class=>'GraphBand', :key=>:band_id
+      one_to_many :tracks, :class=>'GraphTrack', :key=>:album_id
+      many_to_many :genres, :class=>'GraphGenre', :left_key=>:album_id, :right_key=>:genre_id, :join_table=>:ag
+    end
+
+    class GraphBand < Sequel::Model(:bands)
+      dataset.opts[:from] = [:bands]
+      columns :id, :vocalist_id
+      many_to_one :vocalist, :class=>'GraphBandMember', :key=>:vocalist_id
+      one_to_many :albums, :class=>'GraphAlbum', :key=>:band_id
+      many_to_many :members, :class=>'GraphBandMember', :left_key=>:band_id, :right_key=>:member_id, :join_table=>:bm
+      many_to_many :genres, :class=>'GraphGenre', :left_key=>:band_id, :right_key=>:genre_id, :join_table=>:bg
+    end
+    
+    class GraphTrack < Sequel::Model(:tracks)
+      dataset.opts[:from] = [:tracks]
+      columns :id, :album_id
+      many_to_one :album, :class=>'GraphAlbum', :key=>:album_id
+    end
+    
+    class GraphGenre < Sequel::Model(:genres)
+      dataset.opts[:from] = [:genres]
+      columns :id
+      many_to_many :albums, :class=>'GraphAlbum', :left_key=>:genre_id, :right_key=>:album_id, :join_table=>:ag
+    end
+    
+    class GraphBandMember < Sequel::Model(:members)
+      dataset.opts[:from] = [:members]
+      columns :id
+      many_to_many :bands, :class=>'GraphBand', :left_key=>:member_id, :right_key=>:band_id, :join_table=>:bm
+    end
+  end
+    
+  it "should eagerly load a single many_to_one association" do
+    ds = GraphAlbum.eager_graph(:band)
+    ds.sql.should == 'SELECT albums.id, albums.band_id, band.id AS band_id_0, band.vocalist_id FROM albums LEFT OUTER JOIN bands band ON (band.id = albums.band_id)'
+    def ds.fetch_rows(sql, &block)
+      yield({:id=>1, :band_id=>2, :band_id_0=>2, :vocalist_id=>3})
+    end
+    a = ds.all
+    a.should be_a_kind_of(Array)
+    a.size.should == 1
+    a.first.should be_a_kind_of(GraphAlbum)
+    a.first.values.should == {:id => 1, :band_id => 2}
+    a = a.first
+    a.band.should be_a_kind_of(GraphBand)
+    a.band.values.should == {:id => 2, :vocalist_id=>3}
+  end
+
+  it "should eagerly load a single one_to_many association" do
+    ds = GraphAlbum.eager_graph(:tracks)
+    ds.sql.should == 'SELECT albums.id, albums.band_id, tracks.id AS tracks_id, tracks.album_id FROM albums LEFT OUTER JOIN tracks ON (tracks.album_id = albums.id)'
+    def ds.fetch_rows(sql, &block)
+      yield({:id=>1, :band_id=>2, :tracks_id=>3, :album_id=>1})
+    end
+    a = ds.all
+    a.should be_a_kind_of(Array)
+    a.size.should == 1
+    a.first.should be_a_kind_of(GraphAlbum)
+    a.first.values.should == {:id => 1, :band_id => 2}
+    a = a.first
+    a.tracks.should be_a_kind_of(Array)
+    a.tracks.size.should == 1
+    a.tracks.first.should be_a_kind_of(GraphTrack)
+    a.tracks.first.values.should == {:id => 3, :album_id=>1}
+  end
+
+  it "should eagerly load a single many_to_many association" do
+    ds = GraphAlbum.eager_graph(:genres)
+    ds.sql.should == 'SELECT albums.id, albums.band_id, genres.id AS genres_id FROM albums LEFT OUTER JOIN ag ON (ag.album_id = albums.id) LEFT OUTER JOIN genres ON (genres.id = ag.genre_id)'
+    def ds.fetch_rows(sql, &block)
+      yield({:id=>1, :band_id=>2, :genres_id=>4})
+    end
+    a = ds.all
+    a.should be_a_kind_of(Array)
+    a.size.should == 1
+    a.first.should be_a_kind_of(GraphAlbum)
+    a.first.values.should == {:id => 1, :band_id => 2}
+    a = a.first
+    a.genres.should be_a_kind_of(Array)
+    a.genres.size.should == 1
+    a.genres.first.should be_a_kind_of(GraphGenre)
+    a.genres.first.values.should == {:id => 4}
+  end
+
+  it "should eagerly load multiple associations" do 
+    ds = GraphAlbum.eager_graph(:genres, :tracks, :band)
+    ds.sql.should == 'SELECT albums.id, albums.band_id, genres.id AS genres_id, tracks.id AS tracks_id, tracks.album_id, band.id AS band_id_0, band.vocalist_id FROM albums LEFT OUTER JOIN ag ON (ag.album_id = albums.id) LEFT OUTER JOIN genres ON (genres.id = ag.genre_id) LEFT OUTER JOIN tracks ON (tracks.album_id = albums.id) LEFT OUTER JOIN bands band ON (band.id = albums.band_id)'
+    def ds.fetch_rows(sql, &block)
+      yield({:id=>1, :band_id=>2, :genres_id=>4, :tracks_id=>3, :album_id=>1, :band_id_0=>2, :vocalist_id=>6})
+    end
+    a = ds.all
+    a.should be_a_kind_of(Array)
+    a.size.should == 1
+    a.first.should be_a_kind_of(GraphAlbum)
+    a.first.values.should == {:id => 1, :band_id => 2}
+    a = a.first
+    a.band.should be_a_kind_of(GraphBand)
+    a.band.values.should == {:id => 2, :vocalist_id=>6}
+    a.tracks.should be_a_kind_of(Array)
+    a.tracks.size.should == 1
+    a.tracks.first.should be_a_kind_of(GraphTrack)
+    a.tracks.first.values.should == {:id => 3, :album_id=>1}
+    a.genres.should be_a_kind_of(Array)
+    a.genres.size.should == 1
+    a.genres.first.should be_a_kind_of(GraphGenre)
+    a.genres.first.values.should == {:id => 4}
+  end
+
+  it "should allow cascading of eager loading for associations of associated models" do
+    ds = GraphTrack.eager_graph(:album=>{:band=>:members})
+    ds.sql.should == 'SELECT tracks.id, tracks.album_id, album.id AS album_id_0, album.band_id, band.id AS band_id_0, band.vocalist_id, members.id AS members_id FROM tracks LEFT OUTER JOIN albums album ON (album.id = tracks.album_id) LEFT OUTER JOIN bands band ON (band.id = album.band_id) LEFT OUTER JOIN bm ON (bm.band_id = band.id) LEFT OUTER JOIN members ON (members.id = bm.member_id)'
+    def ds.fetch_rows(sql, &block)
+      yield({:id=>3, :album_id=>1, :album_id_0=>1, :band_id=>2, :members_id=>5, :band_id_0=>2, :vocalist_id=>6})
+    end
+    a = ds.all
+    a.should be_a_kind_of(Array)
+    a.size.should == 1
+    a.first.should be_a_kind_of(GraphTrack)
+    a.first.values.should == {:id => 3, :album_id => 1}
+    a = a.first
+    a.album.should be_a_kind_of(GraphAlbum)
+    a.album.values.should == {:id => 1, :band_id => 2}
+    a.album.band.should be_a_kind_of(GraphBand)
+    a.album.band.values.should == {:id => 2, :vocalist_id=>6}
+    a.album.band.members.should be_a_kind_of(Array)
+    a.album.band.members.size.should == 1
+    a.album.band.members.first.should be_a_kind_of(GraphBandMember)
+    a.album.band.members.first.values.should == {:id => 5}
+  end
+  
+  it "should populate the reciprocal many_to_one association when eagerly loading the one_to_many association" do
+    MODEL_DB.reset
+    ds = GraphAlbum.eager_graph(:tracks)
+    ds.sql.should == 'SELECT albums.id, albums.band_id, tracks.id AS tracks_id, tracks.album_id FROM albums LEFT OUTER JOIN tracks ON (tracks.album_id = albums.id)'
+    def ds.fetch_rows(sql, &block)
+      @db << sql
+      yield({:id=>1, :band_id=>2, :tracks_id=>3, :album_id=>1})
+    end
+    a = ds.all
+    a.should be_a_kind_of(Array)
+    a.size.should == 1
+    a.first.should be_a_kind_of(GraphAlbum)
+    a.first.values.should == {:id => 1, :band_id => 2}
+    a = a.first
+    a.tracks.should be_a_kind_of(Array)
+    a.tracks.size.should == 1
+    a.tracks.first.should be_a_kind_of(GraphTrack)
+    a.tracks.first.values.should == {:id => 3, :album_id=>1}
+    a.tracks.first.album.should be_a_kind_of(GraphAlbum)
+    a.tracks.first.album.should == a
+    MODEL_DB.sqls.length.should == 1
+  end
+
+  it "should eager load multiple associations from the same table" do
+    ds = GraphBand.eager_graph(:vocalist, :members)
+    ds.sql.should == 'SELECT bands.id, bands.vocalist_id, vocalist.id AS vocalist_id_0, members.id AS members_id FROM bands LEFT OUTER JOIN members vocalist ON (vocalist.id = bands.vocalist_id) LEFT OUTER JOIN bm ON (bm.band_id = bands.id) LEFT OUTER JOIN members ON (members.id = bm.member_id)'
+    def ds.fetch_rows(sql, &block)
+      yield({:id=>2, :vocalist_id=>6, :vocalist_id_0=>6, :members_id=>5})
+    end
+    a = ds.all
+    a.should be_a_kind_of(Array)
+    a.size.should == 1
+    a.first.should be_a_kind_of(GraphBand)
+    a.first.values.should == {:id => 2, :vocalist_id => 6}
+    a = a.first
+    a.vocalist.should be_a_kind_of(GraphBandMember)
+    a.vocalist.values.should == {:id => 6}
+    a.members.should be_a_kind_of(Array)
+    a.members.size.should == 1
+    a.members.first.should be_a_kind_of(GraphBandMember)
+    a.members.first.values.should == {:id => 5}
+  end
+
+  it "should give you a graph of tables when called without .all" do 
+    ds = GraphAlbum.eager_graph(:band)
+    ds.sql.should == 'SELECT albums.id, albums.band_id, band.id AS band_id_0, band.vocalist_id FROM albums LEFT OUTER JOIN bands band ON (band.id = albums.band_id)'
+    def ds.fetch_rows(sql, &block)
+      yield({:id=>1, :band_id=>2, :band_id_0=>2, :vocalist_id=>3})
+    end
+    ds.first.should == {:albums=>GraphAlbum.new(:id => 1, :band_id => 2), :band=>GraphBand.new(:id => 2, :vocalist_id=>3)}
+  end
+
+  it "should not drop any associated objects if the graph could not be a cartesian product" do
+    ds = GraphBand.eager_graph(:members, :vocalist)
+    ds.sql.should == 'SELECT bands.id, bands.vocalist_id, members.id AS members_id, vocalist.id AS vocalist_id_0 FROM bands LEFT OUTER JOIN bm ON (bm.band_id = bands.id) LEFT OUTER JOIN members ON (members.id = bm.member_id) LEFT OUTER JOIN members vocalist ON (vocalist.id = bands.vocalist_id)'
+    def ds.fetch_rows(sql, &block)
+      yield({:id=>2, :vocalist_id=>6, :members_id=>5, :vocalist_id_0=>6})
+      yield({:id=>2, :vocalist_id=>6, :members_id=>5, :vocalist_id_0=>6})
+    end
+    a = ds.all
+    a.should be_a_kind_of(Array)
+    a.size.should == 1
+    a.first.should be_a_kind_of(GraphBand)
+    a.first.values.should == {:id => 2, :vocalist_id => 6}
+    a = a.first
+    a.vocalist.should be_a_kind_of(GraphBandMember)
+    a.vocalist.values.should == {:id => 6}
+    a.members.should be_a_kind_of(Array)
+    a.members.size.should == 2
+    a.members.first.should be_a_kind_of(GraphBandMember)
+    a.members.first.values.should == {:id => 5}
+    a.members.last.should be_a_kind_of(GraphBandMember)
+    a.members.last.values.should == {:id => 5}
+  end
+
+  it "should drop duplicate items that occur in sequence if the graph could be a cartesian product" do
+    ds = GraphBand.eager_graph(:members, :genres)
+    ds.sql.should == 'SELECT bands.id, bands.vocalist_id, members.id AS members_id, genres.id AS genres_id FROM bands LEFT OUTER JOIN bm ON (bm.band_id = bands.id) LEFT OUTER JOIN members ON (members.id = bm.member_id) LEFT OUTER JOIN bg ON (bg.band_id = bands.id) LEFT OUTER JOIN genres ON (genres.id = bg.genre_id)'
+    def ds.fetch_rows(sql, &block)
+      yield({:id=>2, :vocalist_id=>6, :members_id=>5, :genres_id=>7})
+      yield({:id=>2, :vocalist_id=>6, :members_id=>5, :genres_id=>8})
+      yield({:id=>2, :vocalist_id=>6, :members_id=>6, :genres_id=>7})
+      yield({:id=>2, :vocalist_id=>6, :members_id=>6, :genres_id=>8})
+    end
+    a = ds.all
+    a.should be_a_kind_of(Array)
+    a.size.should == 1
+    a.first.should be_a_kind_of(GraphBand)
+    a.first.values.should == {:id => 2, :vocalist_id => 6}
+    a = a.first
+    a.members.should be_a_kind_of(Array)
+    a.members.size.should == 2
+    a.members.first.should be_a_kind_of(GraphBandMember)
+    a.members.first.values.should == {:id => 5}
+    a.members.last.should be_a_kind_of(GraphBandMember)
+    a.members.last.values.should == {:id => 6}
+    a.genres.size.should == 2
+    a.genres.first.should be_a_kind_of(GraphGenre)
+    a.genres.first.values.should == {:id => 7}
+    a.genres.last.should be_a_kind_of(GraphGenre)
+    a.genres.last.values.should == {:id => 8}
+  end
+
+  it "should be able to be used in combination with #eager" do
+    MODEL_DB.reset
+    ds = GraphAlbum.eager_graph(:tracks).eager(:genres)
+    def ds.fetch_rows(sql, &block)
+      @db << sql
+      yield({:id=>1, :band_id=>2, :tracks_id=>3, :album_id=>1})
+    end
+    ds2 = GraphGenre.dataset
+    def ds2.fetch_rows(sql, &block)
+      @db << sql
+      yield({:id=>6, :x_foreign_key_x=>1})
+    end
+    a = ds.all
+    a.should be_a_kind_of(Array)
+    a.size.should == 1
+    a.first.should be_a_kind_of(GraphAlbum)
+    a.first.values.should == {:id => 1, :band_id => 2}
+    a = a.first
+    a.tracks.should be_a_kind_of(Array)
+    a.tracks.size.should == 1
+    a.tracks.first.should be_a_kind_of(GraphTrack)
+    a.tracks.first.values.should == {:id=>3, :album_id=>1}
+    a.genres.should be_a_kind_of(Array)
+    a.genres.size.should == 1
+    a.genres.first.should be_a_kind_of(GraphGenre)
+    a.genres.first.values.should == {:id=>6}
+    MODEL_DB.sqls[0].should == 'SELECT albums.id, albums.band_id, tracks.id AS tracks_id, tracks.album_id FROM albums LEFT OUTER JOIN tracks ON (tracks.album_id = albums.id)'
+    ["SELECT genres.*, ag.album_id AS x_foreign_key_x FROM genres INNER JOIN ag ON (ag.genre_id = genres.id) AND (ag.album_id IN (1))",
+     "SELECT genres.*, ag.album_id AS x_foreign_key_x FROM genres INNER JOIN ag ON (ag.album_id IN (1)) AND (ag.genre_id = genres.id)"
+    ].should(include(MODEL_DB.sqls[1]))
+  end
+end

data/spec/hooks_spec.rb

@@ -131,18 +131,19 @@ end
 describe "Model#after_initialize" do
   specify "should be called after initialization" do
     $values1 = nil
+    $reached_after_initialized = false
     
     a = Class.new(Sequel::Model) do
+      columns :x, :y
       after_initialize do
         $values1 = @values.clone
-        raise Sequel::Error if @values[:blow]
+        $reached_after_initialized = true
       end
     end
     
     a.new(:x => 1, :y => 2)
     $values1.should == {:x => 1, :y => 2}
-    
-    proc {a.new(:blow => true)}.should raise_error(Sequel::Error)
+    $reached_after_initialized.should == true
   end
 end
 
@@ -151,6 +152,7 @@ describe "Model#before_create && Model#after_create" do
     MODEL_DB.reset
 
     @c = Class.new(Sequel::Model(:items)) do
+      columns :x
       no_primary_key
       
       before_create {MODEL_DB << "BLAH before"}
@@ -194,6 +196,7 @@ describe "Model#before_save && Model#after_save" do
     MODEL_DB.reset
 
     @c = Class.new(Sequel::Model(:items)) do
+      columns :x
       before_save {MODEL_DB << "BLAH before"}
       after_save {MODEL_DB << "BLAH after"}
     end
@@ -266,4 +269,4 @@ describe "Model#has_hooks?" do
     @c.before_save :blah
     @d.has_hooks?(:before_save).should be_true
   end
-end
+end

data/spec/inflector_spec.rb

@@ -0,0 +1,34 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+
+describe Inflector do
+  it "should transform words from singular to plural" do
+    "post".pluralize.should == "posts"
+    "octopus".pluralize.should =="octopi"
+    "the blue mailman".pluralize.should == "the blue mailmen"
+    "CamelOctopus".pluralize.should == "CamelOctopi"
+  end
+  
+  it "should transform words from plural to singular" do
+    "posts".singularize.should == "post"
+    "octopi".singularize.should == "octopus"
+    "the blue mailmen".singularize.should == "the blue mailman"
+    "CamelOctopi".singularize.should == "CamelOctopus"
+  end
+  
+  it "should transform class names to table names" do
+    "RawScaledScorer".tableize.should == "raw_scaled_scorers"
+    "egg_and_ham".tableize.should == "egg_and_hams"
+    "fancyCategory".tableize.should == "fancy_categories"
+  end
+  
+  it "should tranform table names to class names" do
+    "egg_and_hams".classify.should == "EggAndHam"
+    "post".classify.should == "Post"
+  end
+  
+  it "should create a foreign key name from a class name" do
+    "Message".foreign_key.should == "message_id"
+    "Message".foreign_key(false).should == "messageid"
+    "Admin::Post".foreign_key.should == "post_id"
+  end
+end

data/spec/model_spec.rb

@@ -73,6 +73,7 @@ describe Sequel::Model, "constructor" do
   
   before(:each) do
     @m = Class.new(Sequel::Model)
+    @m.columns :a, :b
   end
 
   it "should accept a hash" do
@@ -102,7 +103,6 @@ describe Sequel::Model, "new" do
   it "should be marked as new?" do
     o = @m.new
     o.should be_new
-    o.should be_new_record
   end
 
   it "should not be marked as new? once it is saved" do
@@ -110,7 +110,6 @@ describe Sequel::Model, "new" do
     o.should be_new
     o.save
     o.should_not be_new
-    o.should_not be_new_record
   end
 
   it "should use the last inserted id as primary key if not in values" do
@@ -218,6 +217,7 @@ describe Sequel::Model, ".fetch" do
   
 end
 
+### DEPRECATED
 describe Sequel::Model, "magic methods" do
 
   before(:each) do
@@ -290,6 +290,7 @@ describe Sequel::Model, ".find_or_create" do
     MODEL_DB.reset
     @c = Class.new(Sequel::Model(:items)) do
       no_primary_key
+      columns :x
     end
   end
 
@@ -355,22 +356,6 @@ describe Sequel::Model, ".destroy_all" do
   end
 end
 
-describe Sequel::Model, ".join" do
-
-  before(:each) do
-    MODEL_DB.reset  
-    @c = Class.new(Sequel::Model(:items)) do
-      no_primary_key
-    end
-  end
-  
-  it "should format proper SQL" do
-    @c.join(:atts, :item_id => :id).sql.should == \
-      "SELECT items.* FROM items INNER JOIN atts ON (atts.item_id = items.id)"
-  end
-  
-end
-
 describe Sequel::Model, ".all" do
   
   before(:each) do
@@ -406,6 +391,7 @@ describe Sequel::Model, "A model class without a primary key" do
   before(:each) do
     MODEL_DB.reset
     @c = Class.new(Sequel::Model(:items)) do
+      columns :x
       no_primary_key
     end
   end
@@ -438,52 +424,43 @@ describe Sequel::Model, "attribute accessors" do
   before(:each) do
     MODEL_DB.reset
 
-    @c = Class.new(Sequel::Model(:items)) do
+    @c = Class.new(Sequel::Model) do
+      def self.columns; orig_columns; end
     end
-    
-    @c.dataset.meta_def(:columns) {[:id, :x, :y]}
+    @dataset = Object.new
+    def @dataset.db; end
+    def @dataset.set_model(blah); end
+    def @dataset.naked; self; end
+    def @dataset.columns; [:x, :y]; end
+    def @dataset.def_mutation_method(*names);  end
   end
 
-  it "should be created dynamically" do
+  it "should be created on set_dataset" do
+    %w'x y x= y='.each do |x|
+      @c.instance_methods.include?(x).should == false
+    end
+    @c.set_dataset(@dataset)
+    %w'x y x= y='.each do |x|
+      @c.instance_methods.include?(x).should == true
+    end
     o = @c.new
+    %w'x y x= y='.each do |x|
+      o.methods.include?(x).should == true
+    end
 
-    o.should_not be_respond_to(:x)
     o.x.should be_nil
-    o.should be_respond_to(:x)
-
-    o.should_not be_respond_to(:x=)
     o.x = 34
     o.x.should == 34
-    o.should be_respond_to(:x=)
   end
 
-  it "should raise for a column that doesn't exist in the dataset" do
-    o = @c.new
-
-    proc {o.x}.should_not raise_error
-    proc {o.xx}.should raise_error(Sequel::Error)
-
-    proc {o.x = 3}.should_not raise_error
-    proc {o.yy = 4}.should raise_error(Sequel::Error)
-
-    proc {o.yy?}.should raise_error(NoMethodError)
-  end
-  
-  it "should not raise for a column not in the dataset, but for which there's a value" do
+  it "should be only accept one argument for the write accessor" do
+    @c.set_dataset(@dataset)
     o = @c.new
 
-    proc {o.xx}.should raise_error(Sequel::Error)
-    proc {o.yy}.should raise_error(Sequel::Error)
-
-    o.values[:xx] = 123
-    o.values[:yy] = nil
-
-    proc {o.xx; o.yy}.should_not raise_error(Sequel::Error)
-
-    o.xx.should == 123
-    o.yy.should == nil
-
-    proc {o.xx = 3}.should_not raise_error(Sequel::Error)
+    o.x = 34
+    o.x.should == 34
+    proc{o.send(:x=)}.should raise_error
+    proc{o.send(:x=, 3, 4)}.should raise_error
   end
 end
 
@@ -540,4 +517,4 @@ context "Model#inspect" do
   specify "should include the class name and the values" do
     @o.inspect.should == '#<Sequel::Model @values={:x=>333}>'
   end
-end
+end