active_data 1.0.0 → 1.1.0

data/spec/lib/active_data/model/lifecycle_spec.rb

@@ -1,4 +1,3 @@
-# encoding: UTF-8
 require 'spec_helper'
 
 describe ActiveData::Model::Lifecycle do
@@ -11,7 +10,7 @@ describe ActiveData::Model::Lifecycle do
 
     subject { User.new }
 
-    [:save, :create, :update, :destroy].each do |action|
+    %i[save create update destroy].each do |action|
       specify { expect { subject.public_send "_#{action}_performer=", '' }.to raise_error NoMethodError }
     end
 
@@ -19,9 +18,9 @@ describe ActiveData::Model::Lifecycle do
       let(:foo) { true }
 
       specify { expect { subject.save { foo } }.to raise_error NameError }
-      specify { expect { subject.save { |instance| attributes } }.to raise_error NameError }
+      specify { expect { subject.save { |_| attributes } }.to raise_error NameError }
       specify { expect(subject.save { attributes }).to eq(true) }
-      specify { expect(subject.save { |instance| foo }).to eq(true) }
+      specify { expect(subject.save { |_| foo }).to eq(true) }
     end
 
     context 'save' do
@@ -87,7 +86,7 @@ describe ActiveData::Model::Lifecycle do
 
             attribute :actions, Array, default: []
 
-            def append action
+            def append(action)
               self.actions = actions + [action]
             end
 
@@ -106,7 +105,7 @@ describe ActiveData::Model::Lifecycle do
           subject.destroy
           subject.destroy
           subject.save
-          expect(subject.actions).to eq([:destroy, :create, :update, :destroy, :destroy, :create])
+          expect(subject.actions).to eq(%i[destroy create update destroy destroy create])
         end
       end
     end
@@ -198,10 +197,14 @@ describe ActiveData::Model::Lifecycle do
       specify { expect { subject.update({}) }.not_to change { subject.persisted? } }
       specify { expect { subject.update!({}) }.to raise_error ActiveData::ValidationError }
 
-      specify { expect { subject.update(name: 'Jonny') }
-        .to change { Storage.storage.keys }.from([]).to([subject.id]) }
-      specify { expect { subject.update!(name: 'Jonny') }
-        .to change { Storage.storage.keys }.from([]).to([subject.id]) }
+      specify do
+        expect { subject.update(name: 'Jonny') }
+          .to change { Storage.storage.keys }.from([]).to([subject.id])
+      end
+      specify do
+        expect { subject.update!(name: 'Jonny') }
+          .to change { Storage.storage.keys }.from([]).to([subject.id])
+      end
     end
 
     describe '#update_attributes, #update_attributes!' do
@@ -213,10 +216,14 @@ describe ActiveData::Model::Lifecycle do
       specify { expect { subject.update_attributes({}) }.not_to change { subject.persisted? } }
       specify { expect { subject.update_attributes!({}) }.to raise_error ActiveData::ValidationError }
 
-      specify { expect { subject.update_attributes(name: 'Jonny') }
-        .to change { Storage.storage.keys }.from([]).to([subject.id]) }
-      specify { expect { subject.update_attributes!(name: 'Jonny') }
-        .to change { Storage.storage.keys }.from([]).to([subject.id]) }
+      specify do
+        expect { subject.update_attributes(name: 'Jonny') }
+          .to change { Storage.storage.keys }.from([]).to([subject.id])
+      end
+      specify do
+        expect { subject.update_attributes!(name: 'Jonny') }
+          .to change { Storage.storage.keys }.from([]).to([subject.id])
+      end
     end
 
     describe '#save, #save!' do
@@ -230,7 +237,10 @@ describe ActiveData::Model::Lifecycle do
         specify { expect { subject.save! }.to raise_error ActiveData::ValidationError }
 
         specify { expect { subject.save }.not_to change { subject.persisted? } }
-        specify { expect { subject.save! rescue nil }.not_to change { subject.persisted? } }
+        specify do
+          expect { muffle(ActiveData::ValidationError) { subject.save! } }
+            .not_to change { subject.persisted? }
+        end
       end
 
       context 'create' do
@@ -257,7 +267,10 @@ describe ActiveData::Model::Lifecycle do
           specify { expect { subject.save! }.to raise_error ActiveData::ObjectNotSaved }
 
           specify { expect { subject.save }.not_to change { subject.persisted? } }
-          specify { expect { subject.save! rescue nil }.not_to change { subject.persisted? } }
+          specify do
+            expect { muffle(ActiveData::ObjectNotSaved) { subject.save! } }
+              .not_to change { subject.persisted? }
+          end
         end
       end
 
@@ -273,10 +286,14 @@ describe ActiveData::Model::Lifecycle do
         specify { expect { subject.save }.not_to change { subject.persisted? } }
         specify { expect { subject.save! }.not_to change { subject.persisted? } }
 
-        specify { expect { subject.save }.to change { Storage.storage[subject.id] }
-          .from(hash_including(name: 'Jonny')).to(hash_including(name: 'Jimmy')) }
-        specify { expect { subject.save! }.to change { Storage.storage[subject.id] }
-          .from(hash_including(name: 'Jonny')).to(hash_including(name: 'Jimmy')) }
+        specify do
+          expect { subject.save }.to change { Storage.storage[subject.id] }
+            .from(hash_including(name: 'Jonny')).to(hash_including(name: 'Jimmy'))
+        end
+        specify do
+          expect { subject.save! }.to change { Storage.storage[subject.id] }
+            .from(hash_including(name: 'Jonny')).to(hash_including(name: 'Jimmy'))
+        end
 
         context 'save failed' do
           before { User.define_save { false } }
@@ -287,7 +304,10 @@ describe ActiveData::Model::Lifecycle do
           specify { expect { subject.save! }.to raise_error ActiveData::ObjectNotSaved }
 
           specify { expect { subject.save }.not_to change { subject.persisted? } }
-          specify { expect { subject.save! rescue nil }.not_to change { subject.persisted? } }
+          specify do
+            expect { muffle(ActiveData::ObjectNotSaved) { subject.save! } }
+              .not_to change { subject.persisted? }
+          end
         end
       end
     end
@@ -320,10 +340,16 @@ describe ActiveData::Model::Lifecycle do
         specify { expect { subject.destroy! }.to raise_error ActiveData::ObjectNotDestroyed }
 
         specify { expect { subject.destroy }.not_to change { subject.persisted? } }
-        specify { expect { subject.destroy! rescue nil }.not_to change { subject.persisted? } }
+        specify do
+          expect { muffle(ActiveData::ObjectNotDestroyed) { subject.destroy! } }
+            .not_to change { subject.persisted? }
+        end
 
         specify { expect { subject.destroy }.not_to change { subject.destroyed? } }
-        specify { expect { subject.destroy! rescue nil }.not_to change { subject.destroyed? } }
+        specify do
+          expect { muffle(ActiveData::ObjectNotDestroyed) { subject.destroy! } }
+            .not_to change { subject.destroyed? }
+        end
       end
     end
   end

data/spec/lib/active_data/model/persistence_spec.rb

@@ -1,4 +1,3 @@
-# encoding: UTF-8
 require 'spec_helper'
 
 describe ActiveData::Model::Persistence do
@@ -22,7 +21,7 @@ describe ActiveData::Model::Persistence do
     context do
       subject(:instance) { model.instantiate(name: 'Hello', foo: 'Bar') }
 
-      specify { expect(subject.instance_variable_get(:@initial_attributes)).to eq({ name: 'Hello' }.stringify_keys) }
+      specify { expect(subject.instance_variable_get(:@initial_attributes)).to eq({name: 'Hello'}.stringify_keys) }
     end
   end
 
@@ -31,17 +30,17 @@ describe ActiveData::Model::Persistence do
       subject(:instances) { model.instantiate_collection(name: 'Hello', foo: 'Bar') }
 
       specify { expect(subject).to be_a Array }
-      specify { expect(subject.first.instance_variable_get(:@initial_attributes)).to eq({ name: 'Hello' }.stringify_keys) }
+      specify { expect(subject.first.instance_variable_get(:@initial_attributes)).to eq({name: 'Hello'}.stringify_keys) }
     end
 
     context do
       before { model.send(:include, ActiveData::Model::Scopes) }
-      subject(:instances) { model.instantiate_collection([{ name: 'Hello', foo: 'Bar' }, {name: 'World'}]) }
+      subject(:instances) { model.instantiate_collection([{name: 'Hello', foo: 'Bar'}, {name: 'World'}]) }
 
       specify { expect(subject).to be_a ActiveData::Model::Scopes::ScopeProxy }
       specify { expect(subject.count).to eq(2) }
-      specify { expect(subject.first.instance_variable_get(:@initial_attributes)).to eq({ name: 'Hello' }.stringify_keys) }
-      specify { expect(subject.second.instance_variable_get(:@initial_attributes)).to eq({ name: 'World' }.stringify_keys) }
+      specify { expect(subject.first.instance_variable_get(:@initial_attributes)).to eq({name: 'Hello'}.stringify_keys) }
+      specify { expect(subject.second.instance_variable_get(:@initial_attributes)).to eq({name: 'World'}.stringify_keys) }
     end
   end
 end

data/spec/lib/active_data/model/representation_spec.rb

@@ -0,0 +1,126 @@
+require 'spec_helper'
+
+describe ActiveData::Model::Representation do
+  context 'integration' do
+    before do
+      stub_model(:author) do
+        attribute :rate, Integer
+      end
+
+      stub_model(:post) do
+        include ActiveData::Model::Representation
+
+        attribute :author, Object
+        alias_attribute :a, :author
+        represents :rate, of: :a
+        alias_attribute :r, :rate
+      end
+    end
+    let(:author) { Author.new(rate: '42') }
+
+    specify { expect(Post.reflect_on_attribute(:rate).reference).to eq('author') }
+
+    specify { expect(Post.new(author: author).rate).to eq(42) }
+    specify { expect(Post.new(author: author).rate_before_type_cast).to eq('42') }
+    specify { expect(Post.new(rate: '33', author: author).rate).to eq(33) }
+    specify { expect(Post.new(rate: '33', author: author).author.rate).to eq(33) }
+    specify { expect(Post.new(r: '33', author: author).rate).to eq(33) }
+    specify { expect(Post.new(r: '33', author: author).author.rate).to eq(33) }
+    specify { expect(Post.new(author: author).rate?).to eq(true) }
+    specify { expect(Post.new(rate: nil, author: author).rate?).to eq(false) }
+
+    specify { expect(Post.new.rate).to be_nil }
+    specify { expect(Post.new.rate_before_type_cast).to be_nil }
+    specify { expect { Post.new(rate: '33') }.to raise_error(NoMethodError) }
+
+    context 'ActionController::Parameters' do
+      let(:params) { instance_double('ActionController::Parameters', to_unsafe_hash: {rate: '33', author: author}) }
+      specify { expect { Post.new(params) }.not_to raise_error }
+    end
+
+    context 'dirty' do
+      before { Post.include ActiveData::Model::Dirty }
+
+      specify do
+        expect(Post.new(author: author, rate: '33').changes)
+          .to eq('author' => [nil, author], 'rate' => [42, 33])
+      end
+    end
+
+    context do
+      before do
+        stub_class(:author, ActiveRecord::Base)
+
+        stub_model(:post) do
+          include ActiveData::Model::Associations
+          include ActiveData::Model::Representation
+
+          references_one :author
+          alias_association :a, :author
+          represents :name, of: :a
+        end
+      end
+      let!(:author) { Author.create!(name: 42) }
+
+      specify { expect(Post.reflect_on_attribute(:name).reference).to eq('author') }
+
+      specify { expect(Post.new(name: '33', author: author).name).to eq('33') }
+      specify { expect(Post.new(name: '33', author: author).author.name).to eq('33') }
+    end
+
+    context 'multiple attributes in a single represents definition' do
+      before do
+        stub_model(:author) do
+          attribute :first_name, String
+          attribute :last_name, String
+        end
+
+        stub_model(:post) do
+          include ActiveData::Model::Representation
+
+          attribute :author, Object
+          represents :first_name, :last_name, of: :author
+        end
+      end
+
+      let(:author) { Author.new(first_name: 'John', last_name: 'Doe') }
+      let(:post) { Post.new }
+
+      specify do
+        expect { post.update(author: author) }
+          .to change { post.first_name }.to('John')
+          .and change { post.last_name }.to('Doe')
+      end
+    end
+  end
+
+  describe '#validate' do
+    before do
+      stub_class(:author, ActiveRecord::Base) do
+        validates :name, presence: true
+
+        # Emulate Active Record association auto save error.
+        def errors
+          super.tap do |errors|
+            errors.add(:'user.email', 'is invalid') if errors[:'user.email'].empty?
+          end
+        end
+      end
+
+      stub_model(:post) do
+        include ActiveData::Model::Associations
+        include ActiveData::Model::Representation
+
+        references_one :author
+        represents :name, :email, of: :author
+      end
+    end
+
+    let(:post) { Post.new(author: Author.new) }
+
+    specify do
+      expect { post.validate }.to change { post.errors.messages }
+        .to(hash_including(:'author.user.email' => ['is invalid'], name: ["can't be blank"]))
+    end
+  end
+end

data/spec/lib/active_data/model/scopes_spec.rb

@@ -1,4 +1,3 @@
-# encoding: UTF-8
 require 'spec_helper'
 
 describe ActiveData::Model::Scopes do
@@ -19,8 +18,7 @@ describe ActiveData::Model::Scopes do
 
       private
 
-        def hidden_method
-        end
+        def hidden_method() end
       end
     end
   end

data/spec/lib/active_data/model/typecasting_spec.rb

@@ -1,4 +1,3 @@
-# encoding: UTF-8
 require 'spec_helper'
 
 describe ActiveData::Model::Attributes do
@@ -96,10 +95,11 @@ describe ActiveData::Model::Attributes do
     let(:model) { stub_model { attribute :column, Array } }
 
     specify { expect(model.new(column: [1, 2, 3]).column).to eq([1, 2, 3]) }
-    specify { expect(model.new(column: 'hello, world').column).to eq(['hello', 'world']) }
+    specify { expect(model.new(column: 'hello, world').column).to eq(%w[hello world]) }
     specify { expect(model.new(column: 10).column).to be_nil }
   end
 
+  # rubocop:disable Style/DateTime
   context 'date' do
     let(:model) { stub_model { attribute :column, Date } }
     let(:date) { Date.new(2013, 6, 13) }
@@ -149,6 +149,7 @@ describe ActiveData::Model::Attributes do
       specify { expect(model.new(column: Time.new(2013, 6, 13, 23, 13)).column).to eq(Time.new(2013, 6, 13, 23, 13)) }
     end
   end
+  # rubocop:enable Style/DateTime
 
   context 'time_zone' do
     let(:model) { stub_model { attribute :column, ActiveSupport::TimeZone } }
@@ -175,13 +176,13 @@ describe ActiveData::Model::Attributes do
     let(:uuid_tools) { UUIDTools::UUID.random_create }
 
     specify { expect(uuid.as_json).to eq(uuid.to_s) }
-    specify { expect(uuid.to_json).to eq("\"#{uuid.to_s}\"") }
+    specify { expect(uuid.to_json).to eq("\"#{uuid}\"") }
     specify { expect(uuid.to_param).to eq(uuid.to_s) }
-    specify { expect(uuid.to_query(:key)).to eq("key=#{uuid.to_s}") }
+    specify { expect(uuid.to_query(:key)).to eq("key=#{uuid}") }
 
     specify { expect(model.new(column: nil).column).to be_nil }
     specify { expect(model.new(column: Object.new).column).to be_nil }
-    specify { expect(model.new(column: uuid_tools).column).to be_a ActiveData::UUID  }
+    specify { expect(model.new(column: uuid_tools).column).to be_a ActiveData::UUID }
     specify { expect(model.new(column: uuid_tools).column).to eq(uuid_tools) }
     specify { expect(model.new(column: uuid).column).to eq(uuid) }
     specify { expect(model.new(column: uuid.to_s).column).to eq(uuid) }

data/spec/lib/active_data/model/validations/associated_spec.rb

@@ -35,60 +35,68 @@ describe ActiveData::Model::Validations::AssociatedValidator do
   end
 
   context do
-    subject(:instance) { Main.instantiate name: 'hello', validated_one: { name: 'name' } }
+    subject(:instance) { Main.instantiate name: 'hello', validated_one: {name: 'name'} }
     it { is_expected.to be_valid }
   end
 
   context do
-    subject(:instance) { Main.instantiate name: 'hello', validated_one: { } }
+    subject(:instance) { Main.instantiate name: 'hello', validated_one: {} }
     it { is_expected.not_to be_valid }
-    specify { expect { instance.validate }.to change { instance.errors.messages }
-      .to(validated_one: ['is invalid']) }
+    specify do
+      expect { instance.validate }.to change { instance.errors.messages }
+        .to(validated_one: ['is invalid'])
+    end
   end
 
   context do
-    subject(:instance) { Main.instantiate name: 'hello', unvalidated_one: { name: 'name' } }
+    subject(:instance) { Main.instantiate name: 'hello', unvalidated_one: {name: 'name'} }
     it { is_expected.to be_valid }
   end
 
   context do
-    subject(:instance) { Main.instantiate name: 'hello', unvalidated_one: { } }
+    subject(:instance) { Main.instantiate name: 'hello', unvalidated_one: {} }
     it { is_expected.to be_valid }
   end
 
   context do
-    subject(:instance) { Main.instantiate name: 'hello', validated_many: [{ name: 'name' }] }
+    subject(:instance) { Main.instantiate name: 'hello', validated_many: [{name: 'name'}] }
     it { is_expected.to be_valid }
   end
 
   context do
-    subject(:instance) { Main.instantiate name: 'hello', validated_many: [{ }] }
+    subject(:instance) { Main.instantiate name: 'hello', validated_many: [{}] }
     it { is_expected.not_to be_valid }
-    specify { expect { instance.validate }.to change { instance.errors.messages }
-      .to(:'validated_many.0.name' => ["can't be blank"], validated_many: ['is invalid']) }
+    specify do
+      expect { instance.validate }.to change { instance.errors.messages }
+        .to(:'validated_many.0.name' => ["can't be blank"], validated_many: ['is invalid'])
+    end
   end
 
   context do
-    subject(:instance) { Main.instantiate name: 'hello', unvalidated_many: [{ name: 'name' }] }
+    subject(:instance) { Main.instantiate name: 'hello', unvalidated_many: [{name: 'name'}] }
     it { is_expected.to be_valid }
   end
 
   context do
-    subject(:instance) { Main.instantiate name: 'hello', unvalidated_many: [{ }] }
+    subject(:instance) { Main.instantiate name: 'hello', unvalidated_many: [{}] }
     it { is_expected.to be_valid }
   end
 
   context do
-    subject(:instance) { Main.instantiate name: 'hello', validated_many: [{ name: 'name' }], validated_one: { } }
+    subject(:instance) { Main.instantiate name: 'hello', validated_many: [{name: 'name'}], validated_one: {} }
     it { is_expected.not_to be_valid }
-    specify { expect { instance.validate }.to change { instance.errors.messages }
-      .to(validated_one: ['is invalid']) }
+    specify do
+      expect { instance.validate }.to change { instance.errors.messages }
+        .to(validated_one: ['is invalid'])
+    end
   end
 
   context do
-    subject(:instance) { Main.instantiate name: 'hello', validated_many: [{ }], validated_one: { name: 'name' } }
+    subject(:instance) { Main.instantiate name: 'hello', validated_many: [{}], validated_one: {name: 'name'} }
     it { is_expected.not_to be_valid }
-    specify { expect { instance.validate }.to change { instance.errors.messages }
-      .to(:'validated_many.0.name' => ["can't be blank"], validated_many: ['is invalid']) }
+    specify do
+      expect { instance.validate }.to change { instance.errors.messages }
+        .to(:'validated_many.0.name' => ["can't be blank"], validated_many: ['is invalid'])
+    end
   end
 end

data/spec/lib/active_data/model/validations/nested_spec.rb

@@ -5,7 +5,9 @@ describe ActiveData::Model::Validations::NestedValidator do
     stub_model(:validated_assoc) do
       include ActiveData::Model
       include ActiveData::Model::Lifecycle
+      include ActiveData::Model::Primary
 
+      primary :id, Integer
       attribute :name, String
 
       validates_presence_of :name
@@ -34,60 +36,129 @@ describe ActiveData::Model::Validations::NestedValidator do
   end
 
   context do
-    subject(:instance) { Main.instantiate name: 'hello', validated_one: { name: 'name' } }
+    subject(:instance) { Main.instantiate name: 'hello', validated_one: {name: 'name'} }
     it { is_expected.to be_valid }
   end
 
   context do
-    subject(:instance) { Main.instantiate name: 'hello', validated_one: { } }
+    subject(:instance) { Main.instantiate name: 'hello', validated_one: {} }
     it { is_expected.not_to be_valid }
-    specify { expect { instance.validate }.to change { instance.errors.messages }
-      .to(:'validated_one.name' => ["can't be blank"]) }
+    specify do
+      expect { instance.validate }.to change { instance.errors.messages }
+        .to(:'validated_one.name' => ["can't be blank"])
+    end
   end
 
   context do
-    subject(:instance) { Main.instantiate name: 'hello', unvalidated_one: { name: 'name' } }
+    subject(:instance) { Main.instantiate name: 'hello', unvalidated_one: {name: 'name'} }
     it { is_expected.to be_valid }
   end
 
   context do
-    subject(:instance) { Main.instantiate name: 'hello', unvalidated_one: { } }
+    subject(:instance) { Main.instantiate name: 'hello', unvalidated_one: {} }
     it { is_expected.to be_valid }
   end
 
   context do
-    subject(:instance) { Main.instantiate name: 'hello', validated_many: [{ name: 'name' }] }
+    subject(:instance) { Main.instantiate name: 'hello', validated_many: [{name: 'name'}] }
     it { is_expected.to be_valid }
   end
 
   context do
-    subject(:instance) { Main.instantiate name: 'hello', validated_many: [{ }] }
+    subject(:instance) { Main.instantiate name: 'hello', validated_many: [{}] }
     it { is_expected.not_to be_valid }
-    specify { expect { instance.validate }.to change { instance.errors.messages }
-      .to(:'validated_many.0.name' => ["can't be blank"]) }
+    specify do
+      expect { instance.validate }.to change { instance.errors.messages }
+        .to(:'validated_many.0.name' => ["can't be blank"])
+    end
   end
 
   context do
-    subject(:instance) { Main.instantiate name: 'hello', unvalidated_many: [{ name: 'name' }] }
+    subject(:instance) { Main.instantiate name: 'hello', unvalidated_many: [{name: 'name'}] }
     it { is_expected.to be_valid }
   end
 
   context do
-    subject(:instance) { Main.instantiate name: 'hello', unvalidated_many: [{ }] }
+    subject(:instance) { Main.instantiate name: 'hello', unvalidated_many: [{}] }
     it { is_expected.to be_valid }
   end
 
   context do
-    subject(:instance) { Main.instantiate name: 'hello', validated_many: [{ name: 'name' }], validated_one: { } }
+    subject(:instance) { Main.instantiate name: 'hello', validated_many: [{name: 'name'}], validated_one: {} }
     it { is_expected.not_to be_valid }
-    specify { expect { instance.validate }.to change { instance.errors.messages }
-      .to(:'validated_one.name' => ["can't be blank"]) }
+    specify do
+      expect { instance.validate }.to change { instance.errors.messages }
+        .to(:'validated_one.name' => ["can't be blank"])
+    end
+  end
+
+  context 'accepts nested attributes for one' do
+    before { Main.accepts_nested_attributes_for :validated_one, allow_destroy: true }
+    subject(:instance) { Main.instantiate name: 'hello', validated_one: {id: 1, name: 'name'} }
+
+    specify do
+      instance.validated_one_attributes = {id: 1, name: '', _destroy: true}
+      is_expected.to be_valid
+    end
+  end
+
+  context 'accepts nested attributes for many' do
+    before { Main.accepts_nested_attributes_for :validated_many, allow_destroy: true }
+    subject(:instance) { Main.instantiate name: 'hello', validated_many: [{id: 1, name: 'name'}] }
+
+    specify do
+      instance.validated_many_attributes = [{id: 1, name: '', _destroy: true}]
+      is_expected.to be_valid
+    end
+  end
+
+  context 'object field is invalid and referenced object does not include AutosaveAssociation' do
+    before do
+      stub_class(:validated_object) do
+        include ActiveData::Model::Validations
+        include ActiveData::Model::Attributes
+        include ActiveData::Model::Primary
+
+        primary :id
+        attribute :title, String
+        validates_presence_of :title
+      end
+
+      Main.class_eval do
+        include ActiveData::Model::Associations
+        attribute :object, Object
+        validates :object, nested: true
+      end
+    end
+
+    subject(:instance) { Main.instantiate name: 'hello', object: object, validated_one: {name: 'name'} }
+
+    context do
+      let(:object) { ValidatedObject.new(title: 'Mr.') }
+      it { is_expected.to be_valid }
+    end
+
+    context do
+      let(:object) { ValidatedObject.new }
+      it do
+        expect { subject.valid? }.not_to raise_error
+        expect(subject).not_to be_valid
+      end
+    end
   end
 
   context do
-    subject(:instance) { Main.instantiate name: 'hello', validated_many: [{ }], validated_one: { name: 'name' } }
+    subject(:instance) { Main.instantiate name: 'hello', validated_many: [{}], validated_one: {name: 'name'} }
     it { is_expected.not_to be_valid }
-    specify { expect { instance.validate }.to change { instance.errors.messages }
-      .to(:'validated_many.0.name' => ["can't be blank"]) }
+    specify do
+      expect { instance.validate }.to change { instance.errors.messages }
+        .to(:'validated_many.0.name' => ["can't be blank"])
+    end
+  end
+
+  describe '.validates_nested?' do
+    specify { expect(Main).to be_validates_nested(:validated_one) }
+    specify { expect(Main).to be_validates_nested(:unvalidated_one) }
+    specify { expect(Main).not_to be_validates_nested(:something_else) }
   end
 end

data/spec/lib/active_data/model_spec.rb

@@ -1,4 +1,3 @@
-# encoding: UTF-8
 require 'spec_helper'
 
 describe ActiveData::Model do
@@ -6,6 +5,6 @@ describe ActiveData::Model do
   specify { expect { model.blablabla }.to raise_error NoMethodError }
 
   context 'Fault tolerance' do
-    specify{ expect { model.new(foo: 'bar') }.not_to raise_error }
+    specify { expect { model.new(foo: 'bar') }.not_to raise_error }
   end
 end

data/spec/lib/active_data_spec.rb

@@ -1,4 +1,3 @@
-# encoding: UTF-8
 require 'spec_helper'
 
 describe ActiveData do