virtus 1.0.1 → 2.0.0

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

@@ -19,7 +19,7 @@ describe Virtus::Attribute, '.coerce' do
       described_class.coerce(true)
     end
 
-    it { should be(true) }
+    it { is_expected.to be(true) }
   end
 
   context 'when it is set to false' do
@@ -27,6 +27,6 @@ describe Virtus::Attribute, '.coerce' do
       described_class.coerce(false)
     end
 
-    it { should be(false) }
+    it { is_expected.to be(false) }
   end
 end

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

@@ -7,10 +7,11 @@ describe Virtus::Attribute, '#coerce' do
 
   let(:object)   {
     described_class.build(String,
-      :coercer => coercer, :strict => strict, :required => required)
+      :coercer => coercer, :strict => strict, :required => required, :nullify_blank => nullify_blank)
   }
 
   let(:required) { true }
+  let(:nullify_blank) { false }
   let(:input)    { 1 }
   let(:output)   { '1' }
 
@@ -18,7 +19,7 @@ describe Virtus::Attribute, '#coerce' do
     let(:strict) { false }
 
     it 'uses coercer to coerce the input value' do
-      stub(coercer).call(input) { output }
+      mock(coercer).call(input) { output }
 
       expect(subject).to be(output)
 
@@ -30,8 +31,8 @@ describe Virtus::Attribute, '#coerce' do
     let(:strict) { true }
 
     it 'uses coercer to coerce the input value' do
-      stub(coercer).call(input) { output }
-      stub(coercer).success?(String, output) { true }
+      mock(coercer).call(input) { output }
+      mock(coercer).success?(String, output) { true }
 
       expect(subject).to be(output)
 
@@ -44,8 +45,8 @@ describe Virtus::Attribute, '#coerce' do
       let(:input)    { nil }
 
       it 'returns nil' do
-        stub(coercer).call(input) { input }
-        stub(coercer).success?(String, input) { false }
+        mock(coercer).call(input) { input }
+        mock(coercer).success?(String, input) { false }
 
         expect(subject).to be(nil)
 
@@ -58,8 +59,8 @@ describe Virtus::Attribute, '#coerce' do
       let(:input) { nil }
 
       it 'returns raises error' do
-        stub(coercer).call(input) { input }
-        stub(coercer).success?(String, input) { false }
+        mock(coercer).call(input) { input }
+        mock(coercer).success?(String, input) { false }
 
         expect { subject }.to raise_error(Virtus::CoercionError)
 
@@ -69,8 +70,8 @@ describe Virtus::Attribute, '#coerce' do
     end
 
     it 'raises error when input was not coerced' do
-      stub(coercer).call(input) { input }
-      stub(coercer).success?(String, input) { false }
+      mock(coercer).call(input) { input }
+      mock(coercer).success?(String, input) { false }
 
       expect { subject }.to raise_error(Virtus::CoercionError)
 
@@ -78,4 +79,51 @@ describe Virtus::Attribute, '#coerce' do
       expect(coercer).to have_received.success?(String, input)
     end
   end
+
+  context 'when the input is an empty String' do
+    let(:input) { '' }
+    let(:output) { '' }
+
+    context 'when nullify_blank is turned on' do
+      let(:nullify_blank) { true }
+      let(:strict) { false }
+      let(:require) { false }
+
+      it 'returns nil' do
+        mock(coercer).call(input) { input }
+        mock(coercer).success?(String, input) { false }
+
+        expect(subject).to be_nil
+
+        expect(coercer).to have_received.call(input)
+        expect(coercer).to have_received.success?(String, input)
+      end
+
+      it 'returns the ouput if it was coerced' do
+        mock(coercer).call(input) { output }
+        mock(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
+    end
+
+    context 'when both nullify_blank and strict are turned on' do
+      let(:nullify_blank) { true }
+      let(:strict) { true }
+
+      it 'does not raises an coercion error' do
+        mock(coercer).call(input) { input }
+        mock(coercer).success?(String, input) { false }
+
+        expect { subject }.not_to raise_error
+        expect(subject).to be_nil
+
+        expect(coercer).to have_received.call(input)
+        expect(coercer).to have_received.success?(String, input)
+      end
+    end
+  end
 end

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

@@ -9,12 +9,12 @@ describe Virtus::Attribute, '#coercible?' do
   context 'when :coerce is set to true' do
     let(:coerce) { true }
 
-    it { should be(true) }
+    it { is_expected.to be(true) }
   end
 
   context 'when :coerce is set to false' do
     let(:coerce) { false }
 
-    it { should be(false) }
+    it { is_expected.to be(false) }
   end
 end

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

@@ -1,12 +1,14 @@
 require 'spec_helper'
 
 describe Virtus::Attribute, '.build' do
-  subject { described_class.build(type) }
+  subject { described_class.build(type, options) }
 
-  share_examples_for 'a valid collection attribute instance' do
-    it { should be_instance_of(Virtus::Attribute::Collection) }
+  let(:options) { {} }
 
-    it { should be_frozen }
+  shared_examples_for 'a valid collection attribute instance' do
+    it { is_expected.to be_instance_of(Virtus::Attribute::Collection) }
+
+    it { is_expected.to be_frozen }
   end
 
   context 'when type is Array' do
@@ -91,4 +93,13 @@ describe Virtus::Attribute, '.build' do
       expect(subject.type.member_type).to be(Axiom::Types::String)
     end
   end
+
+  context 'when strict mode is used' do
+    let(:type) { Array[String] }
+    let(:options) { { strict: true } }
+
+    it 'sets strict mode for member type' do
+      expect(subject.member_type).to be_strict
+    end
+  end
 end

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

@@ -16,10 +16,10 @@ describe Virtus::Attribute::Collection, '#coerce' do
       }
 
       it 'uses coercer to coerce members' do
-        stub(coercer).call(input) { input }
-        stub(member_type).finalize { member_type }
-        stub(member_type).coerce('1') { 1 }
-        stub(member_type).coerce('2') { 2 }
+        mock(coercer).call(input) { input }
+        mock(member_type).finalize { member_type }
+        mock(member_type).coerce('1') { 1 }
+        mock(member_type).coerce('2') { 2 }
 
         expect(subject).to eq([1, 2])
 
@@ -50,4 +50,25 @@ describe Virtus::Attribute::Collection, '#coerce' do
       end
     end
   end
+
+  context 'when input is nil' do
+    let(:input) { nil }
+
+    fake(:coercer)     { Virtus::Attribute::Coercer }
+    fake(:member_type) { Virtus::Attribute }
+
+    let(:member_primitive) { Integer }
+
+    let(:object) {
+      described_class.build(
+        Array[member_primitive], coercer: coercer, member_type: member_type
+      )
+    }
+
+    it 'returns nil' do
+      mock(coercer).call(input) { input }
+
+      expect(subject).to be(input)
+    end
+  end
 end

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

@@ -0,0 +1,31 @@
+require 'spec_helper'
+require 'set'
+
+describe Virtus::Attribute::Collection, '#value_coerced?' do
+  subject { object.value_coerced?(input) }
+
+  let(:object) { described_class.build(Array[Integer]) }
+
+  context 'when input has correctly typed members' do
+    let(:input) { [1, 2, 3] }
+
+    it { is_expected.to be(true) }
+  end
+
+  context 'when input has incorrectly typed members' do
+    let(:input) { [1, 2, '3'] }
+
+    it { is_expected.to be(false) }
+  end
+
+  context 'when the collection type is incorrect' do
+    let(:input) { Set[1, 2, 3] }
+
+    it { is_expected.to be(false) }
+  end
+
+  context 'when the input is empty' do
+    let(:input) { [] }
+    it { is_expected.to be(true) }
+  end
+end

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

@@ -0,0 +1,20 @@
+require 'spec_helper'
+
+describe Virtus::Attribute, '#== (defined by including Virtus::Equalizer)' do
+  let(:attribute) { described_class.build(String, :name => :name) }
+
+  it 'returns true when attributes have same type and options' do
+    equal_attribute = described_class.build(String, :name => :name)
+    expect(attribute == equal_attribute).to be_truthy
+  end
+
+  it 'returns false when attributes have different type' do
+    different_attribute = described_class.build(Integer, :name => :name)
+    expect(attribute == different_attribute).to be_falsey
+  end
+
+  it 'returns false when attributes have different options' do
+    different_attribute = described_class.build(Integer, :name => :name_two)
+    expect(attribute == different_attribute).to be_falsey
+  end
+end

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

@@ -12,12 +12,18 @@ describe Virtus::Attribute::Collection, 'custom subclass' do
   context 'when primitive is set on the attribute subclass' do
     let(:attribute_class) { Class.new(described_class).primitive(primitive) }
 
-    its(:primitive) { should be(primitive) }
+    describe '#primitive' do
+      subject { super().primitive }
+      it { is_expected.to be(primitive) }
+    end
   end
 
   context 'when primitive is not set on the attribute subclass' do
     let(:attribute_class) { Class.new(described_class) }
 
-    its(:primitive) { should be(primitive) }
+    describe '#primitive' do
+      subject { super().primitive }
+      it { is_expected.to be(primitive) }
+    end
   end
 end

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

@@ -0,0 +1,20 @@
+require 'spec_helper'
+
+describe Virtus::Attribute, '#defined?' do
+  subject { object.defined?(instance) }
+
+  let(:object) { described_class.build(String, :name => name) }
+
+  let(:model)    { Class.new { attr_accessor :test } }
+  let(:name)     { :test }
+  let(:instance) { model.new }
+
+  context 'when the attribute value has not been defined' do
+    it { is_expected.to be(false) }
+  end
+
+  context 'when the attribute value has been defined' do
+    before { instance.test = nil }
+    it { is_expected.to be(true) }
+  end
+end

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

@@ -6,50 +6,65 @@ describe Virtus::Attribute::EmbeddedValue, '.build' do
   context 'when type is a Virtus.model' do
     let(:type) { Class.new { include Virtus.model } }
 
-    it { should be_frozen }
+    it { is_expected.to be_frozen }
 
-    it { should be_instance_of(Virtus::Attribute::EmbeddedValue) }
+    it { is_expected.to be_instance_of(Virtus::Attribute::EmbeddedValue) }
 
-    its(:coercer) { should be_instance_of(described_class::FromOpenStruct) }
+    describe '#coercer' do
+      subject { super().coercer }
+      it { is_expected.to be_instance_of(described_class::FromOpenStruct) }
+    end
   end
 
   context 'when type includes Virtus' do
     let(:type) { Class.new { include Virtus } }
 
-    it { should be_frozen }
+    it { is_expected.to be_frozen }
 
-    it { should be_instance_of(Virtus::Attribute::EmbeddedValue) }
+    it { is_expected.to be_instance_of(Virtus::Attribute::EmbeddedValue) }
 
-    its(:coercer) { should be_instance_of(described_class::FromOpenStruct) }
+    describe '#coercer' do
+      subject { super().coercer }
+      it { is_expected.to be_instance_of(described_class::FromOpenStruct) }
+    end
   end
 
   context 'when type is an OpenStruct subclass' do
     let(:type) { Class.new(OpenStruct) }
 
-    it { should be_frozen }
+    it { is_expected.to be_frozen }
 
-    it { should be_instance_of(Virtus::Attribute::EmbeddedValue) }
+    it { is_expected.to be_instance_of(Virtus::Attribute::EmbeddedValue) }
 
-    its(:coercer) { should be_instance_of(described_class::FromOpenStruct) }
+    describe '#coercer' do
+      subject { super().coercer }
+      it { is_expected.to be_instance_of(described_class::FromOpenStruct) }
+    end
   end
 
   context 'when type is OpenStruct' do
     let(:type) { OpenStruct }
 
-    it { should be_frozen }
+    it { is_expected.to be_frozen }
 
-    it { should be_instance_of(Virtus::Attribute::EmbeddedValue) }
+    it { is_expected.to be_instance_of(Virtus::Attribute::EmbeddedValue) }
 
-    its(:coercer) { should be_instance_of(described_class::FromOpenStruct) }
+    describe '#coercer' do
+      subject { super().coercer }
+      it { is_expected.to be_instance_of(described_class::FromOpenStruct) }
+    end
   end
 
   context 'when type is Struct' do
     let(:type) { Struct.new(:test) }
 
-    it { should be_frozen }
+    it { is_expected.to be_frozen }
 
-    it { should be_instance_of(Virtus::Attribute::EmbeddedValue) }
+    it { is_expected.to be_instance_of(Virtus::Attribute::EmbeddedValue) }
 
-    its(:coercer) { should be_instance_of(described_class::FromStruct) }
+    describe '#coercer' do
+      subject { super().coercer }
+      it { is_expected.to be_instance_of(described_class::FromStruct) }
+    end
   end
 end

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

@@ -12,22 +12,29 @@ describe Virtus::Attribute::EmbeddedValue, '#coerce' do
     context 'when input is an attribute hash' do
       let(:input) { Hash[name: 'Piotr', age: 30] }
 
-      it { should be_instance_of(model) }
+      it { is_expected.to be_instance_of(model) }
 
-      its(:name) { should eql('Piotr') }
-      its(:age)  { should eql(30) }
+      describe '#name' do
+        subject { super().name }
+        it { is_expected.to eql('Piotr') }
+      end
+
+      describe '#age' do
+        subject { super().age }
+        it { is_expected.to eql(30) }
+      end
     end
 
     context 'when input is nil' do
       let(:input) { nil }
 
-      it { should be(nil) }
+      it { is_expected.to be(nil) }
     end
 
     context 'when input is a model instance' do
       let(:input) { OpenStruct.new }
 
-      it { should be(input) }
+      it { is_expected.to be(input) }
     end
   end
 
@@ -37,22 +44,29 @@ describe Virtus::Attribute::EmbeddedValue, '#coerce' do
     context 'when input is an attribute hash' do
       let(:input) { ['Piotr', 30] }
 
-      it { should be_instance_of(model) }
+      it { is_expected.to be_instance_of(model) }
 
-      its(:name) { should eql('Piotr') }
-      its(:age)  { should eql(30) }
+      describe '#name' do
+        subject { super().name }
+        it { is_expected.to eql('Piotr') }
+      end
+
+      describe '#age' do
+        subject { super().age }
+        it { is_expected.to eql(30) }
+      end
     end
 
     context 'when input is nil' do
       let(:input) { nil }
 
-      it { should be(nil) }
+      it { is_expected.to be(nil) }
     end
 
     context 'when input is a model instance' do
       let(:input) { model.new('Piotr', 30) }
 
-      it { should be(input) }
+      it { is_expected.to be(input) }
     end
   end
 
@@ -63,7 +77,7 @@ describe Virtus::Attribute::EmbeddedValue, '#coerce' do
     context 'when input is coercible' do
       let(:input) { ['Piotr'] }
 
-      it { should eql(model.new('Piotr')) }
+      it { is_expected.to eql(model.new('Piotr')) }
     end
 
     context 'when input is not coercible' do