sequel 3.21.0 → 3.29.0

data/spec/model/base_spec.rb

@@ -1,14 +1,12 @@
 require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
 
 describe "Model attribute setters" do
-
-  before(:each) do
-    MODEL_DB.reset
-
+  before do
     @c = Class.new(Sequel::Model(:items)) do
       columns :id, :x, :y, :"x y"
     end
     @o = @c.new
+    MODEL_DB.reset
   end
 
   it "should mark the column value as changed" do
@@ -41,18 +39,13 @@ describe Sequel::Model, "dataset" do
   before do
     @a = Class.new(Sequel::Model(:items))
     @b = Class.new(Sequel::Model)
-    
-    class Elephant < Sequel::Model(:ele1)
-    end
-    
-    class Maggot < Sequel::Model
-    end
-
-    class ShoeSize < Sequel::Model
-    end
-    
-    class BootSize < ShoeSize
-    end
+    class ::Elephant < Sequel::Model(:ele1); end
+    class ::Maggot < Sequel::Model; end
+    class ::ShoeSize < Sequel::Model; end
+    class ::BootSize < ShoeSize; end
+  end
+  after do
+    [:Elephant, :Maggot, :ShoeSize, :BootSize].each{|x| Object.send(:remove_const, x)}
   end
   
   specify "should default to the plural of the class name" do
@@ -74,33 +67,59 @@ describe Sequel::Model, "dataset" do
   end
   
   specify "should disregard namespaces for the table name" do
-    module BlahBlah
-      class MwaHaHa < Sequel::Model
+    begin
+      module ::BlahBlah
+        class MwaHaHa < Sequel::Model
+        end
       end
-    end
     
-    BlahBlah::MwaHaHa.dataset.sql.should == 'SELECT * FROM mwa_ha_has'
+      BlahBlah::MwaHaHa.dataset.sql.should == 'SELECT * FROM mwa_ha_has'
+    ensure
+      Object.send(:remove_const, :BlahBlah)
+    end
   end
 end
 
 describe Sequel::Model, ".def_dataset_method" do
   before do
-    @c = Class.new(Sequel::Model(:items)) do
-    end
+    @c = Class.new(Sequel::Model(:items))
   end
   
   it "should add a method to the dataset and model if called with a block argument" do
-    @c.instance_eval do
-      def_dataset_method(:return_3){3}
-    end
+    @c.def_dataset_method(:return_3){3}
     @c.return_3.should == 3
     @c.dataset.return_3.should == 3
   end
 
-  it "should add all passed methods to the model if called without a block argument" do
+  it "should handle weird method names" do
+    @c.def_dataset_method(:"return 3"){3}
+    @c.send(:"return 3").should == 3
+    @c.dataset.send(:"return 3").should == 3
+  end
+
+  it "should not add a model method if the model already responds to the method" do
     @c.instance_eval do
-      def_dataset_method(:return_3, :return_4)
+      def foo
+        1
+      end
+
+      private
+
+      def bar
+        2
+      end
+
+      def_dataset_method(:foo){3}
+      def_dataset_method(:bar){4}
     end
+    @c.foo.should == 1
+    @c.dataset.foo.should == 3
+    @c.send(:bar).should == 2
+    @c.dataset.bar.should == 4
+  end
+
+  it "should add all passed methods to the model if called without a block argument" do
+    @c.def_dataset_method(:return_3, :return_4)
     proc{@c.return_3}.should raise_error(NoMethodError)
     proc{@c.return_4}.should raise_error(NoMethodError)
     @c.dataset.instance_eval do
@@ -112,30 +131,113 @@ describe Sequel::Model, ".def_dataset_method" do
   end
 
   it "should cache calls and readd methods if set_dataset is used" do
-    @c.instance_eval do
-      def_dataset_method(:return_3){3}
-    end
+    @c.def_dataset_method(:return_3){3}
     @c.set_dataset :items
     @c.return_3.should == 3
     @c.dataset.return_3.should == 3
   end
 
   it "should readd methods to subclasses, if set_dataset is used in a subclass" do
-    @c.instance_eval do
-      def_dataset_method(:return_3){3}
-    end
+    @c.def_dataset_method(:return_3){3}
+    c = Class.new(@c)
+    c.set_dataset :items
+    c.return_3.should == 3
+    c.dataset.return_3.should == 3
+  end
+end
+
+describe Sequel::Model, ".dataset_module" do
+  before do
+    @c = Class.new(Sequel::Model(:items))
+  end
+  
+  it "should extend the dataset with the module if the model has a dataset" do
+    @c.dataset_module{def return_3() 3 end}
+    @c.dataset.return_3.should == 3
+  end
+
+  it "should add methods defined in the module to the class" do
+    @c.dataset_module{def return_3() 3 end}
+    @c.return_3.should == 3
+  end
+
+  it "should cache calls and readd methods if set_dataset is used" do
+    @c.dataset_module{def return_3() 3 end}
+    @c.set_dataset :items
+    @c.return_3.should == 3
+    @c.dataset.return_3.should == 3
+  end
+
+  it "should readd methods to subclasses, if set_dataset is used in a subclass" do
+    @c.dataset_module{def return_3() 3 end}
     c = Class.new(@c)
     c.set_dataset :items
     c.return_3.should == 3
     c.dataset.return_3.should == 3
   end
+
+  it "should only have a single dataset_module per class" do
+    @c.dataset_module{def return_3() 3 end}
+    @c.dataset_module{def return_3() 3 + (begin; super; rescue NoMethodError; 1; end) end}
+    @c.return_3.should == 4
+  end
+
+  it "should not have subclasses share the dataset_module" do
+    @c.dataset_module{def return_3() 3 end}
+    c = Class.new(@c)
+    c.dataset_module{def return_3() 3 + (begin; super; rescue NoMethodError; 1; end) end}
+    c.return_3.should == 6
+  end
+
+  it "should accept a module object and extend the dataset with it" do
+    @c.dataset_module Module.new{def return_3() 3 end}
+    @c.dataset.return_3.should == 3
+  end
+
+  it "should be able to call dataset_module with a module multiple times" do
+    @c.dataset_module Module.new{def return_3() 3 end}
+    @c.dataset_module Module.new{def return_4() 4 end}
+    @c.dataset.return_3.should == 3
+    @c.dataset.return_4.should == 4
+  end
+
+  it "should be able mix dataset_module calls with and without arguments" do
+    @c.dataset_module{def return_3() 3 end}
+    @c.dataset_module Module.new{def return_4() 4 end}
+    @c.dataset.return_3.should == 3
+    @c.dataset.return_4.should == 4
+  end
+
+  it "should have modules provided to dataset_module extend subclass datasets" do
+    @c.dataset_module{def return_3() 3 end}
+    @c.dataset_module Module.new{def return_4() 4 end}
+    c = Class.new(@c)
+    c.set_dataset :a
+    c.dataset.return_3.should == 3
+    c.dataset.return_4.should == 4
+  end
+
+  it "should return the dataset module if given a block" do
+    Object.new.extend(@c.dataset_module{def return_3() 3 end}).return_3.should == 3
+  end
+
+  it "should return the argument if given one" do
+    Object.new.extend(@c.dataset_module Module.new{def return_3() 3 end}).return_3.should == 3
+  end
+
+  it "should raise error if called with both an argument and ablock" do
+    proc{@c.dataset_module(Module.new{def return_3() 3 end}){}}.should raise_error(Sequel::Error)
+  end
 end
 
 describe "A model class with implicit table name" do
   before do
-    class Donkey < Sequel::Model
+    class ::Donkey < Sequel::Model
     end
   end
+  after do
+    Object.send(:remove_const, :Donkey)
+  end
   
   specify "should have a dataset associated with the model class" do
     Donkey.dataset.model.should == Donkey
@@ -144,11 +246,12 @@ end
 
 describe "A model inheriting from a model" do
   before do
-    class Feline < Sequel::Model
-    end
-    
-    class Leopard < Feline
-    end
+    class ::Feline < Sequel::Model; end
+    class ::Leopard < Feline; end
+  end
+  after do
+    Object.send(:remove_const, :Leopard)
+    Object.send(:remove_const, :Feline)
   end
   
   specify "should have a dataset associated with itself" do
@@ -228,29 +331,27 @@ end
 
 describe "Model.db=" do
   before do
-    $db1 = MockDatabase.new
-    $db2 = MockDatabase.new
+    @db1 = Sequel.mock
+    @db2 = Sequel.mock
     
-    class BlueBlue < Sequel::Model(:items)
-      set_dataset $db1[:blue].filter(:x=>1)
-    end
+    @m = Class.new(Sequel::Model(@db1[:blue].filter(:x=>1)))
   end
   
   specify "should affect the underlying dataset" do
-    BlueBlue.db = $db2
+    @m.db = @db2
     
-    BlueBlue.dataset.db.should === $db2
-    BlueBlue.dataset.db.should_not === $db1
+    @m.dataset.db.should === @db2
+    @m.dataset.db.should_not === @db1
   end
 
   specify "should keep the same dataset options" do
-    BlueBlue.db = $db2
-    BlueBlue.dataset.sql.should == 'SELECT * FROM blue WHERE (x = 1)'
+    @m.db = @db2
+    @m.dataset.sql.should == 'SELECT * FROM blue WHERE (x = 1)'
   end
 
   specify "should use the database for subclasses" do
-    BlueBlue.db = $db2
-    Class.new(BlueBlue).db.should === $db2
+    @m.db = @db2
+    Class.new(@m).db.should === @db2
   end
 end
 
@@ -258,9 +359,6 @@ describe Sequel::Model, ".(allowed|restricted)_columns " do
   before do
     @c = Class.new(Sequel::Model(:blahblah)) do
       columns :x, :y, :z
-      def _refresh(ds)
-        self
-      end
     end
     @c.strict_param_setting = false
     @c.instance_variable_set(:@columns, [:x, :y, :z])
@@ -288,9 +386,12 @@ describe Sequel::Model, ".(allowed|restricted)_columns " do
     i.values.should == {:x => 1, :y => 2}
     i.set(:x => 4, :y => 5, :z => 6)
     i.values.should == {:x => 4, :y => 5}
-    i.update(:x => 7, :y => 8, :z => 9)
-    i.values.delete(:id) # stupid specs
-    i.values.should == {:x => 7, :y => 8}
+
+    @c.dataset._fetch = {:x => 7}
+    i = @c.new
+    i.update(:x => 7, :z => 9)
+    i.values.should == {:x => 7}
+    MODEL_DB.sqls.should == ["INSERT INTO blahblah (x) VALUES (7)", "SELECT * FROM blahblah WHERE (id = 10) LIMIT 1"]
   end
 
   it "should not set restricted columns by default" do
@@ -299,9 +400,12 @@ describe Sequel::Model, ".(allowed|restricted)_columns " do
     i.values.should == {:x => 1, :y => 2}
     i.set(:x => 4, :y => 5, :z => 6)
     i.values.should == {:x => 4, :y => 5}
-    i.update(:x => 7, :y => 8, :z => 9)
-    i.values.delete(:id) # stupid specs
-    i.values.should == {:x => 7, :y => 8}
+
+    @c.dataset._fetch = {:x => 7}
+    i = @c.new
+    i.update(:x => 7, :z => 9)
+    i.values.should == {:x => 7}
+    MODEL_DB.sqls.should == ["INSERT INTO blahblah (x) VALUES (7)", "SELECT * FROM blahblah WHERE (id = 10) LIMIT 1"]
   end
 
   it "should have allowed take precedence over restricted" do
@@ -311,9 +415,12 @@ describe Sequel::Model, ".(allowed|restricted)_columns " do
     i.values.should == {:x => 1, :y => 2}
     i.set(:x => 4, :y => 5, :z => 6)
     i.values.should == {:x => 4, :y => 5}
-    i.update(:x => 7, :y => 8, :z => 9)
-    i.values.delete(:id) # stupid specs
-    i.values.should == {:x => 7, :y => 8}
+
+    @c.dataset._fetch = {:y => 7}
+    i = @c.new
+    i.update(:y => 7, :z => 9)
+    i.values.should == {:y => 7}
+    MODEL_DB.sqls.should == ["INSERT INTO blahblah (y) VALUES (7)", "SELECT * FROM blahblah WHERE (id = 10) LIMIT 1"]
   end
 end
 
@@ -322,12 +429,8 @@ describe Sequel::Model, ".(un)?restrict_primary_key\\??" do
     @c = Class.new(Sequel::Model(:blahblah)) do
       set_primary_key :id
       columns :x, :y, :z, :id
-      def refresh
-        self
-      end
     end
     @c.strict_param_setting = false
-    @c.instance_variable_set(:@columns, [:x, :y, :z])
   end
   
   it "should restrict updates to primary key by default" do
@@ -364,11 +467,7 @@ describe Sequel::Model, ".strict_param_setting" do
     @c = Class.new(Sequel::Model(:blahblah)) do
       columns :x, :y, :z, :id
       set_restricted_columns :z
-      def refresh
-        self
-      end
     end
-    @c.instance_variable_set(:@columns, [:x, :y, :z])
   end
   
   it "should be enabled by default" do
@@ -425,20 +524,18 @@ end
 
 describe Sequel::Model, ".[] optimization" do
   before do
-    @c = Class.new(Sequel::Model(:a))
-    @c.instance_eval do
-      def simple_table
-        @simple_table
-      end
-    end
+    @db = MODEL_DB.clone
+    @db.quote_identifiers = true
+    @c = Class.new(Sequel::Model(@db))
   end
 
   it "should set simple_pk to the literalized primary key column name if a single primary key" do
-    @c.simple_pk.should == 'id'
+    @c.set_primary_key :id
+    @c.simple_pk.should == '"id"'
     @c.set_primary_key :b
-    @c.simple_pk.should == 'b'
+    @c.simple_pk.should == '"b"'
     @c.set_primary_key :b__a.identifier
-    @c.simple_pk.should == 'b__a'
+    @c.simple_pk.should == '"b__a"'
   end
 
   it "should have simple_pk be blank if compound or no primary key" do
@@ -452,36 +549,99 @@ describe Sequel::Model, ".[] optimization" do
 
   it "should have simple table set if passed a Symbol to set_dataset" do
     @c.set_dataset :a
-    @c.simple_table.should == 'a'
+    @c.simple_table.should == '"a"'
     @c.set_dataset :b
-    @c.simple_table.should == 'b'
+    @c.simple_table.should == '"b"'
     @c.set_dataset :b__a
-    @c.simple_table.should == 'b.a'
+    @c.simple_table.should == '"b"."a"'
+  end
+
+  it "should have simple_table set if passed a simple select all dataset to set_dataset" do
+    @c.set_dataset @db[:a]
+    @c.simple_table.should == '"a"'
+    @c.set_dataset @db[:b]
+    @c.simple_table.should == '"b"'
+    @c.set_dataset @db[:b__a]
+    @c.simple_table.should == '"b"."a"'
+  end
+
+  it "should simple_pk and simple_table respect dataset's identifier input methods" do
+    ds = @db[:ab]
+    ds.identifier_input_method = :reverse
+    @c.set_dataset ds
+    @c.simple_table.should == '"ba"'
+    @c.set_primary_key :cd
+    @c.simple_pk.should == '"dc"'
+
+    @c.set_dataset ds.from(:ef__gh)
+    @c.simple_table.should == '"fe"."hg"'
   end
 
-  it "should have simple_table = nil if passed a dataset to set_dataset" do
-    @c.set_dataset @c.db[:a]
+  it "should have simple_table = nil if passed a non-simple select all dataset to set_dataset" do
+    @c.set_dataset @c.db[:a].filter(:active)
     @c.simple_table.should == nil
   end
 
   it "should have simple_table superclasses setting if inheriting" do
-    @c.set_dataset :a
-    Class.new(@c).simple_table.should == 'a'
-    @c.instance_variable_set(:@simple_table, nil)
     Class.new(@c).simple_table.should == nil
-    @c.instance_variable_set(:@simple_table, "'b'")
-    Class.new(@c).simple_table.should == "'b'"
+    @c.set_dataset :a
+    Class.new(@c).simple_table.should == '"a"'
   end
 
   it "should use Dataset#with_sql if simple_table and simple_pk are true" do
     @c.set_dataset :a
-    @c.dataset.should_receive(:with_sql).and_return(@c.dataset)
-    @c[1]
+    @c.dataset._fetch = {:id => 1}
+    @c[1].should == @c.load(:id=>1)
+    @db.sqls.should == ['SELECT * FROM "a" WHERE "id" = 1']
   end
 
   it "should not use Dataset#with_sql if either simple_table or simple_pk is nil" do
-    @c.set_dataset @c.dataset
-    @c.dataset.should_not_receive(:with_sql)
-    @c[1]
+    @c.set_dataset @db[:a].filter(:active)
+    @c.dataset._fetch = {:id => 1}
+    @c[1].should == @c.load(:id=>1)
+    @db.sqls.should == ['SELECT * FROM "a" WHERE ("active" AND ("id" = 1)) LIMIT 1']
+  end
+end
+
+describe "Model datasets #with_pk" do
+  before do
+    @c = Class.new(Sequel::Model(:a))
+    @ds = @c.dataset
+    @ds._fetch = {:id=>1}
+    MODEL_DB.reset
+  end
+
+  it "should return the first record where the primary key matches" do
+    @ds.with_pk(1).should == @c.load(:id=>1)
+    MODEL_DB.sqls.should == ["SELECT * FROM a WHERE (a.id = 1) LIMIT 1"]
+  end
+
+  it "should handle existing filters" do
+    @ds.filter(:a=>2).with_pk(1)
+    MODEL_DB.sqls.should == ["SELECT * FROM a WHERE ((a = 2) AND (a.id = 1)) LIMIT 1"]
+  end
+
+  it "should work with string values" do
+    @ds.with_pk("foo")
+    MODEL_DB.sqls.should == ["SELECT * FROM a WHERE (a.id = 'foo') LIMIT 1"]
+  end
+
+  it "should handle an array for composite primary keys" do
+    @c.set_primary_key :id1, :id2
+    @ds.with_pk([1, 2])
+    sqls = MODEL_DB.sqls
+    ["SELECT * FROM a WHERE ((a.id1 = 1) AND (a.id2 = 2)) LIMIT 1",
+    "SELECT * FROM a WHERE ((a.id2 = 2) AND (a.id1 = 1)) LIMIT 1"].should include(sqls.pop)
+    sqls.should == []
+  end
+
+  it "should have #[] consider an integer as a primary key lookup" do
+    @ds[1].should == @c.load(:id=>1)
+    MODEL_DB.sqls.should == ["SELECT * FROM a WHERE (a.id = 1) LIMIT 1"]
+  end
+
+  it "should not have #[] consider a string as a primary key lookup" do
+    @ds['foo'].should == @c.load(:id=>1)
+    MODEL_DB.sqls.should == ["SELECT * FROM a WHERE (foo) LIMIT 1"]
   end
 end

data/spec/model/dataset_methods_spec.rb

@@ -3,39 +3,25 @@ require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
 describe Sequel::Model::DatasetMethods, "#destroy"  do
   before do
     @c = Class.new(Sequel::Model(:items)) do
-      class_variable_set(:@@destroyed, [])
+      self::Destroyed = []
       def destroy
-        self.class.send(:class_variable_get, :@@destroyed) << self
-      end
-      def self.destroyed
-        class_variable_get(:@@destroyed)
+        model::Destroyed << self
       end
     end
     @d = @c.dataset
+    @d._fetch = [{:id=>1}, {:id=>2}]
     MODEL_DB.reset
   end
 
   it "should instantiate objects in the dataset and call destroy on each" do
-    def @d.fetch_rows(sql)
-      yield({:id=>1})
-      yield({:id=>2})
-    end
     @d.destroy
-    @c.destroyed.collect{|x| x.values}.should == [{:id=>1}, {:id=>2}]
+    @c::Destroyed.collect{|x| x.values}.should == [{:id=>1}, {:id=>2}]
   end
 
   it "should return the number of records destroyed" do
-    def @d.fetch_rows(sql)
-      yield({:id=>1})
-      yield({:id=>2})
-    end
     @d.destroy.should == 2
-    def @d.fetch_rows(sql)
-      yield({:id=>1})
-    end
+    @d._fetch = [[{:i=>1}], []]
     @d.destroy.should == 1
-    def @d.fetch_rows(sql)
-    end
     @d.destroy.should == 0
   end
 
@@ -61,10 +47,7 @@ describe Sequel::Model::DatasetMethods, "#to_hash"  do
   end
 
   it "should result in a hash with primary key value keys and model object values" do
-    def @d.fetch_rows(sql)
-      yield({:name=>1})
-      yield({:name=>2})
-    end
+    @d._fetch = [{:name=>1}, {:name=>2}]
     h = @d.to_hash
     h.should be_a_kind_of(Hash)
     a = h.to_a
@@ -73,10 +56,7 @@ describe Sequel::Model::DatasetMethods, "#to_hash"  do
   end
 
   it "should result in a hash with given value keys and model object values" do
-    def @d.fetch_rows(sql)
-      yield({:name=>1, :number=>3})
-      yield({:name=>2, :number=>4})
-    end
+    @d._fetch = [{:name=>1, :number=>3}, {:name=>2, :number=>4}]
     h = @d.to_hash(:number)
     h.should be_a_kind_of(Hash)
     a = h.to_a