sequel 1.3 → 1.4.0

data/spec/base_spec.rb

@@ -0,0 +1,239 @@
+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
+      def columns
+        [:id, :x, :y]
+      end
+    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
+    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
+    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
+    end
+
+    @c.create(:abc => 1)
+    @c.create(:abc => "hello")
+
+    MODEL_DB.sqls.should == [ \
+      "INSERT INTO items (abc) VALUES ('BAhpBg==\n')", \
+      "INSERT INTO items (abc) VALUES ('BAgiCmhlbGxv\n')", \
+    ]
+  end
+
+  it "should translate values to and from YAML using accessor methods" do
+    @c = Class.new(Sequel::Model(:items)) do
+      serialize :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.set(: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, "super_dataset" do
+  setup do
+    MODEL_DB.reset
+    class SubClass < Sequel::Model(:items) ; end
+  end
+  
+  it "should call the superclass's dataset" do
+    SubClass.should_receive(:superclass).exactly(3).times.and_return(Sequel::Model(:items))
+    Sequel::Model(:items).should_receive(:dataset)
+    SubClass.super_dataset
+  end
+end
+
+describe Sequel::Model, "dataset" do
+  setup 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 "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 = Sequel::Database.new
+    $db2 = Sequel::Database.new
+    
+    class BlueBlue < Sequel::Model
+      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
+

data/spec/caching_spec.rb

@@ -0,0 +1,150 @@
+require File.join(File.dirname(__FILE__), "spec_helper")
+
+describe Sequel::Model, "caching" do
+
+  before(:each) 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)) do
+      set_cache cache
+      
+      def self.columns
+        [:name, :id]
+      end
+    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
+    })
+  end
+  
+  it "should set the model's cache store" do
+    @c.cache_store.should be(@cache)
+  end
+  
+  it "should have a default ttl of 3600" do
+    @c.cache_ttl.should == 3600
+  end
+  
+  it "should take a ttl option" do
+    @c.set_cache @cache, :ttl => 1234
+    @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
+  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"
+    
+    # custom primary key
+    @c.set_primary_key :ttt
+    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"
+  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)
+  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
+    
+    # read from cache
+    m2 = @c[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
+    # fill the cache
+    m = @c[1]
+    @cache[m.cache_key].should == m
+    
+    m.set(: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)"
+  end
+  
+  it "should delete the cache when deleting the record" do
+    # fill the cache
+    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)"
+  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"]
+  end
+  
+end

data/spec/deprecated_relations_spec.rb

@@ -0,0 +1,153 @@
+require File.join(File.dirname(__FILE__), "spec_helper")
+
+describe Sequel::Model, "one_to_one" do
+
+  before(:each) do
+    MODEL_DB.reset
+
+    @c1 = Class.new(Sequel::Model(:attributes)) do
+    end
+
+    @c2 = Class.new(Sequel::Model(:nodes)) do
+      def columns; [:id, :parent_id]; end
+    end
+
+    @dataset = @c2.dataset
+
+    @dataset.extend(Module.new {
+      def fetch_rows(sql)
+        @db << sql
+        yield({:hey => 1})
+      end
+    })
+  end
+
+  it "should use implicit key if omitted" do
+    @c2.one_to_one :parent, :from => @c2
+
+    d = @c2.new(:id => 1, :parent_id => 234)
+    p = d.parent
+    p.class.should == @c2
+    p.values.should == {:hey => 1}
+
+    MODEL_DB.sqls.should == ["SELECT * FROM nodes WHERE (id = 234) LIMIT 1"]
+  end
+
+  it "should use explicit key if given" do
+    @c2.one_to_one :parent, :from => @c2, :key => :blah
+
+    d = @c2.new(:id => 1, :blah => 567)
+    p = d.parent
+    p.class.should == @c2
+    p.values.should == {:hey => 1}
+
+    MODEL_DB.sqls.should == ["SELECT * FROM nodes WHERE (id = 567) LIMIT 1"]
+  end
+
+  # the new implementation doesn't support plain datasets as associations
+  # it "should support plain dataset in the from option" do
+  #   @c2.one_to_one :parent, :from => MODEL_DB[:xyz]
+  #   
+  #   d = @c2.new(:id => 1, :parent_id => 789)
+  #   p = d.parent
+  #   p.class.should == Hash
+  #   
+  #   MODEL_DB.sqls.should == ["SELECT * FROM xyz WHERE (id = 789) LIMIT 1"]
+  # end
+
+  # the new implementation doesn't support plain datasets as associations
+  # it "should support table name in the from option" do
+  #   @c2.one_to_one :parent, :from => :abc
+  # 
+  #   d = @c2.new(:id => 1, :parent_id => 789)
+  #   p = d.parent
+  #   p.class.should == Hash
+  # 
+  #   MODEL_DB.sqls.should == ["SELECT * FROM abc WHERE (id = 789) LIMIT 1"]
+  # end
+
+  it "should return nil if key value is nil" do
+    @c2.one_to_one :parent, :from => @c2
+
+    d = @c2.new(:id => 1)
+    d.parent.should == nil
+  end
+
+  it "should define a setter method" do
+    @c2.one_to_one :parent, :from => @c2
+
+    d = @c2.load(:id => 1)
+    d.parent = @c2.new(:id => 4321)
+    d.values.should == {:id => 1, :parent_id => 4321}
+    d.save_changes
+    MODEL_DB.sqls.last.should == "UPDATE nodes SET parent_id = 4321 WHERE (id = 1)"
+
+    d.parent = nil
+    d.values.should == {:id => 1, :parent_id => nil}
+    d.save_changes
+    MODEL_DB.sqls.last.should == "UPDATE nodes SET parent_id = NULL WHERE (id = 1)"
+
+    e = @c2.new(:id => 6677)
+    d.parent = e
+    d.values.should == {:id => 1, :parent_id => 6677}
+    d.save_changes
+    MODEL_DB.sqls.last.should == "UPDATE nodes SET parent_id = 6677 WHERE (id = 1)"
+  end
+end
+
+describe Sequel::Model, "one_to_many" do
+
+  before(:each) do
+    MODEL_DB.reset
+
+    @c1 = Class.new(Sequel::Model(:attributes)) do
+    end
+
+    @c2 = Class.new(Sequel::Model(:nodes)) do
+    end
+  end
+
+  it "should define a getter method" do
+    @c2.one_to_many :attributes, :from => @c1, :key => :node_id
+
+    n = @c2.new(:id => 1234)
+    a = n.attributes_dataset
+    a.should be_a_kind_of(Sequel::Dataset)
+    a.sql.should == 'SELECT * FROM attributes WHERE (node_id = 1234)'
+  end
+  
+  # the new implementation doesn't support plain datasets as associations
+  # it "should support plain dataset in the from option" do
+  #   @c2.one_to_many :attributes, :from => MODEL_DB[:xyz], :key => :node_id
+  # 
+  #   n = @c2.new(:id => 1234)
+  #   a = n.attributes
+  #   a.should be_a_kind_of(Sequel::Dataset)
+  #   a.sql.should == 'SELECT * FROM xyz WHERE (node_id = 1234)'
+  # end
+
+  # the new implementation doesn't support plain datasets as associations
+  # it "should support table name in the from option" do
+  #   @c2.one_to_many :attributes, :from => :abc, :key => :node_id
+  # 
+  #   n = @c2.new(:id => 1234)
+  #   a = n.attributes
+  #   a.should be_a_kind_of(Sequel::Dataset)
+  #   a.sql.should == 'SELECT * FROM abc WHERE (node_id = 1234)'
+  # end
+  
+  it "should support implicit key names" do
+    $c1 = @c1
+    
+    module Music
+      class BlueNote < Sequel::Model
+        one_to_many :attributes, :from => $c1
+      end
+    end
+    
+    n = Music::BlueNote.new(:id => 1234)
+    a = n.attributes_dataset
+    a.should be_a_kind_of(Sequel::Dataset)
+    a.sql.should == 'SELECT * FROM attributes WHERE (blue_note_id = 1234)'
+  end
+end