datamapper 0.3.2 → 0.9.3

data/spec/single_table_inheritance_spec.rb

@@ -1,43 +0,0 @@
-require File.dirname(__FILE__) + "/spec_helper"
-
-describe 'Single Table Inheritance' do
-  
-  before(:all) do
-    fixtures(:people)
-  end
-  
-  it "should save and load the correct Type" do
-    database do
-      ted = SalesPerson.new(:name => 'Ted')
-      ted.save
-    
-      clone = Person.first(:name => 'Ted')
-      ted.should == clone
-      
-      clone.class.should eql(SalesPerson)      
-    end
-    
-    # Since we're not executing within the same database context
-    # this is not the same object instance as the previous ones.
-    clone2 = Person.first(:name => 'Ted')
-    
-    clone2.class.should eql(SalesPerson)    
-  end
-  
-  it "secondary database should inherit the same attributes" do
-    
-    database(:mock) do |db|
-      db.table(SalesPerson)[:name].should_not be_nil
-    end
-    
-  end
-  
-  it "should inherit the callbacks of the parent class" do
-    database do      
-      adam = SalesPerson.new(:name => 'adam')
-      adam.save
-      adam.reload.notes.should eql("Lorem ipsum dolor sit amet")
-    end
-  end
-  
-end

data/spec/spec_helper.rb

@@ -1,45 +0,0 @@
-require 'pp'
-
-ENV['LOG_NAME'] = 'spec'
-require File.dirname(__FILE__) + '/../environment'
-
-# Define a fixtures helper method to load up our test data.
-def fixtures(name)
-  entry = YAML::load_file(File.dirname(__FILE__) + "/fixtures/#{name}.yaml")
-  klass = begin
-    Kernel::const_get(Inflector.classify(Inflector.singularize(name)))
-  rescue
-    nil
-  end
-
-  unless klass.nil?
-    database.logger.debug { "AUTOMIGRATE: #{klass}" }
-    klass.auto_migrate!
-
-    (entry.kind_of?(Array) ? entry : [entry]).each do |hash|
-      if hash['type']
-        Object::const_get(hash['type'])::create(hash)
-      else
-        klass::create(hash)
-      end
-    end
-  else
-    table = database.table(name.to_s)
-    table.create! true
-    table.activate_associations!
-
-    #pp database.schema
-
-    (entry.kind_of?(Array) ? entry : [entry]).each do |hash|
-      table.insert(hash)
-    end
-  end
-end
-
-def load_database
-  Dir[File.dirname(__FILE__) + "/fixtures/*.yaml"].each do |path|
-    fixtures(File::basename(path).sub(/\.yaml$/, ''))
-  end
-end
-
-load_database

data/spec/support/blank_spec.rb

@@ -1,8 +0,0 @@
-require File.dirname(__FILE__) + "/../spec_helper"
-
-describe DataMapper::Support do
-  it "should mark empty objects as blank" do
-    [ nil, false, '', '   ', "  \n\t  \r ", [], {} ].each { |f| f.should be_blank }
-    [ Object.new, true, 0, 1, 'a', [nil], { nil => 0 } ].each { |t| t.should_not be_blank }
-  end
-end

data/spec/support/inflector_spec.rb

@@ -1,41 +0,0 @@
-require File.dirname(__FILE__) + "/../spec_helper"
-
-describe Inflector do
-  it "should camelize strings" do
-    Inflector.camelize("data_mapper").should == "DataMapper"
-    Inflector.camelize("data_mapper/support").should == "DataMapper::Support"
-  end
-  
-  it "should pluralize strings" do
-    Inflector.pluralize("post").should == "posts"
-    Inflector.pluralize("octopus").should == "octopi"
-    Inflector.pluralize("sheep").should == "sheep"
-    Inflector.pluralize("word").should == "words"
-    Inflector.pluralize("the blue mailman").should == "the blue mailmen"
-    Inflector.pluralize("CamelOctopus").should == "CamelOctopi"
-  end
-  
-  it "should singularize strings" do
-    Inflector.singularize("posts").should == "post"
-    Inflector.singularize("octopi").should == "octopus"
-    Inflector.singularize("sheep").should == "sheep"
-    Inflector.singularize("word").should == "word"
-    Inflector.singularize("the blue mailmen").should == "the blue mailman"
-    Inflector.singularize("CamelOctopi").should == "CamelOctopus"
-  end
-  
-  it "should demodulize strings" do
-    Inflector.demodulize("DataMapper::Support").should == "Support"
-  end
-  
-  it "should create foreign keys from class names and key names" do
-    Inflector.foreign_key("Animal").should == "animal_id"
-    Inflector.foreign_key("Admin::Post").should == "post_id"
-    Inflector.foreign_key("Animal", "name").should == "animal_name"
-  end
-  
-  it "should constantize strings" do
-    Inflector.constantize("Class").should == Class
-    lambda { Inflector.constantize("asdf") }.should raise_error
-  end
-end

data/spec/support/object_spec.rb

@@ -1,9 +0,0 @@
-require File.dirname(__FILE__) + "/../spec_helper"
-
-describe DataMapper::Support::Object do
-  
-  it "should be able to get a recursive constant" do
-    Object.recursive_const_get('DataMapper::Support::String').should == DataMapper::Support::String
-  end
-  
-end

data/spec/support/serialization_spec.rb

@@ -1,61 +0,0 @@
-require File.dirname(__FILE__) + "/../spec_helper"
-
-describe DataMapper::Support::Serialization do
-  
-  before(:all) do
-    fixtures(:animals)
-    fixtures(:zoos)
-  end
-  
-  it "should serialize to YAML" do
-    Animal.first(:name => 'Frog').to_yaml.strip.should == <<-EOS.margin
-      --- 
-      id: 1
-      name: Frog
-      notes: I am a Frog!
-      nice: false
-    EOS
-  end
-  
-  it "should serialize to XML" do
-    Animal.first(:name => 'Frog').to_xml.should == <<-EOS.compress_lines(false)
-      <animal id="1">
-        <name>Frog</name>
-        <notes>I am a Frog!</notes>
-        <nice>false</nice>
-      </animal>
-    EOS
-    
-    san_diego_zoo = Zoo.first(:name => 'San Diego')
-    san_diego_zoo.to_xml.should == <<-EOS.compress_lines(false)
-      <zoo id="2">
-        <name>San Diego</name>
-        <notes/>
-        <updated_at>#{san_diego_zoo.updated_at.dup}</updated_at>
-      </zoo>
-    EOS
-  end
-  
-  it "should serialize to JSON" do
-    
-    Animal.first(:name => 'Frog').to_json.should == <<-EOS.compress_lines
-      {
-        "id": 1,
-        "name": "Frog",
-        "notes": "I am a Frog!",
-        "nice": false
-      }
-    EOS
-    
-    san_diego_zoo = Zoo.first(:name => 'San Diego')
-    san_diego_zoo.to_json.should == <<-EOS.compress_lines
-      {
-        "id": 2,
-        "name": "San Diego",
-        "notes": null,
-        "updated_at": #{san_diego_zoo.updated_at.dup.to_json}
-      }
-    EOS
-  end
-  
-end

data/spec/support/silence_spec.rb

@@ -1,15 +0,0 @@
-require File.dirname(__FILE__) + "/../spec_helper"
-
-describe "Kernel#silence_warnings" do
-  
-  it "should not warn" do
-    $VERBOSE.should_not be_nil
-    
-    silence_warnings do
-      $VERBOSE.should be_nil
-    end
-    
-    $VERBOSE.should_not be_nil
-  end
-  
-end

data/spec/support/string_spec.rb

@@ -1,7 +0,0 @@
-describe DataMapper::Support::String do
-  
-  it "should translate" do
-    "%s is great!".t('DataMapper').should eql("DataMapper is great!")
-  end
-  
-end

data/spec/support/struct_spec.rb

@@ -1,12 +0,0 @@
-require File.dirname(__FILE__) + "/../spec_helper"
-
-describe Struct do
-  
-  it "should have attributes" do
-    
-    s = Struct.new(:name).new('bob')
-    s.attributes.should == { :name => 'bob' }
-    
-  end
-  
-end

data/spec/support/typed_set_spec.rb

@@ -1,66 +0,0 @@
-require File.dirname(__FILE__) + "/../spec_helper"
-
-describe DataMapper::Support::TypedSet do
-  
-  it "should accept objects of a defined type, and raise for others" do
-
-    s = DataMapper::Support::TypedSet.new(Zoo, Animal)
-
-    lambda do
-      s << Zoo.new
-      s.size.should == 1
-    end.should_not raise_error(ArgumentError)
-
-    lambda do
-      s << Animal.new
-      s.size.should == 2
-    end.should_not raise_error(ArgumentError)
-
-    lambda do
-      s << Exhibit.new
-      s.size.should == 2
-    end.should raise_error(ArgumentError)
-
-  end
-
-  it "should be sorted" do
-
-    s = DataMapper::Support::TypedSet.new(Numeric)
-
-    s << 8
-    s << 4
-    s << 9
-    s << 27
-    s << 30
-    s << 1
-    s << 0
-    s << 5
-    s << 3
-
-    s.entries.first.should eql(0)
-    s.entries.last.should eql(30)
-  end
-
-  it "should respond to blank?" do
-    s = DataMapper::Support::TypedSet.new(Numeric)
-    s.should be_blank
-
-    s << 4
-    s.should_not be_blank
-  end
-
-  it "should return the combined entries for two sets" do
-    a = DataMapper::Support::TypedSet.new(Numeric)
-    b = DataMapper::Support::TypedSet.new(Numeric)
-
-    a << 1 << 2 << 3
-    b << 4 << 5 << 6 << 3
-
-    c = (a + b)
-    c.should have(6).entries
-    c.entries.should == [ 1, 2, 3, 4, 5, 6 ]
-
-    lambda { (c + nil) }.should_not raise_error
-  end
-
-end

data/spec/symbolic_operators_spec.rb

@@ -1,27 +0,0 @@
-require File.dirname(__FILE__) + "/spec_helper"
-
-describe Symbol::Operator do
-  
-  before(:all) do
-    fixtures(:people)
-  end
-  
-  it 'should use greater_than_or_equal_to to limit results' do
-    Person.all(:age.gte => 28).size.should == 3
-  end
-  
-  it 'use an Array for in-clauses' do
-    family = Person.all(:id => [1, 2, 4])
-    family[0].name.should == 'Sam'
-    family[1].name.should == 'Amy'
-    family[2].name.should == 'Josh'
-  end
-  
-  it 'use "not" for not-equal operations' do
-    Person.all(:name.not => 'Bob').size.should == 4
-  end
-  
-  it 'age should not be nil' do
-    Person.all(:age.not => nil).size.should == 5
-  end
-end

data/spec/table_spec.rb

@@ -1,79 +0,0 @@
-require File.dirname(__FILE__) + "/spec_helper"
-
-describe DataMapper::Adapters::Sql::Mappings::Table do
-  it "should return all columns from the database" do
-    table = database.adapter.schema.database_tables.detect{|table| table.name == "zoos"}
-    columns = table.database_columns
-    columns.size.should == database.schema[Zoo].columns.size
-    columns.each { |column| column.should be_a_kind_of( DataMapper::Adapters::Sql::Mappings::Column ) }
-  end
-  
-  it "should return the default for a column from the database" do
-    table = database.adapter.schema.database_tables.detect{|table| table.name == "animals"}
-    columns = table.database_columns
-    
-    column1 = columns.detect{|column| column.name == :name }
-    column1.default.should == "No Name"
-    
-    column2 = columns.detect{|column| column.name == :nice }
-    column2.default.should == nil
-  end
-  
-  it "should return the nullability for a column from the database" do
-    table = database.adapter.schema.database_tables.detect{|table| table.name == "animals"}
-    columns = table.database_columns
-    
-    column1 = columns.detect{|column| column.name == :id }
-    column1.nullable?.should be_false
-    
-    column2 = columns.detect{|column| column.name == :nice }
-    column2.nullable?.should be_true
-  end
-  
-  it "should create sql for composite unique indexes" do
-    class Cage #< DataMapper::Base # please do not remove this
-      include DataMapper::Persistence
-      
-      property :name, :string
-      property :cage_id, :integer
-      
-      index [:name, :cage_id], :unique => true
-    end
-    
-    index_sql = database.adapter.table(Cage).to_create_composite_index_sql
-    index_sql[0].should match(/CREATE UNIQUE INDEX cages_name_cage_id_index/)
-  end
-  
-  it "should create sql for composite indexes" do
-    class Lion #< DataMapper::Base # please do not remove this
-      include DataMapper::Persistence
-
-      property :name, :string
-      property :tamer_id, :integer
-      
-      index [:name, :tamer_id]
-    end
-    
-    index_sql = database.adapter.table(Lion).to_create_composite_index_sql
-    index_sql[0].should match(/CREATE INDEX lions_name_tamer_id_index/)
-  end
-  
-  it "should create sql for multiple composite indexes" do
-    class Course #< DataMapper::Base # please do not remove this
-      include DataMapper::Persistence
-
-      property :code, :string
-      property :name, :string
-      property :description, :text
-      property :department_id, :integer
-      property :professor_id, :integer
-      
-      index [:code, :name], :unique => true
-      index [:department_id, :professor_id], :unique => true
-    end
-    
-    index_sql = database.adapter.table(Course).to_create_composite_index_sql
-    index_sql[0].should match(/CREATE UNIQUE INDEX courses_code_name_index/)
-    index_sql[1].should match(/CREATE UNIQUE INDEX courses_department_id_professor_id_index/)    
-  end
-end

data/spec/types/string.rb

@@ -1,81 +0,0 @@
-require File.dirname(__FILE__) + "/../spec_helper"
-
-describe DataMapper::Types::String do
-  it "should look like a String" do
-    DataMapper::Types::String.new("duh").should be_a_kind_of(String)
-  end
-
-  it "should answer for :string" do
-    DataMapper::Types::TYPE_MAP[:string].should == DataMapper::Types::String
-  end
-
-  it "should be ready to replace Strings" do
-    DataMapper::Types::TYPE_MAP[String].should == DataMapper::Types::String
-  end
-
-  describe "with validations" do
-
-    it "should catch length errors" do
-      nval = mock("length validator")
-      nval.should_receive(:<)
-
-      DataMapper::Validations::NumberValidator.should_receive(:new).and_return(nval)
-
-      class T < DataMapper::Types::String
-        length < 25
-      end
-
-      inst = T.new("Whatever")
-
-      nval.should_receive(:errors_for).with(inst.length).and_return(["error"])
-
-      inst.should_not be_valid
-      inst.errors.should have_exactly(1).item
-      inst.errors[0].should == "error"
-    end
-
-    it "should catch match errors" do
-      sval = mock("match validator")
-      sval.should_receive(:matches)
-
-      DataMapper::Validations::StringValidator.should_receive(:new).and_return(sval)
-
-      class R < DataMapper::Types::String
-        matches /aabb/
-      end
-
-      inst = R.new("Whatever")
-
-      sval.should_receive(:errors_for).with(inst).and_return(["error"])
-
-      inst.should_not be_valid
-      inst.errors.should have_exactly(1).item
-      inst.errors[0].should == "error"
-    end
-
-    it "should be valid" do
-      nval = mock("length validator")
-      nval.should_receive(:<)
-
-      DataMapper::Validations::NumberValidator.should_receive(:new).and_return(nval)
-
-      sval = mock("match validator")
-      sval.should_receive(:matches)
-
-      DataMapper::Validations::StringValidator.should_receive(:new).and_return(sval)
-
-      class Q < DataMapper::Types::String
-        length < 25
-        matches /aabb/
-      end
-
-      inst = Q.new("Whatever")
-
-      nval.should_receive(:errors_for).with(inst.length).and_return([])
-      sval.should_receive(:errors_for).with(inst).and_return([])
-
-      inst.should be_valid
-      inst.errors.should be_empty
-    end
-  end
-end