virtus 0.5.5 → 1.0.0.beta3

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

@@ -0,0 +1,32 @@
+require 'spec_helper'
+
+describe Virtus::Attribute, '.coerce' do
+  subject { described_class.coerce }
+
+  after :all do
+    described_class.coerce(true)
+  end
+
+  context 'with a value' do
+    it 'sets the value and return self' do
+      expect(described_class.coerce(false)).to be(described_class)
+      expect(subject).to be(false)
+    end
+  end
+
+  context 'when it is set to true' do
+    before do
+      described_class.coerce(true)
+    end
+
+    it { should be(true) }
+  end
+
+  context 'when it is set to false' do
+    before do
+      described_class.coerce(false)
+    end
+
+    it { should be(false) }
+  end
+end

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

@@ -1,30 +1,47 @@
 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', :public_send => coerced)                         }
-  let(:coerced)         { stub('coerced')                                                  }
-
-  before do
-    Virtus::Coercion.stub(:[]).with(value_class).and_return(coercer)
-  end
+  subject { object.coerce(input) }
+
+  fake(:coercer) { Virtus::Attribute::Coercer }
+
+  let(:object) { described_class.build(String, :coercer => coercer, :strict => strict) }
+  let(:input)  { 1 }
+  let(:output) { '1' }
 
-  it { should be(coerced) }
+  context 'when strict mode is turned off' do
+    let(:strict) { false }
 
-  it 'asks for a coercer object' do
-    Virtus::Coercion.should_receive(:[]).with(value_class)
-    subject
+    it 'uses coercer to coerce the input value' do
+      stub(coercer).call(input) { output }
+
+      expect(subject).to be(output)
+
+      expect(coercer).to have_received.call(input)
+    end
   end
 
-  it 'asks the coercer to coerce the value' do
-    coercer.should_receive(:public_send).with(coercion_method, value)
-    subject
+  context 'when strict mode is turned on' do
+    let(:strict) { true }
+
+    it 'uses coercer to coerce the input value' do
+      stub(coercer).call(input) { output }
+      stub(coercer).success?(String, output) { true }
+
+      expect(subject).to be(output)
+
+      expect(coercer).to have_received.call(input)
+      expect(coercer).to have_received.success?(String, output)
+    end
+
+    it 'raises error when input was not coerced' do
+      stub(coercer).call(input) { input }
+      stub(coercer).success?(String, input) { false }
+
+      expect { subject }.to raise_error(ArgumentError)
+
+      expect(coercer).to have_received.call(input)
+      expect(coercer).to have_received.success?(String, input)
+    end
   end
 end

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

@@ -0,0 +1,20 @@
+require 'spec_helper'
+
+describe Virtus::Attribute, '#coercible?' do
+  subject { object.coercible? }
+
+  let(:object)  { described_class.build(String, options) }
+  let(:options) { Hash[:coerce => coerce] }
+
+  context 'when :coerce is set to true' do
+    let(:coerce) { true }
+
+    it { should be(true) }
+  end
+
+  context 'when :coerce is set to false' do
+    let(:coerce) { false }
+
+    it { should be(false) }
+  end
+end

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

@@ -0,0 +1,84 @@
+require 'spec_helper'
+
+describe Virtus::Attribute, '.build' do
+  subject { described_class.build(type) }
+
+  share_examples_for 'a valid collection attribute instance' do
+    it { should be_instance_of(Virtus::Attribute::Collection) }
+
+    it { should be_frozen }
+  end
+
+  context 'when type is Array' do
+    let(:type) { Array }
+
+    it_behaves_like 'a valid collection attribute instance'
+
+    it 'sets default member type' do
+      expect(subject.type.member_type).to be(Axiom::Types::Object)
+    end
+  end
+
+  context 'when type is Array[Float]' do
+    let(:type) { Array[Float] }
+
+    it_behaves_like 'a valid collection attribute instance'
+
+    it 'sets member type' do
+      expect(subject.type.member_type).to be(Axiom::Types::Float)
+    end
+  end
+
+  context 'when type is Array[String, Integer]' do
+    let(:type) { Array[String, Integer] }
+
+    specify do
+      expect { subject }.to raise_error(
+        NotImplementedError,
+        "build SumType from list of types (#{type.inspect})"
+      )
+    end
+  end
+
+  context 'when type is Set' do
+    let(:type) { Set }
+
+    it_behaves_like 'a valid collection attribute instance'
+
+    it 'sets default member type' do
+      expect(subject.type.member_type).to be(Axiom::Types::Object)
+    end
+  end
+
+  context 'when type is Set[Float]' do
+    let(:type) { Set[Float] }
+
+    it_behaves_like 'a valid collection attribute instance'
+
+    it 'sets member type' do
+      expect(subject.type.member_type).to be(Axiom::Types::Float)
+    end
+  end
+
+  context 'when type is an Enumerable' do
+    let(:type) { Class.new { include Enumerable } }
+
+    it_behaves_like 'a valid collection attribute instance'
+  end
+
+  context 'when type is Array subclass' do
+    let(:type) { Class.new(Array) }
+
+    it_behaves_like 'a valid collection attribute instance'
+  end
+
+  context 'when type is a custom collection instance' do
+    let(:type) { Class.new(Array)[String] }
+
+    it_behaves_like 'a valid collection attribute instance'
+
+    it 'sets member type' do
+      expect(subject.type.member_type).to be(Axiom::Types::String)
+    end
+  end
+end

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

@@ -1,39 +1,52 @@
 require 'spec_helper'
 
 describe Virtus::Attribute::Collection, '#coerce' do
-  subject { object.coerce(value) }
+  subject { object.coerce(input) }
 
-  let(:described_class) { Class.new(Virtus::Attribute::Collection) }
-  let(:object)          { described_class.new(:things) }
-  let(:value)           { [ entry ] }
-  let(:entry)           { mock('entry') }
+  context 'when input is an array' do
+    context 'when member type is a primitive' do
+      fake(:coercer)     { Virtus::Attribute::Coercer }
+      fake(:member_type) { Virtus::Attribute }
 
-  before do
-    described_class.primitive ::Array
-    value.should_receive(:respond_to?).with(:inject).and_return(respond_to_inject)
-  end
+      let(:member_primitive) { Integer }
+      let(:input)            { ['1', '2'] }
 
-  context 'when coerced value responds to #inject' do
-    let(:respond_to_inject) { true }
+      let(:object) {
+        described_class.build(Array[member_primitive], :coercer => coercer, :member_type => member_type)
+      }
 
-    context 'when the object has not implemented #coerce_and_append_member' do
-      specify { expect { subject }.to raise_error(NotImplementedError, "#{object.class}#coerce_and_append_member has not been implemented") }
-    end
+      it 'uses coercer to coerce members' do
+        stub(coercer).call(input) { input }
+        stub(member_type).coerce('1') { 1 }
+        stub(member_type).coerce('2') { 2 }
+
+        expect(subject).to eq([1, 2])
 
-    context 'when the object has implemented #coerce_and_append_member' do
-      before do
-        def object.coerce_and_append_member(collection, entry)
-          collection << entry
-        end
+        expect(member_type).to have_received.coerce('1')
+        expect(member_type).to have_received.coerce('2')
       end
+    end
+
+    context 'when member type is an EV' do
+      let(:member_primitive) { Struct.new(:id) }
+      let(:input)            { [1, 2] }
+      let(:object)           { described_class.build(Array[member_primitive]) }
 
-      it { should eql(value) }
+      it 'coerces members' do
+        expect(subject).to eq([member_primitive.new(1), member_primitive.new(2)])
+      end
     end
-  end
 
-  context 'when coerced value does not respond to #inject' do
-    let(:respond_to_inject) { false }
+    context 'when member type is a hash with key/value coercion' do
+      let(:member_primitive) { Hash[String => Integer] }
+      let(:member_attribute) { Virtus::Attribute.build(member_primitive) }
+      let(:input)            { [{:one => '1'}, {:two => '2'}] }
+      let(:output)           { [member_attribute.coerce(input.first), member_attribute.coerce(input.last)] }
+      let(:object)           { described_class.build(Array[member_primitive]) }
 
-    it { should eql(value) }
+      it 'coerces members' do
+        expect(subject).to eq(output)
+      end
+    end
   end
 end

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

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+describe Virtus::Attribute::Collection, 'custom subclass' do
+  subject { attribute_class.build(primitive) }
+
+  let(:primitive) { Class.new  { include Enumerable } }
+
+  after do
+    described_class.descendants.delete(attribute_class)
+  end
+
+  context 'when primitive is set on the attribute subclass' do
+    let(:attribute_class) { Class.new(described_class).primitive(primitive) }
+
+    its(:primitive) { should be(primitive) }
+  end
+
+  context 'when primitive is not set on the attribute subclass' do
+    let(:attribute_class) { Class.new(described_class) }
+
+    its(:primitive) { should be(primitive) }
+  end
+end

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

@@ -0,0 +1,37 @@
+require 'spec_helper'
+
+describe Virtus::Attribute::EmbeddedValue, '.build' do
+  subject { described_class.build(type) }
+
+  context 'when type is a virtus model' do
+    let(:type) { Class.new { include Virtus } }
+
+    it { should be_frozen }
+
+    it { should be_instance_of(Virtus::Attribute::EmbeddedValue::FromOpenStruct) }
+  end
+
+  context 'when type is an OpenStruct subclass' do
+    let(:type) { Class.new(OpenStruct) }
+
+    it { should be_frozen }
+
+    it { should be_instance_of(Virtus::Attribute::EmbeddedValue::FromOpenStruct) }
+  end
+
+  context 'when type is OpenStruct' do
+    let(:type) { OpenStruct }
+
+    it { should be_frozen }
+
+    it { should be_instance_of(Virtus::Attribute::EmbeddedValue::FromOpenStruct) }
+  end
+
+  context 'when type is Struct' do
+    let(:type) { Struct.new(:test) }
+
+    it { should be_frozen }
+
+    it { should be_instance_of(Virtus::Attribute::EmbeddedValue::FromStruct) }
+  end
+end

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

@@ -1,21 +1,57 @@
 require 'spec_helper'
 
 describe Virtus::Attribute::EmbeddedValue, '#coerce' do
-  subject { object.coerce(value) }
+  subject { object.coerce(input) }
 
-  let(:object)   { described_class.new(:name, :primitive => primitive) }
-  let(:instance) { Object.new                                          }
-  let(:value)    { primitive.new                                       }
+  let(:object) { described_class.build(model) }
 
-  context 'when the value is a virtus object' do
-    let(:primitive) { Class.new { include Virtus } }
+  context 'when primitive is OpenStruct' do
+    let(:model)  { OpenStruct }
 
-    it { should be(value) }
+    context 'when input is an attribute hash' do
+      let(:input) { Hash[name: 'Piotr', age: 30] }
+
+      it { should be_instance_of(model) }
+
+      its(:name) { should eql('Piotr') }
+      its(:age)  { should eql(30) }
+    end
+
+    context 'when input is nil' do
+      let(:input) { nil }
+
+      it { should be(nil) }
+    end
+
+    context 'when input is a model instance' do
+      let(:input) { OpenStruct.new }
+
+      it { should be(input) }
+    end
   end
 
-  context 'when the value is a virtus value object' do
-    let(:primitive) { Class.new { include Virtus::ValueObject } }
+  context 'when primitive is Struct' do
+    let(:model)  { Struct.new(:name, :age) }
+
+    context 'when input is an attribute hash' do
+      let(:input) { ['Piotr', 30] }
+
+      it { should be_instance_of(model) }
+
+      its(:name) { should eql('Piotr') }
+      its(:age)  { should eql(30) }
+    end
+
+    context 'when input is nil' do
+      let(:input) { nil }
+
+      it { should be(nil) }
+    end
+
+    context 'when input is a model instance' do
+      let(:input) { model.new('Piotr', 30) }
 
-    it { should be(value) }
+      it { should be(input) }
+    end
   end
 end

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

@@ -3,78 +3,30 @@ 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                                                       }
+  let(:object) { described_class.build(String, options.update(:name => name)) }
 
-  context 'when the instance variable is set' do
-    let(:value) { stub('value') }
+  let(:model)    { Class.new { attr_accessor :test } }
+  let(:name)     { :test }
+  let(:instance) { model.new }
+  let(:value)    { 'Jane Doe' }
+  let(:options)  { {} }
 
+  context 'with :lazy is set to false' do
     before do
-      instance.instance_variable_set(:@name, value)
+      instance.test = 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
+    it { should be(value) }
   end
-end
 
-describe Virtus::Attribute, '#get!' do
-  subject { object.get!(instance) }
+  context 'with :lazy is set to true' do
+    let(:options) { { :lazy => true, :default => 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(: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 { should eql(value) }
 
-    it 'does not set the ivar' do
-      expect { subject }.to_not change { instance.instance_variable_defined?(:@name) }
+    it 'sets default only on first access' do
+      expect(object.get(instance)).to eql(value)
+      expect(object.get(instance)).to be(instance.test)
     end
   end
 end