virtus2 2.0.1

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

@@ -0,0 +1,47 @@
+require 'spec_helper'
+
+describe Virtus::AttributeSet, '#<<' do
+  subject { object << attribute }
+
+  let(:attributes) { []                                      }
+  let(:parent)     { described_class.new                     }
+  let(:object)     { described_class.new(parent, attributes) }
+  let(:name)       { :name                                   }
+
+  context 'with a new attribute' do
+    let(:attribute) { Virtus::Attribute.build(String, :name => name) }
+
+    it { is_expected.to equal(object) }
+
+    it 'adds an attribute' do
+      expect { subject }.to change { object.to_a }.
+        from(attributes).
+        to([ attribute ])
+    end
+
+    it 'indexes the new attribute under its #name property' do
+      expect { subject }.to change { object[name] }.
+        from(nil).
+        to(attribute)
+    end
+
+    it 'indexes the new attribute under the string version of its #name property' do
+      expect { subject }.to change { object[name.to_s] }.
+        from(nil).
+        to(attribute)
+    end
+  end
+
+  context 'with a duplicate attribute' do
+    let(:attributes) { [Virtus::Attribute.build(String, :name => name)] }
+    let(:attribute)  { Virtus::Attribute.build(String, :name => name) }
+
+    it { is_expected.to equal(object) }
+
+    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

@@ -0,0 +1,36 @@
+require 'spec_helper'
+
+describe Virtus::AttributeSet, '#define_reader_method' do
+  subject(:attribute_set) { described_class.new }
+
+  let(:attribute) { Virtus::Attribute.build(String, :name => method_name) }
+  let(:method_name) { :foo_bar }
+
+  before do
+    attribute_set.define_reader_method(attribute, method_name, visibility)
+  end
+
+  context "with public visibility" do
+    let(:visibility) { :public }
+
+    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 }
+
+    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 }
+
+    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

@@ -0,0 +1,36 @@
+require 'spec_helper'
+
+describe Virtus::AttributeSet, '#define_writer_method' do
+  subject(:attribute_set) { described_class.new }
+
+  let(:attribute) { Virtus::Attribute.build(String, :name => method_name) }
+  let(:method_name) { :foo_bar }
+
+  before do
+    attribute_set.define_writer_method(attribute, method_name, visibility)
+  end
+
+  context "with public visibility" do
+    let(:visibility) { :public }
+
+    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 }
+
+    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 }
+
+    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

@@ -0,0 +1,65 @@
+require 'spec_helper'
+
+describe Virtus::AttributeSet, '#each' do
+  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(:yields)     { Set[] }
+
+  context 'with no block' do
+    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
+      result = []
+      attribute_set.each { |attribute| result << attribute }
+      expect(result).to eql(attributes)
+    end
+  end
+
+  context 'with a block' do
+    subject { attribute_set.each { |attribute| yields << attribute } }
+
+    context 'when the parent has no attributes' do
+      it { is_expected.to equal(attribute_set) }
+
+      it 'yields the expected attributes' do
+        expect { subject }.to change { yields.dup }.
+          from(Set[]).
+          to(attributes.to_set)
+      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 { is_expected.to equal(attribute_set) }
+
+      it 'yields the expected attributes' do
+        result = []
+
+        attribute_set.each { |attribute| result << attribute }
+
+        expect(result).to eql([parent_attribute, 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 { is_expected.to equal(attribute_set) }
+
+      it 'yields the expected attributes' do
+        expect { subject }.to change { yields.dup }.
+          from(Set[]).
+          to(Set[ attribute ])
+      end
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+require 'spec_helper'
+
+describe Virtus::AttributeSet, '#[]' do
+  subject { object[name] }
+
+  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) }
+
+  it { is_expected.to equal(attribute) }
+
+  it 'allows indexed access to attributes by the string representation of their name' do
+    expect(object[name.to_s]).to equal(attribute)
+  end
+end

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

@@ -0,0 +1,64 @@
+require 'spec_helper'
+
+describe Virtus::AttributeSet, '#[]=' do
+  subject { object[name] = attribute }
+
+  let(:attributes) { []                                      }
+  let(:parent)     { described_class.new                     }
+  let(:object)     { described_class.new(parent, attributes) }
+  let(:name)       { :name                                   }
+
+  context 'with a new attribute' do
+    let(:attribute) { Virtus::Attribute.build(String, :name => name) }
+
+    it { is_expected.to equal(attribute) }
+
+    it 'adds an attribute' do
+      expect { subject }.to change { object.to_a }.from(attributes).to([ attribute ])
+    end
+
+    it 'allows #[] to access the attribute with a symbol' do
+      expect { subject }.to change { object['name'] }.from(nil).to(attribute)
+    end
+
+    it 'allows #[] to access the attribute with a string' do
+      expect { subject }.to change { object[:name] }.from(nil).to(attribute)
+    end
+
+    it 'allows #reset to track overridden attributes' do
+      expect { subject }.to change { object.reset.to_a }.from(attributes).to([ attribute ])
+    end
+  end
+
+  context 'with a duplicate attribute' do
+    let(:original)   { Virtus::Attribute.build(String, :name => name) }
+    let(:attributes) { [ original ] }
+    let(:attribute)  { Virtus::Attribute.build(String, :name => name) }
+
+    it { is_expected.to equal(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 string' do
+      expect { subject }.to change { object['name'].__id__ }.
+      from(original.__id__).
+      to(attribute.__id__)
+    end
+
+    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.map(&:__id__) }.
+      from(attributes.map(&:__id__)).
+      to([attribute.__id__])
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+require 'spec_helper'
+
+describe Virtus::AttributeSet, '#merge' do
+  subject { object.merge(other) }
+
+  let(:parent) { described_class.new }
+  let(:object) { described_class.new(parent, attributes) }
+  let(:name)   { :name }
+  let(:other)  { [attribute] }
+
+  context 'with a new attribute' do
+    let(:attributes) { [] }
+    let(:attribute)  { Virtus::Attribute.build(String, :name => name) }
+
+    it { is_expected.to equal(object) }
+
+    it 'adds an attribute' do
+      expect { subject }.to change { object.to_a }.from(attributes).to([attribute])
+    end
+  end
+
+  context 'with a duplicate attribute' do
+    let(:attributes) { [Virtus::Attribute.build(String, :name => name)] }
+    let(:attribute)  {  Virtus::Attribute.build(String, :name => name) }
+
+    it { is_expected.to equal(object) }
+
+    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

@@ -0,0 +1,71 @@
+require 'spec_helper'
+
+describe Virtus::AttributeSet, '#reset' do
+  subject { object.reset }
+
+  let(:name)       { :name }
+  let(:attribute)  { Virtus::Attribute.build(String, :name => :name) }
+  let(:attributes) { [ attribute ]                           }
+  let(:object)     { described_class.new(parent, attributes) }
+
+  context 'when the parent has no attributes' do
+    let(:parent) { described_class.new }
+
+    it { is_expected.to equal(object) }
+
+    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 { is_expected.to equal(object) }
+
+    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 { is_expected.to equal(object) }
+
+    describe '#to_set' do
+      subject { super().to_set }
+      it { is_expected.to eq(Set[ attribute ]) }
+    end
+  end
+
+  context 'when the parent has changed' do
+    let(:parent_attribute) { Virtus::Attribute.build(String, :name => :parent_name) }
+    let(:parent)           { described_class.new([ parent_attribute ])       }
+    let(:new_attribute)    { Virtus::Attribute.build(String, :name => :parent_name) }
+
+    it { is_expected.to equal(object) }
+
+    it 'includes changes from the parent' do
+      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 { is_expected.to equal(object) }
+
+    it 'includes changes from the parent' do
+      expect { subject }.to_not change { object.to_set }
+    end
+  end
+end

data/spec/unit/virtus/attribute_spec.rb

@@ -0,0 +1,229 @@
+require 'spec_helper'
+
+describe Virtus, '#attribute' do
+  let(:name)    { :test }
+  let(:options) { {} }
+
+  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).to be_test
+    end
+
+    it 'defines predicate method' do
+      object.test = false
+
+      expect(object).to_not be_test
+    end
+  end
+
+  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
+      expect(subject.test).to eql('foo')
+    end
+  end
+
+  it 'returns self' do
+    klass = Class.new { include Virtus }
+    expect(klass.attribute(:test, String)).to be(klass)
+  end
+
+  it 'raises error when :name is a reserved name on a class' do
+    klass = Class.new { include Virtus }
+    expect { klass.attribute(:attributes, Set) }.to raise_error(
+      ArgumentError, ':attributes is not allowed as an attribute name'
+    )
+  end
+
+  it 'raises error when :name is a reserved name on an instance' do
+    object = Class.new.new.extend(Virtus)
+    expect { object.attribute(:attributes, Set) }.to raise_error(
+      ArgumentError, ':attributes is not allowed as an attribute name'
+    )
+  end
+
+  it 'allows :attributes as an attribute name when mass-assignment is not included' do
+    klass = Class.new { include Virtus::Model::Core }
+    klass.attribute(:attributes, Set)
+    expect(klass.attribute_set[:attributes]).to be_instance_of(Virtus::Attribute::Collection)
+  end
+
+  it 'allows specifying attribute without type' do
+    klass = Class.new { include Virtus::Model::Core }
+    klass.attribute(:name)
+    expect(klass.attribute_set[:name]).to be_instance_of(Virtus::Attribute)
+  end
+
+  context 'with a class' do
+    context 'when type is Boolean' do
+      before :all do
+        class Test
+          include Virtus
+
+          attribute :test, Boolean
+        end
+      end
+
+      after :all do
+        Object.send(:remove_const, :Test)
+      end
+
+      it_behaves_like 'a class with boolean attribute'
+    end
+
+    context 'when type is "Boolean"' do
+      before :all do
+        class Test
+          include Virtus
+
+          attribute :test, 'Boolean'
+        end
+      end
+
+      after :all do
+        Object.send(:remove_const, :Test)
+      end
+
+      it_behaves_like 'a class with boolean attribute'
+    end
+
+    context 'when type is Axiom::Types::Boolean' do
+      before :all do
+        class Test
+          include Virtus
+
+          attribute :test, Axiom::Types::Boolean
+        end
+      end
+
+      after :all do
+        Object.send(:remove_const, :Test)
+      end
+
+      it_behaves_like 'a class with boolean attribute' do
+        before do
+          pending 'this will be fixed once Attribute::Boolean subclass is gone'
+        end
+      end
+    end
+
+    context 'when type is :Boolean' do
+      before :all do
+        class Test
+          include Virtus
+
+          attribute :test, 'Boolean'
+        end
+      end
+
+      after :all do
+        Object.send(:remove_const, :Test)
+      end
+
+      it_behaves_like 'a class with boolean attribute'
+
+      context 'with a subclass' do
+        it_behaves_like 'a class with boolean attribute' do
+          subject { Class.new(Test) }
+
+          it 'gets attributes from the parent class' do
+            Test.attribute :other, Integer
+            expect(subject.attribute_set[:other]).to eql(Test.attribute_set[:other])
+          end
+        end
+      end
+    end
+
+    context 'when type is Decimal' do
+      before :all do
+        class Test
+          include Virtus
+
+          attribute :test, Decimal
+        end
+      end
+
+      after :all do
+        Object.send(:remove_const, :Test)
+      end
+
+      it 'maps type to the corresponding axiom type' do
+        expect(Test.attribute_set[:test].type).to be(Axiom::Types::Decimal)
+      end
+    end
+  end
+
+  context 'with a module' do
+    let(:mod) {
+      Module.new {
+        include Virtus
+
+        attribute :test, String
+      }
+    }
+
+    let(:model) { Class.new }
+
+    context 'included in the class' do
+      before do
+        model.send(:include, mod)
+      end
+
+      it 'adds attributes from the module to a class that includes it' do
+        expect(model.attribute_set[:test]).to be_instance_of(Virtus::Attribute)
+      end
+
+      it_behaves_like 'an object with string attribute' do
+        subject { model.new }
+      end
+    end
+
+    context 'included in the class' do
+      it_behaves_like 'an object with string attribute' do
+        subject { model.new.extend(mod) }
+      end
+    end
+  end
+
+  context 'with an instance' do
+    subject { model.new }
+
+    let(:model) { Class.new }
+
+    before do
+      subject.extend(Virtus)
+      subject.attribute(:test, String)
+    end
+
+    it_behaves_like 'an object with string attribute'
+  end
+
+  context 'using custom module' do
+    subject { model.new }
+
+    let(:model) {
+      Class.new {
+        include Virtus.model { |config| config.coerce = false }
+
+        attribute :test, String
+      }
+    }
+
+    it { is_expected.to respond_to(:test) }
+    it { is_expected.to respond_to(:test=) }
+
+    it 'writes and reads attributes' do
+      subject.test = :foo
+      expect(subject.test).to be(:foo)
+    end
+  end
+end