virtus 0.5.5 → 1.0.0.beta3

data/spec/unit/virtus/attribute/default_value/from_clonable/call_spec.rb

@@ -1,20 +0,0 @@
-require 'spec_helper'
-
-describe Virtus::Attribute::DefaultValue::FromClonable, '#call' do
-  subject { object.call(instance) }
-
-  let(:object)    { described_class.new(value) }
-  let(:value)     { mock('value')              }
-  let(:instance)  { mock('instance')           }
-  let(:response)  { mock('response')           }
-  let(:clone)     { mock('clone')              }
-
-  before { value.stub(:clone => clone) }
-
-  it { should be(clone) }
-
-  it 'clones the value' do
-    value.should_receive(:clone).with(no_args)
-    subject
-  end
-end

data/spec/unit/virtus/attribute/default_value/from_clonable/class_methods/handle_spec.rb

@@ -1,19 +0,0 @@
-require 'spec_helper'
-
-describe Virtus::Attribute::DefaultValue::FromClonable, '.handle?' do
-  subject { described_class.handle?(default) }
-
-  let(:attribute) { mock('attribute') }
-
-  context 'with a clonable' do
-    let(:default) { 'clonable'  }
-
-    it { should be(true)  }
-  end
-
-  context 'with a non-clonable' do
-    let(:default) { 1 }
-
-    it { should be(false)  }
-  end
-end

data/spec/unit/virtus/attribute/default_value/from_symbol/call_spec.rb

@@ -1,17 +0,0 @@
-require 'spec_helper'
-
-describe Virtus::Attribute::DefaultValue::FromSymbol, '#call' do
-  subject { object.call(instance) }
-
-  let(:object)    { described_class.new(value)              }
-  let(:instance)  { mock('instance', value => retval)       }
-  let(:value)     { :set_default                            }
-  let(:retval)    { mock('retval')                          }
-
-  it { should be(retval) }
-
-  it 'calls the method' do
-    instance.should_receive(value).with(no_args)
-    subject
-  end
-end

data/spec/unit/virtus/attribute/default_value/from_symbol/class_methods/handle_spec.rb

@@ -1,17 +0,0 @@
-require 'spec_helper'
-
-describe Virtus::Attribute::DefaultValue::FromSymbol, '.handle?' do
-  subject { described_class.handle?(default) }
-
-  context 'with a symbol' do
-    let(:default) { :method_name  }
-
-    it { should be(true)  }
-  end
-
-  context 'with a non-symbol' do
-    let(:default) { 'method_name' }
-
-    it { should be(false)  }
-  end
-end

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

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

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

@@ -1,26 +0,0 @@
-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

@@ -1,24 +0,0 @@
-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

@@ -1,24 +0,0 @@
-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/determine_type_spec.rb

@@ -1,23 +0,0 @@
-require 'spec_helper'
-
-describe Virtus::Attribute::EmbeddedValue, '.determine_type' do
-  subject { described_class.determine_type(value) }
-
-  context "with Struct" do
-    let(:value) { Struct.new(:x) }
-
-    it { should be(Virtus::Attribute::EmbeddedValue::FromStruct) }
-  end
-
-  context "with OpenStruct" do
-    let(:value) { OpenStruct }
-
-    it { should be(Virtus::Attribute::EmbeddedValue::FromOpenStruct) }
-  end
-
-  context "with a Virtus descendant" do
-    let(:value) { Class.new { include Virtus; self } }
-
-    it { should be(Virtus::Attribute::EmbeddedValue::FromOpenStruct) }
-  end
-end

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

@@ -1,17 +0,0 @@
-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(:primitive => type)
-  end
-end

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

@@ -1,34 +0,0 @@
-require 'spec_helper'
-
-describe Virtus::Attribute::EmbeddedValue::FromOpenStruct, '#coerce' do
-  subject { object.coerce(value) }
-
-  let(:primitive) { OpenStruct }
-
-  let(:object) do
-    described_class.new(:name, :primitive => primitive)
-  end
-
-  context 'when the value is nil' do
-    let(:value) { nil }
-
-    it { should be_nil }
-  end
-
-  context 'when the value is a primitive instance' do
-    let(:value) { primitive.new }
-
-    it { should be(value) }
-  end
-
-  context 'when the value is a hash' do
-    let(:value)    { Hash[:foo => 'bar'] }
-    let(:instance) { mock('instance') }
-
-    before do
-      primitive.should_receive(:new).with(value).and_return(instance)
-    end
-
-    it { should be(instance) }
-  end
-end

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

@@ -1,34 +0,0 @@
-require 'spec_helper'
-
-describe Virtus::Attribute::EmbeddedValue::FromStruct, '#coerce' do
-  subject { object.coerce(value) }
-
-  let(:primitive) { Struct.new(:x, :y) }
-
-  let(:object) do
-    described_class.new(:name, :primitive => primitive)
-  end
-
-  context 'when the value is nil' do
-    let(:value) { nil }
-
-    it { should be_nil }
-  end
-
-  context 'when the value is a primitive instance' do
-    let(:value) { primitive.new }
-
-    it { should be(value) }
-  end
-
-  context 'when the value is an array' do
-    let(:value)    { [ 1 ,2 ] }
-    let(:instance) { mock('instance') }
-
-    before do
-      primitive.should_receive(:new).with(*value).and_return(instance)
-    end
-
-    it { should be(instance) }
-  end
-end

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

@@ -1,123 +0,0 @@
-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 positive string float and leading non-significant digits' do
-    let (:value) { '00.0' }
-
-    it { should eql(0.0) }
-  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, '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/hash/class_methods/merge_options_spec.rb

@@ -1,33 +0,0 @@
-require 'spec_helper'
-
-describe Virtus::Attribute::Hash, '.merge_options' do
-  subject { described_class.merge_options(type, options) }
-
-  let(:type)        { { String => Integer } }
-  let(:options)     { { :opt => 'val' } }
-
-  context 'when `type` responds to `size`' do
-    context 'when size is == 1' do
-      specify { subject[:opt].should == 'val'          }
-      specify { subject[:key_type].should == String    }
-      specify { subject[:value_type].should == Integer }
-    end
-
-    context 'when size is > 1' do
-      let(:type) { { :opt1 => 'val1', :opt2 => 'val2' } }
-
-      it 'should raise ArgumentError' do
-        message = "more than one [key => value] pair in `#{type.inspect}`"
-        expect { subject }.to raise_error(ArgumentError, message)
-      end
-    end
-  end
-
-  context 'when `type` does not respond to `size`' do
-    before do
-      type.should_receive(:respond_to?).with(:size).and_return(false)
-    end
-
-    it { should be_eql(options) }
-  end
-end

data/spec/unit/virtus/attribute/hash/key_type_spec.rb

@@ -1,10 +0,0 @@
-require 'spec_helper'
-
-describe Virtus::Attribute::Hash, '#key_type' do
-  subject { object.key_type }
-
-  let(:object)   { Virtus::Attribute.build(:meta, Hash[key_type => String]) }
-  let(:key_type) { Symbol }
-
-  it { should be(key_type) }
-end