sequel_model 0.5.0.2 → 3.8.0

data/spec/base_spec.rb

@@ -1,239 +0,0 @@
-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

@@ -1,150 +0,0 @@
-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

@@ -1,153 +0,0 @@
-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
-    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
-    a.should be_a_kind_of(Sequel::Dataset)
-    a.sql.should == 'SELECT * FROM attributes WHERE (blue_note_id = 1234)'
-  end
-end