virtus 0.0.10 → 0.1.0

data/spec/unit/virtus/attribute/collection/coerce_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+
+describe Virtus::Attribute::Collection, '#coerce' do
+  subject { attribute.coerce(value) }
+
+  let(:attribute)   { Class.new(described_class).new(:things, :member_type => member_type) }
+  let(:value)       { [ entry ] }
+  let(:entry)       { mock('entry') }
+  let(:member_type) { Virtus::Attribute::Object }
+
+  before do
+    value.should_receive(:respond_to?).with(:inject).and_return(respond_to_inject)
+  end
+  
+  context 'when coerced value responds to #inject' do
+    let(:respond_to_inject) { true }
+  
+    specify { expect { subject }.to raise_error(NotImplementedError) }
+  end
+
+  context 'when coerced value does not respond to #inject' do
+    let(:respond_to_inject) { false }
+
+    specify { should eql(value) }
+  end
+end

data/spec/unit/virtus/attribute/date/coerce_spec.rb

@@ -0,0 +1,47 @@
+require 'spec_helper'
+
+shared_examples_for 'a correct date' do
+  it          { should be_kind_of(Date) }
+  its(:year)  { should eql(year)        }
+  its(:month) { should eql(month)       }
+  its(:day)   { should eql(day)         }
+end
+
+describe Virtus::Attribute::Date, '#coerce' do
+  subject { attribute.coerce(value) }
+
+  let(:attribute) { described_class.new(:bday) }
+  let(:year)      { 2011                       }
+  let(:month)     { 4                          }
+  let(:day)       { 7                          }
+
+  context 'with a time' do
+    let(:value) { Time.local(year, month, day) }
+
+    it_should_behave_like 'a correct date'
+  end
+
+  context 'with a date time' do
+    let(:value) { DateTime.new(year, month, day) }
+
+    it_should_behave_like 'a correct date'
+  end
+
+  context 'with a hash' do
+    let(:value) { { :year => year, :month => month, :day => day } }
+
+    it_should_behave_like 'a correct date'
+  end
+
+  context 'with a string' do
+    let(:value) { "April #{day}th, #{year}" }
+
+    it_should_behave_like 'a correct date'
+  end
+
+  context 'with a non-date value' do
+    let(:value) { 'non-date' }
+
+    it { should equal(value) }
+  end
+end

data/spec/unit/virtus/attribute/date/value_coerced_spec.rb

@@ -0,0 +1,46 @@
+require 'spec_helper'
+
+describe Virtus::Attribute::Date, '#value_coerced?' do
+  subject { attribute.value_coerced?(value) }
+
+  let(:attribute) { described_class.new(:bday) }
+  let(:year)      { 2011                       }
+  let(:month)     { 4                          }
+  let(:day)       { 7                          }
+
+  context 'with a Date' do
+    let(:value) { Date.new(year, month, day) }
+
+    it { should be(true) }
+  end
+
+  context 'with a date time' do
+    let(:value) { DateTime.new(year, month, day) }
+
+    it { should be(true) }
+  end
+
+  context 'with a time' do
+    let(:value) { Time.local(year, month, day) }
+
+    it { should be(false) }
+  end
+
+  context 'with a hash' do
+    let(:value) { { :year => year, :month => month, :day => day } }
+
+    it { should be(false) }
+  end
+
+  context 'with a string' do
+    let(:value) { "April #{day}th, #{year}" }
+
+    it { should be(false) }
+  end
+
+  context 'with a non-date value' do
+    let(:value) { 'non-date' }
+
+    it { should be(false) }
+  end
+end

data/spec/unit/virtus/attribute/date_time/coerce_spec.rb

@@ -0,0 +1,68 @@
+require 'spec_helper'
+
+shared_examples_for 'a correct date time' do
+  it { should be_kind_of(DateTime) }
+
+  its(:year)  { should eql(year)  }
+  its(:month) { should eql(month) }
+  its(:day)   { should eql(day)   }
+  its(:hour)  { should eql(hour)  }
+  its(:min)   { should eql(min)   }
+  its(:sec)   { should eql(sec)   }
+end
+
+describe Virtus::Attribute::DateTime, '#coerce' do
+  subject { attribute.coerce(value) }
+
+  let(:attribute) { described_class.new(:bday) }
+  let(:year)      { 2011                       }
+  let(:month)     { 4                          }
+  let(:day)       { 7                          }
+  let(:hour)      { 1                          }
+  let(:min)       { 26                         }
+  let(:sec)       { 49                         }
+
+  context 'with a date' do
+    let(:hour)  { 0                          }
+    let(:min)   { 0                          }
+    let(:sec)   { 0                          }
+    let(:value) { Date.new(year, month, day) }
+
+    it_should_behave_like 'a correct date time'
+  end
+
+  context 'with a time' do
+    let(:value) { Time.local(year, month, day, hour, min, sec) }
+
+    it_should_behave_like 'a correct date time'
+  end
+
+  context 'with a hash' do
+    let(:value) { { :year => year, :month => month, :day => day, :hour => hour, :min => min, :sec => sec } }
+
+    it_should_behave_like 'a correct date time'
+  end
+
+  context 'with a string' do
+    context 'without hour, min and sec' do
+      let(:hour)  { 0                         }
+      let(:min)   { 0                         }
+      let(:sec)   { 0                         }
+      let(:value) { "April #{day}th, #{year}" }
+
+      it_should_behave_like 'a correct date time'
+    end
+
+    context 'with hour, min and sec' do
+      let(:value) { "April #{day}th, #{year}, #{hour}:#{min}:#{sec}" }
+
+      it_should_behave_like 'a correct date time'
+    end
+  end
+
+  context 'with a on-date value' do
+    let(:value) { 'non-date' }
+
+    it { should equal(value) }
+  end
+end

data/spec/unit/virtus/attribute/decimal/coerce_spec.rb

@@ -0,0 +1,117 @@
+require 'spec_helper'
+
+describe Virtus::Attribute::Decimal, '#coerce' do
+  subject { attribute.coerce(value) }
+
+  let(:attribute) { described_class.new(:price) }
+
+  context 'with 24.0 big decimal' do
+    let(:value) { BigDecimal('24.0') }
+
+    it { should eql(value) }
+  end
+
+  context 'with a zero string integer' do
+    let(:value) { '0' }
+
+    it { should eql(BigDecimal('0.0')) }
+  end
+
+  context 'with a positive string integer' do
+    let(:value) { '24' }
+
+    it { should eql(BigDecimal('24.0')) }
+  end
+
+  context 'with a negative string integer' do
+    let(:value) { '-24' }
+
+    it { should eql(BigDecimal('-24.0')) }
+  end
+
+  context 'with a zero string float' do
+    let(:value) { '0.0' }
+
+    it { should eql(BigDecimal('0.0')) }
+  end
+
+  context 'with a positive string float' do
+    let(:value) { '24.35' }
+
+    it { should eql(BigDecimal('24.35')) }
+  end
+
+  context 'with a negative string float' do
+    let(:value) { '-24.35' }
+
+    it { should eql(BigDecimal('-24.35')) }
+  end
+
+  context 'with a zero string float, with no leading digits' do
+    let(:value) { '.0' }
+
+    it { should eql(BigDecimal('0.0')) }
+  end
+
+  context 'with a positive string float, with no leading digits' do
+    let(:value) { '0.41' }
+
+    it { should eql(BigDecimal('0.41')) }
+  end
+
+  context 'with a zero integer' do
+    let(:value) { 0 }
+
+    it { should eql(BigDecimal('0.0')) }
+  end
+
+  context 'with a positive integer' do
+    let(:value) { 24 }
+
+    it { should eql(BigDecimal('24.0')) }
+  end
+
+  context 'with a negative integer' do
+    let(:value) { -24 }
+
+    it { should eql(BigDecimal('-24.0')) }
+  end
+
+  context 'with a positive bignum' do
+    let(:value) { 1311936052 }
+
+    it { should eql(BigDecimal('1311936052.0')) }
+  end
+
+  context 'with a negative bignum' do
+    let(:value) { -1311936052 }
+
+    it { should eql(BigDecimal('-1311936052.0')) }
+  end
+
+  context 'with a zero float' do
+    let(:value) { 0.0 }
+
+    it { should eql(BigDecimal('0.0')) }
+  end
+
+  context 'with a positive float' do
+    let(:value) { 24.35 }
+
+    it { should eql(BigDecimal('24.35')) }
+  end
+
+  context 'with a negative float' do
+    let(:value) { -24.35 }
+
+    it { should eql(BigDecimal('-24.35')) }
+  end
+
+  [ Object.new, true, '00.0', '0.', '-.0', 'string' ].each do |non_num_value|
+    context 'with a non-numeric value = #{non_num_value.inspect}' do
+      let(:value) { non_num_value }
+
+      it { should equal(non_num_value) }
+    end
+  end
+end

data/spec/unit/virtus/attribute/default_spec.rb

@@ -0,0 +1,32 @@
+require 'spec_helper'
+
+describe Virtus::Attribute, '#default' do
+  subject { object.default }
+
+  let(:object)          { described_class.new(:name, options)                              }
+  let(:options)         { { :primitive => primitive, :coercion_method => coercion_method } }
+  let(:primitive)       { stub('primitive')                                                }
+  let(:coercion_method) { stub('coercion_method')                                          }
+
+  context 'when the default is not specified' do
+    it { should be_instance_of(Virtus::Attribute::DefaultValue) }
+
+    its(:attribute) { should be(object) }
+
+    its(:value) { should be_nil }
+  end
+
+  context 'when the default is specified' do
+    let(:default) { stub('default') }
+
+    before do
+      options.update(:default => default)
+    end
+
+    it { should be_instance_of(Virtus::Attribute::DefaultValue) }
+
+    its(:attribute) { should be(object) }
+
+    its(:value) { should be(default) }
+  end
+end

data/spec/unit/virtus/attribute/default_value/attribute_spec.rb

@@ -0,0 +1,11 @@
+require 'spec_helper'
+
+describe Virtus::Attribute::DefaultValue, '#attribute' do
+  subject { object.attribute }
+
+  let(:object)    { described_class.new(attribute, value) }
+  let(:attribute) { mock('attribute')                     }
+  let(:value)     { mock('value')                         }
+
+  it { should be(attribute) }
+end

data/spec/unit/virtus/attribute/default_value/class_methods/new_spec.rb

@@ -5,15 +5,17 @@ describe Virtus::Attribute::DefaultValue, '.new' do
 
   let(:attribute) { Virtus::Attribute::String.new(:attribute) }
 
-  context 'with a duplicable value' do
+  context 'with a cloneable value' do
     let(:value) { 'something' }
+
     its(:value) { should equal(value) }
   end
 
-  context 'with a non-duplicable value' do
+  context 'with a non-cloneable value' do
     [ nil, true, false, 1, :symbol ].each do |value|
       context "with #{value.inspect}" do
         let(:value) { value }
+
         its(:value) { should equal(value) }
       end
     end

data/spec/unit/virtus/attribute/default_value/evaluate_spec.rb

@@ -0,0 +1,51 @@
+require 'spec_helper'
+
+describe Virtus::Attribute::DefaultValue, '#evaluate' do
+  subject { object.evaluate(instance) }
+
+  let(:object)    { described_class.new(attribute, value) }
+  let(:attribute) { mock('attribute')                     }
+  let(:value)     { mock('value')                         }
+  let(:instance)  { mock('instance')                      }
+
+  context 'when the value is callable' do
+    let(:response) { stub('response') }
+
+    before do
+      value.stub(:call => response)
+    end
+
+    it { should be(response) }
+
+    it 'calls the value with the instance and attribute' do
+      value.should_receive(:call).with(instance, attribute)
+      subject
+    end
+  end
+
+  context 'when the value is cloneable' do
+    let(:clone) { stub('clone') }
+
+    before do
+      value.stub(:clone => clone)
+    end
+
+    it { should be(clone) }
+
+    it 'clones the value' do
+      value.should_receive(:clone).with(no_args)
+      subject
+    end
+  end
+
+  # smallest number that is Bignum across major ruby impls
+  bignum = 0x7fffffffffffffff + 1
+
+  [ nil, true, false, 0, 0.0, bignum, :symbol ].each do |value|
+    context "when the value is #{value.inspect} (#{value.class})" do
+      let(:value) { value }
+
+      it { should be(value) }
+    end
+  end
+end

data/spec/unit/virtus/attribute/default_value/instance_methods/evaluate_spec.rb

@@ -3,25 +3,28 @@ require 'spec_helper'
 describe Virtus::Attribute::DefaultValue, '#evaluate' do
   subject { object.evaluate(instance) }
 
-  let(:object)    { described_class.new(attribute, value)     }
+  let(:object)    { described_class.new(attribute, value) }
   let(:attribute) { Virtus::Attribute::String.new(:title) }
-  let(:instance)  { Class.new }
+  let(:instance)  { Class.new                             }
 
   context 'with a non-callable value' do
-    context 'with a non-duplicable value' do
+    context 'with a non-cloneable value' do
       let(:value) { nil }
+
       it { should eql(value) }
     end
 
-    context 'with a duplicable value' do
+    context 'with a cloneable value' do
       let(:value) { 'something' }
-      it { should     eql(value) }
-      it { should_not equal(value)}
+
+      it { should     eql(value)   }
+      it { should_not equal(value) }
     end
   end
 
   context 'with a callable value' do
     let(:value) { lambda { |instance, attribute| attribute.name } }
+
     it { should be(:title) }
   end
 end