virtus2 2.0.1

data/spec/integration/inheritance_spec.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+
+describe 'Inheritance' do
+  before do
+    module Examples
+      class Base
+        include Virtus.model
+      end
+
+      class First < Base
+        attribute :id, Fixnum
+        attribute :name, String, default: ->(first, _) { "Named: #{first.id}" }
+        attribute :description, String
+      end
+
+      class Second < Base
+        attribute :something, String
+      end
+    end
+  end
+
+  it 'inherits model from the base class' do
+    expect(Examples::First.attribute_set.map(&:name)).to eql([:id, :name, :description])
+    expect(Examples::Second.attribute_set.map(&:name)).to eql([:something])
+  end
+
+  it 'sets correct attributes on the descendant classes' do
+    first = Examples::First.new(:id => 1, :description => 'hello world')
+
+    expect(first.id).to be(1)
+    expect(first.name).to eql('Named: 1')
+    expect(first.description).to eql('hello world')
+
+    second = Examples::Second.new
+
+    expect(second.something).to be(nil)
+
+    second.something = 'foo bar'
+
+    expect(second.something).to eql('foo bar')
+  end
+end

data/spec/integration/injectible_coercers_spec.rb

@@ -0,0 +1,48 @@
+require 'virtus'
+
+describe 'Injectible coercer' do
+  before do
+    module Examples
+      class EmailAddress
+        include Virtus.value_object
+
+        values do
+          attribute :address, String, :coercer => lambda { |add| add.downcase }
+        end
+
+        def self.coerce(input)
+          if input.is_a?(String)
+            new(:address => input)
+          else
+            new(input)
+          end
+        end
+      end
+
+      class User
+        include Virtus.model
+
+        attribute :email, EmailAddress,
+          :coercer => lambda { |input| Examples::EmailAddress.coerce(input) }
+      end
+    end
+  end
+
+  after do
+    Examples.send(:remove_const, :EmailAddress)
+    Examples.send(:remove_const, :User)
+  end
+
+  let(:doe) { Examples::EmailAddress.new(:address => 'john.doe@example.com') }
+
+  it 'accepts an email hash' do
+    user = Examples::User.new :email => { :address => 'John.Doe@Example.Com' }
+    expect(user.email).to eq(doe)
+  end
+
+  it 'coerces an embedded string' do
+    user = Examples::User.new :email => 'John.Doe@Example.Com'
+    expect(user.email).to eq(doe)
+  end
+
+end

data/spec/integration/mass_assignment_with_accessors_spec.rb

@@ -0,0 +1,44 @@
+require 'spec_helper'
+
+describe "mass assignment with accessors" do
+
+  before do
+    module Examples
+      class Product
+        include Virtus
+
+        attribute :id,          Integer
+        attribute :category,    String
+        attribute :subcategory, String
+
+        def categories=(categories)
+          self.category = categories.first
+          self.subcategory = categories.last
+        end
+
+      private
+
+        def _id=(value)
+          self.id = value
+        end
+      end
+    end
+  end
+
+  subject { Examples::Product.new(:categories => ['Office', 'Printers'], :_id => 100) }
+
+  specify 'works uppon instantiation' do
+    expect(subject.category).to eq('Office')
+    expect(subject.subcategory).to eq('Printers')
+  end
+
+  specify 'can be set with #attributes=' do
+    subject.attributes = {:categories => ['Home', 'Furniture']}
+    expect(subject.category).to eq('Home')
+    expect(subject.subcategory).to eq('Furniture')
+  end
+
+  specify 'respects accessor visibility' do
+    expect(subject.id).not_to eq(100)
+  end
+end

data/spec/integration/overriding_virtus_spec.rb

@@ -0,0 +1,46 @@
+require 'spec_helper'
+
+describe 'overriding virtus behavior' do
+
+  before do
+    module Examples
+      class Article
+        include Virtus
+
+        attribute :title, String
+
+        def title
+          super || '<unknown>'
+        end
+
+        def title=(name)
+          super unless self.title == "can't be changed"
+        end
+      end
+    end
+  end
+
+  describe 'overriding an attribute getter' do
+    specify 'calls the defined getter' do
+      expect(Examples::Article.new.title).to eq('<unknown>')
+    end
+
+    specify 'super can be used to access the getter defined by virtus' do
+      expect(Examples::Article.new(:title => 'example article').title).to eq('example article')
+    end
+  end
+
+  describe 'overriding an attribute setter' do
+    specify 'calls the defined setter' do
+      article = Examples::Article.new(:title => "can't be changed")
+      article.title = 'this will never be assigned'
+      expect(article.title).to eq("can't be changed")
+    end
+
+    specify 'super can be used to access the setter defined by virtus' do
+      article = Examples::Article.new(:title => 'example article')
+      article.title = 'my new title'
+      expect(article.title).to eq('my new title')
+    end
+  end
+end

data/spec/integration/required_attributes_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+describe 'Using required attributes' do
+  before do
+    module Examples
+      class User
+        include Virtus.model(:strict => true)
+
+        attribute :name, String
+        attribute :age,  Integer, :required => false
+      end
+    end
+  end
+
+  it 'raises coercion error when required attribute is nil' do
+    expect { Examples::User.new(:name => nil) }.to raise_error(Virtus::CoercionError, "Failed to coerce attribute `name' from nil into String")
+  end
+
+  it 'does not raise coercion error when not required attribute is nil' do
+    user = Examples::User.new(:name => 'Jane', :age => nil)
+
+    expect(user.name).to eql('Jane')
+    expect(user.age).to be(nil)
+  end
+end

data/spec/integration/struct_as_embedded_value_spec.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+
+describe 'Using Struct as an embedded value attribute' do
+  before do
+    module Examples
+      Point = Struct.new(:x, :y)
+
+      class Rectangle
+        include Virtus
+
+        attribute :top_left,     Point
+        attribute :bottom_right, Point
+      end
+    end
+  end
+
+  subject do
+    Examples::Rectangle.new(:top_left => [ 3, 5 ], :bottom_right => [ 8, 7 ])
+  end
+
+  specify 'initialize a struct object with correct attributes' do
+    expect(subject.top_left.x).to be(3)
+    expect(subject.top_left.y).to be(5)
+
+    expect(subject.bottom_right.x).to be(8)
+    expect(subject.bottom_right.y).to be(7)
+  end
+end

data/spec/integration/using_modules_spec.rb

@@ -0,0 +1,55 @@
+require 'spec_helper'
+
+describe 'I can define attributes within a module' do
+  before do
+    module Examples
+      module Common
+        include Virtus
+      end
+
+      module Name
+        include Common
+
+        attribute :name, String
+        attribute :gamer, Boolean
+      end
+
+      module Age
+        include Common
+
+        attribute :age,  Integer
+      end
+
+      class User
+        include Name
+      end
+
+      class Admin < User
+        include Age
+      end
+
+      class Moderator; end
+    end
+  end
+
+  specify 'including a module with attributes into a class' do
+    expect(Examples::User.attribute_set[:name]).to be_instance_of(Virtus::Attribute)
+    expect(Examples::User.attribute_set[:gamer]).to be_instance_of(Virtus::Attribute::Boolean)
+
+    expect(Examples::Admin.attribute_set[:name]).to be_instance_of(Virtus::Attribute)
+    expect(Examples::Admin.attribute_set[:age]).to be_instance_of(Virtus::Attribute)
+
+    user = Examples::Admin.new(:name => 'Piotr', :age => 29)
+    expect(user.name).to eql('Piotr')
+    expect(user.age).to eql(29)
+  end
+
+  specify 'including a module with attributes into an instance' do
+    moderator = Examples::Moderator.new
+    moderator.extend(Examples::Name, Examples::Age)
+
+    moderator.attributes = { :name => 'John', :age => 21 }
+    expect(moderator.name).to eql('John')
+    expect(moderator.age).to eql(21)
+  end
+end

data/spec/integration/value_object_with_custom_constructor_spec.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+
+describe "Defining a ValueObject with a custom constructor" do
+  before do
+    module Examples
+      class Point
+        include Virtus::ValueObject
+
+        attribute :x, Integer
+        attribute :y, Integer
+
+        def initialize(attributes)
+          if attributes.kind_of?(Array)
+            self.x = attributes.first
+            self.y = attributes.last
+          else
+            super
+          end
+        end
+      end
+
+      class Rectangle
+        include Virtus
+
+        attribute :top_left,     Point
+        attribute :bottom_right, Point
+      end
+    end
+  end
+
+  subject do
+    Examples::Rectangle.new(:top_left => [ 3, 4 ], :bottom_right => [ 5, 8 ])
+  end
+
+  specify "initialize a value object attribute with correct attributes" do
+    expect(subject.top_left.x).to be(3)
+    expect(subject.top_left.y).to be(4)
+
+    expect(subject.bottom_right.x).to be(5)
+    expect(subject.bottom_right.y).to be(8)
+  end
+end

data/spec/integration/virtus/instance_level_attributes_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+describe Virtus, 'instance level attributes' do
+  subject do
+    subject = Object.new
+    subject.singleton_class.send(:include, Virtus)
+    subject
+  end
+
+  let(:attribute) { subject.singleton_class.attribute(:name, String) }
+
+  before do
+    pending if RUBY_VERSION < '1.9'
+  end
+
+  context 'adding an attribute' do
+    it 'allows setting the attribute value on the instance' do
+      attribute
+      subject.name = 'foo'
+      expect(subject.name).to eql('foo')
+    end
+  end
+end

data/spec/integration/virtus/value_object_spec.rb

@@ -0,0 +1,99 @@
+require 'spec_helper'
+
+describe Virtus::ValueObject do
+  let(:class_under_test) do
+    Class.new do
+      def self.name
+        'GeoLocation'
+      end
+
+      include Virtus::ValueObject
+
+      attribute :latitude,  Float
+      attribute :longitude, Float
+    end
+  end
+
+  let(:attribute_values) { { :latitude => 10.0, :longitude => 20.0 } }
+
+  let(:instance_with_equal_state) { class_under_test.new(attribute_values) }
+
+  let(:instance_with_different_state) do
+    class_under_test.new(:latitude => attribute_values[:latitude])
+  end
+
+  subject { class_under_test.new(attribute_values) }
+
+  describe 'initialization' do
+    it 'sets the attribute values provided to Class.new' do
+      expect(class_under_test.new(:latitude => 10000.001).latitude).to eq(10000.001)
+      expect(subject.latitude).to eql(attribute_values[:latitude])
+    end
+  end
+
+  describe 'writer visibility' do
+    it 'attributes are configured for private writers' do
+      expect(class_under_test.attribute_set[:latitude].public_reader?).to be(true)
+      expect(class_under_test.attribute_set[:longitude].public_writer?).to be(false)
+    end
+
+    it 'writer methods are set to private' do
+      private_methods = class_under_test.private_instance_methods
+      private_methods.map! { |m| m.to_s }
+      expect(private_methods).to include('latitude=', 'longitude=', 'attributes=')
+    end
+
+    it 'attempts to call attribute writer methods raises NameError' do
+      expect { subject.latitude  = 5.0 }.to raise_exception(NameError)
+      expect { subject.longitude = 5.0 }.to raise_exception(NameError)
+    end
+  end
+
+  describe 'equality' do
+    describe '#==' do
+      it 'returns true for different objects with the same state' do
+        expect(subject).to eq(instance_with_equal_state)
+      end
+
+      it 'returns false for different objects with different state' do
+        expect(subject).not_to eq(instance_with_different_state)
+      end
+    end
+
+    describe '#eql?' do
+      it 'returns true for different objects with the same state' do
+        expect(subject).to eql(instance_with_equal_state)
+      end
+
+      it 'returns false for different objects with different state' do
+        expect(subject).not_to eql(instance_with_different_state)
+      end
+    end
+
+    describe '#equal?' do
+      it 'returns false for different objects with the same state' do
+        expect(subject).not_to equal(instance_with_equal_state)
+      end
+
+      it 'returns false for different objects with different state' do
+        expect(subject).not_to equal(instance_with_different_state)
+      end
+    end
+
+    describe '#hash' do
+      it 'returns the same value for different objects with the same state' do
+        expect(subject.hash).to eql(instance_with_equal_state.hash)
+      end
+
+      it 'returns different values for different objects with different state' do
+        expect(subject.hash).not_to eql(instance_with_different_state.hash)
+      end
+    end
+  end
+
+  describe '#inspect' do
+    it 'includes the class name and attribute values' do
+      expect(subject.inspect).to eq('#<GeoLocation latitude=10.0 longitude=20.0>')
+    end
+  end
+end