dm-core 0.9.11 → 0.10.0

data/spec/unit/type_map_spec.rb

@@ -1,114 +0,0 @@
-require 'pathname'
-require Pathname(__FILE__).dirname.expand_path.parent + 'spec_helper'
-
-describe DataMapper::TypeMap do
-
-  before(:each) do
-    @tm = DataMapper::TypeMap.new
-  end
-
-  describe "#map" do
-    it "should return a type map chain" do
-      @tm.map(String).should be_instance_of(DataMapper::TypeMap::TypeChain)
-    end
-
-    it "should return the original chain if the type has already been mapped" do
-      tc = @tm.map(String)
-      @tm.map(String).should == tc
-    end
-  end
-
-  describe "#lookup" do
-    it "should the primitive's mapping the class has a primitive type" do
-      @tm.map(String).to(:varchar)
-
-      lambda { @tm.lookup(DM::Text) }.should_not raise_error
-    end
-
-    it "should merge in the parent type map's translated match" do
-
-    end
-
-    describe "#lookup_from_map" do
-      it "should merge the translated type match into the parent match" do
-        @tm.map(String).to(:varchar)
-
-        child = DataMapper::TypeMap.new(@tm)
-        child.map(String).with(:size => 100)
-
-        child.lookup_from_map(String).should == {:primitive => :varchar, :size => 100}
-      end
-    end
-
-    describe "#lookup_by_type" do
-      it "should raise an exception if the type is not mapped and does not have a primitive" do
-        klass = Class.new
-        lambda { @tm.lookup(klass) }.should raise_error("Type #{klass} must have a default primitive or type map entry")
-      end
-    end
-  end
-
-  describe "#map" do
-    it "should create a new TypeChain if there is no match" do
-      @tm.chains.should_not have_key(String)
-
-      DataMapper::TypeMap::TypeChain.should_receive(:new)
-
-      @tm.map(String)
-    end
-
-    it "should not create a new TypeChain if there is a match" do
-      @tm.map(String)
-
-      DataMapper::TypeMap::TypeChain.should_not_receive(:new)
-
-      @tm.map(String)
-    end
-  end
-
-  describe DataMapper::TypeMap::TypeChain do
-    describe "#to" do
-      it "should be a setter for @primitive" do
-        tc = DataMapper::TypeMap::TypeChain.new
-
-        lambda { tc.to(:primitive) }.should change { tc.primitive }.to(:primitive)
-      end
-
-      it "should return itself" do
-        tc = DataMapper::TypeMap::TypeChain.new
-
-        tc.to(:primitive).should == tc
-      end
-    end
-
-    describe "#with" do
-      it "should return itself" do
-        tc = DataMapper::TypeMap::TypeChain.new
-
-        tc.with(:key => :value).should == tc
-      end
-
-      it "should raise an error if the argument is not a hash" do
-        tc = DataMapper::TypeMap::TypeChain.new
-
-        lambda { tc.with(:key) }.should raise_error("method 'with' expects a hash")
-      end
-
-      it "should merge the argument hash into the attributes hash" do
-        tc = DataMapper::TypeMap::TypeChain.new
-
-        tc.with(:key => :value).with(:size => 10).attributes.should == {:key => :value, :size => 10}
-      end
-    end
-
-    describe "#translate" do
-      it "should merge the attributes hash with the primitive value" do
-        DataMapper::TypeMap::TypeChain.new.to(:int).with(:size => 10).translate.should == {:primitive => :int, :size => 10}
-      end
-
-      it "should overwrite any :primitive entry set using the 'with' method" do
-        DataMapper::TypeMap::TypeChain.new.to(:int).with(:primitive => :varchar).translate.should == {:primitive => :int}
-      end
-    end
-  end
-end

data/spec/unit/type_spec.rb

@@ -1,119 +0,0 @@
-require File.expand_path(File.join(File.dirname(__FILE__), '..', 'spec_helper'))
-
-describe DataMapper::Type do
-
-  before(:each) do
-    class TestType < DataMapper::Type
-      primitive String
-      size 10
-    end
-
-    class TestType2 < DataMapper::Type
-      primitive String
-      size 10
-
-      def self.load(value, property)
-        value.reverse
-      end
-
-      def self.dump(value, property)
-        value.reverse
-      end
-    end
-
-    class TestResource
-      include DataMapper::Resource
-    end
-
-    class TestType3 < DataMapper::Type
-      primitive String
-      size 10
-      attr_accessor :property, :value
-
-      def self.load(value, property)
-        type = self.new
-        type.property = property
-        type.value    = value
-        type
-      end
-
-      def self.dump(value, property)
-        value.value
-      end
-    end
-  end
-
-  it "should have the same PROPERTY_OPTIONS array as DataMapper::Property" do
-    DataMapper::Type::PROPERTY_OPTIONS.should == DataMapper::Property::PROPERTY_OPTIONS
-  end
-
-  it "should create a new type based on String primitive" do
-    TestType.primitive.should == String
-  end
-
-  it "should have size of 10" do
-    TestType.size.should == 10
-  end
-
-  it "should have options hash exactly equal to options specified in custom type" do
-    #ie. it should not include null elements
-    TestType.options.should == { :size => 10, :length => 10 }
-  end
-
-  it "should have length aliased to size" do
-    TestType.length.should == TestType.size
-  end
-
-  it "should pass through the value if load wasn't overridden" do
-    TestType.load("test", nil).should == "test"
-  end
-
-  it "should pass through the value if dump wasn't overridden" do
-    TestType.dump("test", nil).should == "test"
-  end
-
-  it "should not raise NotImplementedException if load was overridden" do
-    TestType2.dump("helo", nil).should == "oleh"
-  end
-
-  it "should not raise NotImplementedException if dump was overridden" do
-    TestType2.load("oleh", nil).should == "helo"
-  end
-
-  describe "using a custom type" do
-    before do
-      @property = DataMapper::Property.new TestResource, :name, TestType3, {}
-    end
-
-    it "should return a object of the same type" do
-      TestType3.load("helo", @property).class.should == TestType3
-    end
-
-    it "should contain the property" do
-      TestType3.load("helo", @property).property.should == @property
-    end
-
-    it "should contain the value" do
-      TestType3.load("helo", @property).value.should == "helo"
-    end
-
-    it "should return the value" do
-      obj = TestType3.load("helo", @property)
-      TestType3.dump(obj, @property).should == "helo"
-    end
-  end
-
-  describe "using def Type" do
-    before do
-      @class = Class.new(DataMapper::Type(String, :size => 20))
-    end
-
-    it "should be of the specified type" do
-      @class.primitive.should == String
-    end
-
-    it "should have the right options set" do
-      @class.size.should == 20
-    end
-  end
-end