epugh-sequel 0.0.0

data/spec/extensions/inflector_spec.rb

@@ -0,0 +1,122 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+
+describe String do
+  it "#camelize and #camelcase should transform the word to CamelCase" do
+    "egg_and_hams".camelize.should == "EggAndHams"
+    "egg_and_hams".camelize(false).should == "eggAndHams"
+    "post".camelize.should == "Post"
+    "post".camelcase.should == "Post"
+  end
+
+  it "#constantize should eval the string to get a constant" do
+    "String".constantize.should == String
+    "String::Inflections".constantize.should == String::Inflections
+    proc{"BKSDDF".constantize}.should raise_error
+    proc{"++A++".constantize}.should raise_error
+  end
+  
+  it "#dasherize should transform underscores to dashes" do
+    "egg_and_hams".dasherize.should == "egg-and-hams"
+    "post".dasherize.should == "post"
+  end
+  
+  it "#demodulize should remove any preceding modules" do
+    "String::Inflections::Blah".demodulize.should == "Blah"
+    "String::Inflections".demodulize.should == "Inflections"
+    "String".demodulize.should == "String"
+  end
+  
+  it "#humanize should remove _i, transform underscore to spaces, and capitalize" do
+    "egg_and_hams".humanize.should == "Egg and hams"
+    "post".humanize.should == "Post"
+    "post_id".humanize.should == "Post"
+  end
+  
+  it "#titleize and #titlecase should underscore, humanize, and capitalize all words" do
+    "egg-and: hams".titleize.should == "Egg And: Hams"
+    "post".titleize.should == "Post"
+    "post".titlecase.should == "Post"
+  end
+  
+  it "#underscore should add underscores between CamelCased words, change :: to / and - to _, and downcase" do
+    "EggAndHams".underscore.should == "egg_and_hams"
+    "EGGAndHams".underscore.should == "egg_and_hams"
+    "Egg::And::Hams".underscore.should == "egg/and/hams"
+    "post".underscore.should == "post"
+    "post-id".underscore.should == "post_id"
+  end
+
+  it "#pluralize should transform words from singular to plural" do
+    "post".pluralize.should == "posts"
+    "octopus".pluralize.should =="octopi"
+    "the blue mailman".pluralize.should == "the blue mailmen"
+    "CamelOctopus".pluralize.should == "CamelOctopi"
+  end
+  
+  it "#singularize should transform words from plural to singular" do
+    "posts".singularize.should == "post"
+    "octopi".singularize.should == "octopus"
+    "the blue mailmen".singularize.should == "the blue mailman"
+    "CamelOctopi".singularize.should == "CamelOctopus"
+  end
+  
+  it "#tableize should transform class names to table names" do
+    "RawScaledScorer".tableize.should == "raw_scaled_scorers"
+    "egg_and_ham".tableize.should == "egg_and_hams"
+    "fancyCategory".tableize.should == "fancy_categories"
+  end
+  
+  it "#classify should tranform table names to class names" do
+    "egg_and_hams".classify.should == "EggAndHam"
+    "post".classify.should == "Post"
+  end
+  
+  it "#foreign_key should create a foreign key name from a class name" do
+    "Message".foreign_key.should == "message_id"
+    "Message".foreign_key(false).should == "messageid"
+    "Admin::Post".foreign_key.should == "post_id"
+  end
+end
+
+describe String::Inflections do
+  before do
+    @plurals, @singulars, @uncountables = String.inflections.plurals.dup, String.inflections.singulars.dup, String.inflections.uncountables.dup
+  end
+  after do
+    String.inflections.plurals.replace(@plurals)
+    String.inflections.singulars.replace(@singulars)
+    String.inflections.uncountables.replace(@uncountables)
+    Sequel.inflections.plurals.replace(@plurals)
+    Sequel.inflections.singulars.replace(@singulars)
+    Sequel.inflections.uncountables.replace(@uncountables)
+  end
+
+  it "should be possible to clear the list of singulars, plurals, and uncountables" do
+    String.inflections.clear(:plurals)
+    String.inflections.plurals.should == []
+    String.inflections.plural('blah', 'blahs')
+    String.inflections.clear
+    String.inflections.plurals.should == []
+    String.inflections.singulars.should == []
+    String.inflections.uncountables.should == []
+  end
+
+  it "should be able to specify new inflection rules" do
+    String.inflections do |i|
+      i.plural(/xx$/i, 'xxx')
+      i.singular(/ttt$/i, 'tt')
+      i.irregular('yy', 'yyy')
+      i.uncountable(%w'zz')
+    end
+    'roxx'.pluralize.should == 'roxxx'
+    'rottt'.singularize.should == 'rott'
+    'yy'.pluralize.should == 'yyy'
+    'yyy'.singularize.should == 'yy'
+    'zz'.pluralize.should == 'zz'
+    'zz'.singularize.should == 'zz'
+  end
+
+  it "should be yielded and returned by String.inflections" do
+    String.inflections{|i| i.should == String::Inflections}.should == String::Inflections
+  end
+end

data/spec/extensions/pagination_spec.rb

@@ -0,0 +1,99 @@
+require File.join(File.dirname(__FILE__), "spec_helper")
+
+context "A paginated dataset" do
+  setup 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
+  setup 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
+  setup 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
+
+  teardown 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
+  setup 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
+
+  teardown 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
+  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
+
+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.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/extensions/schema_spec.rb

@@ -0,0 +1,111 @@
+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
+    MODEL_DB.reset
+    @model = Class.new(Sequel::Model(:items))
+  end
+
+  it "should get the table name and question the model's db if table_exists?" do
+    @model.should_receive(:table_name).and_return(:items)
+    @model.db.should_receive(:table_exists?)
+    @model.table_exists?
+  end
+end
+
+describe Sequel::Model, "create_table and schema" do
+
+  before(:each) do
+    MODEL_DB.reset
+    @model = Class.new(Sequel::Model) do
+      set_schema(:items) do
+        text :name
+        float :price, :null => false
+      end
+    end
+  end
+
+  it "should get the create table SQL list from the db and execute it line by line" do
+    @model.create_table
+    MODEL_DB.sqls.should == ['CREATE TABLE items (name text, price float NOT NULL)']
+  end
+
+  it "should reload the schema from the database" do
+    schem = {:name=>{:type=>:string}, :price=>{:type=>:float}}
+    @model.db.should_receive(:schema).with(:items, :reload=>true).and_return(schem.to_a.sort_by{|x| x[0].to_s})
+    @model.create_table
+    @model.db_schema.should == schem
+    @model.instance_variable_get(:@columns).should == [:name, :price]
+  end
+
+  it "should return the schema generator via schema" do
+    @model.schema.should be_a_kind_of(Sequel::Schema::Generator)
+  end
+
+  it "should use the superclasses schema if it exists" do
+    @submodel = Class.new(@model)
+    @submodel.schema.should be_a_kind_of(Sequel::Schema::Generator)
+  end
+
+  it "should return nil if no schema is present" do
+    @model = Class.new(Sequel::Model)
+    @model.schema.should == nil
+    @submodel = Class.new(@model)
+    @submodel.schema.should == nil
+  end
+end
+
+describe Sequel::Model, "drop_table" do
+
+  before(:each) do
+    MODEL_DB.reset
+    @model = Class.new(Sequel::Model(:items))
+  end
+
+  it "should get the drop table SQL for the associated table and then execute the SQL." do
+    @model.should_receive(:table_name).and_return(:items)
+    @model.db.should_receive(:drop_table_sql).with(:items)
+    @model.db.should_receive(:execute).and_return(:true)
+    @model.drop_table
+  end
+
+end
+
+describe Sequel::Model, "create_table!" do
+
+  before(:each) do
+    MODEL_DB.reset
+    @model = Class.new(Sequel::Model(:items))
+  end
+  
+  it "should drop table if it exists and then create the table" do
+    @model.should_receive(:drop_table).and_return(true)
+    @model.should_receive(:create_table).and_return(true)
+
+    @model.create_table!
+  end
+
+end