virtus 0.0.10 → 0.1.0

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

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

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

@@ -0,0 +1,26 @@
+require 'spec_helper'
+
+describe Virtus::Attribute, '#define_accessor_methods' do
+  subject { object.define_accessor_methods(mod) }
+
+  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')                                          }
+  let(:mod)             { stub('mod')                                                      }
+
+  before do
+    object.stub(:define_reader_method).with(mod)
+    object.stub(:define_writer_method).with(mod)
+  end
+
+  it 'delegates to #define_reader_method' do
+    object.should_receive(:define_reader_method).with(mod)
+    subject
+  end
+
+  it 'delegates to #define_writer_method' do
+    object.should_receive(:define_writer_method).with(mod)
+    subject
+  end
+end

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

@@ -0,0 +1,24 @@
+require 'spec_helper'
+
+describe Virtus::Attribute, '#define_reader_method' do
+  subject { object.define_reader_method(mod) }
+
+  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')                                          }
+  let(:reader_visibility) { stub('reader_visibility')                                        }
+  let(:mod)               { mock('mod')                                                      }
+
+  before do
+    options.update(:reader => reader_visibility)
+    mod.stub(:define_reader_method).with(object, :name, reader_visibility)
+  end
+
+  it { should be(object) }
+
+  it 'calls #define_reader_method on the module' do
+    mod.should_receive(:define_reader_method).with(object, :name, reader_visibility)
+    subject
+  end
+end

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

@@ -0,0 +1,24 @@
+require 'spec_helper'
+
+describe Virtus::Attribute, '#define_writer_method' do
+  subject { object.define_writer_method(mod) }
+
+  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')                                          }
+  let(:writer_visibility) { stub('writer_visibility')                                        }
+  let(:mod)               { mock('mod')                                                      }
+
+  before do
+    options.update(:writer => writer_visibility)
+    mod.stub(:define_writer_method).with(object, :name=, writer_visibility)
+  end
+
+  it { should be(object) }
+
+  it 'calls #define_writer_method on the module' do
+    mod.should_receive(:define_writer_method).with(object, :name=, writer_visibility)
+    subject
+  end
+end

data/spec/unit/virtus/attribute/embedded_value/class_methods/merge_options_spec.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+
+describe Virtus::Attribute::EmbeddedValue, '.merge_options' do
+  subject { object.merge_options(type, options) }
+
+  let(:object)  { described_class }
+  let(:type)    { stub('type')    }
+  let(:options) { {}.freeze       }
+
+  it { should be_instance_of(Hash) }
+
+  it { should_not equal(options) }
+
+  it 'merges the type in as the model' do
+    should eql(:model => type)
+  end
+end

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

@@ -0,0 +1,50 @@
+require 'spec_helper'
+
+describe Virtus::Attribute::EmbeddedValue, '#coerce' do
+  subject { object.coerce(value) }
+
+  let(:attribute_name) { :attribute_name }
+  let(:model)          { OpenStruct      }
+  let(:instance)       { Object.new      }
+
+  context 'when the value is a hash' do
+    let(:value) { Hash[:foo => 'bar'] }
+
+    context 'when the options include the model' do
+      let(:object)         { described_class.new(attribute_name, :model => model) }
+      let(:model)          { mock('model')                                        }
+      let(:model_instance) { mock('model_instance') }
+
+      before do
+        model.should_receive(:new).with(value).and_return(model_instance)
+      end
+
+      it { should be(model_instance) }
+    end
+
+    context 'with the default OpenStruct model' do
+      let(:model_instance) { OpenStruct.new(value) }
+
+      context 'when the options are an empty Hash' do
+        let(:object) { described_class.new(attribute_name, {}) }
+
+        it { should == model_instance }
+      end
+
+      context 'when the options are not provided' do
+        let(:object) { described_class.new(attribute_name) }
+
+        it { should == model_instance }
+      end
+    end
+  end
+
+  context 'when the value is not a hash' do
+    let(:object) { described_class.new(attribute_name) }
+    let(:value)  { mock('value')                       }
+
+    before { model.should_not_receive(:new) }
+
+    it { should be(value) }
+  end
+end

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

@@ -0,0 +1,117 @@
+require 'spec_helper'
+
+describe Virtus::Attribute::Float, '#coerce' do
+  subject { attribute.coerce(value) }
+
+  let(:attribute) { described_class.new(:score) }
+
+  context 'with a float' do
+    let(:value) { 24.0 }
+
+    it { should eql(value) }
+  end
+
+  context 'with a zero string integer' do
+    let(:value) { '0' }
+
+    it { should eql(0.0) }
+  end
+
+  context 'with a positive string integer' do
+    let(:value) { '24' }
+
+    it { should eql(24.0) }
+  end
+
+  context 'with a negative string integer' do
+    let(:value) { '-24' }
+
+    it { should eql(-24.0) }
+  end
+
+  context 'with a zero string float' do
+    let(:value) { '0.0' }
+
+    it { should eql(0.0) }
+  end
+
+  context 'with a positive string float' do
+    let(:value) { '24.35' }
+
+    it { should eql(24.35) }
+  end
+
+  context 'with a negative string float' do
+    let(:value) { '-24.35' }
+
+    it { should eql(-24.35) }
+  end
+
+  context 'with a zero string float, with no leading digits' do
+    let(:value) { '.0' }
+
+    it { should eql(0.0) }
+  end
+
+  context 'with a positive string float, with no leading digits' do
+    let(:value) { '.41' }
+
+    it { should eql(0.41) }
+  end
+
+  context 'with a zero integer' do
+    let(:value) { 0 }
+
+    it { should eql(0.0) }
+  end
+
+  context 'with a positive integer' do
+    let(:value) { 24 }
+
+    it { should eql(24.0) }
+  end
+
+  context 'with a negative integer' do
+    let(:value) { -24 }
+
+    it { should eql(-24.0) }
+  end
+
+  context 'with a positive bignum' do
+    let(:value) { 1311935550 }
+
+    it { should eql(1311935550.0) }
+  end
+
+  context 'with a negative bignum' do
+    let(:value) { -1311935550 }
+
+    it { should eql(-1311935550.0) }
+  end
+
+  context 'with a zero decimal' do
+    let(:value) { BigDecimal('0.0') }
+
+    it { should eql(0.0) }
+  end
+
+  context 'with a positive decimal' do
+    let(:value) { BigDecimal('24.35') }
+
+    it { should eql(24.35) }
+  end
+
+  context 'with a negative decimal' do
+    let(:value) { BigDecimal('-24.35') }
+
+    it { should eql(-24.35) }
+  end
+
+  [ Object.new, true, '00.0', '0.', '-.0', 'string' ].each do |non_num_value|
+    context 'does not coerce 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/get_spec.rb

@@ -0,0 +1,80 @@
+require 'spec_helper'
+
+describe Virtus::Attribute, '#get' do
+  subject { object.get(instance) }
+
+  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')                                          }
+  let(:instance)        { Object.new                                                       }
+
+  context 'when the instance variable is set' do
+    let(:value) { stub('value') }
+
+    before do
+      instance.instance_variable_set(:@name, value)
+    end
+
+    it 'gets the value from the instance variable' do
+      should be(value)
+    end
+  end
+
+  context 'when the instance variable is not set' do
+    context 'when there is no default' do
+      it 'returns nil' do
+        should be_nil
+      end
+
+      it 'sets the ivar' do
+        expect { subject }.to change { instance.instance_variable_defined?(:@name) }.from(false).to(true)
+      end
+    end
+
+    context 'when there is a default' do
+      let(:default) { stub('default') }
+
+      before do
+        default.stub(:clone).and_return(default)
+        options.update(:default => default)
+      end
+
+      it 'gets the default from the instance variable' do
+        should be(default)
+      end
+    end
+  end
+end
+
+describe Virtus::Attribute, '#get!' do
+  subject { object.get!(instance) }
+
+  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')                                          }
+  let(:instance)        { Object.new                                                       }
+
+  context 'when the instance variable is set' do
+    let(:value) { stub('value') }
+
+    before do
+      instance.instance_variable_set(:@name, value)
+    end
+
+    it 'gets the value from the instance variable' do
+      should be(value)
+    end
+  end
+
+  context 'when the instance variable is not set' do
+    it 'returns nil' do
+      should be_nil
+    end
+
+    it 'does not set the ivar' do
+      expect { subject }.to_not change { instance.instance_variable_defined?(:@name) }
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+require 'spec_helper'
+
+describe Virtus::Attribute, '#inspect' do
+  subject { object.inspect }
+
+  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 'with a named attribute class' do
+    let(:described_class) { NamedAttribute = Class.new(Virtus::Attribute) }
+
+    after do
+      klass = Object.class_eval { remove_const(:NamedAttribute) }
+      Virtus::Attribute.descendants.delete(klass)
+    end
+
+    it { should eql("#<NamedAttribute @name=:name>") }
+  end
+
+  context 'with an anonymous attribute class' do
+    let(:described_class) { Class.new(Virtus::Attribute) }
+
+    it { should eql("#<#{described_class} @name=:name>") }
+  end
+end

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

@@ -0,0 +1,12 @@
+require 'spec_helper'
+
+describe Virtus::Attribute, '#instance_variable_name' do
+  subject { object.instance_variable_name }
+
+  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')                                          }
+
+  it { should be(:@name) }
+end

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

@@ -0,0 +1,105 @@
+require 'spec_helper'
+
+describe Virtus::Attribute::Integer, '#coerce' do
+  subject { attribute.coerce(value) }
+
+  let(:attribute) { described_class.new(:age) }
+
+  context 'with an integer' do
+    let(:value) { 24 }
+
+    it { should eql(value) }
+  end
+
+  context 'with a zero string integer' do
+    let(:value) { 24 }
+
+    it { should eql(value) }
+  end
+
+  context 'with a positive string integer' do
+    let(:value) { '24' }
+
+    it { should eql(24) }
+  end
+
+  context 'with a negative string integer' do
+    let(:value) { '-24' }
+
+    it { should eql(-24) }
+  end
+
+  context 'with a zero string float' do
+    let(:value) { 0.0 }
+
+    it { should eql(0) }
+  end
+
+  context 'with a positive string float' do
+    let(:value) { '24.35' }
+
+    it { should eql(24) }
+  end
+
+  context 'with a negative string float' do
+    let(:value) { '-24.35' }
+
+    it { should eql(-24) }
+  end
+
+  context 'with a zero string float, with no leading digits' do
+    let(:value) { '.0' }
+
+    it { should eql(0) }
+  end
+
+  context 'with a positive string float, with no leading digits' do
+    let(:value) { '.41' }
+
+    it { should eql(0) }
+  end
+
+  context 'with a zero float' do
+    let(:value) { 0.0 }
+
+    it { should eql(0) }
+  end
+
+  context 'with a positive float' do
+    let(:value) { 24.35 }
+
+    it { should eql(24) }
+  end
+
+  context 'with a negative float' do
+    let(:value) { -24.35 }
+
+    it { should eql(-24) }
+  end
+
+  context 'with a zero decimal' do
+    let(:value) { BigDecimal('0.0') }
+
+    it { should eql(0) }
+  end
+
+  context 'with a positive decimal' do
+    let(:value) { BigDecimal('24.35') }
+
+    it { should eql(24) }
+  end
+
+  context 'with a negative decimal' do
+    let(:value) { BigDecimal('-24.35') }
+
+    it { should eql(-24) }
+  end
+
+  [ Object.new, true, false, '00.0', '0.', '-.0', 'string' ].each do |non_num_value|
+    context 'does not coerce non-numeric value #{non_num_value.inspect}' do
+      let(:value) { non_num_value }
+
+      it { should equal(non_num_value) }
+    end
+  end
+end