virtus 0.0.10 → 0.1.0

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

@@ -0,0 +1,15 @@
+require 'spec_helper'
+
+describe Virtus::Attribute::Boolean, '#define_reader_method' do
+  subject { object.define_reader_method(mod) }
+
+  let(:object) { described_class.new(:active)              }
+  let(:mod)    { mock('mod', :define_reader_method => nil) }
+
+  it { should equal(object) }
+
+  it 'defines a reader method in the module' do
+    mod.should_receive(:define_reader_method).with(object, 'active?', :public)
+    subject
+  end
+end

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

@@ -0,0 +1,97 @@
+require 'spec_helper'
+
+describe Virtus::Attribute::Boolean, '#value_coerced?' do
+  subject { attribute.value_coerced?(value) }
+
+  let(:attribute) { described_class.new(:is_admin) }
+
+  context "with true" do
+    let(:value) { true }
+
+    it { should be(true) }
+  end
+
+  context "with false" do
+    let(:value) { false }
+
+    it { should be(true) }
+  end
+
+  context "with 1" do
+    let(:value) { 1 }
+
+    it { should be(false) }
+  end
+
+  context "with '1'" do
+    let(:value) { '1' }
+
+    it { should be(false) }
+  end
+
+  context "with 'true'" do
+    let(:value) { 'true' }
+
+    it { should be(false) }
+  end
+
+  context "with 'TRUE'" do
+    let(:value) { 'TRUE' }
+
+    it { should be(false) }
+  end
+
+  context "with 't'" do
+    let(:value) { 't' }
+
+    it { should be(false) }
+  end
+
+  context "with 'T'" do
+    let(:value) { 'T' }
+
+    it { should be(false) }
+  end
+
+  context "with 0" do
+    let(:value) { 0 }
+
+    it { should be(false) }
+  end
+
+  context "with '0'" do
+    let(:value) { '0' }
+
+    it { should be(false) }
+  end
+
+  context "with 'false'" do
+    let(:value) { 'false' }
+
+    it { should be(false) }
+  end
+
+  context "with 'FALSE'" do
+    let(:value) { 'FALSE' }
+
+    it { should be(false) }
+  end
+
+  context "with 'f'" do
+    let(:value) { 'f' }
+
+    it { should be(false) }
+  end
+
+  context "with 'F'" do
+    let(:value) { 'F' }
+
+    it { should be(false) }
+  end
+
+  context "with 'Foo'" do
+    let(:value) { 'Foo' }
+
+    it { should be(false) }
+  end
+end

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

@@ -1,15 +1,7 @@
 require 'spec_helper'
 
 describe Virtus::Attribute::Boolean do
-  it_should_behave_like 'Attribute' do
-    let(:attribute_name)         { :is_admin }
-    let(:attribute_value)        { true }
-    let(:attribute_value_other)  { '1' }
-    let(:attribute_default)      { true }
-    let(:attribute_default_proc) { lambda { |instance, attribute| attribute.name == :is_admin } }
-  end
-
-  describe "accessor names" do
+  describe 'accessor names' do
     let(:model) do
       Class.new do
         include Virtus
@@ -20,79 +12,8 @@ describe Virtus::Attribute::Boolean do
 
     let(:object) { model.new(:is_admin => true) }
 
-    it "uses standard boolean reader naming conventions" do
+    it 'uses standard boolean reader naming conventions' do
       object.is_admin?.should be_true
     end
   end
-
-  describe '#coerce' do
-    let(:attribute) { described_class.new(:is_admin) }
-
-    subject { attribute.coerce(value) }
-
-    context "with 1" do
-      let(:value) { 1 }
-      it { should be(true) }
-    end
-
-    context "with '1'" do
-      let(:value) { '1' }
-      it { should be(true) }
-    end
-
-    context "with 'true'" do
-      let(:value) { 'true' }
-      it { should be(true) }
-    end
-
-    context "with 'TRUE'" do
-      let(:value) { 'TRUE' }
-      it { should be(true) }
-    end
-
-    context "with 't'" do
-      let(:value) { 't' }
-      it { should be(true) }
-    end
-
-    context "with 'T'" do
-      let(:value) { 'T' }
-      it { should be(true) }
-    end
-
-    context "with 0" do
-      let(:value) { 0 }
-      it { should be(false) }
-    end
-
-    context "with '0'" do
-      let(:value) { '0' }
-      it { should be(false) }
-    end
-
-    context "with 'false'" do
-      let(:value) { 'false' }
-      it { should be(false) }
-    end
-
-    context "with 'FALSE'" do
-      let(:value) { 'FALSE' }
-      it { should be(false) }
-    end
-
-    context "with 'f'" do
-      let(:value) { 'f' }
-      it { should be(false) }
-    end
-
-    context "with 'F'" do
-      let(:value) { 'F' }
-      it { should be(false) }
-    end
-
-    context "with 'Foo'" do
-      let(:value) { 'Foo' }
-      it { should equal(value) }
-    end
-  end
 end

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

@@ -0,0 +1,13 @@
+require 'spec_helper'
+
+describe Virtus::Attribute::Class, '#coerce' do
+  subject { attribute.coerce(value) }
+
+  let(:attribute) { described_class.new(:type) }
+
+  context 'with a String' do
+    let(:value) { 'String' }
+
+    it { should be(String) }
+  end
+end

data/spec/unit/virtus/attribute/class_methods/accessor_spec.rb

@@ -0,0 +1,12 @@
+require 'spec_helper'
+
+describe Virtus::Attribute, '.accessor' do
+  let(:object)          { Class.new(described_class)                                       }
+  let(:options)         { { :primitive => primitive, :coercion_method => coercion_method } }
+  let(:primitive)       { stub('primitive')                                                }
+  let(:coercion_method) { stub('coercion_method')                                          }
+  let(:method)          { :accessor                                                        }
+  let(:default)         { :public                                                          }
+
+  it_should_behave_like 'an options class method'
+end

data/spec/unit/virtus/attribute/class_methods/build_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+
+describe Virtus::Attribute, '.build' do
+  let(:object) { described_class }
+  let(:name)   { :name           }
+  let(:type)   { String          }
+
+  context 'without options' do
+    subject { object.build(name, type) }
+
+    it { should be_instance_of(Virtus::Attribute::String) }
+
+    its(:name) { should be(name) }
+
+    its(:options) { should == Virtus::Attribute::String.options }
+  end
+
+  context 'with options' do
+    subject { object.build(name, type, options) }
+
+    let(:options) { {} }
+
+    it { should be_instance_of(Virtus::Attribute::String) }
+
+    its(:name) { should be(name) }
+
+    its(:options) { should == Virtus::Attribute::String.options }
+  end
+
+  context 'with an invalid type' do
+    subject { object.build(name, type) }
+
+    let(:type) { 'test' }
+
+    specify { expect { subject }.to raise_error(ArgumentError, '"test" does not map to an attribute type') }
+  end
+end

data/spec/unit/virtus/attribute/class_methods/coercion_method_spec.rb

@@ -0,0 +1,9 @@
+require 'spec_helper'
+
+describe Virtus::Attribute, '.coercion_method' do
+  let(:object)  { Class.new(described_class) }
+  let(:method)  { :coercion_method           }
+  let(:default) { nil                        }
+
+  it_should_behave_like 'an options class method'
+end

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

@@ -0,0 +1,9 @@
+require 'spec_helper'
+
+describe Virtus::Attribute, '.default' do
+  let(:object)  { Class.new(described_class) }
+  let(:method)  { :default                   }
+  let(:default) { nil                        }
+
+  it_should_behave_like 'an options class method'
+end

data/spec/unit/virtus/attribute/class_methods/determine_type_spec.rb

@@ -13,9 +13,15 @@ describe Virtus::Attribute, '.determine_type' do
     end
 
     primitive = attribute_class.primitive
-    context "with primitive #{primitive.inspect}" do
+    context "with #{attribute_class.inspect} and primitive #{primitive.inspect}" do
       subject { object.determine_type(primitive) }
 
+      before do
+        if [Virtus::Attribute::EmbeddedValue, Virtus::Attribute::Collection].include? attribute_class
+          pending 
+        end
+      end
+
       it 'returns the corresponding attribute class' do
         should be(attribute_class)
       end
@@ -31,6 +37,14 @@ describe Virtus::Attribute, '.determine_type' do
     end
   end
 
+  context 'with a virtus model' do
+    subject { object.determine_type(primitive) }
+
+    let(:primitive) { Class.new { include Virtus } }
+
+    it { should equal(Virtus::Attribute::EmbeddedValue) }
+  end
+
   context 'when the primitive defaults to Object' do
     subject { object.determine_type(primitive) }
 
@@ -46,4 +60,20 @@ describe Virtus::Attribute, '.determine_type' do
 
     it { should be_nil }
   end
+
+  context 'with an instance of an array' do
+    subject { object.determine_type(primitive) }
+
+    let(:primitive) { Array[String] }
+
+    it { should equal(Virtus::Attribute::Array) }
+  end
+
+  context 'with an instance of a set' do
+    subject { object.determine_type(primitive) }
+
+    let(:primitive) { Set[String] }
+
+    it { should equal(Virtus::Attribute::Set) }
+  end
 end

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

@@ -0,0 +1,11 @@
+require 'spec_helper'
+
+describe Virtus::Attribute, '.merge_options' do
+  subject { object.merge_options(type, options) }
+
+  let(:object)  { described_class }
+  let(:type)    { stub('type')    }
+  let(:options) { stub('options') }
+
+  it { should == options }
+end

data/spec/unit/virtus/attribute/class_methods/primitive_spec.rb

@@ -0,0 +1,9 @@
+require 'spec_helper'
+
+describe Virtus::Attribute, '.primitive' do
+  let(:object)  { Class.new(described_class) }
+  let(:method)  { :primitive                 }
+  let(:default) { nil                        }
+
+  it_should_behave_like 'an options class method'
+end

data/spec/unit/virtus/attribute/class_methods/reader_spec.rb

@@ -0,0 +1,9 @@
+require 'spec_helper'
+
+describe Virtus::Attribute, '.reader' do
+  let(:object)  { Class.new(described_class) }
+  let(:method)  { :reader                    }
+  let(:default) { nil                        }
+
+  it_should_behave_like 'an options class method'
+end

data/spec/unit/virtus/attribute/class_methods/writer_spec.rb

@@ -0,0 +1,9 @@
+require 'spec_helper'
+
+describe Virtus::Attribute, '.writer' do
+  let(:object)  { Class.new(described_class) }
+  let(:method)  { :writer                    }
+  let(:default) { nil                        }
+
+  it_should_behave_like 'an options class method'
+end

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

@@ -0,0 +1,30 @@
+require 'spec_helper'
+
+describe Virtus::Attribute, '#coerce' do
+  subject { object.coerce(value) }
+
+  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(:value)           { mock('value', :class => value_class)                             }
+  let(:value_class)     { stub('value_class')                                              }
+  let(:coercer)         { mock('coercer', :send => coerced)                                }
+  let(:coerced)         { stub('coerced')                                                  }
+
+  before do
+    Virtus::Coercion.stub(:[]).with(value_class).and_return(coercer)
+  end
+
+  it { should be(coerced) }
+
+  it 'asks for a coercer object' do
+    Virtus::Coercion.should_receive(:[]).with(value_class)
+    subject
+  end
+
+  it 'asks the coercer to coerce the value' do
+    coercer.should_receive(:send).with(coercion_method, value)
+    subject
+  end
+end

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

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

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

@@ -0,0 +1,40 @@
+require 'spec_helper'
+
+describe Virtus::Attribute::Collection, '.merge_options' do
+  subject { described_class.merge_options(type, options) }
+
+  let(:type)        { mock('type')        }
+  let(:member_type) { mock('member_type') }
+  let(:options)     { Hash.new            }
+
+  context 'when `type` responds to `size`' do
+    before do
+      type.should_receive(:respond_to?).with(:size).and_return(true)
+      type.should_receive(:size).and_return(size)
+    end
+
+    context 'when size is == 1' do
+      let(:size) { 1 }
+
+      before do
+        type.should_receive(:first).and_return(member_type)
+      end
+
+      specify { subject[:member_type].should eql(member_type) }
+    end
+
+    context 'when size is > 1' do
+      let(:size) { 2 }
+
+      specify { expect { subject }.to raise_error(NotImplementedError) }
+    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 eql(options) }
+  end
+end