virtus2 2.0.1

data/spec/shared/constants_helpers.rb

@@ -0,0 +1,9 @@
+module ConstantsHelpers
+
+  extend self
+
+  # helper to remove constants after test-runs.
+  def undef_constant(mod, constant_name)
+    mod.send(:remove_const, constant_name)
+  end
+end

data/spec/shared/freeze_method_behavior.rb

@@ -0,0 +1,40 @@
+shared_examples_for 'a #freeze method' do
+  let(:sample_exception) do
+    begin
+      object.dup.freeze.instance_variable_set(:@foo, :bar)
+    rescue => exception
+      exception
+    end
+  end
+
+  let(:expected_exception_class) do
+    # Ruby 1.8 blows up with TypeError Ruby 1.9 with RuntimeError
+    sample_exception.class
+  end
+
+  let(:expected_exception_message) do
+    # Ruby 1.8 blows up with a different message than Ruby 1.9
+    sample_exception.message
+  end
+
+  it_should_behave_like 'an idempotent method'
+
+  it 'returns object' do
+    is_expected.to be(object)
+  end
+
+  it 'prevents future modifications' do
+    subject
+    expectation = raise_error(expected_exception_class,expected_exception_message)
+    expect { object.instance_variable_set(:@foo, :bar) }.to(expectation)
+  end
+
+  describe '#frozen?' do
+    subject { super().frozen? }
+    it { is_expected.to be(true) }
+  end
+
+  it 'allows to access attribute' do
+    expect(subject.name).to eql('John')
+  end
+end

data/spec/shared/idempotent_method_behaviour.rb

@@ -0,0 +1,5 @@
+shared_examples_for 'an idempotent method' do
+  it 'is idempotent' do
+    is_expected.to equal(subject)
+  end
+end

data/spec/shared/options_class_method.rb

@@ -0,0 +1,19 @@
+shared_examples_for 'an options class method' do
+  context 'with no argument' do
+    subject { object.send(method) }
+
+    it { is_expected.to be(default) }
+  end
+
+  context 'with a default value' do
+    subject { object.send(method, value) }
+
+    let(:value) { mock('value') }
+
+    it { is_expected.to equal(object) }
+
+    it 'sets the default value for the class method' do
+      expect { subject }.to change { object.send(method) }.from(default).to(value)
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,41 @@
+if RUBY_ENGINE == 'ruby' && RUBY_VERSION >= '3.0'
+  require 'simplecov'
+  SimpleCov.start
+end
+
+require 'rspec'
+require 'bogus/rspec'
+require 'virtus'
+
+module Virtus
+  def self.warn(*)
+    # shut up in tests
+  end
+end
+
+ENV['TZ'] = 'UTC'
+
+# require spec support files and shared behavior
+Dir[File.expand_path('../shared/**/*.rb', __FILE__)].each { |file| require file }
+
+RSpec.configure do |config|
+  # Remove anonymous- and example- Attribute classes from Attribute descendants
+  config.after :all do
+    stack = [ Virtus::Attribute ]
+    while klass = stack.pop
+      klass.descendants.delete_if do |descendant|
+        descendant.name.nil? || descendant.name.empty? || descendant.name.start_with?('Examples::')
+      end
+      stack.concat(klass.descendants)
+    end
+  end
+
+  # Remove constants in the Example-Module
+  config.after :each do
+    if defined?(Examples)
+      Examples.constants.each do |const_name|
+        ConstantsHelpers.undef_constant(Examples, const_name)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+require 'spec_helper'
+
+describe Virtus::Attribute::Boolean, '#coerce' do
+  subject { object.coerce(input) }
+
+  let(:object)  { described_class.build('Boolean', options) }
+  let(:options) { {} }
+
+  context 'when strict is turned off' do
+    context 'with a truthy value' do
+      let(:input) { 1 }
+
+      it { is_expected.to be(true) }
+    end
+
+    context 'with a falsy value' do
+      let(:input) { 0 }
+
+      it { is_expected.to be(false) }
+    end
+  end
+
+  context 'when strict is turned on' do
+    let(:options) { { :strict => true } }
+
+    context 'with a coercible input' do
+      let(:input) { 1 }
+
+      it { is_expected.to be(true) }
+    end
+
+    context 'with a non-coercible input' do
+      let(:input) { 'no idea if true or false' }
+
+      it 'raises coercion error' do
+        expect { subject }.to raise_error(
+          Virtus::CoercionError,
+          /Failed to coerce "no idea if true or false"/
+        )
+      end
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+describe Virtus::Attribute::Boolean, '#value_coerced?' do
+  subject { object.value_coerced?(input) }
+
+  let(:object) { described_class.build('Boolean') }
+
+  context 'when input is true' do
+    let(:input) { true }
+
+    it { is_expected.to be(true) }
+  end
+
+  context 'when input is false' do
+    let(:input) { false }
+
+    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

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

@@ -0,0 +1,180 @@
+require 'spec_helper'
+
+describe Virtus::Attribute, '.build' do
+  subject { described_class.build(type, options.merge(:name => name)) }
+
+  let(:name)    { :test }
+  let(:type)    { String }
+  let(:options) { {} }
+
+  shared_examples_for 'a valid attribute instance' do
+    it { is_expected.to be_instance_of(Virtus::Attribute) }
+
+    it { is_expected.to be_frozen }
+  end
+
+  context 'without options' do
+    it_behaves_like 'a valid attribute instance'
+
+    it { is_expected.to be_coercible }
+    it { is_expected.to be_public_reader }
+    it { is_expected.to be_public_writer }
+    it { is_expected.not_to be_lazy }
+
+    it 'sets up a coercer' do
+      expect(subject.options[:coerce]).to be(true)
+      expect(subject.coercer).to be_instance_of(Virtus::Attribute::Coercer)
+    end
+  end
+
+  context 'when name is passed as a string' do
+    let(:name) { 'something' }
+
+    describe '#name' do
+      subject { super().name }
+      it { is_expected.to be(:something) }
+    end
+  end
+
+  context 'when coercion is turned off in options' do
+    let(:options) { { :coerce => false } }
+
+    it_behaves_like 'a valid attribute instance'
+
+    it { is_expected.not_to be_coercible }
+  end
+
+  context 'when options specify reader visibility' do
+    let(:options) { { :reader => :private } }
+
+    it_behaves_like 'a valid attribute instance'
+
+    it { is_expected.not_to be_public_reader }
+    it { is_expected.to be_public_writer }
+  end
+
+  context 'when options specify writer visibility' do
+    let(:options) { { :writer => :private } }
+
+    it_behaves_like 'a valid attribute instance'
+
+    it { is_expected.to be_public_reader }
+    it { is_expected.not_to be_public_writer }
+  end
+
+  context 'when options specify lazy accessor' do
+    let(:options) { { :lazy => true } }
+
+    it_behaves_like 'a valid attribute instance'
+
+    it { is_expected.to be_lazy }
+  end
+
+  context 'when options specify strict mode' do
+    let(:options) { { :strict => true } }
+
+    it_behaves_like 'a valid attribute instance'
+
+    it { is_expected.to be_strict }
+  end
+
+  context 'when options specify nullify blank mode' do
+    let(:options) { { :nullify_blank => true } }
+
+    it_behaves_like 'a valid attribute instance'
+
+    it { is_expected.to be_nullify_blank }
+  end
+
+  context 'when type is a string' do
+    let(:type) { 'Integer' }
+
+    it_behaves_like 'a valid attribute instance'
+
+    describe '#type' do
+      subject { super().type }
+      it { is_expected.to be(Axiom::Types::Integer) }
+    end
+  end
+
+  context 'when type is a range' do
+    let(:type) { 0..10 }
+
+    it_behaves_like 'a valid attribute instance'
+
+    describe '#type' do
+      subject { super().type }
+      it { is_expected.to be(Axiom::Types.infer(Range)) }
+    end
+  end
+
+  context 'when type is a symbol of an existing class constant' do
+    let(:type) { :String }
+
+    it_behaves_like 'a valid attribute instance'
+
+    describe '#type' do
+      subject { super().type }
+      it { is_expected.to be(Axiom::Types::String) }
+    end
+  end
+
+  context 'when type is an axiom type' do
+    let(:type) { Axiom::Types::Integer }
+
+    it_behaves_like 'a valid attribute instance'
+
+    describe '#type' do
+      subject { super().type }
+      it { is_expected.to be(type) }
+    end
+  end
+
+  context 'when custom attribute class exists for a given primitive' do
+    let(:type)      { Class.new }
+    let(:attribute) { Class.new(Virtus::Attribute) }
+
+    before do
+      attribute.primitive(type)
+    end
+
+    it { is_expected.to be_instance_of(attribute) }
+
+    describe '#type' do
+      subject { super().type }
+      it { is_expected.to be(Axiom::Types::Object) }
+    end
+  end
+
+  context 'when custom attribute class exists for a given array with member coercion defined' do
+    let(:type)      { Class.new(Array)[String] }
+    let(:attribute) { Class.new(Virtus::Attribute) }
+
+    before do
+      attribute.primitive(type.class)
+    end
+
+    it { is_expected.to be_instance_of(attribute) }
+
+    describe '#type' do
+      subject { super().type }
+      it { is_expected.to be < Axiom::Types::Collection }
+    end
+  end
+
+  context 'when custom collection-like attribute class exists for a given enumerable primitive' do
+    let(:type)      { Class.new { include Enumerable } }
+    let(:attribute) { Class.new(Virtus::Attribute::Collection) }
+
+    before do
+      attribute.primitive(type)
+    end
+
+    it { is_expected.to be_instance_of(attribute) }
+
+    describe '#type' do
+      subject { super().type }
+      it { is_expected.to be < Axiom::Types::Collection }
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+require 'spec_helper'
+
+describe Virtus::Attribute, '.coerce' do
+  subject { described_class.coerce }
+
+  after :all do
+    described_class.coerce(true)
+  end
+
+  context 'with a value' do
+    it 'sets the value and return self' do
+      expect(described_class.coerce(false)).to be(described_class)
+      expect(subject).to be(false)
+    end
+  end
+
+  context 'when it is set to true' do
+    before do
+      described_class.coerce(true)
+    end
+
+    it { is_expected.to be(true) }
+  end
+
+  context 'when it is set to false' do
+    before do
+      described_class.coerce(false)
+    end
+
+    it { is_expected.to be(false) }
+  end
+end

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

@@ -0,0 +1,129 @@
+require 'spec_helper'
+
+describe Virtus::Attribute, '#coerce' do
+  subject { object.coerce(input) }
+
+  fake(:coercer) { Virtus::Attribute::Coercer }
+
+  let(:object)   {
+    described_class.build(String,
+      :coercer => coercer, :strict => strict, :required => required, :nullify_blank => nullify_blank)
+  }
+
+  let(:required) { true }
+  let(:nullify_blank) { false }
+  let(:input)    { 1 }
+  let(:output)   { '1' }
+
+  context 'when strict mode is turned off' do
+    let(:strict) { false }
+
+    it 'uses coercer to coerce the input value' do
+      mock(coercer).call(input) { output }
+
+      expect(subject).to be(output)
+
+      expect(coercer).to have_received.call(input)
+    end
+  end
+
+  context 'when strict mode is turned on' do
+    let(:strict) { true }
+
+    it 'uses coercer to coerce the input value' do
+      mock(coercer).call(input) { output }
+      mock(coercer).success?(String, output) { true }
+
+      expect(subject).to be(output)
+
+      expect(coercer).to have_received.call(input)
+      expect(coercer).to have_received.success?(String, output)
+    end
+
+    context 'when attribute is not required and input is nil' do
+      let(:required) { false }
+      let(:input)    { nil }
+
+      it 'returns nil' do
+        mock(coercer).call(input) { input }
+        mock(coercer).success?(String, input) { false }
+
+        expect(subject).to be(nil)
+
+        expect(coercer).to have_received.call(input)
+        expect(coercer).to have_received.success?(String, input)
+      end
+    end
+
+    context 'when attribute is required and input is nil' do
+      let(:input) { nil }
+
+      it 'returns raises error' do
+        mock(coercer).call(input) { input }
+        mock(coercer).success?(String, input) { false }
+
+        expect { subject }.to raise_error(Virtus::CoercionError)
+
+        expect(coercer).to have_received.call(input)
+        expect(coercer).to have_received.success?(String, input)
+      end
+    end
+
+    it 'raises error when input was not coerced' do
+      mock(coercer).call(input) { input }
+      mock(coercer).success?(String, input) { false }
+
+      expect { subject }.to raise_error(Virtus::CoercionError)
+
+      expect(coercer).to have_received.call(input)
+      expect(coercer).to have_received.success?(String, input)
+    end
+  end
+
+  context 'when the input is an empty String' do
+    let(:input) { '' }
+    let(:output) { '' }
+
+    context 'when nullify_blank is turned on' do
+      let(:nullify_blank) { true }
+      let(:strict) { false }
+      let(:require) { false }
+
+      it 'returns nil' do
+        mock(coercer).call(input) { input }
+        mock(coercer).success?(String, input) { false }
+
+        expect(subject).to be_nil
+
+        expect(coercer).to have_received.call(input)
+        expect(coercer).to have_received.success?(String, input)
+      end
+
+      it 'returns the ouput if it was coerced' do
+        mock(coercer).call(input) { output }
+        mock(coercer).success?(String, output) { true }
+
+        expect(subject).to be(output)
+
+        expect(coercer).to have_received.call(input)
+        expect(coercer).to have_received.success?(String, output)
+      end
+    end
+
+    context 'when both nullify_blank and strict are turned on' do
+      let(:nullify_blank) { true }
+      let(:strict) { true }
+
+      it 'does not raises an coercion error' do
+        mock(coercer).call(input) { input }
+        mock(coercer).success?(String, input) { false }
+
+        expect { subject }.not_to raise_error
+        expect(subject).to be_nil
+
+        expect(coercer).to have_received.call(input)
+        expect(coercer).to have_received.success?(String, input)
+      end
+    end
+  end
+end