virtus2 2.0.1

data/spec/unit/virtus/attributes_reader_spec.rb

@@ -0,0 +1,41 @@
+require 'spec_helper'
+
+describe Virtus, '#attributes' do
+
+  shared_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
+
+  shared_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/finalize_spec.rb

@@ -0,0 +1,67 @@
+require 'spec_helper'
+
+describe Virtus, '.finalize' do
+  before do
+    module Examples
+      class Person
+        include Virtus.model(:finalize => false)
+
+        attribute :name,     String
+        attribute :articles, Array['Examples::Article']
+        attribute :address,  :'Examples::Address'
+      end
+
+      class Article
+        include Virtus.model(:finalize => false)
+
+        attribute :posts, Hash['Examples::Person' => 'Examples::Post']
+        attribute :person, :'Examples::Person'
+      end
+
+      class Post
+        include Virtus.model
+
+        attribute :title, String
+      end
+
+      class Address
+        include Virtus.model
+
+        attribute :street, String
+      end
+    end
+
+    expect(Examples::Post.attribute_set[:title]).to be_finalized
+    expect(Examples::Address.attribute_set[:street]).to be_finalized
+
+    expect(Virtus::Builder.pending).not_to include(Examples::Post)
+    expect(Virtus::Builder.pending).not_to include(Examples::Address)
+
+    Virtus.finalize
+  end
+
+  it "sets attributes that don't require finalization" do
+    expect(Examples::Person.attribute_set[:name]).to be_instance_of(Virtus::Attribute)
+    expect(Examples::Person.attribute_set[:name].primitive).to be(String)
+  end
+
+  it 'it finalizes member type for a collection attribute' do
+    expect(Examples::Person.attribute_set[:address].primitive).to be(Examples::Address)
+  end
+
+  it 'it finalizes key type for a hash attribute' do
+    expect(Examples::Article.attribute_set[:posts].key_type.primitive).to be(Examples::Person)
+  end
+
+  it 'it finalizes value type for a hash attribute' do
+    expect(Examples::Article.attribute_set[:posts].value_type.primitive).to be(Examples::Post)
+  end
+
+  it 'it finalizes type for an EV attribute' do
+    expect(Examples::Article.attribute_set[:person].type.primitive).to be(Examples::Person)
+  end
+
+  it 'automatically resolves constant when it is already available' do
+    expect(Examples::Article.attribute_set[:person].type.primitive).to be(Examples::Person)
+  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

data/spec/unit/virtus/config_spec.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+
+describe Virtus, '.config' do
+  it 'provides global configuration' do
+    Virtus.config { |config| config.coerce = false }
+
+    expect(Virtus.coerce).to be(false)
+
+    Virtus.config { |config| config.coerce = true }
+
+    expect(Virtus.coerce).to be(true)
+  end
+end

data/spec/unit/virtus/element_reader_spec.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+
+describe Virtus, '#[]' do
+  subject { object[:test] }
+
+  let(:model) {
+    Class.new {
+      include Virtus
+
+      attribute :test, String
+    }
+  }
+
+  let(:object) { model.new }
+
+  before do
+    object.test = 'foo'
+  end
+
+  it { is_expected.to eq('foo') }
+end

data/spec/unit/virtus/element_writer_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+
+describe Virtus, '#[]=' do
+  subject { object[:test] = 'foo' }
+
+  let(:model) {
+    Class.new {
+      include Virtus
+
+      attribute :test, String
+    }
+  }
+
+  let(:object) { model.new }
+
+  specify do
+    expect { subject }.to change { object.test }.from(nil).to('foo')
+  end
+end

data/spec/unit/virtus/freeze_spec.rb

@@ -0,0 +1,41 @@
+require 'spec_helper'
+
+describe Virtus, '#freeze' do
+  subject { object.freeze }
+
+  let(:model) {
+    Class.new {
+      include Virtus
+
+      attribute :name, String,  :default => 'foo', :lazy => true
+      attribute :age,  Integer, :default => 30
+      attribute :rand, Float,   :default => Proc.new { rand }
+    }
+  }
+
+  let(:object) { model.new }
+
+  it { is_expected.to be_frozen }
+
+  describe '#name' do
+    subject { super().name }
+    it { is_expected.to eql('foo') }
+  end
+
+  describe '#age' do
+    subject { super().age }
+    it { is_expected.to be(30) }
+  end
+
+  it "does not change dynamic default values" do
+    original_value = object.rand
+    object.freeze
+    expect(object.rand).to eq original_value
+  end
+
+  it "does not change default attributes that have been explicitly set" do
+    object.rand = 3.14
+    object.freeze
+    expect(object.rand).to eq 3.14
+  end
+end

data/spec/unit/virtus/model_spec.rb

@@ -0,0 +1,197 @@
+require 'spec_helper'
+
+describe Virtus, '.model' do
+  shared_examples_for 'a model with constructor' do
+    it 'accepts attribute hash' do
+      instance = subject.new(:name => 'Jane')
+      expect(instance.name).to eql('Jane')
+    end
+  end
+
+  shared_examples_for 'a model with mass-assignment' do
+    let(:attributes) do
+      { :name => 'Jane', :something => nil }
+    end
+
+    before do
+      instance.attributes = attributes
+    end
+
+    it 'accepts attribute hash' do
+      expect(instance.attributes).to eql(attributes)
+    end
+  end
+
+  shared_examples_for 'a model with strict mode turned off' do
+    it 'has attributes with strict set to false' do
+      expect(subject.send(:attribute_set)[:name]).to_not be_strict
+    end
+  end
+
+  context 'with default configuration' do
+    let(:mod) { Virtus.model }
+
+    context 'with a class' do
+      let(:model) { Class.new }
+
+      subject { model }
+
+      before do
+        subject.send(:include, mod)
+        subject.attribute :name, String, :default => 'Jane'
+        subject.attribute :something
+      end
+
+      it_behaves_like 'a model with constructor'
+
+      it_behaves_like 'a model with strict mode turned off'
+
+      it_behaves_like 'a model with mass-assignment' do
+        let(:instance) { subject.new }
+      end
+
+      it 'defaults to Object for attribute type' do
+        expect(model.attribute_set[:something].type).to be(Axiom::Types::Object)
+      end
+
+      context 'with a sub-class' do
+        subject { Class.new(model) }
+
+        before do
+          subject.attribute :age, Integer
+        end
+
+        it_behaves_like 'a model with constructor'
+
+        it_behaves_like 'a model with strict mode turned off'
+
+        it_behaves_like 'a model with mass-assignment' do
+          let(:instance) { subject.new }
+
+          let(:attributes) {
+            { :name => 'Jane', :something => nil, :age => 23 }
+          }
+        end
+
+        it 'has its own attributes' do
+          expect(subject.attribute_set[:age]).to be_kind_of(Virtus::Attribute)
+        end
+      end
+    end
+
+    context 'with an instance' do
+      subject { Class.new.new }
+
+      before do
+        subject.extend(mod)
+        subject.attribute :name, String
+        subject.attribute :something
+      end
+
+      it_behaves_like 'a model with strict mode turned off'
+
+      it_behaves_like 'a model with mass-assignment' do
+        let(:instance) { subject }
+      end
+    end
+  end
+
+  context 'when constructor is disabled' do
+    subject { Class.new.send(:include, mod) }
+
+    let(:mod) { Virtus.model(:constructor => false) }
+
+    it 'does not accept attribute hash in the constructor' do
+      expect { subject.new({}) }.to raise_error(ArgumentError)
+    end
+  end
+
+  context 'when strict mode is enabled' do
+    let(:mod)   { Virtus.model(:strict => true) }
+    let(:model) { Class.new }
+
+    context 'with a class' do
+      subject { model.new }
+
+      before do
+        model.send(:include, mod)
+        model.attribute :name, String
+      end
+
+      it 'has attributes with strict set to true' do
+        expect(model.attribute_set[:name]).to be_strict
+      end
+    end
+
+    context 'with an instance' do
+      subject { model.new }
+
+      before do
+        subject.extend(mod)
+        subject.attribute :name, String
+      end
+
+      it 'has attributes with strict set to true' do
+        expect(subject.send(:attribute_set)[:name]).to be_strict
+      end
+    end
+  end
+
+  context 'when mass-assignment is disabled' do
+    let(:mod)   { Virtus.model(:mass_assignment => false) }
+    let(:model) { Class.new }
+
+    context 'with a class' do
+      subject { model.new }
+
+      before do
+        model.send(:include, mod)
+      end
+
+      it { is_expected.not_to respond_to(:attributes) }
+      it { is_expected.not_to respond_to(:attributes=) }
+    end
+
+    context 'with an instance' do
+      subject { model.new }
+
+      before do
+        subject.extend(mod)
+      end
+
+      it { is_expected.not_to respond_to(:attributes) }
+      it { is_expected.not_to respond_to(:attributes=) }
+    end
+  end
+
+  context 'when :required is set' do
+    let(:mod)   { Virtus.model(:required => false) }
+    let(:model) { Class.new }
+
+    context 'with a class' do
+      subject { model.new }
+
+      before do
+        model.send(:include, mod)
+        model.attribute :name, String
+      end
+
+      it 'has attributes with :required option inherited from module' do
+        expect(model.attribute_set[:name]).to_not be_required
+      end
+    end
+
+    context 'with an instance' do
+      subject { model.new }
+
+      before do
+        subject.extend(mod)
+        subject.attribute :name, String
+      end
+
+      it 'has attributes with strict set to true' do
+        expect(subject.send(:attribute_set)[:name]).not_to be_required
+      end
+    end
+  end
+end