sequel 2.11.0 → 2.12.0

data/spec/extensions/pagination_spec.rb

@@ -0,0 +1,99 @@
+require File.join(File.dirname(__FILE__), "spec_helper")
+
+context "A paginated dataset" do
+  before do
+    @d = Sequel::Dataset.new(nil)
+    @d.meta_def(:count) {153}
+    
+    @paginated = @d.paginate(1, 20)
+  end
+  
+  specify "should raise an error if the dataset already has a limit" do
+    proc{@d.limit(10).paginate(1,10)}.should raise_error(Sequel::Error)
+    proc{@paginated.paginate(2,20)}.should raise_error(Sequel::Error)
+  end
+  
+  specify "should set the limit and offset options correctly" do
+    @paginated.opts[:limit].should == 20
+    @paginated.opts[:offset].should == 0
+  end
+  
+  specify "should set the page count correctly" do
+    @paginated.page_count.should == 8
+    @d.paginate(1, 50).page_count.should == 4
+  end
+  
+  specify "should set the current page number correctly" do
+    @paginated.current_page.should == 1
+    @d.paginate(3, 50).current_page.should == 3
+  end
+  
+  specify "should return the next page number or nil if we're on the last" do
+    @paginated.next_page.should == 2
+    @d.paginate(4, 50).next_page.should be_nil
+  end
+  
+  specify "should return the previous page number or nil if we're on the last" do
+    @paginated.prev_page.should be_nil
+    @d.paginate(4, 50).prev_page.should == 3
+  end
+  
+  specify "should return the page range" do
+    @paginated.page_range.should == (1..8)
+    @d.paginate(4, 50).page_range.should == (1..4)
+  end
+  
+  specify "should return the record range for the current page" do
+    @paginated.current_page_record_range.should == (1..20)
+    @d.paginate(4, 50).current_page_record_range.should == (151..153)
+    @d.paginate(5, 50).current_page_record_range.should == (0..0)
+  end
+
+  specify "should return the record count for the current page" do
+    @paginated.current_page_record_count.should == 20
+    @d.paginate(3, 50).current_page_record_count.should == 50
+    @d.paginate(4, 50).current_page_record_count.should == 3
+    @d.paginate(5, 50).current_page_record_count.should == 0
+  end
+
+  specify "should know if current page is last page" do
+    @paginated.last_page?.should be_false
+    @d.paginate(2, 20).last_page?.should be_false
+    @d.paginate(5, 30).last_page?.should be_false
+    @d.paginate(6, 30).last_page?.should be_true
+  end
+
+  specify "should know if current page is first page" do
+    @paginated.first_page?.should be_true
+    @d.paginate(1, 20).first_page?.should be_true
+    @d.paginate(2, 20).first_page?.should be_false
+  end
+
+  specify "should work with fixed sql" do
+    ds = @d.clone(:sql => 'select * from blah')
+    ds.meta_def(:count) {150}
+    ds.paginate(2, 50).sql.should == 'SELECT * FROM (select * from blah) AS t1 LIMIT 50 OFFSET 50'
+  end
+end
+
+context "Dataset#each_page" do
+  before do
+    @d = Sequel::Dataset.new(nil).from(:items)
+    @d.meta_def(:count) {153}
+  end
+  
+  specify "should raise an error if the dataset already has a limit" do
+    proc{@d.limit(10).each_page(10){}}.should raise_error(Sequel::Error)
+  end
+  
+  specify "should iterate over each page in the resultset as a paginated dataset" do
+    a = []
+    @d.each_page(50) {|p| a << p}
+    a.map {|p| p.sql}.should == [
+      'SELECT * FROM items LIMIT 50 OFFSET 0',
+      'SELECT * FROM items LIMIT 50 OFFSET 50',
+      'SELECT * FROM items LIMIT 50 OFFSET 100',
+      'SELECT * FROM items LIMIT 50 OFFSET 150',
+    ]
+  end
+end

data/spec/extensions/pretty_table_spec.rb

@@ -0,0 +1,91 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+
+require 'stringio'
+
+context "Dataset#print" do
+  before do
+    @output = StringIO.new
+    @orig_stdout = $stdout
+    $stdout = @output
+    @dataset = Sequel::Dataset.new(nil).from(:items)
+    def @dataset.fetch_rows(sql)
+      yield({:a=>1, :b=>2})
+      yield({:a=>3, :b=>4})
+      yield({:a=>5, :b=>6})
+    end
+  end
+
+  after do
+    $stdout = @orig_stdout
+  end
+
+  specify "should print out a table with the values" do
+    @dataset.print(:a, :b)
+    @output.rewind
+    @output.read.should == \
+      "+-+-+\n|a|b|\n+-+-+\n|1|2|\n|3|4|\n|5|6|\n+-+-+\n"
+  end
+
+  specify "should default to the dataset's columns" do
+    @dataset.meta_def(:columns) {[:a, :b]}
+    @dataset.print
+    @output.rewind
+    @output.read.should == \
+      "+-+-+\n|a|b|\n+-+-+\n|1|2|\n|3|4|\n|5|6|\n+-+-+\n"
+  end
+end
+
+context "PrettyTable" do
+  before do
+    @data1 = [
+      {:x => 3, :y => 4}
+    ]
+    
+    @data2 = [
+      {:a => 23, :b => 45},
+      {:a => 45, :b => 2377}
+    ]
+
+    @data3 = [
+      {:aaa => 1},
+      {:bb => 2},
+      {:c => 3}
+    ]
+
+    @output = StringIO.new
+    @orig_stdout = $stdout
+    $stdout = @output
+  end
+
+  after do
+    $stdout = @orig_stdout
+  end
+  
+  specify "should infer the columns if not given" do
+    Sequel::PrettyTable.print(@data1)
+    @output.rewind
+    @output.read.should =~ \
+      /\n(\|x\|y\|)|(\|y\|x\|)\n/
+  end
+  
+  specify "should calculate the maximum width of each column correctly" do
+    Sequel::PrettyTable.print(@data2, [:a, :b])
+    @output.rewind
+    @output.read.should == \
+      "+--+----+\n|a |b   |\n+--+----+\n|23|  45|\n|45|2377|\n+--+----+\n"
+  end
+
+  specify "should also take header width into account" do
+    Sequel::PrettyTable.print(@data3, [:aaa, :bb, :c])
+    @output.rewind
+    @output.read.should == \
+      "+---+--+-+\n|aaa|bb|c|\n+---+--+-+\n|  1|  | |\n|   | 2| |\n|   |  |3|\n+---+--+-+\n"
+  end
+  
+  specify "should print only the specified columns" do
+    Sequel::PrettyTable.print(@data2, [:a])
+    @output.rewind
+    @output.read.should == \
+      "+--+\n|a |\n+--+\n|23|\n|45|\n+--+\n"
+  end
+end

data/spec/extensions/query_spec.rb

@@ -0,0 +1,85 @@
+require File.join(File.dirname(__FILE__), "spec_helper")
+
+context "Database#dataset" do
+  before 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
+
+context "Dataset#query" do
+  before 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.sql_number > 1) & (:y.sql_number > 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.sql_number >= 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 {first_source}}.should raise_error(Sequel::Error)
+  end
+  
+  specify "should raise on each, insert, update, delete" do
+    proc {@d.query {each}}.should raise_error(Sequel::Error)
+    proc {@d.query {insert(:x => 1)}}.should raise_error(Sequel::Error)
+    proc {@d.query {update(:x => 1)}}.should raise_error(Sequel::Error)
+    proc {@d.query {delete}}.should raise_error(Sequel::Error)
+  end
+end

data/spec/{sequel_model → extensions}/schema_spec.rb

@@ -1,5 +1,27 @@
 require File.join(File.dirname(__FILE__), "spec_helper")
 
+describe Sequel::Model, "dataset & schema" do
+  before do
+    @model = Class.new(Sequel::Model(:items))
+  end 
+
+  specify "sets schema with implicit table name" do
+    @model.set_schema do
+      primary_key :ssn, :string
+    end
+    @model.primary_key.should == :ssn
+    @model.table_name.should == :items
+  end
+
+  specify "sets schema with explicit table name" do
+    @model.set_schema :foo do
+      primary_key :id
+    end
+    @model.primary_key.should == :id
+    @model.table_name.should == :foo
+  end
+end
+
 describe Sequel::Model, "table_exists?" do
 
   before(:each) do
@@ -12,7 +34,6 @@ describe Sequel::Model, "table_exists?" do
     @model.db.should_receive(:table_exists?)
     @model.table_exists?
   end
-
 end
 
 describe Sequel::Model, "create_table and schema" do

data/spec/extensions/serialization_spec.rb

@@ -0,0 +1,109 @@
+require File.join(File.dirname(__FILE__), "spec_helper")
+
+describe "Serialization plugin" do
+  before do
+    @c = Class.new(Sequel::Model(:items)) do
+      include(Module.new do
+        def before_save
+        end
+      end)
+      no_primary_key
+      columns :id, :abc, :def
+    end
+    MODEL_DB.reset
+  end
+
+  it "should allow serializing attributes to yaml" do
+    @c.plugin :serialization, :yaml, :abc
+    @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 allow serializing attributes to marshal" do
+    @c.plugin :serialization, :marshal, :abc
+    @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 serialization format using accessor methods" do
+    @c.set_primary_key :id
+    @c.plugin :serialization, :yaml, :abc, :def
+    vals = nil
+
+    ds = @c.dataset
+    def ds.fetch_rows(sql, &block)
+      block.call(:id => 1, :abc => "--- 1\n", :def => "--- hello\n")
+    end
+
+    o = @c.first
+    o.id.should == 1
+    o.abc.should == 1
+    o.def.should == "hello"
+
+    o.update(:abc => 23)
+    @c.create(:abc => [1, 2, 3])
+    MODEL_DB.sqls.should == ["UPDATE items SET abc = '--- 23\n' WHERE (id = 1)",
+      "INSERT INTO items (abc) VALUES ('#{[1, 2, 3].to_yaml}')"]
+  end
+
+  it "should translate values to and from marshal serialization format using accessor methods" do
+    @c.set_primary_key :id
+    @c.plugin :serialization, :marshal, :abc, :def
+
+    ds = @c.dataset
+    def ds.fetch_rows(sql, &block)
+      block.call(:id => 1, :abc =>[Marshal.dump(1)].pack('m'), :def =>[Marshal.dump('hello')].pack('m'))
+    end
+
+    o = @c.first
+    o.id.should == 1
+    o.abc.should == 1
+    o.def.should == "hello"
+
+    o.update(:abc => 23)
+    @c.create(:abc => [1, 2, 3])
+    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 copy serialization formats and columns to subclasses" do
+    @c.set_primary_key :id
+    @c.plugin :serialization, :yaml, :abc, :def
+
+    ds = @c.dataset
+    def ds.fetch_rows(sql, &block)
+      block.call(:id => 1, :abc => "--- 1\n", :def => "--- hello\n")
+    end
+
+    o = Class.new(@c).first
+    o.id.should == 1
+    o.abc.should == 1
+    o.def.should == "hello"
+
+    o.update(:abc => 23)
+    Class.new(@c).create(:abc => [1, 2, 3])
+    MODEL_DB.sqls.should == ["UPDATE items SET abc = '--- 23\n' WHERE (id = 1)",
+      "INSERT INTO items (abc) VALUES ('#{[1, 2, 3].to_yaml}')"]
+  end
+
+  it "should clear the deserialized columns when refreshing" do
+    @c.set_primary_key :id
+    @c.plugin :serialization, :yaml, :abc, :def
+    o = @c.load(:id => 1, :abc => "--- 1\n", :def => "--- hello\n")
+    o.abc = 23
+    o.deserialized_values.length.should == 1
+    o.refresh
+    o.deserialized_values.length.should == 0
+  end
+end

data/spec/extensions/single_table_inheritance_spec.rb

@@ -0,0 +1,53 @@
+require File.join(File.dirname(__FILE__), "spec_helper")
+
+describe Sequel::Model, "#sti_key" do
+  before do
+    class ::StiTest < Sequel::Model
+      def kind=(x); self[:kind] = x; end 
+      def refresh; end 
+      plugin :single_table_inheritance, :kind
+    end 
+    class ::StiTestSub1 < StiTest
+    end 
+    class ::StiTestSub2 < StiTest
+    end 
+    @ds = StiTest.dataset
+    MODEL_DB.reset
+  end 
+  
+  it "should return rows with the correct class based on the polymorphic_key value" do
+    def @ds.fetch_rows(sql)
+      yield({:kind=>'StiTest'})
+      yield({:kind=>'StiTestSub1'})
+      yield({:kind=>'StiTestSub2'})
+    end 
+    StiTest.all.collect{|x| x.class}.should == [StiTest, StiTestSub1, StiTestSub2]
+  end 
+
+  it "should fallback to the main class if polymophic_key value is NULL" do
+    def @ds.fetch_rows(sql)
+      yield({:kind=>nil})
+    end 
+    StiTest.all.collect{|x| x.class}.should == [StiTest]
+  end 
+  
+  it "should fallback to the main class if the given class does not exist" do
+    def @ds.fetch_rows(sql)
+      yield({:kind=>'StiTestSub3'})
+    end
+    StiTest.all.collect{|x| x.class}.should == [StiTest]
+  end
+
+  it "should add a before_create hook that sets the model class name for the key" do
+    StiTest.new.save
+    StiTestSub1.new.save
+    StiTestSub2.new.save
+    MODEL_DB.sqls.should == ["INSERT INTO sti_tests (kind) VALUES ('StiTest')", "INSERT INTO sti_tests (kind) VALUES ('StiTestSub1')", "INSERT INTO sti_tests (kind) VALUES ('StiTestSub2')"]
+  end
+
+  it "should add a filter to model datasets inside subclasses hook to only retreive objects with the matching key" do
+    StiTest.dataset.sql.should == "SELECT * FROM sti_tests"
+    StiTestSub1.dataset.sql.should == "SELECT * FROM sti_tests WHERE (kind = 'StiTestSub1')"
+    StiTestSub2.dataset.sql.should == "SELECT * FROM sti_tests WHERE (kind = 'StiTestSub2')"
+  end
+end