virtus 1.0.1 → 2.0.0

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

@@ -9,9 +9,9 @@ describe Virtus::AttributeSet, '#[]' do
   let(:parent)     { described_class.new                     }
   let(:object)     { described_class.new(parent, attributes) }
 
-  it { should equal(attribute) }
+  it { is_expected.to equal(attribute) }
 
   it 'allows indexed access to attributes by the string representation of their name' do
-    object[name.to_s].should equal(attribute)
+    expect(object[name.to_s]).to equal(attribute)
   end
 end

data/spec/unit/virtus/attribute_set/element_set_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(attribute) }
+    it { is_expected.to equal(attribute) }
 
     it 'adds an attribute' do
       expect { subject }.to change { object.to_a }.from(attributes).to([ attribute ])
@@ -35,22 +35,30 @@ describe Virtus::AttributeSet, '#[]=' do
     let(:attributes) { [ original ] }
     let(:attribute)  { Virtus::Attribute.build(String, :name => name) }
 
-    it { should equal(attribute) }
+    it { is_expected.to equal(attribute) }
 
-    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
 
-    it 'allows #[] to access the attribute with a symbol' do
-      expect { subject }.to change { object['name'] }.from(original).to(attribute)
+    it 'allows #[] to access the attribute with a string' do
+      expect { subject }.to change { object['name'].__id__ }.
+      from(original.__id__).
+      to(attribute.__id__)
     end
 
-    it 'allows #[] to access the attribute with a string' do
-      expect { subject }.to change { object[:name] }.from(original).to(attribute)
+    it 'allows #[] to access the attribute with a symbol' do
+      expect { subject }.to change { object[:name].__id__ }.
+      from(original.__id__).
+      to(attribute.__id__)
     end
 
     it 'allows #reset to track overridden attributes' do
-      expect { subject }.to change { object.reset.to_a }.from(attributes).to([ attribute ])
+      expect { subject }.to change { object.reset.to_a.map(&:__id__) }.
+      from(attributes.map(&:__id__)).
+      to([attribute.__id__])
     end
   end
 end

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

@@ -12,7 +12,7 @@ describe Virtus::AttributeSet, '#merge' do
     let(:attributes) { [] }
     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 }.from(attributes).to([attribute])
@@ -21,12 +21,14 @@ describe Virtus::AttributeSet, '#merge' do
 
   context 'with a duplicate attribute' do
     let(:attributes) { [Virtus::Attribute.build(String, :name => name)] }
-    let(:attribute)  { 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/reset_spec.rb

@@ -11,27 +11,36 @@ describe Virtus::AttributeSet, '#reset' do
   context 'when the parent has no attributes' do
     let(:parent) { described_class.new }
 
-    it { should equal(object) }
+    it { is_expected.to equal(object) }
 
-    its(:to_set) { should == Set[ attribute ] }
+    describe '#to_set' do
+      subject { super().to_set }
+      it { is_expected.to eq(Set[ attribute ]) }
+    end
   end
 
   context 'when the parent has attributes that are not duplicates' 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(object) }
 
-    its(:to_set) { should == Set[ attribute, parent_attribute ] }
+    describe '#to_set' do
+      subject { super().to_set }
+      it { is_expected.to eq(Set[ attribute, parent_attribute ]) }
+    end
   end
 
   context 'when the parent has attributes that are duplicates' 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(object) }
 
-    its(:to_set) { should == Set[ attribute ] }
+    describe '#to_set' do
+      subject { super().to_set }
+      it { is_expected.to eq(Set[ attribute ]) }
+    end
   end
 
   context 'when the parent has changed' do
@@ -39,19 +48,21 @@ describe Virtus::AttributeSet, '#reset' do
     let(:parent)           { described_class.new([ parent_attribute ])       }
     let(:new_attribute)    { Virtus::Attribute.build(String, :name => :parent_name) }
 
-    it { should equal(object) }
+    it { is_expected.to equal(object) }
 
     it 'includes changes from the parent' do
-      expect { parent << new_attribute; subject }.to change { object.to_set }.
-        from(Set[ attribute, parent_attribute ]).
-        to(Set[ attribute, new_attribute ])
+      expect(object.to_set).to eql(Set[attribute, parent_attribute])
+
+      parent << new_attribute
+
+      expect(subject.to_set).to eql(Set[attribute, new_attribute])
     end
   end
 
   context 'when the parent is nil' do
     let(:parent) { nil }
 
-    it { should equal(object) }
+    it { is_expected.to equal(object) }
 
     it 'includes changes from the parent' do
       expect { subject }.to_not change { object.to_set }

data/spec/unit/virtus/attribute_spec.rb

@@ -4,14 +4,15 @@ describe Virtus, '#attribute' do
   let(:name)    { :test }
   let(:options) { {} }
 
-  share_examples_for 'a class with boolean attribute' do
+  shared_examples_for 'a class with boolean attribute' do
     subject { Test }
 
     let(:object) { subject.new }
 
     it 'defines reader and writer' do
       object.test = true
-      expect(object.test).to be(true)
+
+      expect(object).to be_test
     end
 
     it 'defines predicate method' do
@@ -21,9 +22,9 @@ describe Virtus, '#attribute' do
     end
   end
 
-  share_examples_for 'an object with string attribute' do
-    it { should respond_to(:test) }
-    it { should respond_to(:test=) }
+  shared_examples_for 'an object with string attribute' do
+    it { is_expected.to respond_to(:test) }
+    it { is_expected.to respond_to(:test=) }
 
     it 'can write and read the attribute' do
       subject.test = :foo
@@ -217,8 +218,8 @@ describe Virtus, '#attribute' do
       }
     }
 
-    it { should respond_to(:test) }
-    it { should respond_to(:test=) }
+    it { is_expected.to respond_to(:test) }
+    it { is_expected.to respond_to(:test=) }
 
     it 'writes and reads attributes' do
       subject.test = :foo

data/spec/unit/virtus/attributes_reader_spec.rb

@@ -2,7 +2,7 @@ require 'spec_helper'
 
 describe Virtus, '#attributes' do
 
-  share_examples_for 'attribute hash' do
+  shared_examples_for 'attribute hash' do
     it 'includes all attributes' do
       subject.attributes = { :test => 'Hello World', :test_priv => 'Yo' }
 

data/spec/unit/virtus/attributes_writer_spec.rb

@@ -2,7 +2,7 @@ require 'spec_helper'
 
 describe Virtus, '#attributes=' do
 
-  share_examples_for 'mass-assignment' do
+  shared_examples_for 'mass-assignment' do
     it 'allows writing known attributes' do
       subject.attributes = { :test => 'Hello World' }
 

data/spec/unit/virtus/element_reader_spec.rb

@@ -17,5 +17,5 @@ describe Virtus, '#[]' do
     object.test = 'foo'
   end
 
-  it { should eq('foo') }
+  it { is_expected.to eq('foo') }
 end

data/spec/unit/virtus/freeze_spec.rb

@@ -9,13 +9,33 @@ describe Virtus, '#freeze' do
 
       attribute :name, String,  :default => 'foo', :lazy => true
       attribute :age,  Integer, :default => 30
+      attribute :rand, Float,   :default => Proc.new { rand }
     }
   }
 
   let(:object) { model.new }
 
-  it { should be_frozen }
+  it { is_expected.to be_frozen }
 
-  its(:name) { should eql('foo') }
-  its(:age)  { should be(30) }
+  describe '#name' do
+    subject { super().name }
+    it { is_expected.to eql('foo') }
+  end
+
+  describe '#age' do
+    subject { super().age }
+    it { is_expected.to be(30) }
+  end
+
+  it "does not change dynamic default values" do
+    original_value = object.rand
+    object.freeze
+    expect(object.rand).to eq original_value
+  end
+
+  it "does not change default attributes that have been explicitly set" do
+    object.rand = 3.14
+    object.freeze
+    expect(object.rand).to eq 3.14
+  end
 end

data/spec/unit/virtus/model_spec.rb

@@ -1,14 +1,14 @@
 require 'spec_helper'
 
 describe Virtus, '.model' do
-  share_examples_for 'a model with constructor' do
+  shared_examples_for 'a model with constructor' do
     it 'accepts attribute hash' do
       instance = subject.new(:name => 'Jane')
       expect(instance.name).to eql('Jane')
     end
   end
 
-  share_examples_for 'a model with mass-assignment' do
+  shared_examples_for 'a model with mass-assignment' do
     let(:attributes) do
       { :name => 'Jane', :something => nil }
     end
@@ -22,7 +22,7 @@ describe Virtus, '.model' do
     end
   end
 
-  share_examples_for 'a model with strict mode turned off' do
+  shared_examples_for 'a model with strict mode turned off' do
     it 'has attributes with strict set to false' do
       expect(subject.send(:attribute_set)[:name]).to_not be_strict
     end
@@ -148,8 +148,8 @@ describe Virtus, '.model' do
         model.send(:include, mod)
       end
 
-      it { should_not respond_to(:attributes) }
-      it { should_not respond_to(:attributes=) }
+      it { is_expected.not_to respond_to(:attributes) }
+      it { is_expected.not_to respond_to(:attributes=) }
     end
 
     context 'with an instance' do
@@ -159,8 +159,39 @@ describe Virtus, '.model' do
         subject.extend(mod)
       end
 
-      it { should_not respond_to(:attributes) }
-      it { should_not respond_to(:attributes=) }
+      it { is_expected.not_to respond_to(:attributes) }
+      it { is_expected.not_to respond_to(:attributes=) }
+    end
+  end
+
+  context 'when :required is set' do
+    let(:mod)   { Virtus.model(:required => false) }
+    let(:model) { Class.new }
+
+    context 'with a class' do
+      subject { model.new }
+
+      before do
+        model.send(:include, mod)
+        model.attribute :name, String
+      end
+
+      it 'has attributes with :required option inherited from module' do
+        expect(model.attribute_set[:name]).to_not be_required
+      end
+    end
+
+    context 'with an instance' do
+      subject { model.new }
+
+      before do
+        subject.extend(mod)
+        subject.attribute :name, String
+      end
+
+      it 'has attributes with strict set to true' do
+        expect(subject.send(:attribute_set)[:name]).not_to be_required
+      end
     end
   end
 end

data/spec/unit/virtus/module_spec.rb

@@ -1,14 +1,14 @@
 require 'spec_helper'
 
 describe Virtus, '.module' do
-  share_examples_for 'a valid virtus object' do
+  shared_examples_for 'a valid virtus object' do
     it 'reads and writes attribute' do
       instance.name = 'John'
       expect(instance.name).to eql('John')
     end
   end
 
-  share_examples_for 'an object extended with virtus module' do
+  shared_examples_for 'an object extended with virtus module' do
     context 'with default configuration' do
       subject { Virtus.module }
 
@@ -114,4 +114,61 @@ describe Virtus, '.module' do
     end
   end
 
+  context 'as a peer to another module within a class' do
+    subject { Virtus.module }
+    let(:other)  { Module.new }
+
+    before do
+      other.send(:include, Virtus.module)
+      other.attribute :last_name, String, :default => 'Doe'
+      other.attribute :something_else
+      model.send(:include, mod)
+      model.send(:include, other)
+    end
+
+    it 'provides attributes for the model from both modules' do
+      expect(model.attribute_set[:name]).to be_kind_of(Virtus::Attribute)
+      expect(model.attribute_set[:something]).to be_kind_of(Virtus::Attribute)
+      expect(model.attribute_set[:last_name]).to be_kind_of(Virtus::Attribute)
+      expect(model.attribute_set[:something_else]).to be_kind_of(Virtus::Attribute)
+    end
+
+    it 'includes the attributes from both modules' do
+      expect(model.new.attributes.keys).to eq(
+        [:name, :something, :last_name, :something_else]
+      )
+    end
+  end
+
+  context 'with multiple other modules mixed into it' do
+    subject { Virtus.module }
+    let(:other)  { Module.new }
+    let(:yet_another)  { Module.new }
+
+    before do
+      other.send(:include, Virtus.module)
+      other.attribute :last_name, String, :default => 'Doe'
+      other.attribute :something_else
+      yet_another.send(:include, Virtus.module)
+      yet_another.send(:include, mod)
+      yet_another.send(:include, other)
+      yet_another.attribute :middle_name, String, :default => 'Foobar'
+      model.send(:include, yet_another)
+    end
+
+    it 'provides attributes for the model from all modules' do
+      expect(model.attribute_set[:name]).to be_kind_of(Virtus::Attribute)
+      expect(model.attribute_set[:something]).to be_kind_of(Virtus::Attribute)
+      expect(model.attribute_set[:last_name]).to be_kind_of(Virtus::Attribute)
+      expect(model.attribute_set[:something_else]).to be_kind_of(Virtus::Attribute)
+      expect(model.attribute_set[:middle_name]).to be_kind_of(Virtus::Attribute)
+    end
+
+    it 'includes the attributes from all modules' do
+      expect(model.new.attributes.keys).to eq(
+        [:name, :something, :last_name, :something_else, :middle_name]
+      )
+    end
+  end
+
 end

data/spec/unit/virtus/set_default_attributes_spec.rb

@@ -18,8 +18,15 @@ describe Virtus, '#set_default_attributes!' do
     object.set_default_attributes!
   end
 
-  it { should be(object) }
+  it { is_expected.to be(object) }
 
-  its(:name) { should eql('foo') }
-  its(:age)  { should be(30) }
+  describe '#name' do
+    subject { super().name }
+    it { is_expected.to eql('foo') }
+  end
+
+  describe '#age' do
+    subject { super().age }
+    it { is_expected.to be(30) }
+  end
 end

data/spec/unit/virtus/value_object_spec.rb

@@ -1,13 +1,20 @@
 require 'spec_helper'
 
 describe Virtus::ValueObject do
-  share_examples_for 'a valid value object' do
+  shared_examples_for 'a valid value object' do
     subject { model.new(attributes) }
 
     let(:attributes) { Hash[:id => 1, :name => 'Jane Doe'] }
 
-    its(:id)   { should be(1) }
-    its(:name) { should eql('Jane Doe') }
+    describe '#id' do
+      subject { super().id }
+      it { is_expected.to be(1) }
+    end
+
+    describe '#name' do
+      subject { super().name }
+      it { is_expected.to eql('Jane Doe') }
+    end
 
     it 'sets private writers' do
       expect(subject.class.attribute_set[:id]).to_not be_public_writer
@@ -43,7 +50,7 @@ describe Virtus::ValueObject do
     end
   end
 
-  share_examples_for 'a valid value object with mass-assignment turned on' do
+  shared_examples_for 'a valid value object with mass-assignment turned on' do
     subject { model.new }
 
     it 'disallows mass-assignment' do
@@ -95,7 +102,10 @@ describe Virtus::ValueObject do
 
           let(:attributes) { Hash[:id => 1, :name => 'Jane Doe', :email => 'jane@doe.com'] }
 
-          its(:email) { should eql('jane@doe.com') }
+          describe '#email' do
+            subject { super().email }
+            it { is_expected.to eql('jane@doe.com') }
+          end
 
           it 'sets private writers for additional values' do
             expect(subclass.attribute_set[:email]).to_not be_public_writer