virtus 1.0.1 → 2.0.0

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

@@ -16,13 +16,13 @@ describe Virtus::Attribute, '#get' do
       instance.test = value
     end
 
-    it { should be(value) }
+    it { is_expected.to be(value) }
   end
 
   context 'with :lazy is set to true' do
     let(:options) { { :lazy => true, :default => value } }
 
-    it { should eql(value) }
+    it { is_expected.to eql(value) }
 
     it 'sets default only on first access' do
       expect(object.get(instance)).to eql(value)

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

@@ -1,18 +1,20 @@
 require 'spec_helper'
 
 describe Virtus::Attribute::Hash, '.build' do
-  subject { described_class.build(type) }
+  subject { described_class.build(type, options) }
 
-  share_examples_for 'a valid hash attribute instance' do
-    it { should be_instance_of(Virtus::Attribute::Hash) }
+  let(:options) { {} }
 
-    it { should be_frozen }
+  shared_examples_for 'a valid hash attribute instance' do
+    it { is_expected.to be_instance_of(Virtus::Attribute::Hash) }
+
+    it { is_expected.to be_frozen }
   end
 
   context 'when type is Hash' do
     let(:type) { Hash }
 
-    it { should be_instance_of(Virtus::Attribute::Hash) }
+    it { is_expected.to be_instance_of(Virtus::Attribute::Hash) }
 
     it 'sets default key type' do
       expect(subject.type.key_type).to be(Axiom::Types::Object)
@@ -26,7 +28,7 @@ describe Virtus::Attribute::Hash, '.build' do
   context 'when type is Hash[String => Integer]' do
     let(:type) { Hash[String => Integer] }
 
-    it { should be_instance_of(Virtus::Attribute::Hash) }
+    it { is_expected.to be_instance_of(Virtus::Attribute::Hash) }
 
     it 'sets key type' do
       expect(subject.type.key_type).to be(Axiom::Types::String)
@@ -40,7 +42,7 @@ describe Virtus::Attribute::Hash, '.build' do
   context 'when type is Hash[Virtus::Attribute::Hash => Virtus::Attribute::Boolean]' do
     let(:type) { Hash[Virtus::Attribute::Hash => Virtus::Attribute::Boolean] }
 
-    it { should be_instance_of(Virtus::Attribute::Hash) }
+    it { is_expected.to be_instance_of(Virtus::Attribute::Hash) }
 
     it 'sets key type' do
       expect(subject.type.key_type).to be(Axiom::Types::Hash)
@@ -55,7 +57,7 @@ describe Virtus::Attribute::Hash, '.build' do
     let(:type)     { Hash[key_type => Integer] }
     let(:key_type) { Struct.new(:id) }
 
-    it { should be_instance_of(Virtus::Attribute::Hash) }
+    it { is_expected.to be_instance_of(Virtus::Attribute::Hash) }
 
     it 'sets key type' do
       expect(subject.type.key_type).to be(key_type)
@@ -70,7 +72,7 @@ describe Virtus::Attribute::Hash, '.build' do
     let(:type)       { Hash[String => value_type] }
     let(:value_type) { Struct.new(:id) }
 
-    it { should be_instance_of(Virtus::Attribute::Hash) }
+    it { is_expected.to be_instance_of(Virtus::Attribute::Hash) }
 
     it 'sets key type' do
       expect(subject.type.key_type).to be(Axiom::Types::String)
@@ -91,4 +93,14 @@ describe Virtus::Attribute::Hash, '.build' do
       )
     end
   end
+
+  context 'when strict mode is used' do
+    let(:type) { Hash[String => Integer] }
+    let(:options) { { :strict => true } }
+
+    it 'sets the strict mode for key/value types' do
+      expect(subject.key_type).to be_strict
+      expect(subject.value_type).to be_strict
+    end
+  end
 end

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

@@ -17,14 +17,14 @@ describe Virtus::Attribute::Hash, '#coerce' do
     let(:input)  { Class.new { def to_hash; { :hello => 'World' }; end }.new }
     let(:object) { described_class.build(Hash) }
 
-    it { should eq(:hello => 'World') }
+    it { is_expected.to eq(:hello => 'World') }
   end
 
   context 'when input is not coercible to hash' do
     let(:input)  { 'not really a hash' }
     let(:object) { described_class.build(Hash) }
 
-    it { should be(input) }
+    it { is_expected.to be(input) }
   end
 
   context 'when input is a hash' do
@@ -39,15 +39,15 @@ describe Virtus::Attribute::Hash, '#coerce' do
       let(:input) { Hash[1 => '1', 2 => '2'] }
 
       it 'uses coercer to coerce key and value' do
-        stub(coercer).call(input) { input }
+        mock(coercer).call(input) { input }
 
-        stub(key_type).finalize { key_type }
-        stub(key_type).coerce(1) { '1' }
-        stub(key_type).coerce(2) { '2' }
+        mock(key_type).finalize { key_type }
+        mock(key_type).coerce(1) { '1' }
+        mock(key_type).coerce(2) { '2' }
 
-        stub(value_type).finalize { value_type }
-        stub(value_type).coerce('1') { 1 }
-        stub(value_type).coerce('2') { 2 }
+        mock(value_type).finalize { value_type }
+        mock(value_type).coerce('1') { 1 }
+        mock(value_type).coerce('2') { 2 }
 
         expect(subject).to eq(Hash['1' => 1, '2' => 2])
 

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

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

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

@@ -6,8 +6,11 @@ describe Virtus::Attribute, '#rename' do
   let(:object) { described_class.build(String, :name => :foo, :strict => true) }
   let(:other)  { described_class.build(String, :name => :bar, :strict => true) }
 
-  its(:name) { should be(:bar) }
+  describe '#name' do
+    subject { super().name }
+    it { is_expected.to be(:bar) }
+  end
 
-  it { should_not be(object) }
-  it { should be_strict }
+  it { is_expected.not_to be(object) }
+  it { is_expected.to be_strict }
 end

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

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

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

@@ -15,8 +15,15 @@ describe Virtus::Attribute, '#set_default_value' do
 
     let(:default) { nil }
 
-    its(:test) { should be(nil) }
-    its(:instance_variables) { should include(:'@test') }
+    describe '#test' do
+      subject { super().test }
+      it { is_expected.to be(nil) }
+    end
+
+    describe '#instance_variables' do
+      subject { super().instance_variables }
+      it { is_expected.to include(:'@test') }
+    end
   end
 
   context 'with a non-clonable object' do
@@ -25,8 +32,15 @@ describe Virtus::Attribute, '#set_default_value' do
     let(:object)  { described_class.build('Boolean', options.merge(:name => name, :default => default)) }
     let(:default) { true }
 
-    its(:test) { should be(true) }
-    its(:instance_variables) { should include(:'@test') }
+    describe '#test' do
+      subject { super().test }
+      it { is_expected.to be(true) }
+    end
+
+    describe '#instance_variables' do
+      subject { super().instance_variables }
+      it { is_expected.to include(:'@test') }
+    end
   end
 
   context 'with a clonable' do
@@ -34,8 +48,15 @@ describe Virtus::Attribute, '#set_default_value' do
 
     let(:default) { [] }
 
-    its(:test) { should eq(default) }
-    its(:test) { should_not be(default) }
+    describe '#test' do
+      subject { super().test }
+      it { is_expected.to eq(default) }
+    end
+
+    describe '#test' do
+      subject { super().test }
+      it { is_expected.not_to be(default) }
+    end
   end
 
   context 'with a callable' do
@@ -43,7 +64,10 @@ describe Virtus::Attribute, '#set_default_value' do
 
     let(:default) { lambda { |model, attribute| "#{model.name}-#{attribute.name}" } }
 
-    its(:test) { should eq('model-test') }
+    describe '#test' do
+      subject { super().test }
+      it { is_expected.to eq('model-test') }
+    end
   end
 
   context 'with a symbol' do
@@ -55,20 +79,29 @@ describe Virtus::Attribute, '#set_default_value' do
       context 'when method is public' do
         let(:model) { Class.new { attr_reader :test; def set_test; @test = 'hello world'; end } }
 
-        its(:test) { should eq('hello world') }
+        describe '#test' do
+          subject { super().test }
+          it { is_expected.to eq('hello world') }
+        end
       end
 
       context 'when method is private' do
         let(:model) { Class.new { attr_reader :test; private; def set_test; @test = 'hello world'; end } }
 
-        its(:test) { should eq('hello world') }
+        describe '#test' do
+          subject { super().test }
+          it { is_expected.to eq('hello world') }
+        end
       end
     end
 
     context 'when it is not a method name' do
       let(:default) { :hello_world }
 
-      its(:test) { should eq('hello_world') }
+      describe '#test' do
+        subject { super().test }
+        it { is_expected.to eq('hello_world') }
+      end
     end
   end
 end

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

@@ -11,7 +11,7 @@ describe Virtus::Attribute, '#set' do
   let(:value)    { 'Jane Doe' }
   let(:options)  { {} }
 
-  it { should be(value) }
+  it { is_expected.to be(value) }
 
   context 'without coercion' do
     specify do

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

@@ -8,12 +8,12 @@ describe Virtus::Attribute, '#value_coerced?' do
   context 'when input is coerced' do
     let(:input)  { '1' }
 
-    it { should be(true) }
+    it { is_expected.to be(true) }
   end
 
   context 'when input is not coerced' do
     let(:input)  { 1 }
 
-    it { should be(false) }
+    it { is_expected.to be(false) }
   end
 end

data/spec/unit/virtus/attribute_set/append_spec.rb

@@ -11,7 +11,7 @@ describe Virtus::AttributeSet, '#<<' do
   context 'with a new attribute' do
     let(:attribute) { Virtus::Attribute.build(String, :name => name) }
 
-    it { should equal(object) }
+    it { is_expected.to equal(object) }
 
     it 'adds an attribute' do
       expect { subject }.to change { object.to_a }.
@@ -36,12 +36,12 @@ describe Virtus::AttributeSet, '#<<' do
     let(:attributes) { [Virtus::Attribute.build(String, :name => name)] }
     let(:attribute)  { Virtus::Attribute.build(String, :name => name) }
 
-    it { should equal(object) }
+    it { is_expected.to equal(object) }
 
-    it 'replaces the original attribute' do
-      expect { subject }.to change { object.to_a }.
-        from(attributes).
-        to([ attribute ])
+    it "replaces the original attribute object" do
+      expect { subject }.to change { object.to_a.map(&:__id__) }.
+      from(attributes.map(&:__id__)).
+      to([attribute.__id__])
     end
   end
 end

data/spec/unit/virtus/attribute_set/define_reader_method_spec.rb

@@ -1,35 +1,36 @@
 require 'spec_helper'
 
 describe Virtus::AttributeSet, '#define_reader_method' do
-  subject { described_class.new }
+  subject(:attribute_set) { described_class.new }
 
   let(:attribute) { Virtus::Attribute.build(String, :name => method_name) }
-
-  if RUBY_VERSION < '1.9'
-    let(:method_name) { 'foo_bar' }
-  else
-    let(:method_name) { :foo_bar }
-  end
+  let(:method_name) { :foo_bar }
 
   before do
-    subject.define_reader_method(attribute, method_name, visibility)
+    attribute_set.define_reader_method(attribute, method_name, visibility)
   end
 
   context "with public visibility" do
     let(:visibility) { :public }
 
-    its(:public_instance_methods) { should include(method_name) }
+    it "defines public writer" do
+      expect(attribute_set.public_instance_methods).to include(method_name)
+    end
   end
 
   context "with private visibility" do
     let(:visibility) { :private }
 
-    its(:private_instance_methods) { should include(method_name) }
+    it "defines public writer" do
+      expect(attribute_set.private_instance_methods).to include(method_name)
+    end
   end
 
   context "with protected visibility" do
     let(:visibility) { :protected }
 
-    its(:protected_instance_methods) { should include(method_name) }
+    it "defines protected writer" do
+      expect(attribute_set.protected_instance_methods).to include(method_name)
+    end
   end
 end

data/spec/unit/virtus/attribute_set/define_writer_method_spec.rb

@@ -1,35 +1,36 @@
 require 'spec_helper'
 
 describe Virtus::AttributeSet, '#define_writer_method' do
-  subject { described_class.new }
+  subject(:attribute_set) { described_class.new }
 
-  let(:attribute) { Virtus::Attribute.build(String, :name => :foo_bar) }
-
-  if RUBY_VERSION < '1.9'
-    let(:method_name) { 'foo_bar=' }
-  else
-    let(:method_name) { :foo_bar= }
-  end
+  let(:attribute) { Virtus::Attribute.build(String, :name => method_name) }
+  let(:method_name) { :foo_bar }
 
   before do
-    subject.define_reader_method(attribute, method_name, visibility)
+    attribute_set.define_writer_method(attribute, method_name, visibility)
   end
 
   context "with public visibility" do
     let(:visibility) { :public }
 
-    its(:public_instance_methods) { should include(method_name) }
+    it "defines public writer" do
+      expect(attribute_set.public_instance_methods).to include(method_name)
+    end
   end
 
   context "with private visibility" do
     let(:visibility) { :private }
 
-    its(:private_instance_methods) { should include(method_name) }
+    it "defines private writer" do
+      expect(attribute_set.private_instance_methods).to include(method_name)
+    end
   end
 
   context "with protected visibility" do
     let(:visibility) { :protected }
 
-    its(:protected_instance_methods) { should include(method_name) }
+    it "defines protected writer" do
+      expect(attribute_set.protected_instance_methods).to include(method_name)
+    end
   end
 end

data/spec/unit/virtus/attribute_set/each_spec.rb

@@ -1,28 +1,31 @@
 require 'spec_helper'
 
 describe Virtus::AttributeSet, '#each' do
-  let(:name)       { :name                                   }
+  subject(:attribute_set) { described_class.new(parent, attributes) }
+
+  let(:name)       { :name }
   let(:attribute)  { Virtus::Attribute.build(String, :name => :name) }
-  let(:attributes) { [ attribute ]                           }
-  let(:parent)     { described_class.new                     }
-  let(:object)     { described_class.new(parent, attributes) }
-  let(:yields)     { Set[]                                   }
+  let(:attributes) { [ attribute ] }
+  let(:parent)     { described_class.new }
+  let(:yields)     { Set[] }
 
   context 'with no block' do
-    subject { object.each }
-
-    it { should be_instance_of(to_enum.class) }
+    it 'returns an enumerator when block is not provided' do
+      expect(attribute_set.each).to be_kind_of(Enumerator)
+    end
 
     it 'yields the expected attributes' do
-      subject.to_a.should eql(object.to_a)
+      result = []
+      attribute_set.each { |attribute| result << attribute }
+      expect(result).to eql(attributes)
     end
   end
 
   context 'with a block' do
-    subject { object.each { |attribute| yields << attribute } }
+    subject { attribute_set.each { |attribute| yields << attribute } }
 
     context 'when the parent has no attributes' do
-      it { should equal(object) }
+      it { is_expected.to equal(attribute_set) }
 
       it 'yields the expected attributes' do
         expect { subject }.to change { yields.dup }.
@@ -35,12 +38,14 @@ describe Virtus::AttributeSet, '#each' do
       let(:parent_attribute) { Virtus::Attribute.build(String, :name => :parent_name) }
       let(:parent)           { described_class.new([ parent_attribute ])       }
 
-      it { should equal(object) }
+      it { is_expected.to equal(attribute_set) }
 
       it 'yields the expected attributes' do
-        expect { subject }.to change { yields.dup }.
-          from(Set[]).
-          to(Set[ attribute, parent_attribute ])
+        result = []
+
+        attribute_set.each { |attribute| result << attribute }
+
+        expect(result).to eql([parent_attribute, attribute])
       end
     end
 
@@ -48,7 +53,7 @@ describe Virtus::AttributeSet, '#each' do
       let(:parent_attribute) { Virtus::Attribute.build(String, :name => name) }
       let(:parent)           { described_class.new([ parent_attribute ]) }
 
-      it { should equal(object) }
+      it { is_expected.to equal(attribute_set) }
 
       it 'yields the expected attributes' do
         expect { subject }.to change { yields.dup }.