sequel 0.2.0.2 → 0.2.1

data/spec/core_ext_spec.rb

@@ -136,6 +136,20 @@ context "Symbol#to_field_name" do
     :xyz___x.to_field_name.should == 'xyz AS x'
     :abc__def___x.to_field_name.should == 'abc.def AS x'
   end
+  
+  specify "should support names with digits" do
+    :abc2.to_field_name.should == 'abc2'
+    :xx__yy3.to_field_name.should == 'xx.yy3'
+    :ab34__temp3_4ax.to_field_name.should == 'ab34.temp3_4ax'
+    :x1___y2.to_field_name.should == 'x1 AS y2'
+    :abc2__def3___ggg4.to_field_name.should == 'abc2.def3 AS ggg4'
+  end
+  
+  specify "should support upper case and lower case" do
+    :ABC.to_field_name.should == 'ABC'
+    :Zvashtoy__aBcD.to_field_name.should == 'Zvashtoy.aBcD'
+    
+  end
 end
 
 context "FieldCompositionMethods#field_title" do

data/spec/database_spec.rb

@@ -476,6 +476,17 @@ context "A database" do
     db = Sequel::Database.new(:max_options => 4)
     db.should be_single_threaded
     db.should_not be_multi_threaded
-    
+  end
+end
+
+context "Database#dataset" do
+  setup do
+    @db = Sequel::Database.new
+  end
+  
+  specify "should delegate to Dataset#query if block is provided" do
+    @d = @db.query {select :x; from :y}
+    @d.should be_a_kind_of(Sequel::Dataset)
+    @d.sql.should == "SELECT x FROM y"
   end
 end

data/spec/dataset_spec.rb

@@ -446,6 +446,24 @@ context "a grouped dataset" do
   end
 end
 
+context "Dataset#group_by" do
+  setup do
+    @dataset = Sequel::Dataset.new(nil).from(:test).group_by(:type_id)
+  end
+
+  specify "should raise when trying to generate an update statement" do
+    proc {@dataset.update_sql(:id => 0)}.should raise_error
+  end
+
+  specify "should raise when trying to generate a delete statement" do
+    proc {@dataset.delete_sql}.should raise_error
+  end
+
+  specify "should specify the grouping in generated select statement" do
+    @dataset.select_sql.should ==
+      "SELECT * FROM test GROUP BY type_id"
+  end
+end
 
 context "Dataset#literal" do
   setup do
@@ -600,6 +618,32 @@ context "Dataset#order" do
   end
 end
 
+context "Dataset#order_by" do
+  setup do
+    @dataset = Sequel::Dataset.new(nil).from(:test)
+  end
+  
+  specify "should include an ORDER BY clause in the select statement" do
+    @dataset.order_by(:name).sql.should == 
+      'SELECT * FROM test ORDER BY name'
+  end
+  
+  specify "should accept multiple arguments" do
+    @dataset.order_by(:name, :price.DESC).sql.should ==
+      'SELECT * FROM test ORDER BY name, price DESC'
+  end
+  
+  specify "should overrun a previous ordering" do
+    @dataset.order_by(:name).order(:stamp).sql.should ==
+      'SELECT * FROM test ORDER BY stamp'
+  end
+  
+  specify "should accept a string" do
+    @dataset.order_by('dada ASC').sql.should ==
+      'SELECT * FROM test ORDER BY dada ASC'
+  end
+end
+
 context "Dataset#reverse_order" do
   setup do
     @dataset = Sequel::Dataset.new(nil).from(:test)
@@ -769,6 +813,26 @@ context "Dataset#count" do
   end
 end
 
+context "Dataset#empty?" do
+  specify "should return true if #count == 0" do
+    @c = Class.new(Sequel::Dataset) do
+      def count
+        0
+      end
+    end
+    @dataset = @c.new(nil).from(:test)
+    @dataset.empty?.should be_true
+
+    @c = Class.new(Sequel::Dataset) do
+      def count
+        1
+      end
+    end
+    @dataset = @c.new(nil).from(:test)
+    @dataset.empty?.should be_false
+  end
+end
+
 context "Dataset#join_table" do
   setup do
     @d = Sequel::Dataset.new(nil).from(:items)
@@ -1157,6 +1221,33 @@ context "Dataset#single_value" do
   end
 end
 
+context "Dataset#set_row_proc" do
+  setup do
+    @c = Class.new(Sequel::Dataset) do
+      def fetch_rows(sql, &block)
+        # yield a hash with kind as the 1 bit of a number
+        (1..10).each {|i| block.call({:kind => i[0]})}
+      end
+    end
+    @dataset = @c.new(nil).from(:items)
+  end
+  
+  specify "should cause dataset to pass all rows through the filter" do
+    @dataset.set_row_proc {|h| h[:der] = h[:kind] + 2; h}
+    
+    rows = @dataset.all
+    rows.size.should == 10
+    
+    rows.each {|r| r[:der].should == (r[:kind] + 2)}
+  end
+  
+  specify "should be copied over when dataset is cloned" do
+    @dataset.set_row_proc {|h| h[:der] = h[:kind] + 2; h}
+    
+    @dataset.filter(:a => 1).first.should == {:kind => 1, :der => 3}
+  end
+end
+
 context "Dataset#set_model" do
   setup do
     @c = Class.new(Sequel::Dataset) do
@@ -1570,4 +1661,187 @@ context "Dataset#multi_insert" do
       'COMMIT;'
     ]
   end
+end
+
+context "Dataset#query" do
+  setup do
+    @d = Sequel::Dataset.new(nil)
+  end
+  
+  specify "should support #from" do
+    q = @d.query {from :xxx}
+    q.class.should == @d.class
+    q.sql.should == "SELECT * FROM xxx"
+  end
+  
+  specify "should support #select" do
+    q = @d.query do
+      select :a, :b___mongo
+      from :yyy
+    end
+    q.class.should == @d.class
+    q.sql.should == "SELECT a, b AS mongo FROM yyy"
+  end
+  
+  specify "should support #where" do
+    q = @d.query do
+      from :zzz
+      where {:x + 2 > :y + 3}
+    end
+    q.class.should == @d.class
+    q.sql.should == "SELECT * FROM zzz WHERE ((x + 2) > (y + 3))"
+
+    q = @d.from(:zzz).query do
+      where {:x > 1 && :y > 2}
+    end
+    q.class.should == @d.class
+    q.sql.should == "SELECT * FROM zzz WHERE ((x > 1) AND (y > 2))"
+
+    q = @d.from(:zzz).query do
+      where :x => 33
+    end
+    q.class.should == @d.class
+    q.sql.should == "SELECT * FROM zzz WHERE (x = 33)"
+  end
+  
+  specify "should support #group_by and #having" do
+    q = @d.query do
+      from :abc
+      group_by :id
+      having {:x >= 2}
+    end
+    q.class.should == @d.class
+    q.sql.should == "SELECT * FROM abc GROUP BY id HAVING (x >= 2)"
+  end
+  
+  specify "should support #order, #order_by" do
+    q = @d.query do
+      from :xyz
+      order_by :stamp
+    end
+    q.class.should == @d.class
+    q.sql.should == "SELECT * FROM xyz ORDER BY stamp"
+  end
+  
+  specify "should raise on non-chainable method calls" do
+    proc {@d.query {count}}.should raise_error(SequelError)
+  end
+  
+  specify "should raise on each, insert, update, delete" do
+    proc {@d.query {each}}.should raise_error(SequelError)
+    proc {@d.query {insert(:x => 1)}}.should raise_error(SequelError)
+    proc {@d.query {update(:x => 1)}}.should raise_error(SequelError)
+    proc {@d.query {delete}}.should raise_error(SequelError)
+  end
+end
+
+context "Dataset" do
+  setup do
+    @d = Sequel::Dataset.new(nil).from(:x)
+  end
+
+  specify "should support self-changing select!" do
+    @d.select!(:y)
+    @d.sql.should == "SELECT y FROM x"
+  end
+  
+  specify "should support self-changing from!" do
+    @d.from!(:y)
+    @d.sql.should == "SELECT * FROM y"
+  end
+
+  specify "should support self-changing order!" do
+    @d.order!(:y)
+    @d.sql.should == "SELECT * FROM x ORDER BY y"
+  end
+  
+  specify "should support self-changing filter!" do
+    @d.filter!(:y => 1)
+    @d.sql.should == "SELECT * FROM x WHERE (y = 1)"
+  end
+
+  specify "should support self-changing filter! with block" do
+    @d.filter! {:y == 2}
+    @d.sql.should == "SELECT * FROM x WHERE (y = 2)"
+  end
+  
+  specify "should raise for ! methods that don't return a dataset" do
+    proc {@d.opts!}.should raise_error(NameError)
+  end
+  
+  specify "should raise for missing methods" do
+    proc {@d.xuyz}.should raise_error(NameError)
+    proc {@d.xyz!}.should raise_error(NameError)
+    proc {@d.xyz?}.should raise_error(NameError)
+  end
+  
+  specify "should support chaining of bang methods" do
+      @d.order!(:y)
+      @d.filter!(:y => 1)
+      @d.sql.should == "SELECT * FROM x WHERE (y = 1) ORDER BY y"
+  end
+end
+
+context "Dataset#transform" do
+  setup do
+    @c = Class.new(Sequel::Dataset) do
+      attr_accessor :raw
+      attr_accessor :sql
+      
+      def fetch_rows(sql, &block)
+        block[@raw]
+      end
+      
+      def insert(v)
+        @sql = insert_sql(v)
+      end
+      
+      def update(v)
+        @sql = update_sql(v)
+      end
+    end
+
+    @ds = @c.new(nil).from(:items)
+    @ds.transform(:x => [
+      proc {|v| Marshal.load(v)},
+      proc {|v| Marshal.dump(v)}
+    ])
+  end
+  
+  specify "should change the dataset to transform values loaded from the database" do
+    @ds.raw = {:x => Marshal.dump([1, 2, 3]), :y => 'hello'}
+    @ds.first.should == {:x => [1, 2, 3], :y => 'hello'}
+  end
+  
+  specify "should change the dataset to transform values saved to the database" do
+    @ds.insert(:x => :toast)
+    @ds.sql.should == "INSERT INTO items (x) VALUES ('#{Marshal.dump(:toast)}');"
+
+    @ds.insert(:y => 'butter')
+    @ds.sql.should == "INSERT INTO items (y) VALUES ('butter');"
+    
+    @ds.update(:x => ['dream'])
+    @ds.sql.should == "UPDATE items SET x = '#{Marshal.dump(['dream'])}'"
+  end
+  
+  specify "should be transferred to cloned datasets" do
+    @ds2 = @ds.filter(:a => 1)
+
+    @ds2.raw = {:x => Marshal.dump([1, 2, 3]), :y => 'hello'}
+    @ds2.first.should == {:x => [1, 2, 3], :y => 'hello'}
+
+    @ds2.insert(:x => :toast)
+    @ds2.sql.should == "INSERT INTO items (x) VALUES ('#{Marshal.dump(:toast)}');"
+  end
+  
+  specify "should work correctly together with set_row_proc" do
+    @ds.set_row_proc {|r| r[:z] = r[:x] * 2; r}
+    @ds.raw = {:x => Marshal.dump("wow"), :y => 'hello'}
+    @ds.first.should == {:x => "wow", :y => 'hello', :z => "wowwow"}
+
+    f = nil
+    @ds.raw = {:x => Marshal.dump("wow"), :y => 'hello'}
+    @ds.each(:naked => true) {|r| f = r}
+    f.should == {:x => "wow", :y => 'hello'}
+  end
 end

data/spec/model_spec.rb

@@ -1,6 +1,132 @@
 require File.join(File.dirname(__FILE__), 'spec_helper')
 
-Sequel::Model.db = SchemaDummyDatabase.new
+Sequel::Model.db = MODEL_DB = MockDatabase.new
+
+context "A model class" do
+  specify "should be associated with a dataset" do
+    @m = Class.new(Sequel::Model) do
+      set_dataset MODEL_DB[:items]
+    end
+    
+    @m.dataset.should be_a_kind_of(MockDataset)
+    @m.dataset.opts[:from].should == [:items]
+
+    @m2 = Class.new(Sequel::Model) do
+      set_dataset MODEL_DB[:zzz]
+    end
+    
+    @m2.dataset.should be_a_kind_of(MockDataset)
+    @m2.dataset.opts[:from].should == [:zzz]
+    @m.dataset.opts[:from].should == [:items]
+  end
+end
+
+context "A model's primary key" do
+  specify "should default to id" do
+    @m = Class.new(Sequel::Model) do
+    end
+    
+    @m.primary_key.should == :id
+  end
+  
+  specify "should be changeable through Model.set_primary_key" do
+    @m = Class.new(Sequel::Model) do
+      set_primary_key :xxx
+    end
+    
+    @m.primary_key.should == :xxx
+  end
+  
+  specify "should support composite primary keys" do
+    @m = Class.new(Sequel::Model) do
+      set_primary_key [:node_id, :session_id]
+    end
+    @m.primary_key.should == [:node_id, :session_id]
+  end
+end
+
+context "A model without a primary key" do
+  setup do
+    @m = Class.new(Sequel::Model) do
+      no_primary_key
+    end
+  end
+  
+  specify "should return nil for primary_key" do
+    @m.primary_key.should be_nil
+  end
+  
+  specify "should raise on #this" do
+    o = @m.new
+    proc {o.this}.should raise_error(SequelError)
+  end
+end
+
+context "Model#this" do
+  setup do
+    @m = Class.new(Sequel::Model(:items)) do
+    end
+  end
+  
+  specify "should return a dataset identifying the record" do
+    o = @m.new(:id => 3)
+    o.this.sql.should == "SELECT * FROM items WHERE (id = 3)"
+  end
+  
+  specify "should support arbitrary primary keys" do
+    @m.set_primary_key(:xxx)
+    
+    o = @m.new(:xxx => 3)
+    o.this.sql.should == "SELECT * FROM items WHERE (xxx = 3)"
+  end
+  
+  specify "should support composite primary keys" do
+    @m.set_primary_key [:x, :y]
+    o = @m.new(:x => 4, :y => 5)
+
+    o.this.sql.should =~ /^SELECT \* FROM items WHERE (\(x = 4\) AND \(y = 5\))|(\(y = 5\) AND \(x = 4\))$/
+  end
+end
+
+context "A new model instance" do
+  setup do
+    @m = Class.new(Sequel::Model) do
+      set_dataset MODEL_DB[:items]
+    end
+  end
+  
+  specify "should be marked as new?" do
+    o = @m.new
+    o.should be_new
+  end
+  
+  specify "should not be marked as new? once it is saved" do
+    o = @m.new(:x => 1)
+    o.should be_new
+    o.save
+    o.should_not be_new
+  end
+  
+  specify "should use the last inserted id as primary key if not in values" do
+    d = @m.dataset
+    def d.insert(*args)
+      super
+      1234
+    end
+    
+    def d.first
+      {:x => 1, :id => 1234}
+    end
+    
+    o = @m.new(:x => 1)
+    o.save
+    o.id.should == 1234
+    
+    o = @m.new(:x => 1, :id => 333)
+    o.save
+    o.id.should == 333
+  end
+end
 
 describe Sequel::Model do
   before do
@@ -20,8 +146,8 @@ describe Sequel::Model do
     @model.primary_key.should == :ssn
   end
   
-  it "allows table name change" do
-    @model.set_table_name :foo
+  it "allows dataset change" do
+    @model.set_dataset(MODEL_DB[:foo])
     @model.table_name.should == :foo
   end
   
@@ -55,4 +181,161 @@ context "Sequel::Model()" do
       eval "class DummyModelBased < Sequel::Model(:blog); end"
     end.should_not raise_error
   end
+end
+
+context "A model class" do
+  setup do
+    MODEL_DB.reset
+    @c = Class.new(Sequel::Model(:items))
+  end
+  
+  specify "should be able to create rows in the associated table" do
+    o = @c.create(:x => 1)
+    o.class.should == @c
+    MODEL_DB.sqls.should == ['INSERT INTO items (x) VALUES (1);']
+  end
+  
+  specify "should be able to create rows without any values specified" do
+    o = @c.create
+    o.class.should == @c
+    MODEL_DB.sqls.should == ['INSERT INTO items DEFAULT VALUES;']
+  end
+end
+
+context "A model class without a primary key" do
+  setup do
+    MODEL_DB.reset
+    @c = Class.new(Sequel::Model(:items)) do
+      no_primary_key
+    end
+  end
+  
+  specify "should be able to insert records without selecting them back" do
+    i = nil
+    proc {i = @c.create(:x => 1)}.should_not raise_error
+    i.class.should be(@c)
+    i.values.should == {:x => 1}
+    
+    MODEL_DB.sqls.should == ['INSERT INTO items (x) VALUES (1);']
+  end
+  
+  specify "should raise when deleting" do
+    o = @c.new
+    proc {o.delete}.should raise_error
+  end
+
+  specify "should insert a record when saving" do
+    o = @c.new(:x => 2)
+    o.should be_new
+    o.save
+    MODEL_DB.sqls.should == ['INSERT INTO items (x) VALUES (2);']
+  end
+end
+
+context "Model#serialize" do
+  setup do
+    MODEL_DB.reset
+  end
+  
+  specify "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
+  
+  specify "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)"
+    
+    o = @c.create(:abc => [1, 2, 3])
+    ds.sqls.should == "INSERT INTO items (abc) VALUES ('#{[1, 2, 3].to_yaml}');"
+  end
+end
+
+context "Model attribute accessors" do
+  setup do
+    MODEL_DB.reset
+
+    @c = Class.new(Sequel::Model(:items)) do
+      def columns
+        [:id, :x, :y]
+      end
+    end
+    
+    ds = @c.dataset
+    ds.extend(Module.new {
+      def columns
+        [:id, :x, :y]
+      end
+    })
+  end
+  
+  specify "should be created dynamically" do
+    o = @c.new
+    
+    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
+  
+  specify "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(SequelError)
+    
+    proc {o.x = 3}.should_not raise_error
+    proc {o.yy = 4}.should raise_error
+  end
 end