colincasey-sequel 2.10.0 → 2.10.1

data/spec/sequel_model/base_spec.rb

@@ -0,0 +1,419 @@
+require File.join(File.dirname(__FILE__), "spec_helper")
+
+describe "Model attribute setters" do
+
+  before(:each) do
+    MODEL_DB.reset
+
+    @c = Class.new(Sequel::Model(:items)) do
+      columns :id, :x, :y
+    end
+  end
+
+  it "should mark the column value as changed" do
+    o = @c.new
+    o.changed_columns.should == []
+
+    o.x = 2
+    o.changed_columns.should == [:x]
+
+    o.y = 3
+    o.changed_columns.should == [:x, :y]
+
+    o.changed_columns.clear
+
+    o[:x] = 2
+    o.changed_columns.should == [:x]
+
+    o[:y] = 3
+    o.changed_columns.should == [:x, :y]
+  end
+
+end
+
+describe "Model#serialize" do
+
+  before(:each) do
+    MODEL_DB.reset
+  end
+
+  it "should translate values to YAML when creating records" do
+    @c = Class.new(Sequel::Model(:items)) do
+      no_primary_key
+      serialize :abc
+      columns :abc
+    end
+
+    @c.create(:abc => 1)
+    @c.create(:abc => "hello")
+
+    MODEL_DB.sqls.should == [ \
+      "INSERT INTO items (abc) VALUES ('--- 1\n')", \
+      "INSERT INTO items (abc) VALUES ('--- hello\n')", \
+    ]
+  end
+
+  it "should support calling after the class is defined" do
+    @c = Class.new(Sequel::Model(:items)) do
+      no_primary_key
+      columns :def
+    end
+
+    @c.serialize :def
+
+    @c.create(:def => 1)
+    @c.create(:def => "hello")
+
+    MODEL_DB.sqls.should == [ \
+      "INSERT INTO items (def) VALUES ('--- 1\n')", \
+      "INSERT INTO items (def) VALUES ('--- hello\n')", \
+    ]
+  end
+
+  it "should support using the Marshal format" do
+    @c = Class.new(Sequel::Model(:items)) do
+      no_primary_key
+      serialize :abc, :format => :marshal
+      columns :abc
+    end
+
+    @c.create(:abc => 1)
+    @c.create(:abc => "hello")
+    x = [Marshal.dump("hello")].pack('m')
+
+    MODEL_DB.sqls.should == [ \
+      "INSERT INTO items (abc) VALUES ('BAhpBg==\n')", \
+      "INSERT INTO items (abc) VALUES ('#{x}')", \
+    ]
+  end
+
+  it "should translate values to and from YAML using accessor methods" do
+    @c = Class.new(Sequel::Model(:items)) do
+      serialize :abc, :def
+      columns :abc, :def
+    end
+
+    ds = @c.dataset
+    ds.extend(Module.new {
+      attr_accessor :raw
+
+      def fetch_rows(sql, &block)
+        block.call(@raw)
+      end
+
+      @@sqls = nil
+
+      def insert(*args)
+        @@sqls = insert_sql(*args)
+      end
+
+      def update(*args)
+        @@sqls = update_sql(*args)
+      end
+
+      def sqls
+        @@sqls
+      end
+
+      def columns
+        [:id, :abc, :def]
+      end
+    }
+    )
+
+    ds.raw = {:id => 1, :abc => "--- 1\n", :def => "--- hello\n"}
+    o = @c.first
+    o.id.should == 1
+    o.abc.should == 1
+    o.def.should == "hello"
+
+    o.update_values(:abc => 23)
+    ds.sqls.should == "UPDATE items SET abc = '#{23.to_yaml}' WHERE (id = 1)"
+
+    ds.raw = {:id => 1, :abc => "--- 1\n", :def => "--- hello\n"}
+    o = @c.create(:abc => [1, 2, 3])
+    ds.sqls.should == "INSERT INTO items (abc) VALUES ('#{[1, 2, 3].to_yaml}')"
+  end
+
+end
+
+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
+  end
+  
+  specify "should default to the plural of the class name" do
+    Maggot.dataset.sql.should == 'SELECT * FROM maggots'
+    ShoeSize.dataset.sql.should == 'SELECT * FROM shoe_sizes'
+  end
+  
+  specify "should return the dataset for the superclass if available" do
+    BootSize.dataset.sql.should == 'SELECT * FROM shoe_sizes'
+  end
+  
+  specify "should return the correct dataset if set explicitly" do
+    Elephant.dataset.sql.should == 'SELECT * FROM ele1'
+    @a.dataset.sql.should == 'SELECT * FROM items'
+  end
+  
+  specify "should raise if no dataset is explicitly set and the class is anonymous" do
+    proc {@b.dataset}.should raise_error(Sequel::Error)
+  end
+  
+  specify "should disregard namespaces for the table name" do
+    module BlahBlah
+      class MwaHaHa < Sequel::Model
+      end
+    end
+    
+    BlahBlah::MwaHaHa.dataset.sql.should == 'SELECT * FROM mwa_ha_has'
+  end
+end
+
+describe Sequel::Model, ".def_dataset_method" do
+  setup do
+    @c = Class.new(Sequel::Model(:items)) do
+      @dataset = Object.new
+    end
+  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.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
+    @c.instance_eval do
+      def_dataset_method(:return_3, :return_4)
+    end
+    proc{@c.return_3}.should raise_error(NoMethodError)
+    proc{@c.return_4}.should raise_error(NoMethodError)
+    @c.dataset.instance_eval do
+      def return_3; 3; end
+      def return_4; 4; end
+    end
+    @c.return_3.should == 3
+    @c.return_4.should == 4
+  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.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 = Class.new(@c)
+    c.set_dataset :items
+    c.return_3.should == 3
+    c.dataset.return_3.should == 3
+  end
+end
+
+describe "A model class with implicit table name" do
+  setup do
+    class Donkey < Sequel::Model
+    end
+  end
+  
+  specify "should have a dataset associated with the model class" do
+    Donkey.dataset.model_classes.should == {nil => Donkey}
+  end
+end
+
+describe "A model inheriting from a model" do
+  setup do
+    class Feline < Sequel::Model
+    end
+    
+    class Leopard < Feline
+    end
+  end
+  
+  specify "should have a dataset associated with itself" do
+    Feline.dataset.model_classes.should == {nil => Feline}
+    Leopard.dataset.model_classes.should == {nil => Leopard}
+  end
+end
+
+describe "Model.db=" do
+  setup do
+    $db1 = MockDatabase.new
+    $db2 = MockDatabase.new
+    
+    class BlueBlue < Sequel::Model(:items)
+      set_dataset $db1[:blue]
+    end
+  end
+  
+  specify "should affect the underlying dataset" do
+    BlueBlue.db = $db2
+    
+    BlueBlue.dataset.db.should === $db2
+    BlueBlue.dataset.db.should_not === $db1
+  end
+end
+
+describe Sequel::Model, ".(allowed|restricted)_columns " do
+  setup do
+    @c = Class.new(Sequel::Model(:blahblah)) do
+      columns :x, :y, :z
+      def refresh
+        self
+      end
+    end
+    @c.strict_param_setting = false
+    @c.instance_variable_set(:@columns, [:x, :y, :z])
+  end
+  
+  it "should set the allowed columns correctly" do
+    @c.allowed_columns.should == nil
+    @c.set_allowed_columns :x
+    @c.allowed_columns.should == [:x]
+    @c.set_allowed_columns :x, :y
+    @c.allowed_columns.should == [:x, :y]
+  end
+
+  it "should set the restricted columns correctly" do
+    @c.restricted_columns.should == nil
+    @c.set_restricted_columns :x
+    @c.restricted_columns.should == [:x]
+    @c.set_restricted_columns :x, :y
+    @c.restricted_columns.should == [:x, :y]
+  end
+
+  it "should only set allowed columns by default" do
+    @c.set_allowed_columns :x, :y
+    i = @c.new(:x => 1, :y => 2, :z => 3)
+    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}
+  end
+
+  it "should not set restricted columns by default" do
+    @c.set_restricted_columns :z
+    i = @c.new(:x => 1, :y => 2, :z => 3)
+    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}
+  end
+
+  it "should have allowed take precedence over restricted" do
+    @c.set_allowed_columns :x, :y
+    @c.set_restricted_columns :y, :z
+    i = @c.new(:x => 1, :y => 2, :z => 3)
+    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}
+  end
+end
+
+describe Sequel::Model, ".(un)?restrict_primary_key\\??" do
+  setup 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
+    i = @c.new(:x => 1, :y => 2, :id => 3)
+    i.values.should == {:x => 1, :y => 2}
+    i.set(:x => 4, :y => 5, :id => 6)
+    i.values.should == {:x => 4, :y => 5}
+  end
+
+  it "should allow updates to primary key if unrestrict_primary_key is used" do
+    @c.unrestrict_primary_key
+    i = @c.new(:x => 1, :y => 2, :id => 3)
+    i.values.should == {:x => 1, :y => 2, :id=>3}
+    i.set(:x => 4, :y => 5, :id => 6)
+    i.values.should == {:x => 4, :y => 5, :id=>6}
+  end
+
+  it "should have restrict_primary_key? return true or false depending" do
+    @c.restrict_primary_key?.should == true
+    @c.unrestrict_primary_key
+    @c.restrict_primary_key?.should == false
+    c1 = Class.new(@c)
+    c1.restrict_primary_key?.should == false
+    @c.restrict_primary_key
+    @c.restrict_primary_key?.should == true
+    c1.restrict_primary_key?.should == false
+    c2 = Class.new(@c)
+    c2.restrict_primary_key?.should == true
+  end
+end
+
+describe Sequel::Model, ".strict_param_setting" do
+  setup 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
+    @c.strict_param_setting.should == true
+  end
+
+  it "should raise an error if a missing/restricted column/method is accessed" do
+    proc{@c.new(:z=>1)}.should raise_error(Sequel::Error)
+    proc{@c.create(:z=>1)}.should raise_error(Sequel::Error)
+    c = @c.new
+    proc{c.set(:z=>1)}.should raise_error(Sequel::Error)
+    proc{c.set_all(:id=>1)}.should raise_error(Sequel::Error)
+    proc{c.set_only({:x=>1}, :y)}.should raise_error(Sequel::Error)
+    proc{c.set_except({:x=>1}, :x)}.should raise_error(Sequel::Error)
+    proc{c.update(:z=>1)}.should raise_error(Sequel::Error)
+    proc{c.update_all(:id=>1)}.should raise_error(Sequel::Error)
+    proc{c.update_only({:x=>1}, :y)}.should raise_error(Sequel::Error)
+    proc{c.update_except({:x=>1}, :x)}.should raise_error(Sequel::Error)
+  end
+
+  it "should be disabled by strict_param_setting = false" do
+    @c.strict_param_setting = false
+    @c.strict_param_setting.should == false
+    proc{@c.new(:z=>1)}.should_not raise_error
+  end
+end

data/spec/sequel_model/caching_spec.rb

@@ -0,0 +1,215 @@
+require File.join(File.dirname(__FILE__), "spec_helper")
+
+describe Sequel::Model, "caching" do
+  before do
+    MODEL_DB.reset
+    
+    @cache_class = Class.new(Hash) do
+      attr_accessor :ttl
+      def set(k, v, ttl); self[k] = v; @ttl = ttl; end
+      def get(k); self[k]; end
+    end
+    cache = @cache_class.new
+    @cache = cache
+    
+    @c = Class.new(Sequel::Model(:items))
+    @c.class_eval do
+      set_cache cache
+      def self.name; 'Item' end
+      
+      columns :name, :id
+    end
+    
+    $cache_dataset_row = {:name => 'sharon', :id => 1}
+    @dataset = @c.dataset
+    $sqls = []
+    @dataset.extend(Module.new {
+      def fetch_rows(sql)
+        $sqls << sql
+        yield $cache_dataset_row
+      end
+      
+      def update(values)
+        $sqls << update_sql(values)
+        $cache_dataset_row.merge!(values)
+      end
+      
+      def delete
+        $sqls << delete_sql
+      end
+    })
+    @c2 = Class.new(@c) do
+      def self.name; 'SubItem' end
+    end
+  end
+  
+  it "should set the model's cache store" do
+    @c.cache_store.should be(@cache)
+    @c2.cache_store.should be(@cache)
+  end
+  
+  it "should have a default ttl of 3600" do
+    @c.cache_ttl.should == 3600
+    @c2.cache_ttl.should == 3600
+  end
+  
+  it "should take a ttl option" do
+    @c.set_cache @cache, :ttl => 1234
+    @c.cache_ttl.should == 1234
+    Class.new(@c).cache_ttl.should == 1234
+  end
+  
+  it "should offer a set_cache_ttl method for setting the ttl" do
+    @c.cache_ttl.should == 3600
+    @c.set_cache_ttl 1234
+    @c.cache_ttl.should == 1234
+    Class.new(@c).cache_ttl.should == 1234
+  end
+  
+  it "should generate a cache key appropriate to the class" do
+    m = @c.new
+    m.values[:id] = 1
+    m.cache_key.should == "#{m.class}:1"
+    m = @c2.new
+    m.values[:id] = 1
+    m.cache_key.should == "#{m.class}:1"
+    
+    # custom primary key
+    @c.set_primary_key :ttt
+    m = @c.new
+    m.values[:ttt] = 333
+    m.cache_key.should == "#{m.class}:333"
+    c = Class.new(@c)
+    m = c.new
+    m.values[:ttt] = 333
+    m.cache_key.should == "#{m.class}:333"
+    
+    # composite primary key
+    @c.set_primary_key [:a, :b, :c]
+    m = @c.new
+    m.values[:a] = 123
+    m.values[:c] = 456
+    m.values[:b] = 789
+    m.cache_key.should == "#{m.class}:123,789,456"
+    c = Class.new(@c)
+    m = c.new
+    m.values[:a] = 123
+    m.values[:c] = 456
+    m.values[:b] = 789
+    m.cache_key.should == "#{m.class}:123,789,456"
+  end
+  
+  it "should raise error if attempting to generate cache_key and primary key value is null" do
+    m = @c.new
+    proc {m.cache_key}.should raise_error(Sequel::Error)
+    m.values[:id] = 1
+    proc {m.cache_key}.should_not raise_error(Sequel::Error)
+
+    m = @c2.new
+    proc {m.cache_key}.should raise_error(Sequel::Error)
+    m.values[:id] = 1
+    proc {m.cache_key}.should_not raise_error(Sequel::Error)
+  end
+  
+  it "should not raise error if trying to save a new record" do
+    proc {@c.new(:name=>'blah').save}.should_not raise_error
+    proc {@c.create(:name=>'blah')}.should_not raise_error
+    proc {@c2.new(:name=>'blah').save}.should_not raise_error
+    proc {@c2.create(:name=>'blah')}.should_not raise_error
+  end
+  
+  it "should set the cache when reading from the database" do
+    $sqls.should == []
+    @cache.should be_empty
+    
+    m = @c[1]
+    $sqls.should == ['SELECT * FROM items WHERE (id = 1) LIMIT 1']
+    m.values.should == $cache_dataset_row
+    @cache[m.cache_key].should == m
+    m2 = @c[1]
+    $sqls.should == ['SELECT * FROM items WHERE (id = 1) LIMIT 1']
+    m2.should == m
+    m2.values.should == $cache_dataset_row
+
+    $sqls.clear
+    m = @c2[1]
+    $sqls.should == ['SELECT * FROM items WHERE (id = 1) LIMIT 1']
+    m.values.should == $cache_dataset_row
+    @cache[m.cache_key].should == m
+    m2 = @c2[1]
+    $sqls.should == ['SELECT * FROM items WHERE (id = 1) LIMIT 1']
+    m2.should == m
+    m2.values.should == $cache_dataset_row
+  end
+  
+  it "should delete the cache when writing to the database" do
+    m = @c[1]
+    @cache[m.cache_key].should == m
+    
+    m.update_values(:name => 'tutu')
+    @cache.has_key?(m.cache_key).should be_false
+    $sqls.last.should == "UPDATE items SET name = 'tutu' WHERE (id = 1)"
+    
+    m = @c[1]
+    @cache[m.cache_key].should == m
+    m.name = 'hey'
+    m.save
+    @cache.has_key?(m.cache_key).should be_false
+    $sqls.last.should == "UPDATE items SET name = 'hey', id = 1 WHERE (id = 1)"
+
+    m = @c2[1]
+    @cache[m.cache_key].should == m
+    
+    m.update_values(:name => 'tutu')
+    @cache.has_key?(m.cache_key).should be_false
+    $sqls.last.should == "UPDATE items SET name = 'tutu' WHERE (id = 1)"
+    
+    m = @c2[1]
+    @cache[m.cache_key].should == m
+    m.name = 'hey'
+    m.save
+    @cache.has_key?(m.cache_key).should be_false
+    $sqls.last.should == "UPDATE items SET name = 'hey', id = 1 WHERE (id = 1)"
+  end
+  
+  it "should delete the cache when deleting the record" do
+    m = @c[1]
+    @cache[m.cache_key].should == m
+    m.delete
+    @cache.has_key?(m.cache_key).should be_false
+    $sqls.last.should == "DELETE FROM items WHERE (id = 1)"
+
+    m = @c2[1]
+    @cache[m.cache_key].should == m
+    m.delete
+    @cache.has_key?(m.cache_key).should be_false
+    $sqls.last.should == "DELETE FROM items WHERE (id = 1)"
+  end
+  
+  it "should support #[] as a shortcut to #find with hash" do
+    m = @c[:id => 3]
+    @cache[m.cache_key].should be_nil
+    $sqls.last.should == "SELECT * FROM items WHERE (id = 3) LIMIT 1"
+    m = @c[1]
+    @cache[m.cache_key].should == m
+    $sqls.should == ["SELECT * FROM items WHERE (id = 3) LIMIT 1", \
+      "SELECT * FROM items WHERE (id = 1) LIMIT 1"]
+    @c[:id => 4]
+    $sqls.should == ["SELECT * FROM items WHERE (id = 3) LIMIT 1", \
+      "SELECT * FROM items WHERE (id = 1) LIMIT 1", \
+      "SELECT * FROM items WHERE (id = 4) LIMIT 1"]
+
+    $sqls.clear
+    m = @c2[:id => 3]
+    @cache[m.cache_key].should be_nil
+    $sqls.last.should == "SELECT * FROM items WHERE (id = 3) LIMIT 1"
+    m = @c2[1]
+    @cache[m.cache_key].should == m
+    $sqls.should == ["SELECT * FROM items WHERE (id = 3) LIMIT 1", \
+      "SELECT * FROM items WHERE (id = 1) LIMIT 1"]
+    @c2[:id => 4]
+    $sqls.should == ["SELECT * FROM items WHERE (id = 3) LIMIT 1", \
+      "SELECT * FROM items WHERE (id = 1) LIMIT 1", \
+      "SELECT * FROM items WHERE (id = 4) LIMIT 1"]
+  end
+end

data/spec/sequel_model/dataset_methods_spec.rb

@@ -0,0 +1,78 @@
+require File.join(File.dirname(__FILE__), "spec_helper")
+
+describe Sequel::Model::DatasetMethods, "#destroy"  do
+  before do
+    @c = Class.new(Sequel::Model(:items)) do
+      @@destroyed = []
+      def destroy
+        @@destroyed << self
+      end
+      def self.destroyed
+        @@destroyed
+      end
+    end
+    @d = @c.dataset
+  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}]
+  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.destroy.should == 1
+    def @d.fetch_rows(sql)
+    end
+    @d.destroy.should == 0
+  end
+end
+
+describe Sequel::Model::DatasetMethods, "#to_hash"  do
+  before do
+    @c = Class.new(Sequel::Model(:items)) do
+      set_primary_key :name
+    end
+    @d = @c.dataset
+  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
+    h = @d.to_hash
+    h.should be_a_kind_of(Hash)
+    a = h.to_a
+    a.collect{|x| x[1].class}.should == [@c, @c]
+    a.sort_by{|x| x[0]}.collect{|x| [x[0], x[1].values]}.should == [[1, {:name=>1}], [2, {:name=>2}]]
+  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
+    h = @d.to_hash(:number)
+    h.should be_a_kind_of(Hash)
+    a = h.to_a
+    a.collect{|x| x[1].class}.should == [@c, @c]
+    a.sort_by{|x| x[0]}.collect{|x| [x[0], x[1].values]}.should == [[3, {:name=>1, :number=>3}], [4, {:name=>2, :number=>4}]]
+  end
+
+  it "should raise an error if the class doesn't have a primary key" do
+    @c.no_primary_key
+    proc{@d.to_hash}.should raise_error(Sequel::Error)
+  end
+end