virtus 0.5.5 → 1.0.0.beta3

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

@@ -0,0 +1,80 @@
+require 'spec_helper'
+
+describe Virtus::Attribute::Hash, '.build' do
+  subject { described_class.build(type) }
+
+  share_examples_for 'a valid hash attribute instance' do
+    it { should be_instance_of(Virtus::Attribute::Hash) }
+
+    it { should be_frozen }
+  end
+
+  context 'when type is Hash' do
+    let(:type) { Hash }
+
+    it { should 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 { should 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[Struct.new(:id) => Integer]' do
+    let(:type)     { Hash[key_type => Integer] }
+    let(:key_type) { Struct.new(:id) }
+
+    it { should 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 { should 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
+end

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

@@ -1,28 +1,90 @@
 require 'spec_helper'
 
 describe Virtus::Attribute::Hash, '#coerce' do
-  subject { object.coerce(input_value) }
+  subject { object.coerce(input) }
 
-  let(:options) { { :key_type => String, :value_type => Float } }
-  let(:object)  { Virtus::Attribute::Hash.new('stuff', options) }
+  fake(:coercer)    { Virtus::Attribute::Coercer }
+  fake(:key_type)   { Virtus::Attribute }
+  fake(:value_type) { Virtus::Attribute }
 
-  context 'respond to `inject`' do
-    let(:input_value) { { :one => '1', 'two' => 2 } }
+  let(:object) {
+    described_class.build(Hash[key_primitive => value_primitive], options)
+  }
 
-    it { should eql('one' => 1.0, 'two' => 2.0) }
+  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 { should eq(:hello => 'World') }
   end
 
-  context 'does not respond to `inject`' do
-    let(:input_value) { :symbol }
+  context 'when input is not coercible to hash' do
+    let(:input)  { 'not really a hash' }
+    let(:object) { described_class.build(Hash) }
 
-    it { should be(:symbol) }
+    it { should be(input) }
   end
 
-  context "without Hash Coerce type define" do
-    let(:options) { { } }
-    let(:input_value) { { :one => '1', 'two' => 2 } }
+  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
+        stub(coercer).call(input) { input }
+
+        stub(key_type).coerce(1) { '1' }
+        stub(key_type).coerce(2) { '2' }
+
+        stub(value_type).coerce('1') { 1 }
+        stub(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) }
 
-    it { should eq(:one => '1', 'two' => 2) }
+      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 { should be(true) }
+  end
+
+  context 'when :lazy is set to false' do
+    let(:lazy) { false }
+
+    it { should be(false) }
+  end
+end

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

@@ -0,0 +1,74 @@
+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 }
+
+    its(:test) { should be(nil) }
+    its(:instance_variables) { should include(:'@test') }
+  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 }
+
+    its(:test) { should be(true) }
+    its(:instance_variables) { should include(:'@test') }
+  end
+
+  context 'with a clonable' do
+    subject { instance }
+
+    let(:default) { [] }
+
+    its(:test) { should eq(default) }
+    its(:test) { should_not be(default) }
+  end
+
+  context 'with a callable' do
+    subject { instance }
+
+    let(:default) { lambda { |model, attribute| "#{model.name}-#{attribute.name}" } }
+
+    its(:test) { should eq('model-test') }
+  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 } }
+
+        its(:test) { should eq('hello world') }
+      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') }
+      end
+    end
+
+    context 'when it is not a method name' do
+      let(:default) { :hello_world }
+
+      its(:test) { should eq('hello_world') }
+    end
+  end
+end

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

@@ -3,47 +3,27 @@ require 'spec_helper'
 describe Virtus::Attribute, '#set' do
   subject { object.set(instance, value) }
 
-  let(:object)          { described_class.new(:name, options)                              }
-  let(:options)         { { :primitive => primitive, :coercion_method => coercion_method } }
-  let(:primitive)       { stub('primitive')                                                }
-  let(:coercion_method) { stub('coercion_method')                                          }
-  let(:instance)        { Object.new                                                       }
-  let(:value)           { stub('value')                                                    }
-  let(:coerced)         { stub('coerced')                                                  }
+  let(:object) { described_class.build(String, options.merge(:name => name)) }
 
-  before do
-    object.stub(:coerce).with(value).and_return(coerced)
-    object.stub(:set!).with(instance, coerced).and_return(object)
-  end
-
-  it { should be(object) }
+  let(:model)    { Class.new { attr_reader :test } }
+  let(:name)     { :test }
+  let(:instance) { model.new }
+  let(:value)    { 'Jane Doe' }
+  let(:options)  { {} }
 
-  it 'coerces the value' do
-    object.should_receive(:coerce).with(value)
-    subject
-  end
+  it { should be(value) }
 
-  it 'sets the instance variable to the coerced value' do
-    object.should_receive(:set!).with(instance, coerced)
-    subject
+  context 'without coercion' do
+    specify do
+      expect { subject }.to change { instance.test }.to(value)
+    end
   end
-end
-
-describe Virtus::Attribute, '#set!' do
-  subject { object.set!(instance, value) }
-
-  let(:object)          { described_class.new(:name, options)                              }
-  let(:options)         { { :primitive => primitive, :coercion_method => coercion_method } }
-  let(:primitive)       { stub('primitive')                                                }
-  let(:coercion_method) { stub('coercion_method')                                          }
-  let(:instance)        { Object.new                                                       }
-  let(:value)           { stub('value')                                                    }
 
-  it { should be(object) }
+  context 'with coercion' do
+    let(:value) { :'Jane Doe' }
 
-  it 'sets the instance variable to the value' do
-    instance.instance_variable_get(:@name).should be_nil
-    subject
-    instance.instance_variable_get(:@name).should be(value)
+    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 { should be(true) }
+  end
+
+  context 'when input is not coerced' do
+    let(:input)  { 1 }
+
+    it { should be(false) }
+  end
+end

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

@@ -8,10 +8,8 @@ describe Virtus::AttributeSet, '#<<' do
   let(:object)     { described_class.new(parent, attributes) }
   let(:name)       { :name                                   }
 
-  before { attribute.stub(:define_accessor_methods) }
-
   context 'with a new attribute' do
-    let(:attribute) { mock('Attribute', :name => name) }
+    let(:attribute) { Virtus::Attribute.build(String, :name => name) }
 
     it { should equal(object) }
 
@@ -35,8 +33,8 @@ describe Virtus::AttributeSet, '#<<' do
   end
 
   context 'with a duplicate attribute' do
-    let(:attributes) { [ mock('Attribute', :name => name) ] }
-    let(:attribute)  { mock('Duplicate', :name => name)     }
+    let(:attributes) { [Virtus::Attribute.build(String, :name => name)] }
+    let(:attribute)  { Virtus::Attribute.build(String, :name => name) }
 
     it { should equal(object) }
 

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

@@ -3,7 +3,7 @@ require 'spec_helper'
 describe Virtus::AttributeSet, '#define_reader_method' do
   subject { described_class.new }
 
-  let(:attribute) { mock('attribute') }
+  let(:attribute) { Virtus::Attribute.build(String, :name => method_name) }
 
   if RUBY_VERSION < '1.9'
     let(:method_name) { 'foo_bar' }

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

@@ -3,7 +3,7 @@ require 'spec_helper'
 describe Virtus::AttributeSet, '#define_writer_method' do
   subject { described_class.new }
 
-  let(:attribute) { mock('attribute') }
+  let(:attribute) { Virtus::Attribute.build(String, :name => :foo_bar) }
 
   if RUBY_VERSION < '1.9'
     let(:method_name) { 'foo_bar=' }

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

@@ -2,7 +2,7 @@ require 'spec_helper'
 
 describe Virtus::AttributeSet, '#each' do
   let(:name)       { :name                                   }
-  let(:attribute)  { mock('Attribute', :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) }
@@ -32,7 +32,7 @@ describe Virtus::AttributeSet, '#each' do
     end
 
     context 'when the parent has attributes that are not duplicates' do
-      let(:parent_attribute) { mock('Parent Attribute', :name => :parent_name) }
+      let(:parent_attribute) { Virtus::Attribute.build(String, :name => :parent_name) }
       let(:parent)           { described_class.new([ parent_attribute ])       }
 
       it { should equal(object) }
@@ -45,7 +45,7 @@ describe Virtus::AttributeSet, '#each' do
     end
 
     context 'when the parent has attributes that are duplicates' do
-      let(:parent_attribute) { mock('Parent Attribute', :name => name)   }
+      let(:parent_attribute) { Virtus::Attribute.build(String, :name => name) }
       let(:parent)           { described_class.new([ parent_attribute ]) }
 
       it { should equal(object) }

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

@@ -4,7 +4,7 @@ describe Virtus::AttributeSet, '#[]' do
   subject { object[name] }
 
   let(:name)       { :name                                   }
-  let(:attribute)  { mock('Attribute', :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) }

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

@@ -9,7 +9,7 @@ describe Virtus::AttributeSet, '#[]=' do
   let(:name)       { :name                                   }
 
   context 'with a new attribute' do
-    let(:attribute) { mock('attribute', :name => name) }
+    let(:attribute) { Virtus::Attribute.build(String, :name => name) }
 
     it { should equal(attribute) }
 
@@ -31,9 +31,9 @@ describe Virtus::AttributeSet, '#[]=' do
   end
 
   context 'with a duplicate attribute' do
-    let(:original)   { mock('original', :name => name)  }
-    let(:attributes) { [ original ]                     }
-    let(:attribute)  { mock('attribute', :name => name) }
+    let(:original)   { Virtus::Attribute.build(String, :name => name) }
+    let(:attributes) { [ original ] }
+    let(:attribute)  { Virtus::Attribute.build(String, :name => name) }
 
     it { should equal(attribute) }