virtus2 2.0.1

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

@@ -0,0 +1,20 @@
+require 'spec_helper'
+
+describe Virtus::Attribute, '#coercible?' do
+  subject { object.coercible? }
+
+  let(:object)  { described_class.build(String, options) }
+  let(:options) { Hash[:coerce => coerce] }
+
+  context 'when :coerce is set to true' do
+    let(:coerce) { true }
+
+    it { is_expected.to be(true) }
+  end
+
+  context 'when :coerce is set to false' do
+    let(:coerce) { false }
+
+    it { is_expected.to be(false) }
+  end
+end

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

@@ -0,0 +1,105 @@
+require 'spec_helper'
+
+describe Virtus::Attribute, '.build' do
+  subject { described_class.build(type, options) }
+
+  let(:options) { {} }
+
+  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
+    let(:type) { Array }
+
+    it_behaves_like 'a valid collection attribute instance'
+
+    it 'sets default member type' do
+      expect(subject.type.member_type).to be(Axiom::Types::Object)
+    end
+  end
+
+  context 'when type is Array[Virtus::Attribute::Boolean]' do
+    let(:type) { Array[Virtus::Attribute::Boolean] }
+
+    it_behaves_like 'a valid collection attribute instance'
+
+    it 'sets member type' do
+      expect(subject.type.member_type).to be(Axiom::Types::Boolean)
+    end
+  end
+
+  context 'when type is Array[Float]' do
+    let(:type) { Array[Float] }
+
+    it_behaves_like 'a valid collection attribute instance'
+
+    it 'sets member type' do
+      expect(subject.type.member_type).to be(Axiom::Types::Float)
+    end
+  end
+
+  context 'when type is Array[String, Integer]' do
+    let(:type) { Array[String, Integer] }
+
+    specify do
+      expect { subject }.to raise_error(
+        NotImplementedError,
+        "build SumType from list of types (#{type.inspect})"
+      )
+    end
+  end
+
+  context 'when type is Set' do
+    let(:type) { Set }
+
+    it_behaves_like 'a valid collection attribute instance'
+
+    it 'sets default member type' do
+      expect(subject.type.member_type).to be(Axiom::Types::Object)
+    end
+  end
+
+  context 'when type is Set[Float]' do
+    let(:type) { Set[Float] }
+
+    it_behaves_like 'a valid collection attribute instance'
+
+    it 'sets member type' do
+      expect(subject.type.member_type).to be(Axiom::Types::Float)
+    end
+  end
+
+  context 'when type is an Enumerable' do
+    let(:type) { Class.new { include Enumerable } }
+
+    it_behaves_like 'a valid collection attribute instance'
+  end
+
+  context 'when type is Array subclass' do
+    let(:type) { Class.new(Array) }
+
+    it_behaves_like 'a valid collection attribute instance'
+  end
+
+  context 'when type is a custom collection instance' do
+    let(:type) { Class.new(Array)[String] }
+
+    it_behaves_like 'a valid collection attribute instance'
+
+    it 'sets member type' 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

@@ -0,0 +1,74 @@
+require 'spec_helper'
+
+describe Virtus::Attribute::Collection, '#coerce' do
+  subject { object.coerce(input) }
+
+  context 'when input is an array' do
+    context 'when member type is a primitive' do
+      fake(:coercer)     { Virtus::Attribute::Coercer }
+      fake(:member_type) { Virtus::Attribute }
+
+      let(:member_primitive) { Integer }
+      let(:input)            { ['1', '2'] }
+
+      let(:object) {
+        described_class.build(Array[member_primitive], :coercer => coercer, :member_type => member_type)
+      }
+
+      it 'uses coercer to coerce members' do
+        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])
+
+        expect(member_type).to have_received.coerce('1')
+        expect(member_type).to have_received.coerce('2')
+      end
+    end
+
+    context 'when member type is an EV' do
+      let(:member_primitive) { Struct.new(:id) }
+      let(:input)            { [1, 2] }
+      let(:object)           { described_class.build(Array[member_primitive]) }
+
+      it 'coerces members' do
+        expect(subject).to eq([member_primitive.new(1), member_primitive.new(2)])
+      end
+    end
+
+    context 'when member type is a hash with key/value coercion' do
+      let(:member_primitive) { Hash[String => Integer] }
+      let(:member_attribute) { Virtus::Attribute.build(member_primitive) }
+      let(:input)            { [{:one => '1'}, {:two => '2'}] }
+      let(:output)           { [member_attribute.coerce(input.first), member_attribute.coerce(input.last)] }
+      let(:object)           { described_class.build(Array[member_primitive]) }
+
+      it 'coerces members' do
+        expect(subject).to eq(output)
+      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

@@ -0,0 +1,29 @@
+require 'spec_helper'
+
+describe Virtus::Attribute::Collection, 'custom subclass' do
+  subject { attribute_class.build(primitive) }
+
+  let(:primitive) { Class.new  { include Enumerable } }
+
+  after do
+    described_class.descendants.delete(attribute_class)
+  end
+
+  context 'when primitive is set on the attribute subclass' do
+    let(:attribute_class) { Class.new(described_class).primitive(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) }
+
+    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

@@ -0,0 +1,70 @@
+require 'spec_helper'
+
+describe Virtus::Attribute::EmbeddedValue, '.build' do
+  subject { described_class.build(type) }
+
+  context 'when type is a Virtus.model' do
+    let(:type) { Class.new { include Virtus.model } }
+
+    it { is_expected.to be_frozen }
+
+    it { is_expected.to be_instance_of(Virtus::Attribute::EmbeddedValue) }
+
+    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 { is_expected.to be_frozen }
+
+    it { is_expected.to be_instance_of(Virtus::Attribute::EmbeddedValue) }
+
+    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 { is_expected.to be_frozen }
+
+    it { is_expected.to be_instance_of(Virtus::Attribute::EmbeddedValue) }
+
+    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 { is_expected.to be_frozen }
+
+    it { is_expected.to be_instance_of(Virtus::Attribute::EmbeddedValue) }
+
+    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 { is_expected.to be_frozen }
+
+    it { is_expected.to be_instance_of(Virtus::Attribute::EmbeddedValue) }
+
+    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

@@ -0,0 +1,91 @@
+require 'spec_helper'
+
+describe Virtus::Attribute::EmbeddedValue, '#coerce' do
+  subject { object.coerce(input) }
+
+  let(:object)  { described_class.build(model, options) }
+  let(:options) { {} }
+
+  context 'when primitive is OpenStruct' do
+    let(:model)  { OpenStruct }
+
+    context 'when input is an attribute hash' do
+      let(:input) { Hash[name: 'Piotr', age: 30] }
+
+      it { is_expected.to be_instance_of(model) }
+
+      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 { is_expected.to be(nil) }
+    end
+
+    context 'when input is a model instance' do
+      let(:input) { OpenStruct.new }
+
+      it { is_expected.to be(input) }
+    end
+  end
+
+  context 'when primitive is Struct' do
+    let(:model)  { Struct.new(:name, :age) }
+
+    context 'when input is an attribute hash' do
+      let(:input) { ['Piotr', 30] }
+
+      it { is_expected.to be_instance_of(model) }
+
+      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 { is_expected.to be(nil) }
+    end
+
+    context 'when input is a model instance' do
+      let(:input) { model.new('Piotr', 30) }
+
+      it { is_expected.to be(input) }
+    end
+  end
+
+  context 'when :strict mode is enabled' do
+    let(:model)   { Struct.new(:name) }
+    let(:options) { { :strict => true } }
+
+    context 'when input is coercible' do
+      let(:input) { ['Piotr'] }
+
+      it { is_expected.to eql(model.new('Piotr')) }
+    end
+
+    context 'when input is not coercible' do
+      let(:input) { nil }
+
+      it 'raises error' do
+        expect { subject }.to raise_error(Virtus::CoercionError)
+      end
+    end
+  end
+end