virtus 1.0.3 → 1.0.4

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

@@ -8,18 +8,18 @@ describe Virtus::Attribute, '.build' do
   let(:options) { {} }
 
   shared_examples_for 'a valid attribute instance' do
-    it { should be_instance_of(Virtus::Attribute) }
+    it { is_expected.to be_instance_of(Virtus::Attribute) }
 
-    it { should be_frozen }
+    it { is_expected.to be_frozen }
   end
 
   context 'without options' do
     it_behaves_like 'a valid attribute instance'
 
-    it { should be_coercible }
-    it { should be_public_reader }
-    it { should be_public_writer }
-    it { should_not be_lazy }
+    it { is_expected.to be_coercible }
+    it { is_expected.to be_public_reader }
+    it { is_expected.to be_public_writer }
+    it { is_expected.not_to be_lazy }
 
     it 'sets up a coercer' do
       expect(subject.options[:coerce]).to be(true)
@@ -30,7 +30,10 @@ describe Virtus::Attribute, '.build' do
   context 'when name is passed as a string' do
     let(:name) { 'something' }
 
-    its(:name) { should be(:something) }
+    describe '#name' do
+      subject { super().name }
+      it { is_expected.to be(:something) }
+    end
   end
 
   context 'when coercion is turned off in options' do
@@ -38,7 +41,7 @@ describe Virtus::Attribute, '.build' do
 
     it_behaves_like 'a valid attribute instance'
 
-    it { should_not be_coercible }
+    it { is_expected.not_to be_coercible }
   end
 
   context 'when options specify reader visibility' do
@@ -46,8 +49,8 @@ describe Virtus::Attribute, '.build' do
 
     it_behaves_like 'a valid attribute instance'
 
-    it { should_not be_public_reader }
-    it { should be_public_writer }
+    it { is_expected.not_to be_public_reader }
+    it { is_expected.to be_public_writer }
   end
 
   context 'when options specify writer visibility' do
@@ -55,8 +58,8 @@ describe Virtus::Attribute, '.build' do
 
     it_behaves_like 'a valid attribute instance'
 
-    it { should be_public_reader }
-    it { should_not be_public_writer }
+    it { is_expected.to be_public_reader }
+    it { is_expected.not_to be_public_writer }
   end
 
   context 'when options specify lazy accessor' do
@@ -64,7 +67,7 @@ describe Virtus::Attribute, '.build' do
 
     it_behaves_like 'a valid attribute instance'
 
-    it { should be_lazy }
+    it { is_expected.to be_lazy }
   end
 
   context 'when options specify strict mode' do
@@ -72,7 +75,7 @@ describe Virtus::Attribute, '.build' do
 
     it_behaves_like 'a valid attribute instance'
 
-    it { should be_strict }
+    it { is_expected.to be_strict }
   end
 
   context 'when type is a string' do
@@ -80,7 +83,10 @@ describe Virtus::Attribute, '.build' do
 
     it_behaves_like 'a valid attribute instance'
 
-    its(:type) { should be(Axiom::Types::Integer) }
+    describe '#type' do
+      subject { super().type }
+      it { is_expected.to be(Axiom::Types::Integer) }
+    end
   end
 
   context 'when type is a range' do
@@ -88,7 +94,10 @@ describe Virtus::Attribute, '.build' do
 
     it_behaves_like 'a valid attribute instance'
 
-    its(:type) { should be(Axiom::Types.infer(Range)) }
+    describe '#type' do
+      subject { super().type }
+      it { is_expected.to be(Axiom::Types.infer(Range)) }
+    end
   end
 
   context 'when type is a symbol of an existing class constant' do
@@ -96,7 +105,10 @@ describe Virtus::Attribute, '.build' do
 
     it_behaves_like 'a valid attribute instance'
 
-    its(:type) { should be(Axiom::Types::String) }
+    describe '#type' do
+      subject { super().type }
+      it { is_expected.to be(Axiom::Types::String) }
+    end
   end
 
   context 'when type is an axiom type' do
@@ -104,7 +116,10 @@ describe Virtus::Attribute, '.build' do
 
     it_behaves_like 'a valid attribute instance'
 
-    its(:type) { should be(type) }
+    describe '#type' do
+      subject { super().type }
+      it { is_expected.to be(type) }
+    end
   end
 
   context 'when custom attribute class exists for a given primitive' do
@@ -115,9 +130,12 @@ describe Virtus::Attribute, '.build' do
       attribute.primitive(type)
     end
 
-    it { should be_instance_of(attribute) }
+    it { is_expected.to be_instance_of(attribute) }
 
-    its(:type) { should be(Axiom::Types::Object) }
+    describe '#type' do
+      subject { super().type }
+      it { is_expected.to be(Axiom::Types::Object) }
+    end
   end
 
   context 'when custom attribute class exists for a given array with member coercion defined' do
@@ -128,9 +146,12 @@ describe Virtus::Attribute, '.build' do
       attribute.primitive(type.class)
     end
 
-    it { should be_instance_of(attribute) }
+    it { is_expected.to be_instance_of(attribute) }
 
-    its(:type) { should be < Axiom::Types::Collection }
+    describe '#type' do
+      subject { super().type }
+      it { is_expected.to be < Axiom::Types::Collection }
+    end
   end
 
   context 'when custom collection-like attribute class exists for a given enumerable primitive' do
@@ -141,8 +162,11 @@ describe Virtus::Attribute, '.build' do
       attribute.primitive(type)
     end
 
-    it { should be_instance_of(attribute) }
+    it { is_expected.to be_instance_of(attribute) }
 
-    its(:type) { should be < Axiom::Types::Collection }
+    describe '#type' do
+      subject { super().type }
+      it { is_expected.to be < Axiom::Types::Collection }
+    end
   end
 end

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

@@ -18,7 +18,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 +30,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 +44,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 +58,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 +69,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)
 

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

@@ -6,9 +6,9 @@ describe Virtus::Attribute, '.build' do
   let(:options) { {} }
 
   shared_examples_for 'a valid collection attribute instance' do
-    it { should be_instance_of(Virtus::Attribute::Collection) }
+    it { is_expected.to be_instance_of(Virtus::Attribute::Collection) }
 
-    it { should be_frozen }
+    it { is_expected.to be_frozen }
   end
 
   context 'when type is Array' do

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])
 
@@ -66,7 +66,7 @@ describe Virtus::Attribute::Collection, '#coerce' do
     }
 
     it 'returns nil' do
-      stub(coercer).call(input) { input }
+      mock(coercer).call(input) { input }
 
       expect(subject).to be(input)
     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

@@ -10,11 +10,11 @@ describe Virtus::Attribute, '#defined?' do
   let(:instance) { model.new }
 
   context 'when the attribute value has not been defined' do
-    it { should be(false) }
+    it { is_expected.to be(false) }
   end
 
   context 'when the attribute value has been defined' do
     before { instance.test = nil }
-    it { should be(true) }
+    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