sequel 3.3.0 → 3.4.0

data/spec/extensions/serialization_spec.rb

@@ -1,6 +1,7 @@
 require File.join(File.dirname(__FILE__), "spec_helper")
 
 require 'yaml'
+require 'json'
 
 describe "Serialization plugin" do
   before do
@@ -10,7 +11,7 @@ describe "Serialization plugin" do
         end
       end)
       no_primary_key
-      columns :id, :abc, :def
+      columns :id, :abc, :def, :ghi
     end
     MODEL_DB.reset
   end
@@ -23,6 +24,10 @@ describe "Serialization plugin" do
     @c.plugin :serialization, :marshal, :def
     @c.create(:abc => 1, :def=> 1)
     MODEL_DB.sqls.last.should =~ /INSERT INTO items \((abc, def|def, abc)\) VALUES \(('--- 1\n', 'BAhpBg==\n'|'BAhpBg==\n', '--- 1\n')\)/
+    
+    @c.plugin :serialization, :json, :ghi
+    @c.create(:ghi => [123])
+    MODEL_DB.sqls.last.should =~ /INSERT INTO items \((ghi)\) VALUES \('\[123\]'\)/
   end
 
   it "should allow serializing attributes to yaml" do
@@ -57,6 +62,18 @@ describe "Serialization plugin" do
       "INSERT INTO items (abc) VALUES ('#{x}')", \
     ]
   end
+  
+  it "should allow serializing attributes to json" do
+    @c.plugin :serialization, :json, :ghi
+    @c.create(:ghi => [1])
+    @c.create(:ghi => ["hello"])
+    
+    x = JSON.generate ["hello"]
+    MODEL_DB.sqls.should == [ \
+      "INSERT INTO items (ghi) VALUES ('[1]')", \
+      "INSERT INTO items (ghi) VALUES ('#{x}')", \
+    ]
+  end
 
   it "should translate values to and from yaml serialization format using accessor methods" do
     @c.set_primary_key :id
@@ -102,6 +119,29 @@ describe "Serialization plugin" do
     MODEL_DB.sqls.should == ["UPDATE items SET abc = '#{[Marshal.dump(23)].pack('m')}' WHERE (id = 1)",
       "INSERT INTO items (abc) VALUES ('#{[Marshal.dump([1, 2, 3])].pack('m')}')"]
   end
+  
+  it "should translate values to and from json serialization format using accessor methods" do
+    @c.set_primary_key :id
+    @c.plugin :serialization, :json, :abc, :def
+    
+    ds = @c.dataset
+    def ds.fetch_rows(sql, &block)
+      block.call(:id => 1, :abc => JSON.generate([1]), :def => JSON.generate(["hello"]))
+    end
+    
+    o = @c.first
+    o.id.should == 1
+    o.abc.should == [1]
+    o.abc.should == [1]
+    o.def.should == ["hello"]
+    o.def.should == ["hello"]
+    
+    o.update(:abc => [23])
+    @c.create(:abc => [1,2,3])
+    
+    MODEL_DB.sqls.should == ["UPDATE items SET abc = '#{JSON.generate([23])}' WHERE (id = 1)",
+      "INSERT INTO items (abc) VALUES ('#{JSON.generate([1,2,3])}')"]
+  end
 
   it "should copy serialization formats and columns to subclasses" do
     @c.set_primary_key :id
@@ -143,4 +183,27 @@ describe "Serialization plugin" do
     lambda{o.send(:serialize_value, :abc, 1)}.should raise_error(Sequel::Error)
     lambda{o.send(:deserialize_value, :abc, "--- hello\n")}.should raise_error(Sequel::Error)
   end
+
+  it "should add the accessors to a module included in the class, so they can be easily overridden" do
+    @c.class_eval do
+      def abc
+        "#{super}-blah"
+      end
+    end
+    @c.plugin :serialization, :yaml, :abc
+    o = @c.load(:abc => "--- 1\n")
+    o.abc.should == "1-blah"
+  end
+
+  it "should call super to get the deserialized value from a previous accessor" do
+    m = Module.new do
+      def abc
+        "--- #{@values[:abc]*3}\n"
+      end
+    end
+    @c.send(:include, m)
+    @c.plugin :serialization, :yaml, :abc
+    o = @c.load(:abc => 3)
+    o.abc.should == 9
+  end
 end

data/spec/extensions/timestamps_spec.rb

@@ -0,0 +1,150 @@
+require File.join(File.dirname(__FILE__), "spec_helper")
+
+describe "Sequel::Plugins::Timestamps" do
+  before do
+    dc = Object.new
+    dc.instance_eval do
+      def now
+        '2009-08-01'
+      end
+    end
+    Sequel.datetime_class = dc
+    @c = Class.new(Sequel::Model(:t))
+    @c.class_eval do
+      columns :id, :created_at, :updated_at
+      plugin :timestamps
+      db.reset
+      def _refresh(ds); self end
+    end
+  end 
+  after do
+    Sequel.datetime_class = Time
+  end
+  
+  it "should set the create timestamp field on creation" do
+    o = @c.create
+    @c.db.sqls.should == ["INSERT INTO t (created_at) VALUES ('2009-08-01')"]
+    o.created_at.should == '2009-08-01'
+  end
+
+  it "should set the update timestamp field on update" do
+    o = @c.load(:id=>1).save
+    @c.db.sqls.should == ["UPDATE t SET updated_at = '2009-08-01' WHERE (id = 1)"]
+    o.updated_at.should == '2009-08-01'
+  end
+
+  it "should not update the update timestamp on creation" do
+    @c.create.updated_at.should == nil
+  end
+
+  it "should use the same value for the creation and update timestamps when creating if the :update_on_create option is given" do
+    @c.plugin :timestamps, :update_on_create=>true
+    o = @c.create
+    @c.db.sqls.length.should == 1
+    @c.db.sqls.first.should =~ /INSERT INTO t \((creat|updat)ed_at, (creat|updat)ed_at\) VALUES \('2009-08-01', '2009-08-01'\)/
+    o.created_at.should === o.updated_at
+  end
+
+  it "should allow specifying the create timestamp field via the :create option" do
+    c = Class.new(Sequel::Model(:t))
+    c.class_eval do
+      columns :id, :c
+      plugin :timestamps, :create=>:c
+      db.reset
+      def _refresh(ds); self end
+    end
+    o = c.create
+    c.db.sqls.should == ["INSERT INTO t (c) VALUES ('2009-08-01')"]
+    o.c.should == '2009-08-01'
+  end
+
+  it "should allow specifying the update timestamp field via the :update option" do
+    c = Class.new(Sequel::Model(:t))
+    c.class_eval do
+      columns :id, :u
+      plugin :timestamps, :update=>:u
+      db.reset
+      def _refresh(ds); self end
+    end
+    o = c.load(:id=>1).save
+    c.db.sqls.should == ["UPDATE t SET u = '2009-08-01' WHERE (id = 1)"]
+    o.u.should == '2009-08-01'
+  end
+
+  it "should not raise an error if the model doesn't have the timestamp columns" do
+    c = Class.new(Sequel::Model(:t))
+    c.class_eval do
+      columns :id, :x
+      plugin :timestamps
+      db.reset
+      def _refresh(ds); self end
+    end
+    c.create(:x=>2)
+    c.load(:id=>1, :x=>2).save
+    c.db.sqls.should == ["INSERT INTO t (x) VALUES (2)", "UPDATE t SET x = 2 WHERE (id = 1)"] 
+  end
+
+  it "should not overwrite an existing create timestamp" do
+    o = @c.create(:created_at=>'2009-08-03')
+    @c.db.sqls.should == ["INSERT INTO t (created_at) VALUES ('2009-08-03')"]
+    o.created_at.should == '2009-08-03'
+  end
+
+  it "should overwrite an existing create timestamp if the :force option is used" do
+    @c.plugin :timestamps, :force=>true
+    o = @c.create(:created_at=>'2009-08-03')
+    @c.db.sqls.should == ["INSERT INTO t (created_at) VALUES ('2009-08-01')"]
+    o.created_at.should == '2009-08-01'
+  end
+
+  it "should have create_timestamp_field give the create timestamp field" do
+    @c.create_timestamp_field.should == :created_at
+    @c.plugin :timestamps, :create=>:c
+    @c.create_timestamp_field.should == :c
+  end
+
+  it "should have update_timestamp_field give the update timestamp field" do
+    @c.update_timestamp_field.should == :updated_at
+    @c.plugin :timestamps, :update=>:u
+    @c.update_timestamp_field.should == :u
+  end
+
+  it "should have create_timestamp_overwrite? give the whether to overwrite an existing create timestamp" do
+    @c.create_timestamp_overwrite?.should == false
+    @c.plugin :timestamps, :force=>true
+    @c.create_timestamp_overwrite?.should == true
+  end
+
+  it "should have set_update_timestamp_on_create? give whether to set the update timestamp on create" do
+    @c.set_update_timestamp_on_create?.should == false
+    @c.plugin :timestamps, :update_on_create=>true
+    @c.set_update_timestamp_on_create?.should == true
+  end
+
+  it "should work with subclasses" do
+    c = Class.new(@c)
+    o = c.create
+    o.created_at.should == '2009-08-01'
+    o.updated_at.should == nil
+    o = c.load(:id=>1).save
+    o.updated_at.should == '2009-08-01'
+    c.db.sqls.should == ["INSERT INTO t (created_at) VALUES ('2009-08-01')", "UPDATE t SET updated_at = '2009-08-01' WHERE (id = 1)"]
+    c.create(:created_at=>'2009-08-03').created_at.should == '2009-08-03'
+
+    c.class_eval do
+      columns :id, :c, :u
+      plugin :timestamps, :create=>:c, :update=>:u, :force=>true, :update_on_create=>true
+    end
+    c2 = Class.new(c)
+    c2.db.reset
+    o = c2.create
+    o.c.should == '2009-08-01'
+    o.u.should === o.c 
+    c2.db.sqls.first.should =~ /INSERT INTO t \([cu], [cu]\) VALUES \('2009-08-01', '2009-08-01'\)/
+    c2.db.reset
+    o = c2.load(:id=>1).save
+    o.u.should == '2009-08-01'
+    c2.db.sqls.should == ["UPDATE t SET u = '2009-08-01' WHERE (id = 1)"]
+    c2.create(:c=>'2009-08-03').c.should == '2009-08-01'
+  end
+end

data/spec/extensions/validation_helpers_spec.rb

@@ -288,4 +288,22 @@ describe "Sequel::Plugins::ValidationHelpers" do
     @user.should be_valid
     MODEL_DB.sqls.last.should == "SELECT COUNT(*) AS count FROM items WHERE ((username = '0records') AND (password = 'anothertest')) LIMIT 1"
   end
+
+  it "should support validates_unique with a block" do
+    @c.columns(:id, :username, :password)
+    @c.set_dataset MODEL_DB[:items]
+    @c.set_validations{validates_unique(:username){|ds| ds.filter(:active)}}
+    @c.dataset.extend(Module.new {
+      def fetch_rows (sql)
+        @db << sql
+        yield({:v => 0})
+      end
+    })
+    
+    MODEL_DB.reset
+    @c.new(:username => "0records", :password => "anothertest").should be_valid
+    @c.load(:id=>3, :username => "0records", :password => "anothertest").should be_valid
+    MODEL_DB.sqls.should == ["SELECT COUNT(*) AS count FROM items WHERE ((username = '0records') AND active) LIMIT 1",
+                    "SELECT COUNT(*) AS count FROM items WHERE (((username = '0records') AND active) AND (id != 3)) LIMIT 1"]
+  end
 end 

data/spec/integration/dataset_test.rb

@@ -135,6 +135,15 @@ describe Sequel::Dataset do
     @d.count.should == 1
     @d.first[:name].should == 'def'
   end
+  
+  specify "should be able to truncate the table" do
+    @d << {:name => 'abc', :value => 123}
+    @d << {:name => 'abc', :value => 456}
+    @d << {:name => 'def', :value => 789}
+    @d.count.should == 3
+    @d.truncate.should == nil
+    @d.count.should == 0
+  end
 
   specify "should be able to literalize booleans" do
     proc {@d.literal(true)}.should_not raise_error
@@ -164,7 +173,7 @@ describe Sequel::Database do
   end
 end
 
-context "An SQLite dataset" do
+context Sequel::Dataset do
   before do
     INTEGRATION_DB.create_table! :items do
       primary_key :id 
@@ -418,4 +427,72 @@ if INTEGRATION_DB.dataset.supports_window_functions?
         [{:sum=>1, :id=>1}, {:sum=>11, :id=>2}, {:sum=>111, :id=>3}, {:sum=>1111, :id=>4}, {:sum=>11111, :id=>5}, {:sum=>111111, :id=>6}]
     end
   end
-end
+end
+
+describe Sequel::SQL::Constants do
+  before do
+    @db = INTEGRATION_DB
+    @ds = @db[:constants]
+    @c = proc do |v|
+      case v
+      when Time
+        v
+      when DateTime, String
+        Time.parse(v.to_s)
+      else
+        v
+      end
+    end
+    @c2 = proc{|v| v.is_a?(Date) ? v : Date.parse(v) }
+  end
+  after do
+    @db.drop_table(:constants)
+  end
+  
+  it "should have working CURRENT_DATE" do
+    @db.create_table!(:constants){Date :d}
+    @ds.insert(:d=>Sequel::CURRENT_DATE)
+    Date.today.should == @c2[@ds.get(:d)]
+  end
+
+  it "should have working CURRENT_TIME" do
+    @db.create_table!(:constants){Time :t, :only_time=>true}
+    @ds.insert(:t=>Sequel::CURRENT_TIME)
+    (Time.now - @c[@ds.get(:t)]).should be_close(0, 1)
+  end
+
+  it "should have working CURRENT_TIMESTAMP" do
+    @db.create_table!(:constants){DateTime :ts}
+    @ds.insert(:ts=>Sequel::CURRENT_TIMESTAMP)
+    (Time.now - @c[@ds.get(:ts)]).should be_close(0, 1)
+  end
+end
+
+describe "Sequel::Dataset#import and #multi_insert" do
+  before do
+    @db = INTEGRATION_DB
+    @db.create_table!(:imp){Integer :i}
+    @db.create_table!(:exp2){Integer :i}
+    @ids = @db[:imp].order(:i)
+    @eds = @db[:exp2]
+  end
+  after do
+    @db.drop_table(:imp, :exp2)
+  end
+
+  it "should import with multi_insert and an array of hashes" do
+    @ids.multi_insert([{:i=>10}, {:i=>20}])
+    @ids.all.should == [{:i=>10}, {:i=>20}]
+  end
+
+  it "should import with an array of arrays of values" do
+    @ids.import([:i], [[10], [20]])
+    @ids.all.should == [{:i=>10}, {:i=>20}]
+  end
+
+  it "should import with a dataset" do
+    @eds.import([:i], [[10], [20]])
+    @ids.import([:i], @eds)
+    @ids.all.should == [{:i=>10}, {:i=>20}]
+  end
+end

data/spec/integration/schema_test.rb

@@ -293,6 +293,23 @@ describe "Database schema modifiers" do
     @db.schema(:items, :reload=>true).map{|x| x.first}.should == [:id]
     @ds.columns!.should == [:id]
   end
+
+  specify "should remove multiple columns in a single alter_table block" do
+    @db.create_table!(:items) do
+      primary_key :id
+      String :name
+      Integer :number
+    end
+    @ds.insert(:number=>10)
+    @db.schema(:items, :reload=>true).map{|x| x.first}.should == [:id, :name, :number]
+    @ds.columns!.should == [:id, :name, :number]
+    @db.alter_table(:items) do
+      drop_column :name
+      drop_column :number
+    end
+    @db.schema(:items, :reload=>true).map{|x| x.first}.should == [:id]
+    @ds.columns!.should == [:id]
+  end
 end
 
 if INTEGRATION_DB.respond_to?(:tables)

data/spec/integration/timezone_test.rb

@@ -0,0 +1,55 @@
+require File.join(File.dirname(__FILE__), 'spec_helper.rb')
+
+describe "Sequel timezone support" do
+  def test_timezone
+    t = Time.now
+    @db[:t].insert(t)
+    t2 = @db[:t].single_value
+    t2 = Sequel.database_to_application_timestamp(t2.to_s) unless t2.is_a?(Time)
+    (t2 - t).should be_close(0, 2)
+    t2.utc_offset.should == 0 if Sequel.application_timezone == :utc
+    t2.utc_offset.should == t.getlocal.utc_offset if Sequel.application_timezone == :local
+    @db[:t].delete
+    
+    dt = DateTime.now
+    Sequel.datetime_class = DateTime
+    @db[:t].insert(dt)
+    dt2 = @db[:t].single_value
+    dt2 = Sequel.database_to_application_timestamp(dt2.to_s) unless dt2.is_a?(DateTime)
+    (dt2 - dt).should be_close(0, 0.00002)
+    dt2.offset.should == 0 if Sequel.application_timezone == :utc
+    dt2.offset.should == dt.offset if Sequel.application_timezone == :local
+  end
+  
+  before do
+    @db = INTEGRATION_DB
+    @db.create_table!(:t){DateTime :t}
+  end
+  after do
+    @db.drop_table(:t)
+    Sequel.default_timezone = nil
+    Sequel.datetime_class = Time
+  end
+
+  specify "should support using UTC for database storage and local time for the application" do
+    Sequel.database_timezone = :utc
+    Sequel.application_timezone = :local
+    test_timezone
+  end
+  
+  specify "should support using local time for database storage and UTC for the application" do
+    Sequel.database_timezone = :local
+    Sequel.application_timezone = :utc
+    test_timezone
+  end
+  
+  specify "should support using UTC for both database storage and for application" do
+    Sequel.default_timezone = :utc
+    test_timezone
+  end
+  
+  specify "should support using local time for both database storage and for application" do
+    Sequel.default_timezone = :local
+    test_timezone
+  end
+end