Initial implementation of ValueObjects::ValidValidator to be used for validating ActiveModel attributes containing a value object or value object collection.

Author: tbsmatt

lib/value_objects.rb

@@ -2,3 +2,4 @@
 require 'active_record'
 require 'value_objects/version'
 require 'value_objects/value'
+require 'value_objects/valid_validator'

lib/value_objects/valid_validator.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+module ValueObjects
+
+  class ValidValidator < ActiveModel::EachValidator
+
+    def validate_each(record, attribute, value)
+      record.errors.add(attribute, :invalid) unless value && (value.is_a?(Array) ? value.count(&:invalid?) == 0 : value.valid?)
+    end
+
+  end
+
+end

spec/value_objects/valid_validator_spec.rb

@@ -0,0 +1,169 @@
+RSpec.describe ValueObjects::ValidValidator do
+
+  class NilAllowedRecord
+
+    include ActiveModel::Model
+    include ActiveModel::Validations
+
+    attr_accessor :foo
+
+    validates :foo, 'value_objects/valid': true, allow_nil: true
+
+  end
+
+  class NilForbiddenRecord
+
+    include ActiveModel::Model
+    include ActiveModel::Validations
+
+    attr_accessor :foo
+
+    validates :foo, 'value_objects/valid': true
+
+  end
+
+  context 'with allow_nil' do
+
+    let(:record) { NilAllowedRecord.new(foo: value) }
+
+    context 'and nil value' do
+
+      let(:value) { nil }
+
+      it 'passes validation' do
+        aggregate_failures do
+          expect(record.valid?).to eq(true)
+          expect(record.errors).not_to include(:foo)
+        end
+      end
+
+    end
+
+    context 'and invalid value' do
+
+      let(:value) { instance_double('InvalidValue', valid?: false) }
+
+      it 'fails validation' do
+        aggregate_failures do
+          expect(record.valid?).to eq(false)
+          expect(record.errors).to include(:foo)
+        end
+      end
+
+    end
+
+    context 'and valid value' do
+
+      let(:value) { instance_double('ValidValue', valid?: true) }
+
+      it 'passes validation' do
+        aggregate_failures do
+          expect(record.valid?).to eq(true)
+          expect(record.errors).to be_empty
+        end
+      end
+
+    end
+
+  end
+
+  context 'without allow_nil' do
+
+    let(:validation_options) { { valid: true } }
+    let(:record) { NilForbiddenRecord.new(foo: value) }
+
+    context 'and nil value' do
+
+      let(:value) { nil }
+
+      it 'fails validation' do
+        aggregate_failures do
+          expect(record.valid?).to eq(false)
+          expect(record.errors).to include(:foo)
+        end
+      end
+
+    end
+
+    context 'and invalid value' do
+
+      let(:value) { instance_double('InvalidValue', valid?: false) }
+
+      it 'fails validation' do
+        aggregate_failures do
+          expect(record.valid?).to eq(false)
+          expect(record.errors).to include(:foo)
+        end
+      end
+
+    end
+
+    context 'and valid value' do
+
+      let(:value) { instance_double('ValidValue', valid?: true) }
+
+      it 'passes validation' do
+        aggregate_failures do
+          expect(record.valid?).to eq(true)
+          expect(record.errors).to be_empty
+        end
+      end
+
+    end
+
+  end
+
+  context 'with collection' do
+
+    let(:record) { NilForbiddenRecord.new(foo: values) }
+
+    context 'and no values' do
+
+      let(:values) { [] }
+
+      it 'passes validation' do
+        aggregate_failures do
+          expect(record.valid?).to eq(true)
+          expect(record.errors).to be_empty
+        end
+      end
+
+    end
+
+    context 'and no invalid values' do
+
+      let(:values) { [value1, value2] }
+      let(:value1) { instance_double('ValidValue') }
+      let(:value2) { instance_double('ValidValue') }
+
+      it 'passes validation' do
+        expect(value1).to receive(:invalid?).and_return(false).once
+        expect(value2).to receive(:invalid?).and_return(false).once
+        aggregate_failures do
+          expect(record.valid?).to eq(true)
+          expect(record.errors).to be_empty
+        end
+      end
+
+    end
+
+    context 'and some invalid values' do
+
+      let(:values) { [value1, value2] }
+      let(:value1) { instance_double('ValidValue') }
+      let(:value2) { instance_double('InvalidValue') }
+
+      it 'fails validation' do
+        expect(value1).to receive(:invalid?).and_return(false).once
+        expect(value2).to receive(:invalid?).and_return(true).once
+        aggregate_failures do
+          expect(record.valid?).to eq(false)
+          expect(record.errors).to include(:foo)
+        end
+      end
+
+    end
+
+  end
+
+end