much-rails 0.1.3 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e37cec5104bf60569eb8a0310184ed80c9083fa3fa0f68fcd02d0ee1a25aee92
-  data.tar.gz: e2cffa2635a4fe025913d78ce78f81dcaba12b232129969ed0a3646a6d8c9928
+  metadata.gz: 612174b3a0ff8ace3d3f203a69a69586be9e2d2a7946ab20c8934e07209f8e95
+  data.tar.gz: d74beef0988406dc358b7bbccd6f5d23dc47e8f2997616b1323af8467c16dfff
 SHA512:
-  metadata.gz: cfd22f4cdd2dd60540e417606990bdcd13ac92cb1e83d6175462ac37aa066de6c478c0c06dcb27af6112ec35eb0fcd1c0828375cdbbc9e8e60e6f1d4a2249cce
-  data.tar.gz: e7c12b68abe00c404d4ab361ea1a5f49150a8877bf30619b7f01b478190cd14a027f3fec543c0d604339993a5803d9340251d53989d780d692015960e40cb075
+  metadata.gz: ffe4bf14bdafb94b01c7078b70d0f01eda42e45aedc5dcc935d616e2fc5149c7b1901577af8da172c2df457da8cbeed9dbd30327276dca94ce214f808fac51be
+  data.tar.gz: 77a0d880a84289e969c99644429458a991c125287205b086953f73c683e1b730842d727e42621561c1b9d7cfb122de2c7f025951b7e7cafc852f50efce3a345a

data/lib/much-rails.rb

@@ -46,6 +46,14 @@ module MuchRails
     add_instance_config :action, method_name: :action
     add_instance_config :layout, method_name: :layout
 
+    def add_save_service_validation_error(exception_class, &block)
+      MuchRails::SaveService::ValidationErrors.add(exception_class, &block)
+    end
+
+    def add_destroy_service_validation_error(exception_class, &block)
+      MuchRails::DestroyService::ValidationErrors.add(exception_class, &block)
+    end
+
     class ActionConfig
       attr_accessor :namespace
       attr_accessor :sanitized_exception_classes

data/lib/much-rails/destroy_service.rb

@@ -18,12 +18,49 @@ module MuchRails::DestroyService
 
     around_call do |receiver|
       receiver.call
-    rescue MuchRails::Records::ValidateDestroy::DestructionInvalid => ex
+    rescue *MuchRails::DestroyService::ValidationErrors.exception_classes => ex
       set_the_return_value_for_the_call_method(
-        MuchRails::Result.failure(
-          exception: ex,
-          validation_errors: ex&.destruction_errors.to_h,
-        ),
+        MuchRails::DestroyService::ValidationErrors.result_for(ex),
+      )
+    end
+  end
+
+  module ValidationErrors
+    def self.add(exception_class, &block)
+      service_validation_errors.add(exception_class, &block)
+    end
+
+    def self.exception_classes
+      service_validation_errors.exception_classes
+    end
+
+    def self.result_for(ex)
+      service_validation_errors.result_for(ex)
+    end
+
+    def self.service_validation_errors
+      @service_validation_errors ||=
+        MuchRails::ServiceValidationErrors
+          .new
+          .tap do |e|
+            e.add(MuchRails::Records::DestructionInvalid) do |ex|
+              MuchRails::DestroyService::FailureResult.new(
+                record: ex.record,
+                exception: ex,
+                validation_errors: ex.errors.to_h,
+                validation_error_messages: ex.error_full_messages.to_a,
+              )
+            end
+          end
+    end
+  end
+
+  module FailureResult
+    def self.new(exception:, validation_errors:, **kargs)
+      MuchResult.failure(
+        exception: exception,
+        validation_errors: validation_errors,
+        **kargs,
       )
     end
   end

data/lib/much-rails/railtie.rb

@@ -27,6 +27,13 @@ class MuchRails::Railtie < Rails::Railtie
       # This should be `false` in all other envs so proper HTTP response
       # statuses are returned.
       config.action.raise_response_exceptions = Rails.env.development?
+
+      config.save_service_validation_error_exception_classes = [
+        ActiveRecord::RecordInvalid,
+      ]
+      config.destroy_service_validation_error_exception_classes = [
+        MuchRails::Records::DestructionInvalid,
+      ]
     end
   end
 end

data/lib/much-rails/records/validate_destroy.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "active_model/error"
 require "much-rails/mixin"
 
 module MuchRails; end
@@ -33,7 +34,7 @@ module MuchRails::Records::ValidateDestroy
 
     def destroy!(as: :base, validate: true)
       if validate && !destroyable?
-        raise DestructionInvalid.new(self, field_name: as)
+        raise MuchRails::Records::DestructionInvalid.new(self, field_name: as)
       end
 
       # `_raise_record_not_destroyed` is from ActiveRecord. This logic was
@@ -61,22 +62,31 @@ module MuchRails::Records::ValidateDestroy
       raise NotImplementedError
     end
   end
+end
+
+class MuchRails::Records::DestructionInvalid < StandardError
+  attr_reader :record, :errors, :error_full_messages
 
-  class DestructionInvalid < StandardError
-    attr_reader :record, :destruction_errors
+  def initialize(record = nil, field_name: :base)
+    super(record&.destruction_error_messages.to_a.join("\n"))
 
-    def initialize(record = nil, field_name: :base)
-      super(record&.destruction_error_messages.to_a.join("\n"))
+    @record = record
 
-      @record = record
+    messages = record&.destruction_error_messages.to_a
+    @errors =
+      if messages.any?
+        { field_name.to_sym => messages }
+      else
+        {}
+      end
 
-      messages = record&.destruction_error_messages.to_a
-      @destruction_errors =
-        if messages.any?
-          { field_name.to_sym => messages }
-        else
-          {}
+    @error_full_messages =
+      if field_name == :base
+        messages
+      else
+        messages.map do |m|
+          ActiveModel::Error.new(@record, field_name, m).full_message
         end
-    end
+      end
   end
 end

data/lib/much-rails/save_service.rb

@@ -4,6 +4,7 @@ require "active_record"
 require "much-rails/mixin"
 require "much-rails/result"
 require "much-rails/service"
+require "much-rails/service_validation_errors"
 
 module MuchRails; end
 
@@ -17,14 +18,50 @@ module MuchRails::SaveService
 
     around_call do |receiver|
       receiver.call
-    rescue ActiveRecord::RecordInvalid => ex
+    rescue *MuchRails::SaveService::ValidationErrors.exception_classes => ex
       set_the_return_value_for_the_call_method(
-        MuchRails::Result.failure(
-          record: ex.record,
-          exception: ex,
-          validation_errors: ex.record&.errors.to_h,
-          validation_error_messages: ex.record&.errors&.full_messages.to_a,
-        ),
+        MuchRails::SaveService::ValidationErrors.result_for(ex),
+      )
+    end
+  end
+
+  module ValidationErrors
+    def self.add(exception_class, &block)
+      service_validation_errors.add(exception_class, &block)
+    end
+
+    def self.exception_classes
+      service_validation_errors.exception_classes
+    end
+
+    def self.result_for(ex)
+      service_validation_errors.result_for(ex)
+    end
+
+    def self.service_validation_errors
+      @service_validation_errors ||=
+        MuchRails::ServiceValidationErrors
+          .new
+          .tap do |e|
+            e.add(ActiveRecord::RecordInvalid) do |ex|
+              MuchRails::SaveService::FailureResult.new(
+                record: ex.record,
+                exception: ex,
+                validation_errors: ex.record&.errors.to_h,
+                validation_error_messages:
+                  ex.record&.errors&.full_messages.to_a,
+              )
+            end
+          end
+    end
+  end
+
+  module FailureResult
+    def self.new(exception:, validation_errors:, **kargs)
+      MuchResult.failure(
+        exception: exception,
+        validation_errors: validation_errors,
+        **kargs,
       )
     end
   end

data/lib/much-rails/service_validation_errors.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module MuchRails; end
+
+class MuchRails::ServiceValidationErrors
+  attr_reader :hash
+
+  def initialize
+    @hash = {}
+  end
+
+  def add(exception_class, &block)
+    unless exception_class < Exception
+      raise(ArgumentError, "#{exception_class} is not an Exception")
+    end
+
+    @hash[exception_class] = block
+  end
+
+  def exception_classes
+    @hash.keys
+  end
+
+  def result_for(ex)
+    result_proc = nil
+    exception_class = ex.class
+    loop do
+      result_proc = @hash[exception_class]
+      break unless result_proc.nil?
+
+      exception_class =
+        if exception_class.superclass.nil?
+          raise ArgumentError, "#{ex.class} hasn't been configured"
+        else
+          exception_class.superclass
+        end
+    end
+
+    result_proc.call(ex)
+  end
+end

data/lib/much-rails/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module MuchRails
-  VERSION = "0.1.3"
+  VERSION = "0.2.0"
 end

data/test/unit/destroy_service_tests.rb

@@ -44,45 +44,189 @@ module MuchRails::DestroyService
     end
   end
 
-  class DestructionInvalidErrorSetupTests < ReceiverTests
-    desc "with a MuchRails::Records::ValidateDestroy::DestructionInvalid error"
+  class ReceiverInitTests < ReceiverTests
+    desc "when init"
+    subject{ receiver_class.new(exception: exception) }
+
+    let(:exception){ nil }
+  end
+
+  class ReceiverInitAroundCallCallbackTests < ReceiverInitTests
+    desc "around_call callback"
+    setup do
+      Assert.stub(
+        MuchRails::DestroyService::ValidationErrors,
+        :exception_classes,
+      ){ exception_classes }
+      Assert.stub_on_call(
+        MuchRails::DestroyService::ValidationErrors,
+        :result_for,
+      ) do |call|
+        @result_for_call = call
+        validation_error_result
+      end
+    end
+
+    let(:exception){ exceptions.sample }
+    let(:exceptions) do
+      [
+        RuntimeError.new(Factory.string),
+        ArgumentError.new(Factory.string),
+        MuchRails::Records::DestructionInvalid.new(FakeRecord.new),
+      ]
+    end
+    let(:exception_classes){ exceptions.map(&:class) }
+    let(:validation_error_result) do
+      MuchResult.failure(error: result_error_message)
+    end
+    let(:result_error_message){ Factory.string }
+
+    should "rescue raised exceptions and "\
+           "use the ValidationErrors to build a result" do
+      result = subject.call
+
+      assert_that(result.failure?).is_true
+      assert_that(result.error).equals(result_error_message)
+    end
+  end
+
+  class ValidationErrorsTests < UnitTests
+    desc "ValidationErrors"
+    subject{ unit_class::ValidationErrors }
+
+    should have_imeths :add, :exception_classes, :result_for
+    should have_imeths :service_validation_errors
+
+    should "know its ServiceValidationErrors" do
+      assert_that(subject.service_validation_errors)
+        .is_an_instance_of(MuchRails::ServiceValidationErrors)
+      assert_that(subject.service_validation_errors.exception_classes)
+        .includes(MuchRails::Records::DestructionInvalid)
+    end
+  end
+
+  class ValidationErrorsAddTests < ValidationErrorsTests
+    desc ".add"
+
+    setup do
+      Assert.stub_on_call(subject.service_validation_errors, :add) do |call|
+        @add_call = call
+      end
+    end
+
+    let(:exception_class){ StandardError }
+    let(:block){ proc{ MuchResult.failure } }
+
+    should "call #add on its ServiceValidationErrors" do
+      subject.add(exception_class, &block)
+      assert_that(@add_call.args).equals([exception_class])
+      assert_that(@add_call.block).is(block)
+    end
+  end
+
+  class ValidationErrorsExceptionClassesTests < ValidationErrorsTests
+    desc ".exception_classes"
+
     setup do
-      Assert.stub(exception, :record){ record }
+      Assert.stub(
+        subject.service_validation_errors,
+        :exception_classes,
+      ){ exception_classes }
+    end
+
+    let(:exception_classes) do
+      [
+        StandardError,
+        ArgumentError,
+      ]
     end
 
-    let(:exception) do
-      MuchRails::Records::ValidateDestroy::DestructionInvalid.new
+    should "call #exception_classes on its ServiceValidationErrors" do
+      assert_that(subject.exception_classes).is(exception_classes)
     end
   end
 
-  class ExceptionWithDestructionErrorMessagesTests <
-          DestructionInvalidErrorSetupTests
-    desc "with an exception record that has destruction_error_messages"
+  class ValidationErrorsResultForTests < ValidationErrorsTests
+    desc ".result_for"
 
-    let(:record){ @fake_record ||= FakeRecord.new }
+    setup do
+      Assert.stub_on_call(
+        subject.service_validation_errors,
+        :result_for,
+      ) do |call|
+        @result_for_call = call
+        result_for_result
+      end
+    end
 
-    should "return a failure result with the exception and validation_errors" do
-      result = subject.call(exception: exception)
+    let(:exception){ StandardError.new(Factory.string) }
+    let(:result_for_result){ MuchResult.failure }
+
+    should "call #result_for on its ServiceValidationErrors" do
+      assert_that(subject.result_for(exception)).is(result_for_result)
+      assert_that(@result_for_call.args).equals([exception])
+    end
+  end
+
+  class ValidationErrorsResultForDestructionInvalidTests < ValidationErrorsTests
+    desc "when .result_for is passed an MuchRails::Records::DestructionInvalid"
+
+    let(:exception){ MuchRails::Records::DestructionInvalid.new(record) }
+    let(:record){ FakeRecord.new }
+
+    should "return a failure result with the record and validation errors" do
+      result = subject.result_for(exception)
 
       assert_that(result.failure?).is_true
       assert_that(result.exception).equals(exception)
-      assert_that(result.validation_errors).equals(exception.destruction_errors)
+      assert_that(result.validation_errors).equals(exception.errors.to_h)
+      assert_that(result.validation_error_messages)
+        .equals(exception.error_full_messages.to_a)
     end
   end
 
-  class ExceptionWithoutDestructionErrorMessagesTests <
-          DestructionInvalidErrorSetupTests
-    desc "with an exception record that has no destruction_error_messages"
+  class FailureResultTests < UnitTests
+    desc "FailureResult"
+    subject{ unit_class::FailureResult }
+
+    setup do
+      Assert.stub_tap_on_call(MuchResult, :failure) do |_, call|
+        @much_result_failure_call = call
+      end
+    end
 
-    let(:record){ nil }
+    let(:exception){ StandardError.new(Factory.string) }
+    let(:validation_errors){ { Factory.symbol => Factory.string } }
+    let(:custom_value){ Factory.string }
 
-    should "return a failure result with the exception and empty "\
-           "validation_errors" do
-      result = subject.call(exception: exception)
+    should have_imeths :new
 
+    should "use MuchResult.failure to build a result" do
+      result =
+        subject.new(
+          exception: exception,
+          validation_errors: validation_errors,
+          custom: custom_value,
+        )
       assert_that(result.failure?).is_true
-      assert_that(result.exception).equals(exception)
-      assert_that(result.validation_errors).equals({})
+      assert_that(@much_result_failure_call.kargs)
+        .equals(
+          exception: exception,
+          validation_errors: validation_errors,
+          custom: custom_value,
+        )
+    end
+
+    should "raise an error without an exception or validation errors" do
+      assert_that{
+        subject.new(validation_errors: validation_errors)
+      }.raises(ArgumentError)
+    end
+
+    should "raise an error without an exception or validation errors" do
+      assert_that{
+        subject.new(exception: exception)
+      }.raises(ArgumentError)
     end
   end
 

data/test/unit/much-rails_tests.rb

@@ -23,10 +23,51 @@ module MuchRails
     desc ".config"
     subject{ unit_class.config }
 
-    should have_imeths :action
+    should have_imeths :action, :layout
+    should have_imeths :add_save_service_validation_error
+    should have_imeths :add_destroy_service_validation_error
 
     should "be configured as expected" do
       assert_that(subject.action).is_not_nil
+      assert_that(subject.layout).is_not_nil
+    end
+  end
+
+  class ConfigServiceValidationErrorTests < ConfigTests
+    setup do
+      Assert.stub_on_call(
+        MuchRails::SaveService::ValidationErrors,
+        :add,
+      ) do |call|
+        @save_service_validation_errors_add_call = call
+      end
+      Assert.stub_on_call(
+        MuchRails::DestroyService::ValidationErrors,
+        :add,
+      ) do |call|
+        @destroy_service_validation_errors_add_call = call
+      end
+    end
+
+    let(:exception_class){ StandardError }
+    let(:block){ proc{ MuchResult.failure } }
+
+    should "know how to add an exception class "\
+           "to the save service validation errors" do
+      subject.add_save_service_validation_error(exception_class, &block)
+      assert_that(@save_service_validation_errors_add_call.args)
+        .equals([exception_class])
+      assert_that(@save_service_validation_errors_add_call.block)
+        .is(block)
+    end
+
+    should "know how to add an exception class "\
+           "to the destroy service validation errors" do
+      subject.add_destroy_service_validation_error(exception_class, &block)
+      assert_that(@destroy_service_validation_errors_add_call.args)
+        .equals([exception_class])
+      assert_that(@destroy_service_validation_errors_add_call.block)
+        .is(block)
     end
   end
 

data/test/unit/records/always_destroyable_tests.rb

@@ -34,7 +34,7 @@ module MuchRails::Records::AlwaysDestroyable
 
       assert_that(subject.destroy).is_true
 
-      # won't raise MuchRails::Records::ValidateDestroy::DestructionInvalid
+      # won't raise MuchRails::Records::DestructionInvalid
       subject.destroy!
 
       assert_that(subject.destroyable?).is_true

data/test/unit/records/not_destroyable_tests.rb

@@ -32,7 +32,7 @@ module MuchRails::Records::NotDestroyable
       assert_that(subject.destroy).is_false
 
       assert_that(->{ subject.destroy! })
-        .raises(MuchRails::Records::ValidateDestroy::DestructionInvalid)
+        .raises(MuchRails::Records::DestructionInvalid)
 
       assert_that(subject.destroyable?).is_false
     end

data/test/unit/records/validate_destroy_tests.rb

@@ -62,17 +62,17 @@ module MuchRails::Records::ValidateDestroy
 
       exception =
         assert_that(->{ subject.destroy! })
-          .raises(MuchRails::Records::ValidateDestroy::DestructionInvalid)
+          .raises(MuchRails::Records::DestructionInvalid)
       assert_that(exception.message)
         .equals("TEST DESTRUCTION ERROR1\nTEST DESTRUCTION ERROR2")
-      assert_that(exception.destruction_errors)
+      assert_that(exception.errors)
         .equals(base: subject.destruction_error_messages.to_a)
       assert_that(subject.super_destroy_called).is_true
 
       exception =
         assert_that(->{ subject.destroy!(as: :thing) })
-          .raises(MuchRails::Records::ValidateDestroy::DestructionInvalid)
-      assert_that(exception.destruction_errors)
+          .raises(MuchRails::Records::DestructionInvalid)
+      assert_that(exception.errors)
         .equals(thing: subject.destruction_error_messages.to_a)
 
       subject.super_destroy_called = nil
@@ -138,9 +138,85 @@ module MuchRails::Records::ValidateDestroy
     end
   end
 
+  class DestructionInvalidTests < UnitTests
+    desc "MuchRails::Records::DestructionInvalid"
+    subject{ exception_class }
+
+    let(:exception_class){ MuchRails::Records::DestructionInvalid }
+
+    let(:record){ FakeRecordClass.new }
+
+    should "be configured as expected" do
+      assert_that(subject < StandardError).is_true
+    end
+  end
+
+  class DestructionInvalidInitTests < DestructionInvalidTests
+    desc "when init"
+    subject{ exception_class.new(record) }
+
+    should have_readers :record, :errors, :error_full_messages
+
+    should "know its attributes when destruction errors exist" do
+      record.destruction_errors_exist = true
+      record.validate_destroy
+
+      assert_that(subject.message)
+        .equals(record.destruction_error_messages.to_a.join("\n"))
+      assert_that(subject.record).is(record)
+      assert_that(subject.errors).equals(
+        base: record.destruction_error_messages.to_a,
+      )
+      assert_that(subject.error_full_messages)
+        .equals(record.destruction_error_messages.to_a)
+    end
+
+    should "know its attributes when destruction errors don't exist" do
+      assert_that(subject.message).equals("")
+      assert_that(subject.record).is(record)
+      assert_that(subject.errors).equals({})
+      assert_that(subject.error_full_messages).equals([])
+    end
+  end
+
+  class DestructionInvalidInitWithFieldNameTests < DestructionInvalidTests
+    desc "when init with a field name"
+    subject{ exception_class.new(record, field_name: field_name) }
+
+    let(:field_name){ Factory.string }
+
+    should "know its attributes when destruction errors exist" do
+      record.destruction_errors_exist = true
+      record.validate_destroy
+
+      assert_that(subject.message)
+        .equals(record.destruction_error_messages.to_a.join("\n"))
+      assert_that(subject.record).is(record)
+      assert_that(subject.errors).equals(
+        field_name.to_sym => record.destruction_error_messages.to_a,
+      )
+      assert_that(subject.error_full_messages)
+        .equals(
+          record
+            .destruction_error_messages
+            .map do |m|
+              ActiveModel::Error.new(record, field_name, m).full_message
+            end,
+        )
+    end
+
+    should "know its attributes when destruction errors don't exist" do
+      assert_that(subject.message).equals("")
+      assert_that(subject.record).is(record)
+      assert_that(subject.errors).equals({})
+      assert_that(subject.error_full_messages).equals([])
+    end
+  end
+
   require "active_record"
 
   class FakeRecordBaseClass
+    extend ActiveRecord::Translation
     # Include ActiveRecord::Persistence to test the `destroy!` logic
     # (the `_raise_record_not_destroyed` method) that we had to re-implement in
     # the MuchRails::Records::ValidateDestroy.
@@ -150,6 +226,10 @@ module MuchRails::Records::ValidateDestroy
 
     attr_accessor :destruction_errors_exist
 
+    def self.base_class?
+      true
+    end
+
     def destroy
       @super_destroy_called = true
     end

data/test/unit/save_service_tests.rb

@@ -44,49 +44,209 @@ module MuchRails::SaveService
     end
   end
 
-  class RecordInvalidErrorSetupTests < ReceiverTests
-    desc "with an ActiveRecord::RecordInvalid error"
+  class ReceiverInitTests < ReceiverTests
+    desc "when init"
+    subject{ receiver_class.new(exception: exception) }
+
+    let(:exception){ nil }
+  end
+
+  class ReceiverInitAroundCallCallbackTests < ReceiverInitTests
+    desc "around_call callback"
     setup do
-      Assert.stub(exception, :record){ record }
+      Assert.stub(
+        MuchRails::SaveService::ValidationErrors,
+        :exception_classes,
+      ){ exception_classes }
+      Assert.stub_on_call(
+        MuchRails::SaveService::ValidationErrors,
+        :result_for,
+      ) do |call|
+        @result_for_call = call
+        validation_error_result
+      end
     end
 
-    let(:exception){ ActiveRecord::RecordInvalid.new }
+    let(:exception){ exceptions.sample }
+    let(:exceptions) do
+      [
+        RuntimeError.new(Factory.string),
+        ArgumentError.new(Factory.string),
+        ActiveRecord::RecordInvalid.new(FakeRecord.new),
+      ]
+    end
+    let(:exception_classes){ exceptions.map(&:class) }
+    let(:validation_error_result) do
+      MuchResult.failure(error: result_error_message)
+    end
+    let(:result_error_message){ Factory.string }
+
+    should "rescue raised exceptions and "\
+           "use the ValidationErrors to build a result" do
+      result = subject.call
+
+      assert_that(result.failure?).is_true
+      assert_that(result.error).equals(result_error_message)
+    end
   end
 
-  class ExceptionWithRecordErrorsTests < RecordInvalidErrorSetupTests
-    desc "with an exception that has record errors"
+  class ValidationErrorsTests < UnitTests
+    desc "ValidationErrors"
+    subject{ unit_class::ValidationErrors }
 
-    let(:record){ @fake_record ||= FakeRecord.new }
+    should have_imeths :add, :exception_classes, :result_for
+    should have_imeths :service_validation_errors
+
+    should "know its ServiceValidationErrors" do
+      assert_that(subject.service_validation_errors)
+        .is_an_instance_of(MuchRails::ServiceValidationErrors)
+      assert_that(subject.service_validation_errors.exception_classes)
+        .includes(ActiveRecord::RecordInvalid)
+    end
+  end
 
-    should "return a failure result with the exception and record errors" do
-      result = subject.call(exception: exception)
+  class ValidationErrorsAddTests < ValidationErrorsTests
+    desc ".add"
 
-      assert_that(result.failure?).is_true
-      assert_that(result.exception).equals(exception)
-      assert_that(result.validation_errors)
-        .equals(some_field: %w[ERROR1 ERROR2])
-      assert_that(result.validation_error_messages)
-        .equals(["some_field ERROR1", "some_field ERROR2"])
+    setup do
+      Assert.stub_on_call(subject.service_validation_errors, :add) do |call|
+        @add_call = call
+      end
+    end
+
+    let(:exception_class){ StandardError }
+    let(:block){ proc{ MuchResult.failure } }
+
+    should "call #add on its ServiceValidationErrors" do
+      subject.add(exception_class, &block)
+      assert_that(@add_call.args).equals([exception_class])
+      assert_that(@add_call.block).is(block)
+    end
+  end
+
+  class ValidationErrorsExceptionClassesTests < ValidationErrorsTests
+    desc ".exception_classes"
+
+    setup do
+      Assert.stub(
+        subject.service_validation_errors,
+        :exception_classes,
+      ){ exception_classes }
+    end
+
+    let(:exception_classes) do
+      [
+        StandardError,
+        ArgumentError,
+      ]
+    end
+
+    should "call #exception_classes on its ServiceValidationErrors" do
+      assert_that(subject.exception_classes).is(exception_classes)
+    end
+  end
+
+  class ValidationErrorsResultForTests < ValidationErrorsTests
+    desc ".result_for"
+
+    setup do
+      Assert.stub_on_call(
+        subject.service_validation_errors,
+        :result_for,
+      ) do |call|
+        @result_for_call = call
+        result_for_result
+      end
+    end
+
+    let(:exception){ StandardError.new(Factory.string) }
+    let(:result_for_result){ MuchResult.failure }
+
+    should "call #result_for on its ServiceValidationErrors" do
+      assert_that(subject.result_for(exception)).is(result_for_result)
+      assert_that(@result_for_call.args).equals([exception])
     end
   end
 
-  class ExceptionWithoutRecordErrorsTests < RecordInvalidErrorSetupTests
-    desc "with an exception that has no record errors"
+  class ValidationErrorsResultForRecordInvalidTests < ValidationErrorsTests
+    desc "when .result_for is passed an ActiveRecord::RecordInvalid"
+
+    let(:exception){ ActiveRecord::RecordInvalid.new(record) }
+    let(:record){ FakeRecord.new }
 
-    let(:record){ nil }
+    let(:no_record_exception){ ActiveRecord::RecordInvalid.new }
+
+    should "return a failure result with the record and validation errors" do
+      result = subject.result_for(exception)
+
+      assert_that(result.failure?).is_true
+      assert_that(result.exception).equals(exception)
+      assert_that(result.validation_errors).equals(record.errors.to_h)
+      assert_that(result.validation_error_messages)
+        .equals(record.errors.full_messages.to_a)
+    end
 
     should "return a failure result with the exception and empty "\
            "record errors" do
-      result = subject.call(exception: exception)
+      result = subject.result_for(no_record_exception)
 
       assert_that(result.failure?).is_true
-      assert_that(result.exception).equals(exception)
+      assert_that(result.exception).equals(no_record_exception)
       assert_that(result.validation_errors).equals({})
       assert_that(result.validation_error_messages).equals([])
     end
   end
 
+  class FailureResultTests < UnitTests
+    desc "FailureResult"
+    subject{ unit_class::FailureResult }
+
+    setup do
+      Assert.stub_tap_on_call(MuchResult, :failure) do |_, call|
+        @much_result_failure_call = call
+      end
+    end
+
+    let(:exception){ StandardError.new(Factory.string) }
+    let(:validation_errors){ { Factory.symbol => Factory.string } }
+    let(:custom_value){ Factory.string }
+
+    should have_imeths :new
+
+    should "use MuchResult.failure to build a result" do
+      result =
+        subject.new(
+          exception: exception,
+          validation_errors: validation_errors,
+          custom: custom_value,
+        )
+      assert_that(result.failure?).is_true
+      assert_that(@much_result_failure_call.kargs)
+        .equals(
+          exception: exception,
+          validation_errors: validation_errors,
+          custom: custom_value,
+        )
+    end
+
+    should "raise an error without an exception or validation errors" do
+      assert_that{
+        subject.new(validation_errors: validation_errors)
+      }.raises(ArgumentError)
+    end
+
+    should "raise an error without an exception or validation errors" do
+      assert_that{
+        subject.new(exception: exception)
+      }.raises(ArgumentError)
+    end
+  end
+
   class FakeRecord
+    def self.i18n_scope
+      "fake_record"
+    end
+
     def errors
       Errors.new
     end

data/test/unit/service_validation_errors_tests.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+class MuchRails::ServiceValidationErrors
+  class UnitTests < Assert::Context
+    desc "MuchRails::ServiceValidationErrors"
+    subject{ unit_class }
+
+    let(:unit_class){ MuchRails::ServiceValidationErrors }
+  end
+
+  class InitTests < UnitTests
+    desc "when init"
+    subject{ unit_class.new }
+
+    should have_readers :hash
+    should have_imeths :add, :exception_classes, :result_for
+  end
+
+  class InitAddTests < InitTests
+    desc "#add"
+
+    let(:exception_class){ StandardError }
+    let(:block){ proc{ MuchResult.failure } }
+
+    let(:invalid_exception_class) do
+      [
+        Class.new,
+        Factory.string,
+        nil,
+      ].sample
+    end
+
+    should "add an exception class and block" do
+      subject.add(exception_class, &block)
+      assert_that(subject.hash[exception_class]).is(block)
+    end
+
+    should "raise an error when it's not passed an Exception" do
+      assert_that{
+        subject.add(invalid_exception_class, &block)
+      }.raises(ArgumentError)
+    end
+  end
+
+  class InitExceptionClassesTests < InitTests
+    desc "#exception_classes"
+
+    setup do
+      exception_classes.each do |exception_class|
+        subject.add(exception_class, &block)
+      end
+    end
+
+    let(:exception_classes) do
+      [
+        StandardError,
+        ArgumentError,
+        RuntimeError,
+      ]
+    end
+    let(:block){ proc{ MuchResult.failure } }
+
+    should "return all the added exception classes" do
+      assert_that(subject.exception_classes).equals(exception_classes)
+    end
+  end
+
+  class InitResultForTests < InitTests
+    desc "#result_for"
+
+    setup do
+      subject.add(exception_class, &block)
+    end
+
+    let(:exception){ exception_class.new(Factory.string) }
+    let(:exception_class){ StandardError }
+    let(:block) do
+      proc{ MuchResult.failure(error_message: failure_result_error_message) }
+    end
+    let(:failure_result_error_message){ Factory.string }
+
+    let(:inherited_exception){ RuntimeError.new(Factory.string) }
+
+    let(:invalid_exception){ Exception.new(Factory.string) }
+
+    should "return the result of calling the added block "\
+           "for the exception class" do
+      result = subject.result_for(exception)
+      assert_that(result.failure?).is_true
+      assert_that(result.error_message).equals(failure_result_error_message)
+    end
+
+    should "return the result of calling the added block "\
+           "for an exception class ancestor" do
+      result = subject.result_for(exception)
+      assert_that(result.failure?).is_true
+      assert_that(result.error_message).equals(failure_result_error_message)
+    end
+
+    should "raise an error if a block hasn't been added "\
+           "for the exception class" do
+      assert_that{
+        subject.result_for(invalid_exception)
+      }.raises(ArgumentError)
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: much-rails
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 0.2.0
 platform: ruby
 authors:
 - Kelly Redding
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-01-15 00:00:00.000000000 Z
+date: 2021-01-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: much-style-guide
@@ -291,6 +291,7 @@ files:
 - lib/much-rails/save_action.rb
 - lib/much-rails/save_service.rb
 - lib/much-rails/service.rb
+- lib/much-rails/service_validation_errors.rb
 - lib/much-rails/time.rb
 - lib/much-rails/version.rb
 - lib/much-rails/view_models.rb
@@ -343,6 +344,7 @@ files:
 - test/unit/save_action_tests.rb
 - test/unit/save_service_tests.rb
 - test/unit/service_tests.rb
+- test/unit/service_validation_errors_tests.rb
 - test/unit/time_tests.rb
 - test/unit/view_models/breadcrumb_tests.rb
 - test/unit/wrap_and_call_method_tests.rb
@@ -367,7 +369,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.4
+rubyforge_project: 
+rubygems_version: 2.7.6.2
 signing_key: 
 specification_version: 4
 summary: Rails utilities.
@@ -416,6 +419,7 @@ test_files:
 - test/unit/save_action_tests.rb
 - test/unit/save_service_tests.rb
 - test/unit/service_tests.rb
+- test/unit/service_validation_errors_tests.rb
 - test/unit/time_tests.rb
 - test/unit/view_models/breadcrumb_tests.rb
 - test/unit/wrap_and_call_method_tests.rb