dm-types 0.9.11 → 0.10.0

data/spec/unit/file_path_spec.rb

@@ -1,49 +1,70 @@
-require 'pathname'
-require Pathname(__FILE__).dirname.parent.expand_path + 'spec_helper'
+require 'spec_helper'
 
-describe DataMapper::Types::FilePath do
+try_spec do
+  describe DataMapper::Types::FilePath do
+    before do
+      @input = '/usr/bin/ruby'
+      @path  = Pathname.new(@input)
+    end
 
-  before(:each) do
-    @path_str = "/usr/bin/ruby"
-    @path = Pathname.new(@path_str)
-  end
+    describe '.dump' do
+      describe 'when input is a string' do
+        it 'does not modify input' do
+          DataMapper::Types::FilePath.dump(@input, :property).should == @input
+        end
+      end
 
-  describe ".dump" do
-    it "should return the file path as a String" do
-      DataMapper::Types::FilePath.dump(@path_str, :property).should == @path_str
-    end
+      describe 'when input is nil' do
+        it 'returns nil' do
+          DataMapper::Types::FilePath.dump(nil, :property).should be_nil
+        end
+      end
 
-    it "should return nil if the String is nil" do
-      DataMapper::Types::FilePath.dump(nil, :property).should be_nil
+      describe 'when input is a blank string' do
+        it 'returns nil' do
+          DataMapper::Types::FilePath.dump('', :property).should be_nil
+        end
+      end
     end
 
-    it "should return an empty file path if the String is empty" do
-      DataMapper::Types::FilePath.dump("", :property).should == ""
-    end
-  end
+    describe '.load' do
+      describe 'when value is a non-blank file path' do
+        it 'returns Pathname for a path' do
+          DataMapper::Types::FilePath.load(@input, :property).should == @path
+        end
+      end
 
-  describe ".load" do
-    it "should return the file path as a Pathname" do
-      DataMapper::Types::FilePath.load(@uri_str, :property).should == @uri
-    end
+      describe 'when value is nil' do
+        it 'return nil' do
+          DataMapper::Types::FilePath.load(nil, :property).should be_nil
+        end
+      end
 
-    it "should return nil if given nil" do
-      DataMapper::Types::FilePath.load(nil, :property).should be_nil
+      describe 'when value is a blank string' do
+        it 'returns nil' do
+          DataMapper::Types::FilePath.load('', :property).should be_nil
+        end
+      end
     end
 
-    it "should return an empty Pathname if given an empty String" do
-      DataMapper::Types::FilePath.load("", :property).should == Pathname.new("")
-    end
-  end
+    describe '.typecast' do
+      describe 'when a Pathname is given' do
+        it 'does not modify input' do
+          DataMapper::Types::FilePath.typecast(@path, :property).should == @path
+        end
+      end
 
-  describe '.typecast' do
-    it 'should do nothing if a Pathname is provided' do
-      DataMapper::Types::FilePath.typecast(@path, :property).should == @path
-    end
+      describe 'when a nil is given' do
+        it 'does not modify input' do
+          DataMapper::Types::FilePath.typecast(nil, :property).should == nil
+        end
+      end
 
-    it 'should defer to .load if a string is provided' do
-      DataMapper::Types::FilePath.should_receive(:load).with(@path_str, :property)
-      DataMapper::Types::FilePath.typecast(@path_str, :property)
+      describe 'when a string is given' do
+        it 'returns Pathname for given path' do
+          DataMapper::Types::FilePath.typecast(@input, :property).should == @path
+        end
+      end
     end
   end
 end

data/spec/unit/flag_spec.rb

@@ -1,86 +1,123 @@
-require 'pathname'
-require Pathname(__FILE__).dirname.parent.expand_path + 'spec_helper'
+require 'spec_helper'
 
-describe DataMapper::Types::Flag do
-
-  describe ".new" do
-    it "should create a Class" do
-      DataMapper::Types::Flag.new.should be_instance_of(Class)
-    end
-
-    it "should create unique a Class each call" do
-      DataMapper::Types::Flag.new.should_not == DataMapper::Types::Flag.new
-    end
+describe 'factory method for Flag type', :shared => true do
+  it 'creates a Class' do
+    DataMapper::Types::Flag.new.should be_instance_of(Class)
+  end
 
-    it "should use the arguments as the values in the @flag_map hash" do
-      DataMapper::Types::Flag.new(:first, :second, :third).flag_map.values.should == [:first, :second, :third]
-    end
+  it 'creates unique a Class each call' do
+    DataMapper::Types::Flag.new.should_not == DataMapper::Types::Flag.new
+  end
 
-    it "should create keys by the 2 power series for the @flag_map hash, staring at 1" do
-      DataMapper::Types::Flag.new(:one, :two, :three, :four, :five).flag_map.keys.should include(1, 2, 4, 8, 16)
-    end
+  it 'builds up flags map from arguments' do
+    DataMapper::Types::Flag.new(:first, :second, :third).flag_map.values.should == [ :first, :second, :third ]
   end
 
-  describe ".[]" do
-    it "should be an alias for the new method" do
-      DataMapper::Types::Flag.should_receive(:new).with(:uno, :dos, :tres)
-      DataMapper::Types::Flag[:uno, :dos, :tres]
-    end
+  it 'should create keys that is +1 for every increment for the @flag_map hash, staring at 0' do
+    DataMapper::Types::Flag.new(:one, :two, :three, :four, :five).flag_map.keys.should include(0, 1, 2, 3, 4)
   end
+end
 
-  describe ".dump" do
-    before(:each) do
-      @flag = DataMapper::Types::Flag[:first, :second, :third, :fourth, :fifth]
+try_spec do
+  describe DataMapper::Types::Flag do
+    describe '.new' do
+      it_should_behave_like 'factory method for Flag type'
     end
 
-    it "should return the key of the value match from the flag map" do
-      @flag.dump(:first, :property).should == 1
-      @flag.dump(:second, :property).should == 2
-      @flag.dump(:third, :property).should == 4
-      @flag.dump(:fourth, :property).should == 8
-      @flag.dump(:fifth, :property).should == 16
+    describe '.[]' do
+      it_should_behave_like 'factory method for Flag type'
     end
 
-    it "should return a binary flag built from the key values of all matches" do
-      @flag.dump([:first, :second], :property).should == 3
-      @flag.dump([:second, :fourth], :property).should == 10
-      @flag.dump([:first, :second, :third, :fourth, :fifth], :property).should == 31
-    end
+    describe '.dump' do
+      before :all do
+        @flag = DataMapper::Types::Flag[:first, :second, :third, :fourth, :fifth]
+      end
 
-    it "should return a binary flag built from the key values of all matches even if strings" do
-      @flag.dump(["first", "second"], :property).should == 3
-      @flag.dump(["second", "fourth"], :property).should == 10
-      @flag.dump(["first", "second", "third", "fourth", "fifth"], :property).should == 31
-    end
+      describe 'when argument matches a value in the flag map' do
+        before :all do
+          @result = @flag.dump(:first, :property)
+        end
 
-    it "should return 0 if there is no match" do
-      @flag.dump(:zero, :property).should == 0
-    end
-  end
+        it 'returns flag bit of value' do
+          @result.should == 1
+        end
+      end
 
-  describe ".load" do
-    before(:each) do
-      @flag = DataMapper::Types::Flag[:uno, :dos, :tres, :cuatro, :cinco]
-    end
+      describe 'when argument matches 2nd value in the flag map' do
+        before :all do
+          @result = @flag.dump(:second, :property)
+        end
 
-    it "should return the value of the key match from the flag map" do
-      @flag.load(1,  :property).should == [:uno]
-      @flag.load(2,  :property).should == [:dos]
-      @flag.load(4,  :property).should == [:tres]
-      @flag.load(8,  :property).should == [:cuatro]
-      @flag.load(16, :property).should == [:cinco]
-    end
+        it 'returns flag bit of value' do
+          @result.should == 2
+        end
+      end
+
+      describe 'when argument matches multiple Symbol values in the flag map' do
+        before :all do
+          @result = @flag.dump([ :second, :fourth ], :property)
+        end
+
+        it 'builds binary flag from key values of all matches' do
+          @result.should == 10
+        end
+      end
+
+      describe 'when argument matches multiple string values in the flag map' do
+        before :all do
+          @result = @flag.dump(['first', 'second', 'third', 'fourth', 'fifth'], :property)
+        end
+
+        it 'builds binary flag from key values of all matches' do
+          @result.should == 31
+        end
+      end
+
+      describe 'when argument does not match a single value in the flag map' do
+        before :all do
+          @result = @flag.dump(:zero, :property)
+        end
 
-    it "should return an array of all flags matches" do
-      @flag.load(3,  :property).should include(:uno, :dos)
-      @flag.load(10, :property).should include(:dos, :cuatro)
-      @flag.load(31, :property).should include(:uno, :dos, :tres, :cuatro, :cinco)
+        it 'returns zero' do
+          @result.should == 0
+        end
+      end
     end
 
-    it "should return an empty array if there is no key" do
-      @flag.load(-1,  :property).should == []
-      @flag.load(nil, :property).should == []
-      @flag.load(32,  :property).should == []
+    describe '.load' do
+      before :all do
+        @flag = DataMapper::Types::Flag[:uno, :dos, :tres, :cuatro, :cinco]
+      end
+
+      describe 'when argument matches a key in the flag map' do
+        before :all do
+          @result = @flag.load(4,  :property)
+        end
+
+        it 'returns array with a single matching element' do
+          @result.should == [ :tres ]
+        end
+      end
+
+      describe 'when argument matches multiple keys in the flag map' do
+        before :all do
+          @result = @flag.load(10, :property)
+        end
+
+        it 'returns array of matching values' do
+          @result.should == [ :dos, :cuatro ]
+        end
+      end
+
+      describe 'when argument does not match a single key in the flag map' do
+        before :all do
+          @result = @flag.load(nil, :property)
+        end
+
+        it 'returns an empty array' do
+          @result.should == []
+        end
+      end
     end
   end
 end

data/spec/unit/ip_address_spec.rb

@@ -1,56 +1,106 @@
-require 'pathname'
-require Pathname(__FILE__).dirname.parent.expand_path + 'spec_helper'
+require 'spec_helper'
 
-describe DataMapper::Types::IPAddress do
+try_spec do
+  describe DataMapper::Types::IPAddress do
+    before :all do
+      @stored = '81.20.130.1'
+      @input  = IPAddr.new(@stored)
+    end
 
-  before(:each) do
-    @ip_str = "81.20.130.1"
-    @ip = IPAddr.new(@ip_str)
-  end
+    describe '.dump' do
+      describe 'when argument is an IP address given as Ruby object' do
+        before :all do
+          @result = DataMapper::Types::IPAddress.dump(@input, :property)
+        end
 
-  describe ".dump" do
-    it "should return the IP address as a string" do
-      DataMapper::Types::IPAddress.dump(@ip, :property).should == @ip_str
-    end
+        it 'dumps input into a string' do
+          @result.should == @stored
+        end
+      end
 
-    it "should return nil if the string is nil" do
-      DataMapper::Types::IPAddress.dump(nil, :property).should be_nil
-    end
+      describe 'when argument is nil' do
+        before :all do
+          @result = DataMapper::Types::IPAddress.dump(nil, :property)
+        end
 
-    it "should return an empty IP address if the string is empty" do
-      DataMapper::Types::IPAddress.dump("", :property).should == ""
-    end
-  end
+        it 'returns nil' do
+          @result.should be_nil
+        end
+      end
 
-  describe ".load" do
-    it "should return the IP address string as IPAddr" do
-      DataMapper::Types::IPAddress.load(@ip_str, :property).should == @ip
-    end
+      describe 'when input is a blank string' do
+        before :all do
+          @result = DataMapper::Types::IPAddress.dump('', :property)
+        end
 
-    it "should return nil if given nil" do
-      DataMapper::Types::IPAddress.load(nil, :property).should be_nil
+        it 'retuns a blank string' do
+          @result.should == ''
+        end
+      end
     end
 
-    it "should return an empty IP address if given an empty string" do
-      DataMapper::Types::IPAddress.load("", :property).should == IPAddr.new("0.0.0.0")
-    end
+    describe '.load' do
+      describe 'when argument is a valid IP address as a string' do
+        before :all do
+          @result = DataMapper::Types::IPAddress.load(@stored, :property)
+        end
 
-    it 'should raise an ArgumentError if given something else' do
-      lambda {
-        DataMapper::Types::IPAddress.load([], :property)
-      }.should raise_error(ArgumentError, '+value+ must be nil or a String')
-    end
-  end
+        it 'returns IPAddr instance from stored value' do
+          @result.should == @input
+        end
+      end
 
-  describe '.typecast' do
-    it 'should do nothing if an IpAddr is provided' do
-      DataMapper::Types::IPAddress.typecast(@ip, :property).should == @ip
+      describe 'when argument is nil' do
+        before :all do
+          @result = DataMapper::Types::IPAddress.load(nil, :property)
+        end
+
+        it 'returns nil' do
+          @result.should be_nil
+        end
+      end
+
+      describe 'when argument is a blank string' do
+        before :all do
+          @result = DataMapper::Types::IPAddress.load('', :property)
+        end
+
+        it 'returns IPAddr instance from stored value' do
+          @result.should == IPAddr.new('0.0.0.0')
+        end
+      end
+
+      describe 'when argument is an Array instance' do
+        before :all do
+          @operation = lambda { DataMapper::Types::IPAddress.load([], :property) }
+        end
+
+        it 'raises ArgumentError with a meaningful message' do
+          @operation.should raise_error(ArgumentError, '+value+ must be nil or a String')
+        end
+      end
     end
 
-    it 'should defer to .load if a string is provided' do
-      DataMapper::Types::IPAddress.should_receive(:load).with(@ip_str, :property)
-      DataMapper::Types::IPAddress.typecast(@ip_str, :property)
+    describe '.typecast' do
+      describe 'when argument is an IpAddr object' do
+        before :all do
+          @result = DataMapper::Types::IPAddress.typecast(@input, :property)
+        end
+
+        it 'does not change the value' do
+          @result.should == @input
+        end
+      end
+
+      describe 'when argument is a valid IP address as a string' do
+        before :all do
+          @result = DataMapper::Types::IPAddress.typecast(@stored, :property)
+        end
+
+        it 'instantiates IPAddr instance' do
+          @result.should == @input
+        end
+      end
     end
   end
-
 end

data/spec/unit/json_spec.rb

@@ -1,53 +1,120 @@
-require 'pathname'
-require Pathname(__FILE__).dirname.parent.expand_path + 'spec_helper'
+require 'spec_helper'
+require 'shared/identity_function_group'
 
-describe DataMapper::Types::Json, ".load" do
-  it 'should return nil if nil is provided' do
-    DataMapper::Types::Json.load(nil, :property).should be_nil
-  end
+try_spec do
+  describe DataMapper::Types::Json do
+    describe '.load' do
+      describe 'when nil is provided' do
+        it 'returns nil' do
+          DataMapper::Types::Json.load(nil, :property).should be_nil
+        end
+      end
 
-  it 'should parse the value if a string is provided' do
-    JSON.should_receive(:load).with('json_string').once
-    DataMapper::Types::Json.load('json_string', :property)
-  end
+      describe 'when Json encoded primitive string is provided' do
+        it 'returns decoded value as Ruby string' do
+          DataMapper::Types::Json.load(JSON.dump(:value => 'JSON encoded string'), :property).should == { 'value' => 'JSON encoded string' }
+        end
+      end
 
-  it 'should raise an ArgumentError if something else is given' do
-    lambda {
-      DataMapper::Types::Json.load(:sym, :property)
-    }.should raise_error(ArgumentError, '+value+ must be nil or a String')
-  end
-end
+      describe 'when something else is provided' do
+        it 'raises ArgumentError with a meaningful message' do
+          lambda {
+            DataMapper::Types::Json.load(:sym, :property)
+          }.should raise_error(ArgumentError, '+value+ of a property of JSON type must be nil or a String')
+        end
+      end
+    end
 
-describe DataMapper::Types::Json, ".dump" do
-  it 'should return nil if the value is nil' do
-    DataMapper::Types::Json.dump(nil, :property).should be_nil
-  end
+    describe '.dump' do
+      describe 'when nil is provided' do
+        it 'returns nil' do
+          DataMapper::Types::Json.dump(nil, :property).should be_nil
+        end
+      end
 
-  it 'should do nothing if the value is a string' do
-    JSON.should_not_receive(:dump)
-    DataMapper::Types::Json.dump('', :property).should be_kind_of(String)
-  end
+      describe 'when Json encoded primitive string is provided' do
+        it 'does not do double encoding' do
+          DataMapper::Types::Json.dump('Json encoded string', :property).should == 'Json encoded string'
+        end
+      end
 
-  it 'should dump to a JSON string otherwise' do
-    JSON.should_receive(:dump).with([]).once
-    DataMapper::Types::Json.dump([], :property)
-  end
-end
+      describe 'when regular Ruby string is provided' do
+        it 'dumps argument to Json' do
+          DataMapper::Types::Json.dump('dump me (to JSON)', :property).should == 'dump me (to JSON)'
+        end
+      end
 
-describe DataMapper::Types::Json, ".typecast" do
-  it 'should parse the value if a string is provided' do
-    JSON.should_receive(:load).with('json_string')
+      describe 'when Ruby array is provided' do
+        it 'dumps argument to Json' do
+          DataMapper::Types::Json.dump([1, 2, 3], :property).should == '[1,2,3]'
+        end
+      end
 
-    DataMapper::Types::Json.typecast('json_string', :property)
-  end
+      describe 'when Ruby hash is provided' do
+        it 'dumps argument to Json' do
+          DataMapper::Types::Json.dump({ :datamapper => 'Data access layer in Ruby' }, :property).
+            should == '{"datamapper":"Data access layer in Ruby"}'
+        end
+      end
+    end
 
-  it 'should leave the value alone if an array is given' do
-    JSON.should_not_receive(:load)
-    DataMapper::Types::Json.typecast([], :property)
-  end
+    describe '.typecast' do
+      class SerializeMe
+        attr_accessor :name
+      end
+
+      describe 'when given instance of a Hash' do
+        before :all do
+          @input = { :library => 'DataMapper' }
+
+          @result = DataMapper::Types::Json.typecast(@input, :property)
+        end
+
+        it_should_behave_like 'identity function'
+      end
+
+      describe 'when given instance of an Array' do
+        before :all do
+          @input = %w[ dm-core dm-more ]
+
+          @result = DataMapper::Types::Json.typecast(@input, :property)
+        end
+
+        it_should_behave_like 'identity function'
+      end
+
+      describe 'when given nil' do
+        before :all do
+          @input = nil
+
+          @result = DataMapper::Types::Json.typecast(@input, :property)
+        end
+
+        it_should_behave_like 'identity function'
+      end
+
+      describe 'when given JSON encoded value' do
+        before :all do
+          @input = '{ "value": 11 }'
+
+          @result = DataMapper::Types::Json.typecast(@input, :property)
+        end
+
+        it 'decodes value from JSON' do
+          @result.should == { 'value' => 11 }
+        end
+      end
+
+      describe 'when given instance of a custom class' do
+        before :all do
+          @input      = SerializeMe.new
+          @input.name = 'Hello!'
+
+          # @result = DataMapper::Types::Json.typecast(@input, :property)
+        end
 
-  it 'should leave the value alone if a hash is given' do
-    JSON.should_not_receive(:load)
-    DataMapper::Types::Json.typecast({}, :property)
+        it 'attempts to load value from JSON string'
+      end
+    end
   end
 end