virtus 0.5.5 → 1.0.0.beta3

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

@@ -3,36 +3,30 @@ require 'spec_helper'
 describe Virtus::AttributeSet, '#merge' do
   subject { object.merge(other) }
 
-  let(:attributes) { []                                      }
-  let(:parent)     { described_class.new                     }
-  let(:object)     { described_class.new(parent, attributes) }
-  let(:name)       { :name                                   }
-  let(:other)      { [ attribute ]                           }
-
-  before { attribute.stub(:define_accessor_methods) }
+  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(:attribute) { mock('Attribute', :name => name) }
+    let(:attributes) { [] }
+    let(:attribute)  { Virtus::Attribute.build(String, :name => name) }
 
     it { should equal(object) }
 
     it 'adds an attribute' do
-      expect { subject }.to change { object.to_a }.
-        from(attributes).
-        to([ attribute ])
+      expect { subject }.to change { object.to_a }.from(attributes).to([attribute])
     end
   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) }
 
     it 'replaces the original attribute' do
-      expect { subject }.to change { object.to_a }.
-        from(attributes).
-        to([ attribute ])
+      expect { subject }.to change { object.to_a }.from(attributes).to([attribute])
     end
   end
 end

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

@@ -3,13 +3,11 @@ require 'spec_helper'
 describe Virtus::AttributeSet, '#reset' do
   subject { object.reset }
 
-  let(:name)       { :name                                   }
-  let(:attribute)  { mock('Attribute', :name => name)        }
+  let(:name)       { :name }
+  let(:attribute)  { Virtus::Attribute.build(String, :name => :name) }
   let(:attributes) { [ attribute ]                           }
   let(:object)     { described_class.new(parent, attributes) }
 
-  before { attribute.stub(:define_accessor_methods) }
-
   context 'when the parent has no attributes' do
     let(:parent) { described_class.new }
 
@@ -19,7 +17,7 @@ describe Virtus::AttributeSet, '#reset' 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) }
@@ -28,7 +26,7 @@ describe Virtus::AttributeSet, '#reset' 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) }
@@ -37,11 +35,9 @@ describe Virtus::AttributeSet, '#reset' do
   end
 
   context 'when the parent has changed' 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 ])       }
-    let(:new_attribute)    { mock('New Attribute', :name => :parent_name)    }
-
-    before { new_attribute.stub(:define_accessor_methods) }
+    let(:new_attribute)    { Virtus::Attribute.build(String, :name => :parent_name) }
 
     it { should equal(object) }
 

data/spec/unit/virtus/attribute_spec.rb

@@ -0,0 +1,222 @@
+require 'spec_helper'
+
+describe Virtus, '#attribute' do
+  let(:name)    { :test }
+  let(:options) { {} }
+
+  share_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)
+    end
+
+    it 'defines predicate method' do
+      object.test = false
+
+      expect(object).to_not be_test
+    end
+  end
+
+  share_examples_for 'an object with string attribute' do
+    it { should respond_to(:test) }
+    it { should 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
+
+  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 { should respond_to(:test) }
+    it { should respond_to(:test=) }
+
+    it 'writes and reads attributes' do
+      subject.test = :foo
+      expect(subject.test).to be(:foo)
+    end
+  end
+end

data/spec/unit/virtus/attributes_reader_spec.rb

@@ -0,0 +1,41 @@
+require 'spec_helper'
+
+describe Virtus, '#attributes' do
+
+  share_examples_for 'attribute hash' do
+    it 'includes all attributes' do
+      subject.attributes = { :test => 'Hello World', :test_priv => 'Yo' }
+
+      expect(subject.attributes).to eql(:test => 'Hello World')
+    end
+  end
+
+  context 'with a class' do
+    let(:model) {
+      Class.new {
+        include Virtus
+
+        attribute :test,      String
+        attribute :test_priv, String, :reader => :private
+      }
+    }
+
+    it_behaves_like 'attribute hash' do
+      subject { model.new }
+    end
+  end
+
+  context 'with an instance' do
+    subject { model.new }
+
+    let(:model) { Class.new }
+
+    before do
+      subject.extend(Virtus)
+      subject.attribute :test,      String
+      subject.attribute :test_priv, String, :reader => :private
+    end
+
+    it_behaves_like 'attribute hash'
+  end
+end

data/spec/unit/virtus/attributes_writer_spec.rb

@@ -0,0 +1,51 @@
+require 'spec_helper'
+
+describe Virtus, '#attributes=' do
+
+  share_examples_for 'mass-assignment' do
+    it 'allows writing known attributes' do
+      subject.attributes = { :test => 'Hello World' }
+
+      expect(subject.test).to eql('Hello World')
+    end
+
+    it 'skips writing unknown attributes' do
+      subject.attributes = { :test => 'Hello World', :nothere => 'boom!' }
+
+      expect(subject.test).to eql('Hello World')
+    end
+  end
+
+  context 'with a class' do
+    let(:model) {
+      Class.new {
+        include Virtus
+
+        attribute :test, String
+      }
+    }
+
+    it_behaves_like 'mass-assignment' do
+      subject { model.new }
+    end
+
+    it 'raises when attributes is not hash-like object' do
+      expect { model.new('not a hash, really') }.to raise_error(
+        NoMethodError, 'Expected "not a hash, really" to respond to #to_hash'
+      )
+    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 'mass-assignment'
+  end
+end

data/spec/unit/virtus/class_methods/new_spec.rb

@@ -0,0 +1,39 @@
+require 'spec_helper'
+
+describe Virtus, '.new' do
+  let(:model) {
+    Class.new {
+      include Virtus
+
+      attribute :id,    Integer
+      attribute :name,  String, :default => 'John Doe'
+      attribute :email, String, :default => 'john@doe.com', :lazy => true, :writer => :private
+    }
+  }
+
+  context 'without attribute hash' do
+    subject { model.new }
+
+    it 'sets default values for non-lazy attributes' do
+      expect(subject.instance_variable_get('@name')).to eql('John Doe')
+    end
+
+    it 'skips setting default values for lazy attributes' do
+      expect(subject.instance_variable_get('@email')).to be(nil)
+    end
+  end
+
+  context 'with attribute hash' do
+    subject { model.new(:id => 1, :name => 'Jane Doe') }
+
+    it 'sets attributes with public writers' do
+      expect(subject.id).to be(1)
+      expect(subject.name).to eql('Jane Doe')
+    end
+
+    it 'skips setting attributes with private writers' do
+      expect(subject.instance_variable_get('@email')).to be(nil)
+    end
+  end
+
+end