virtus 0.5.5 → 1.0.0.beta3

data/spec/unit/virtus/equalizer/class_method/new_spec.rb

@@ -1,111 +0,0 @@
-require 'spec_helper'
-
-describe Virtus::Equalizer, '.new' do
-  let(:object) { described_class }
-  let(:name)   { 'User'          }
-
-  let(:klass) do
-    klass = ::Class.new
-    klass.send(:include, subject)
-    klass
-  end
-
-  context 'with a name' do
-    subject { object.new(name) }
-
-    let(:instance) { klass.new }
-
-    it { should be_instance_of(object) }
-
-    describe '#eql?' do
-      context 'when the objects are similar' do
-        let(:other) { instance.dup }
-
-        it { instance.eql?(other).should be(true) }
-      end
-
-      context 'when the objects are different' do
-        let(:other) { stub('other') }
-
-        it { instance.eql?(other).should be(false) }
-      end
-    end
-
-    describe '#==' do
-      context 'when the objects are similar' do
-        let(:other) { instance.dup }
-
-        it { (instance == other).should be(true) }
-      end
-
-      context 'when the objects are different' do
-        let(:other) { stub('other') }
-
-        it { (instance == other).should be(false) }
-      end
-    end
-
-    describe '#hash' do
-      it { instance.hash.should eql(klass.hash) }
-    end
-
-    describe '#inspect' do
-      it { instance.inspect.should eql('#<User>') }
-    end
-  end
-
-  context 'with a name and keys' do
-    subject { object.new(name, keys) }
-
-    let(:keys)       { [ :first_name ].freeze }
-    let(:first_name) { 'John'                 }
-
-    let(:instance) do
-      instance = klass.new
-      instance.first_name = first_name
-      instance
-    end
-
-    before do
-      klass.send(:attr_accessor, *keys)
-    end
-
-    it { should be_instance_of(object) }
-
-    describe '#eql?' do
-      context 'when the objects are similar' do
-        let(:other) { instance.dup }
-
-        it { instance.eql?(other).should be(true) }
-      end
-
-      context 'when the objects are different' do
-        let(:other) { stub('other') }
-
-        it { instance.eql?(other).should be(false) }
-      end
-    end
-
-    describe '#==' do
-      context 'when the objects are similar' do
-        let(:other) { instance.dup }
-
-        it { (instance == other).should be(true) }
-      end
-
-      context 'when the objects are different' do
-        let(:other) { stub('other') }
-
-        it { (instance == other).should be(false) }
-      end
-    end
-
-    describe '#hash' do
-      it { instance.hash.should eql(klass.hash ^ first_name.hash) }
-    end
-
-    describe '#inspect' do
-      it { instance.inspect.should eql('#<User first_name="John">') }
-    end
-  end
-end

data/spec/unit/virtus/equalizer/methods/eql_spec.rb

@@ -1,47 +0,0 @@
-require 'spec_helper'
-
-describe Virtus::Equalizer::Methods, '#eql?' do
-  subject { object.eql?(other) }
-
-  let(:object) { described_class.new }
-
-  let(:described_class) do
-    Class.new do
-      include Virtus::Equalizer::Methods
-
-      def cmp?(comparator, other)
-        !!(comparator and other)
-      end
-    end
-  end
-
-  context 'with the same object' do
-    let(:other) { object }
-
-    it { should be(true) }
-
-    it 'is symmetric' do
-      should eql(other.eql?(object))
-    end
-  end
-
-  context 'with an equivalent object' do
-    let(:other) { object.dup }
-
-    it { should be(true) }
-
-    it 'is symmetric' do
-      should eql(other.eql?(object))
-    end
-  end
-
-  context 'with an equivalent object of a subclass' do
-    let(:other) { Class.new(described_class).new }
-
-    it { should be(false) }
-
-    it 'is symmetric' do
-      should eql(other.eql?(object))
-    end
-  end
-end

data/spec/unit/virtus/equalizer/methods/equal_value_spec.rb

@@ -1,57 +0,0 @@
-require 'spec_helper'
-
-describe Virtus::Equalizer::Methods, '#==' do
-  subject { object == other }
-
-  let(:object) { described_class.new }
-
-  let(:described_class) do
-    Class.new do
-      include Virtus::Equalizer::Methods
-
-      def cmp?(comparator, other)
-        !!(comparator and other)
-      end
-    end
-  end
-
-  context 'with the same object' do
-    let(:other) { object }
-
-    it { should be(true) }
-
-    it 'is symmetric' do
-      should eql(other == object)
-    end
-  end
-
-  context 'with an equivalent object' do
-    let(:other) { object.dup }
-
-    it { should be(true) }
-
-    it 'is symmetric' do
-      should eql(other == object)
-    end
-  end
-
-  context 'with an equivalent object of a subclass' do
-    let(:other) { Class.new(described_class).new }
-
-    it { should be(true) }
-
-    it 'is symmetric' do
-      should eql(other == object)
-    end
-  end
-
-  context 'with an object of another class' do
-    let(:other) { Class.new.new }
-
-    it { should be(false) }
-
-    it 'is symmetric' do
-      should eql(other == object)
-    end
-  end
-end

data/spec/unit/virtus/extensions/allowed_writer_methods_spec.rb

@@ -1,25 +0,0 @@
-require 'spec_helper'
-
-describe Virtus::Extensions, '#allowed_writer_methods' do
-  subject { object.allowed_writer_methods }
-
-  let(:object) do
-    Class.new do
-      include Virtus
-      attribute :virtus_attribute, String
-      attr_accessor :some_other_attribute
-    private
-      attr_accessor :private_attribute
-    end
-  end
-
-  it { should include('virtus_attribute=') }
-  it { should include('some_other_attribute=') }
-  it { should_not include('private_attribute=') }
-
-  %w[ == != === []= attributes= ].each do |invalid_method|
-    it { should_not include(invalid_method) }
-  end
-
-  it { should be_frozen }
-end

data/spec/unit/virtus/extensions/attribute_spec.rb

@@ -1,26 +0,0 @@
-require 'spec_helper'
-
-describe Virtus::Extensions, '#attribute' do
-  subject { object.attribute(name, type) }
-
-  let(:object)     { Class.new { extend Virtus::Extensions } }
-  let(:descendant) { Class.new(object)                       }
-  let(:name)       { :name                                   }
-  let(:type)       { Virtus::Attribute::String               }
-
-  def assert_attribute_added(klass, name, attribute_class)
-    klass.should_not be_public_method_defined(name)
-    subject
-    klass.should_not be_public_method_defined(name)
-  end
-
-  it { should be(object) }
-
-  it 'adds the attribute to the class' do
-    assert_attribute_added(object, name, type)
-  end
-
-  it 'adds the attribute to the descendant' do
-    assert_attribute_added(descendant, name, type)
-  end
-end

data/spec/unit/virtus/instance_methods/attributes_spec.rb

@@ -1,140 +0,0 @@
-require 'spec_helper'
-
-describe Virtus::InstanceMethods do
-  let(:model) do
-    Class.new do
-      include Virtus
-
-      attribute :name,  String
-      attribute :age,   Integer
-      attribute :email, String, :accessor => :private
-
-      attr_accessor :non_attribute
-
-      def private_non_attribute_reader
-        @private_non_attribute
-      end
-
-      private
-
-      attr_accessor :private_non_attribute
-    end
-  end
-
-  let(:hash_object) do
-    Class.new do
-      def to_hash
-        {:age => 5}
-      end
-    end.new
-  end
-
-  let(:attributes) { { :name => 'john', :age => 28 } }
-
-  describe '#attributes' do
-    subject { object.attributes }
-
-    let(:object) { model.new(attributes) }
-
-    it { should be_instance_of(Hash) }
-
-    it { should eql(attributes) }
-  end
-
-  describe '#attributes=' do
-    subject { object.attributes = attribute_values }
-
-    let(:object) { model.new }
-
-    context 'when given values for publicly writable attributes' do
-      let(:attribute_values) { attributes }
-
-      it { should be(attribute_values) }
-
-      it 'sets all provided attribute values' do
-        object.attributes.should eql(:age => nil, :name => nil)
-        subject
-        object.attributes.should eql(attributes)
-      end
-    end
-
-    context 'when given string keys for attributes' do
-      let(:attribute_values) { { 'name' => 'john', 'age' => 28 } }
-
-      it { should be(attribute_values) }
-
-      it 'sets values for publicly accessible attributes' do
-        object.attributes.should eql(:age => nil, :name => nil)
-        subject
-        object.attributes.should eql(attributes)
-      end
-    end
-
-    context 'when given values for privately writable attributes' do
-      let(:attribute_values) { attributes.merge(:email => 'john@domain.tld') }
-
-      it { should be(attribute_values) }
-
-      it 'only sets values for publicly accessible attributes' do
-        object.attributes.should eql(:age => nil, :name => nil)
-        subject
-        object.attributes.should eql(attributes)
-      end
-    end
-
-    context 'when given values for non-attribute setters' do
-      let(:attribute_values) { attributes.merge(:non_attribute => 'foobar') }
-
-      it { should be(attribute_values) }
-
-      it 'sets values for publicly accessible attributes' do
-        object.attributes.should eql(:age => nil, :name => nil)
-        subject
-        object.attributes.should eql(attributes)
-      end
-
-      it 'sets publicly accessible non-Virtus attributes' do
-        expect { subject }.to change { object.non_attribute }
-      end
-
-      it 'silently ignores private non-Virtus attributes' do
-        expect { subject }.to_not change { object.private_non_attribute_reader }
-      end
-    end
-
-    context "when given values that don't correspond to attributes" do
-      let(:attribute_values) { attributes.merge(:quux => 'foobar') }
-
-      it { should be(attribute_values) }
-
-      it 'sets values for publicly accessible attributes' do
-        object.attributes.should eql(:age => nil, :name => nil)
-        subject
-        object.attributes.should eql(attributes)
-      end
-
-      it 'silently ignores non-attribute keys' do
-        expect { subject }.to_not raise_exception
-      end
-    end
-
-    context "when given values respond_to?(:to_hash)" do
-      let(:attribute_values) { hash_object }
-
-      it 'sets attributes' do
-        subject
-        object.age.should == 5
-      end
-    end
-
-    context "when given values does not respond_to?(:to_hash)" do
-      let(:attribute_values) { '' }
-
-      it 'raises an exception' do
-        expect {
-          subject
-        }.to raise_error(NoMethodError, 'Expected "" to respond to #to_hash')
-      end
-    end
-  end
-end

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

@@ -1,24 +0,0 @@
-require 'spec_helper'
-
-describe Virtus::InstanceMethods, '#[]' do
-  subject { object[:name] }
-
-  let(:described_class) do
-    Class.new do
-      include Virtus
-      attribute :name, String
-    end
-  end
-
-  let(:object) do
-    described_class.new(:name => value)
-  end
-
-  let(:value) do
-    'john'
-  end
-
-  it 'returns the value of an attribute' do
-    should eql(value)
-  end
-end

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

@@ -1,28 +0,0 @@
-require 'spec_helper'
-
-describe Virtus::InstanceMethods, '#[]=' do
-  subject { object[:name] = value }
-
-  let(:described_class) do
-    Class.new do
-      include Virtus
-      attribute :name, String
-    end
-  end
-
-  let(:object) do
-    described_class.new
-  end
-
-  let(:value) do
-    'john'
-  end
-
-  it 'returns the value' do
-    should eql(value)
-  end
-
-  it 'sets value of an attribute' do
-    expect { subject }.to change { object.name }.from(nil).to(value)
-  end
-end