sequel 0.4.5 → 0.5

data/spec/model/relations_spec.rb

@@ -1,148 +0,0 @@
-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
-    end
-
-    @dataset = @c2.dataset
-
-    $sqls = []
-    @dataset.extend(Module.new {
-      def fetch_rows(sql)
-        $sqls << sql
-        yield({:hey => 1})
-      end
-
-      def update(values)
-        $sqls << update_sql(values)
-      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}
-
-    $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}
-
-    $sqls.should == ["SELECT * FROM nodes WHERE (id = 567) LIMIT 1"]
-  end
-
-  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
-
-  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.new(:id => 1)
-    d.parent = {:id => 4321}
-    d.values.should == {:id => 1, :parent_id => 4321}
-    $sqls.last.should == "UPDATE nodes SET parent_id = 4321 WHERE (id = 1)"
-
-    d.parent = nil
-    d.values.should == {:id => 1, :parent_id => nil}
-    $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}
-    $sqls.last.should == "UPDATE nodes SET parent_id = 6677 WHERE (id = 1)"
-  end
-
-  it "should warn with a depreciation notice if :class option was used" do
-    pending("write this spec")
-  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
-
-  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
-
-  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 warn with a depreciation notice if :class option was used" do
-    pending("write this spec")
-  end
-
-  it "should warn with a depreciation notice if :on option was used" do
-    pending("write this spec")
-  end
-
-end

data/spec/model/schema_spec.rb

@@ -1,80 +0,0 @@
-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" do
-
-  before(:each) do
-    MODEL_DB.reset
-    @model = Class.new(Sequel::Model(:items))
-  end
-
-  it "should get the create table SQL list from the db and execute it line by line" do
-    #db.create_table_sql_list(table_name, *schema.create_info).each {|s| db << s} 
-    @model.should_receive(:table_name).and_return(:items)
-    @model.schema.should_receive(:create_info)
-    @model.db.should_receive(:create_table_sql_list)
-    pending("Finish specing this")
-    @model.create_table
-  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(:table_exists?).and_return(true)
-    @model.should_receive(:drop_table).and_return(true)
-    @model.should_receive(:create_table).and_return(true)
-
-    @model.create_table!
-  end
-
-end
-
-describe Sequel::Model, "recreate_table" do
-
-  before(:each) do
-    MODEL_DB.reset
-    @model = Class.new(Sequel::Model(:items))
-  end
-
-  it "should raise a depreciation warning and then call create_table!" do
-    @model.should_receive(:warn)
-    @model.should_receive(:create_table!).and_return(true)
-    @model.recreate_table
-  end
-
-end

data/spec/model/validations_spec.rb

@@ -1,292 +0,0 @@
-describe Sequel::Model, "Validations" do
-
-  before(:all) do
-    class Person < Sequel::Model(:people)
-      def columns
-        [:id,:name,:first_name,:last_name,:middle_name,:initials,:age, :terms]
-      end
-    end
-
-    class Smurf < Person
-    end
-    
-    class Cow < Sequel::Model(:cows)
-      def columns
-        [:id, :name, :got_milk]
-      end
-    end
-
-    class User < Sequel::Model(:users)
-      def columns
-        [:id, :username, :password]
-      end
-    end
-    
-    class Address < Sequel::Model(:addresses)
-      def columns
-        [:id, :zip_code]
-      end
-    end
-  end
-  
-  it "should have a hook before validating" do
-    class Person < Sequel::Model(:people)      
-      before_validation do
-        self.name = "default name"
-      end
-      validations.clear
-      validates_presence_of :name
-    end
-
-    @person = Person.new
-    @person.valid?.should be_true
-  end
-  
-  it "should include errors from other models" do
-    pending("Waiting for Wayne's amazing associations!")
-  end
-  
-  it "should validate the acceptance of a column" do
-    class Cow < Sequel::Model(:cows)      
-      validations.clear
-      validates_acceptance_of :got_milk
-    end
-    
-    @cow = Cow.new
-    @cow.valid?.should be_false
-    @cow.errors.on(:got_milk).should == "must be accepted"
-    
-    @cow.got_milk = "true"
-    @cow.valid?.should be_true
-  end
-  
-  it "should validate the confirmation of a column" do
-    class User < Sequel::Model(:users)      
-      def password_confirmation
-        "test"
-      end
-      
-      validations.clear
-      validates_confirmation_of :password
-    end
-    
-    @user = User.new
-    @user.valid?.should be_false
-    @user.errors.on(:password).should == "doesn't match confirmation"
-    
-    @user.password = "test"
-    @user.valid?.should be_true
-  end
-  
-  it "should validate each with logic" do
-    class ZipCodeService; end
-    
-    class Address < Sequel::Model(:addresses)      
-      validations.clear
-      validates_each :zip_code, :logic => lambda { errors.add(:zip_code, "is not valid") unless ZipCodeService.allows(zip_code) }
-    end
-    
-    @address = Address.new :zip_code => "48108"
-    ZipCodeService.should_receive(:allows).with("48108").and_return(false)
-    @address.valid?.should be_false
-    @address.errors.on(:zip_code).should == "is not valid"
-    
-    @address2 = Address.new :zip_code => "48104"
-    ZipCodeService.should_receive(:allows).with("48104").and_return(true)
-    @address2.valid?.should be_true
-  end
-  
-  it "should validate format of column" do
-    class Person < Sequel::Model(:people)  
-      validates_format_of :first_name, :with => /^[a-zA-Z]+$/
-    end
-
-    @person = Person.new :first_name => "Lancelot99"
-    @person.valid?.should be_false
-    @person = Person.new :first_name => "Anita"
-    @person.valid?.should be_true
-  end
-  
-  it "should allow for :with_exactly => /[a-zA-Z/, which wraps the supplied regex with ^<regex>$" do
-    pending("TODO: Add this option to Validatable#validates_format_of")
-  end
-
-  it "should validate length of column" do
-    class Person < Sequel::Model(:people)
-      validations.clear
-      validates_length_of :first_name, :maximum => 30
-      validates_length_of :last_name, :minimum => 30
-      validates_length_of :middle_name, :within => 1..5
-      validates_length_of :initials, :is => 2
-    end
-    
-    @person = Person.new(
-      :first_name => "Anamethatiswaytofreakinglongandwayoverthirtycharacters",
-      :last_name => "Alastnameunderthirtychars",
-      :initials => "LGC",
-      :middle_name => "danger"
-    )
-    
-    @person.valid?.should be_false
-    @person.errors.on(:first_name).should  == "is invalid"
-    @person.errors.on(:last_name).should   == "is invalid"
-    @person.errors.on(:initials).should    == "is invalid"
-    @person.errors.on(:middle_name).should == "is invalid"
-    
-    @person.first_name  = "Lancelot"
-    @person.last_name   = "1234567890123456789012345678901"
-    @person.initials    = "LC"
-    @person.middle_name = "Will"
-    @person.valid?.should be_true
-  end
-  
-  it "should validate numericality of column" do
-    class Person < Sequel::Model(:people)
-      validations.clear
-      validates_numericality_of :age
-    end
-    
-    @person = Person.new :age => "Twenty"
-    @person.valid?.should be_false
-    @person.errors.on(:age).should == "must be a number"
-    
-    @person.age = 20
-    @person.valid?.should be_true
-  end
-  
-  it "should validate the presence of a column" do
-    class Cow < Sequel::Model(:cows)      
-      validations.clear
-      validates_presence_of :name
-    end
-    
-    @cow = Cow.new
-    @cow.valid?.should be_false
-    @cow.errors.on(:name).should == "can't be empty"
-    @cow.errors.full_messages.first.should == "Name can't be empty"
-    
-    @cow.name = "Betsy"
-    @cow.valid?.should be_true
-  end
-  
-  it "should validate true for a column" do
-    class Person < Sequel::Model(:people)
-      validations.clear
-      validates_true_for :first_name, :logic => lambda { first_name == "Alison" }
-    end
-
-    @person = Person.new :first_name => "Nina"
-    @person.valid?.should be_false
-    @person.errors.on(:first_name).should == "is invalid"
-    
-    @person.first_name = "Alison"
-    @person.valid?.should be_true
-  end
-    
-  it "should have a validates block that calls multple validations" do
-    class Person < Sequel::Model(:people)
-      validations.clear
-      validates do
-        format_of :first_name, :with => /^[a-zA-Z]+$/
-        length_of :first_name, :maximum => 30
-      end
-    end
-
-    Person.validations.length.should eql(2)
-    
-    @person = Person.new :first_name => "Lancelot99"
-    @person.valid?.should be_false
-    
-    @person2 = Person.new :first_name => "Wayne"
-    @person2.valid?.should be_true
-  end
-
-  it "should require and include the validatable gem" do
-    Gem.loaded_specs["validatable"].should_not be_nil
-    Sequel::Model.should respond_to(:validates_format_of) # validatable gem
-    Sequel::Model.should respond_to(:validations)         # Validations module
-  end
-  
-  it "should description" do
-    Sequel::Model.should_receive(:require).with("validatable").and_raise(LoadError)
-    STDERR.should_receive(:puts)
-    load File.join(File.dirname(__FILE__), "../../lib/sequel/model/validations.rb")
-  end
-  
-  it "should allow 'longhand' validations direcly within the model." do
-    lambda {
-      class Person < Sequel::Model(:people)
-        validations.clear
-        validates_length_of :first_name, :maximum => 30
-      end
-    }.should_not raise_error
-    Person.validations.length.should eql(1)
-  end
-
-  it "should validates do should allow shorthand method for every longhand validates_* method" do
-    class Person
-      validations.clear
-      validates do
-        format_of       :first_name, :with => /^[a-zA-Z]+$/
-        length_of       :first_name, :maximum => 30
-        presence_of     :first_name
-        numericality_of :age
-        acceptance_of   :terms
-        confirmation_of :password
-        true_for        :first_name, :logic => lambda { first_name == "Alison" }
-        #validates_each :last_name, :logic => lambda { errors.add(:zip_code, "is not valid") unless ZipCodeService.allows(zip_code) }
-        #base
-      end
-      
-      # Now check to make sure that each validation exists in the model's validations.
-    end
-    pending("finish this spec for each case")
-  end
-
-  it "should define a has_validations? method which returns true if the model has validations, false otherwise" do
-    class Person < Sequel::Model(:people)
-      validations.clear
-      validates do
-        format_of :first_name, :with => /\w+/
-        length_of :first_name, :maximum => 30
-      end
-    end
-
-    class Smurf < Person
-      validations.clear
-    end
-
-    Person.should have_validations
-    Smurf.should_not have_validations
-  end
-
-end
-
-describe Sequel::Model, "validates" do
-  
-
-  before(:all) do
-    class Person < Sequel::Model(:people)
-      def columns
-        [:id,:name,:first_name,:last_name,:middle_name,:initials,:age]
-      end
-    end
-  end
-  
-  it "should runs the validations block on the model & store as :default when only a validations block is passed in" do
-    pending
-  end
-
-  it "should store the block under the name passed in when both a name and a validations block are passed in" do
-    pending
-  end
-
-  it "should return the stored validations block corresponding to the name given, if only a name is given (no block)" do
-    pending
-  end
-
-  it "should return true or false based on if validations exist on the model if no arguments are given" do
-    pending
-  end
-
-end