dm-types 0.9.11 → 0.10.0

data/spec/unit/csv_spec.rb

@@ -1,35 +1,119 @@
-require 'pathname'
-require Pathname(__FILE__).dirname.parent.expand_path + 'spec_helper'
+require 'spec_helper'
 
-describe DataMapper::Types::Csv, ".load" do
-  it 'should parse the value if a string is provided' do
-    CSV.should_receive(:parse).with('csv_string').once
-    DataMapper::Types::Csv.load('csv_string', :property)
-  end
+try_spec do
+  describe DataMapper::Types::Csv do
+    describe '.load' do
+      describe 'when argument is a comma separated string' do
+        before :all do
+          @input  = 'uno,due,tre'
+          @result = DataMapper::Types::Csv.load(@input, :property)
+        end
 
-  it 'should do nothing if the value is a string' do
-    CSV.should_not_receive(:parse)
-    DataMapper::Types::Csv.load([], :property).should == []
-  end
+        it 'parses the argument using CVS parser' do
+          @result.should == [ %w[ uno due tre ] ]
+        end
+      end
 
-  it 'should return nil otherwise' do
-    DataMapper::Types::Csv.load({},  :property).should == nil
-    DataMapper::Types::Csv.load(nil, :property).should == nil
-  end
-end
+      describe 'when argument is an empty array' do
+        before :all do
+          @input    = []
+          @result   = DataMapper::Types::Csv.load(@input, :property)
+        end
 
-describe DataMapper::Types::Csv, ".dump" do
-  it 'should dump to CSV' do
-    DataMapper::Types::Csv.dump([[1, 2, 3]], :property).should == "1,2,3\n"
-  end
+        it 'does not change the input' do
+          @result.should == @input
+        end
+      end
 
-  it 'should do nothing if the value is a string' do
-    CSV.should_not_receive(:generate)
-    DataMapper::Types::Csv.dump('string', :property).should == 'string'
-  end
+      describe 'when argument is an empty hash' do
+        before :all do
+          @input    = {}
+          @result   = DataMapper::Types::Csv.load(@input, :property)
+        end
+
+        it 'returns nil' do
+          @result.should be_nil
+        end
+      end
+
+      describe 'when argument is nil' do
+        before :all do
+          @input    = nil
+          @result   = DataMapper::Types::Csv.load(@input, :property)
+        end
+
+        it 'returns nil' do
+          @result.should be_nil
+        end
+      end
+
+      describe 'when argument is an integer' do
+        before :all do
+          @input    = 7
+          @result   = DataMapper::Types::Csv.load(@input, :property)
+        end
+
+        it 'returns nil' do
+          @result.should be_nil
+        end
+      end
+
+      describe 'when argument is a float' do
+        before :all do
+          @input    = 7.0
+          @result   = DataMapper::Types::Csv.load(@input, :property)
+        end
+
+        it 'returns nil' do
+          @result.should be_nil
+        end
+      end
+    end
+
+    describe '.dump' do
+      describe 'when value is a list of lists' do
+        before :all do
+          @input  = [ %w[ uno due tre ], %w[ uno dos tres ] ]
+          @result = DataMapper::Types::Csv.dump(@input, :property)
+        end
+
+        it 'dumps value to comma separated string' do
+          @result.should == "uno,due,tre\nuno,dos,tres\n"
+        end
+      end
+
+      describe 'when value is a string' do
+        before :all do
+          @input  = 'beauty hides in the deep'
+          @result = DataMapper::Types::Csv.dump(@input, :property)
+        end
+
+        it 'returns input as is' do
+          @result.should == @input
+        end
+      end
+
+      describe 'when value is nil' do
+        before :all do
+          @input  = nil
+          @result = DataMapper::Types::Csv.dump(@input, :property)
+        end
+
+        it 'returns nil' do
+          @result.should be_nil
+        end
+      end
+
+      describe 'when value is a hash' do
+        before :all do
+          @input  = { :library => 'DataMapper', :language => 'Ruby' }
+          @result = DataMapper::Types::Csv.dump(@input, :property)
+        end
 
-  it 'should return nil otherwise' do
-    DataMapper::Types::Csv.dump({},  :property).should == nil
-    DataMapper::Types::Csv.dump(nil, :property).should == nil
+        it 'returns nil' do
+          @result.should be_nil
+        end
+      end
+    end
   end
 end

data/spec/unit/enum_spec.rb

@@ -1,96 +1,137 @@
-require 'pathname'
-require Pathname(__FILE__).dirname.parent.expand_path + 'spec_helper'
-
-describe DataMapper::Types::Enum do
-
-  describe ".new" do
-    it "should create a Class" do
-      DataMapper::Types::Enum.new.should be_instance_of(Class)
-    end
-
-    it "should create unique a Class each call" do
-      DataMapper::Types::Enum.new.should_not == DataMapper::Types::Enum.new
-    end
-
-    it "should use the arguments as the values in the @flag_map hash" do
-      DataMapper::Types::Enum.new(:first, :second, :third).flag_map.values.should == [:first, :second, :third]
-    end
-
-    it "should create incremental keys for the @flag_map hash, staring at 1" do
-      DataMapper::Types::Enum.new(:one, :two, :three, :four).flag_map.keys.should == (1..4).to_a
-    end
-
-    it "should have an Integer primitive type" do
-      DataMapper::Types::Enum.new.primitive.should == Integer
-    end
-  end
-
-  describe ".[]" do
-    it "should be an alias for the new method" do
-      DataMapper::Types::Enum.should_receive(:new).with(:uno, :dos, :tres)
-      DataMapper::Types::Enum[:uno, :dos, :tres]
-    end
-  end
-
-  describe ".dump" do
-    before(:each) do
-      @enum = DataMapper::Types::Enum[:first, :second, :third]
-    end
-
-    it "should return the key of the value match from the flag map" do
-      @enum.dump(:first, :property).should == 1
-      @enum.dump(:second, :property).should == 2
-      @enum.dump(:third, :property).should == 3
-    end
-
-    it "should return nil if there is no match" do
-      @enum.dump(:zero, :property).should be_nil
-    end
-  end
-
-  describe ".load" do
-    before(:each) do
-      @enum = DataMapper::Types::Enum[:uno, :dos, :tres]
+require 'spec_helper'
+
+try_spec do
+  describe DataMapper::Types::Enum do
+    describe '.new' do
+      it 'returns a Class' do
+        DataMapper::Types::Enum.new.should be_instance_of(Class)
+      end
+
+      it 'returns an unique Class each time' do
+        DataMapper::Types::Enum.new.should_not == DataMapper::Types::Enum.new
+      end
+
+      it 'stores enumeration items' do
+        DataMapper::Types::Enum.new(:first, :second, :third).flag_map.values.should == [:first, :second, :third]
+      end
+
+      it 'assigns incremental numeric keys to enumeration items' do
+        DataMapper::Types::Enum.new(:one, :two, :three, :four).flag_map.keys.should == (1..4).to_a
+      end
+
+      it 'uses Integer as a primitive' do
+        DataMapper::Types::Enum.new.primitive.should == Integer
+      end
     end
 
-    it "should return the value of the key match from the flag map" do
-      @enum.load(1, :property).should == :uno
-      @enum.load(2, :property).should == :dos
-      @enum.load(3, :property).should == :tres
+    describe '.dump' do
+      before do
+        @enum = DataMapper::Types::Enum[:first, :second, :third]
+      end
+
+      it 'should return the key of the value match from the flag map' do
+        @enum.dump(:first, :property).should == 1
+        @enum.dump(:second, :property).should == 2
+        @enum.dump(:third, :property).should == 3
+      end
+
+      describe 'when there is no match' do
+        it 'should return nil' do
+          @enum.dump(:zero, :property).should be_nil
+        end
+      end
     end
 
-    it "should return nil if there is no key" do
-      @enum.load(-1, :property).should be_nil
+    describe '.load' do
+      before do
+        @enum = DataMapper::Types::Enum[:uno, :dos, :tres]
+      end
+
+      it 'returns the value of the key match from the flag map' do
+        @enum.load(1, :property).should == :uno
+        @enum.load(2, :property).should == :dos
+        @enum.load(3, :property).should == :tres
+      end
+
+      describe 'when there is no key' do
+        it 'returns nil' do
+          @enum.load(-1, :property).should be_nil
+        end
+      end
     end
-  end
-
-  describe ".typecast" do
-    it 'should attempt to use the Enum type' do
-      # Symbol.
-      @sym_enum = DataMapper::Types::Enum[:uno]
-      @sym_enum.typecast(:uno,  :property).should == :uno
-      @sym_enum.typecast("uno", :property).should == :uno
-
-      # String
-      @str_enum = DataMapper::Types::Enum["uno"]
-      @str_enum.typecast(:uno,  :property).should == "uno"
-      @str_enum.typecast("uno", :property).should == "uno"
-
-      # Integer
-      @int_enum = DataMapper::Types::Enum[1, 2, 3]
-      @int_enum.typecast(1,   :property).should == 1
-      @int_enum.typecast(1.1, :property).should == 1
-    end
-
-    it "should not throw an error when value is nil" do
-      @sym_enum = DataMapper::Types::Enum[:uno]
-      @sym_enum.typecast( nil, :property).should == nil
-
-      @str_enum = DataMapper::Types::Enum["uno"]
-      @str_enum.typecast( nil, :property).should == nil
 
-      @int_enum = DataMapper::Types::Enum[1, 2, 3]
-      @int_enum.typecast( nil, :property ).should == nil
+    describe '.typecast' do
+      describe 'of Enum created from a symbol' do
+        before :all do
+          @enum = DataMapper::Types::Enum[:uno]
+        end
+
+        describe 'when given a symbol' do
+          it 'uses Enum type' do
+            @enum.typecast(:uno,  :property).should == :uno
+          end
+        end
+
+        describe 'when given a string' do
+          it 'uses Enum type' do
+            @enum.typecast('uno', :property).should == :uno
+          end
+        end
+
+        describe 'when given nil' do
+          it 'returns nil' do
+            @enum.typecast( nil, :property).should == nil
+          end
+        end
+      end
+
+      describe 'of Enum created from integer list' do
+        before :all do
+          @enum = DataMapper::Types::Enum[1, 2, 3]
+        end
+
+        describe 'when given an integer' do
+          it 'uses Enum type' do
+            @enum.typecast(1, :property).should == 1
+          end
+        end
+
+        describe 'when given a float' do
+          it 'uses Enum type' do
+            @enum.typecast(1.1, :property).should == 1
+          end
+        end
+
+        describe 'when given nil' do
+          it 'returns nil' do
+            @enum.typecast( nil, :property).should == nil
+          end
+        end
+      end
+
+      describe 'of Enum created from a string' do
+        before :all do
+          @enum = DataMapper::Types::Enum['uno']
+        end
+
+        describe 'when given a symbol' do
+          it 'uses Enum type' do
+            @enum.typecast(:uno,  :property).should == 'uno'
+          end
+        end
+
+        describe 'when given a string' do
+          it 'uses Enum type' do
+            @enum.typecast('uno', :property).should == 'uno'
+          end
+        end
+
+        describe 'when given nil' do
+          it 'returns nil' do
+            @enum.typecast( nil, :property).should == nil
+          end
+        end
+      end
     end
   end
 end

data/spec/unit/epoch_time_spec.rb

@@ -1,37 +1,62 @@
-require 'pathname'
-require Pathname(__FILE__).dirname.parent.expand_path + 'spec_helper'
-
-describe DataMapper::Types::EpochTime do
-
-  describe ".dump" do
-    it "should accept Time objects" do
-      t = Time.now
-
-      DataMapper::Types::EpochTime.dump(t, :property).should == t.to_i
-    end
-
-    it "should accept DateTime objects" do
-      t = DateTime.now
-
-      DataMapper::Types::EpochTime.dump(t, :property).should == Time.parse(t.to_s).to_i
-    end
-
-    it "should accept Integer objects" do
-      t = Time.now.to_i
-
-      DataMapper::Types::EpochTime.dump(t, :property).should == t
-    end
-  end
-
-  describe ".load" do
-
-    it "should load null as nil" do
-      DataMapper::Types::EpochTime.load(nil, :property).should == nil
+require 'spec_helper'
+
+try_spec do
+  describe DataMapper::Types::EpochTime do
+    describe '.dump' do
+      describe 'when given Time instance' do
+        before :all do
+          @input = Time.now
+        end
+
+        it 'returns timestamp' do
+          DataMapper::Types::EpochTime.dump(@input, :property).should == @input.to_i
+        end
+      end
+
+      describe 'when given DateTime instance' do
+        before :all do
+          @input = DateTime.now
+        end
+
+        it 'returns timestamp' do
+          DataMapper::Types::EpochTime.dump(@input, :property).should == Time.parse(@input.to_s).to_i
+        end
+      end
+
+      describe 'when given an integer' do
+        before :all do
+          @input = Time.now.to_i
+        end
+
+        it 'returns value as is' do
+          DataMapper::Types::EpochTime.dump(@input, :property).should == @input
+        end
+      end
+
+      describe 'when given nil' do
+        before :all do
+          @input = nil
+        end
+
+        it 'returns value as is' do
+          DataMapper::Types::EpochTime.dump(@input, :property).should == @input
+        end
+      end
     end
 
-    it "should load #{Time.now.to_i} as Time.at(#{Time.now.to_i})" do
-      t = Time.now.to_i
-      DataMapper::Types::EpochTime.load(Time.now.to_i, :property).should == Time.at(t)
+    describe '.load' do
+      describe 'when value is nil' do
+        it 'returns nil' do
+          DataMapper::Types::EpochTime.load(nil, :property).should == nil
+        end
+      end
+
+      describe 'when value is an integer' do
+        it 'returns time object from timestamp' do
+          t = Time.now.to_i
+          DataMapper::Types::EpochTime.load(Time.now.to_i, :property).should == Time.at(t)
+        end
+      end
     end
   end
 end