virtus2 2.0.1

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

@@ -0,0 +1,32 @@
+require 'spec_helper'
+
+describe Virtus::Attribute, '#get' do
+  subject { object.get(instance) }
+
+  let(:object) { described_class.build(String, options.update(:name => name)) }
+
+  let(:model)    { Class.new { attr_accessor :test } }
+  let(:name)     { :test }
+  let(:instance) { model.new }
+  let(:value)    { 'Jane Doe' }
+  let(:options)  { {} }
+
+  context 'with :lazy is set to false' do
+    before do
+      instance.test = value
+    end
+
+    it { is_expected.to be(value) }
+  end
+
+  context 'with :lazy is set to true' do
+    let(:options) { { :lazy => true, :default => value } }
+
+    it { is_expected.to eql(value) }
+
+    it 'sets default only on first access' do
+      expect(object.get(instance)).to eql(value)
+      expect(object.get(instance)).to be(instance.test)
+    end
+  end
+end

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

@@ -0,0 +1,106 @@
+require 'spec_helper'
+
+describe Virtus::Attribute::Hash, '.build' do
+  subject { described_class.build(type, options) }
+
+  let(:options) { {} }
+
+  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 { 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)
+    end
+
+    it 'sets default value type' do
+      expect(subject.type.value_type).to be(Axiom::Types::Object)
+    end
+  end
+
+  context 'when type is Hash[String => Integer]' do
+    let(:type) { Hash[String => Integer] }
+
+    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)
+    end
+
+    it 'sets value type' do
+      expect(subject.type.value_type).to be(Axiom::Types::Integer)
+    end
+  end
+
+  context 'when type is Hash[Virtus::Attribute::Hash => Virtus::Attribute::Boolean]' do
+    let(:type) { Hash[Virtus::Attribute::Hash => Virtus::Attribute::Boolean] }
+
+    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)
+    end
+
+    it 'sets value type' do
+      expect(subject.type.value_type).to be(Axiom::Types::Boolean)
+    end
+  end
+
+  context 'when type is Hash[Struct.new(:id) => Integer]' do
+    let(:type)     { Hash[key_type => Integer] }
+    let(:key_type) { Struct.new(:id) }
+
+    it { is_expected.to be_instance_of(Virtus::Attribute::Hash) }
+
+    it 'sets key type' do
+      expect(subject.type.key_type).to be(key_type)
+    end
+
+    it 'sets value type' do
+      expect(subject.type.value_type).to be(Axiom::Types::Integer)
+    end
+  end
+
+  context 'when type is Hash[String => Struct.new(:id)]' do
+    let(:type)       { Hash[String => value_type] }
+    let(:value_type) { Struct.new(:id) }
+
+    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)
+    end
+
+    it 'sets value type' do
+      expect(subject.type.value_type).to be(value_type)
+    end
+  end
+
+  context 'when type is Hash[String => Integer, Integer => String]' do
+    let(:type) { Hash[String => Integer, :Integer => :String] }
+
+    specify do
+      expect { subject }.to raise_error(
+        ArgumentError,
+        "more than one [key => value] pair in `#{type}`"
+      )
+    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

@@ -0,0 +1,92 @@
+require 'spec_helper'
+
+describe Virtus::Attribute::Hash, '#coerce' do
+  subject { object.coerce(input) }
+
+  fake(:coercer)    { Virtus::Attribute::Coercer }
+  fake(:key_type)   { Virtus::Attribute }
+  fake(:value_type) { Virtus::Attribute }
+
+  let(:object) {
+    described_class.build(Hash[key_primitive => value_primitive], options)
+  }
+
+  let(:options) { {} }
+
+  context 'when input is coercible to hash' do
+    let(:input)  { Class.new { def to_hash; { :hello => 'World' }; end }.new }
+    let(:object) { described_class.build(Hash) }
+
+    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 { is_expected.to be(input) }
+  end
+
+  context 'when input is a hash' do
+    context 'when key/value types are primitives' do
+      let(:options) {
+        { :coercer => coercer, :key_type => key_type, :value_type => value_type }
+      }
+
+      let(:key_primitive)   { String }
+      let(:value_primitive) { Integer }
+
+      let(:input) { Hash[1 => '1', 2 => '2'] }
+
+      it 'uses coercer to coerce key and value' do
+        mock(coercer).call(input) { input }
+
+        mock(key_type).finalize { key_type }
+        mock(key_type).coerce(1) { '1' }
+        mock(key_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])
+
+        expect(key_type).to have_received.coerce(1)
+        expect(key_type).to have_received.coerce(2)
+
+        expect(value_type).to have_received.coerce('1')
+        expect(value_type).to have_received.coerce('2')
+      end
+    end
+
+    context 'when key/value types are EVs' do
+      let(:key_primitive)   { OpenStruct }
+      let(:value_primitive) { Struct.new(:id) }
+
+      let(:input)  { Hash[{:name => 'Test'} => [1]] }
+      let(:output) { Hash[key_primitive.new(:name => 'Test') => value_primitive.new(1)] }
+
+      it 'coerces keys and values' do
+        # FIXME: expect(subject).to eq(output) crashes in rspec
+        expect(subject.keys.first).to eq(output.keys.first)
+        expect(subject.values.first).to eq(output.values.first)
+        expect(subject.size).to be(1)
+      end
+    end
+
+    context 'when key type is an array and value type is another hash' do
+      let(:key_primitive)   { Array[String] }
+      let(:value_primitive) { Hash[String => Integer] }
+
+      let(:key_attribute)   { Virtus::Attribute.build(key_primitive) }
+      let(:value_attribute) { Virtus::Attribute.build(value_primitive) }
+
+      let(:input)  { Hash[[1, 2], {:one => '1', :two => '2'}] }
+      let(:output) { Hash[key_attribute.coerce(input.keys.first) => value_attribute.coerce(input.values.first)] }
+
+      it 'coerces keys and values' do
+        expect(subject).to eq(output)
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,16 @@
+require 'spec_helper'
+
+describe Virtus::Attribute, '#rename' do
+  subject { object.rename(:bar) }
+
+  let(:object) { described_class.build(String, :name => :foo, :strict => true) }
+  let(:other)  { described_class.build(String, :name => :bar, :strict => true) }
+
+  describe '#name' do
+    subject { super().name }
+    it { is_expected.to be(:bar) }
+  end
+
+  it { is_expected.not_to be(object) }
+  it { is_expected.to be_strict }
+end

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

@@ -0,0 +1,19 @@
+require 'spec_helper'
+
+describe Virtus::Attribute, '#required?' do
+  subject { object.required? }
+
+  let(:object) { described_class.build(String, :required => required) }
+
+  context 'when required option is true' do
+    let(:required) { true }
+
+    it { is_expected.to be(true) }
+  end
+
+  context 'when required option is false' do
+    let(:required) { false }
+
+    it { is_expected.to be(false) }
+  end
+end

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

@@ -0,0 +1,107 @@
+require 'spec_helper'
+
+describe Virtus::Attribute, '#set_default_value' do
+  let(:object) { described_class.build(String, options.merge(:name => name, :default => default)) }
+
+  let(:model)    { Class.new { def name; 'model'; end; attr_reader :test } }
+  let(:name)     { :test }
+  let(:instance) { model.new }
+  let(:options)  { {} }
+
+  before { object.set_default_value(instance) }
+
+  context 'with a nil' do
+    subject { instance }
+
+    let(:default) { nil }
+
+    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
+    subject { instance }
+
+    let(:object)  { described_class.build('Boolean', options.merge(:name => name, :default => default)) }
+    let(:default) { true }
+
+    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
+    subject { instance }
+
+    let(: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
+    subject { instance }
+
+    let(:default) { lambda { |model, attribute| "#{model.name}-#{attribute.name}" } }
+
+    describe '#test' do
+      subject { super().test }
+      it { is_expected.to eq('model-test') }
+    end
+  end
+
+  context 'with a symbol' do
+    subject { instance }
+
+    context 'when it is a method name' do
+      let(:default) { :set_test }
+
+      context 'when method is public' do
+        let(:model) { Class.new { attr_reader :test; def set_test; @test = 'hello world'; end } }
+
+        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 } }
+
+        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 }
+
+      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

@@ -0,0 +1,29 @@
+require 'spec_helper'
+
+describe Virtus::Attribute, '#set' do
+  subject { object.set(instance, value) }
+
+  let(:object) { described_class.build(String, options.merge(:name => name)) }
+
+  let(:model)    { Class.new { attr_reader :test } }
+  let(:name)     { :test }
+  let(:instance) { model.new }
+  let(:value)    { 'Jane Doe' }
+  let(:options)  { {} }
+
+  it { is_expected.to be(value) }
+
+  context 'without coercion' do
+    specify do
+      expect { subject }.to change { instance.test }.to(value)
+    end
+  end
+
+  context 'with coercion' do
+    let(:value) { :'Jane Doe' }
+
+    specify do
+      expect { subject }.to change { instance.test }.to('Jane Doe')
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+require 'spec_helper'
+
+describe Virtus::Attribute, '#value_coerced?' do
+  subject { object.value_coerced?(input) }
+
+  let(:object) { described_class.build(String) }
+
+  context 'when input is coerced' do
+    let(:input)  { '1' }
+
+    it { is_expected.to be(true) }
+  end
+
+  context 'when input is not coerced' do
+    let(:input)  { 1 }
+
+    it { is_expected.to be(false) }
+  end
+end