much-rails 0.1.0 → 0.2.1

data/test/unit/layout_tests.rb

@@ -6,9 +6,9 @@ require "much-rails/layout"
 module MuchRails::Layout
   class UnitTests < Assert::Context
     desc "MuchRails::Layout"
-    subject{ unit_class }
+    subject{ unit_module }
 
-    let(:unit_class){ MuchRails::Layout }
+    let(:unit_module){ MuchRails::Layout }
 
     should "include MuchRails::Mixin" do
       assert_that(subject).includes(MuchRails::Mixin)
@@ -30,15 +30,16 @@ module MuchRails::Layout
     end
 
     should have_imeths :page_title, :page_titles, :application_page_title
-    should have_imeths :breadcrumb, :breadcrumbs, :stylesheet, :stylesheets
-    should have_imeths :javascript, :javascripts, :layout, :layouts
+    should have_imeths :breadcrumb, :breadcrumbs
+    should have_imeths :stylesheet, :stylesheets, :javascript, :javascripts
+    should have_imeths :head_link, :head_links, :layout, :layouts
   end
 
   class InitTests < ReceiverTests
     desc "when init"
     subject{ receiver_class.new }
 
-    should "know its #page_title" do
+    should "know its page title" do
       assert_that(subject.page_title).is_nil
 
       receiver_class.page_title{ "Some Portal" }
@@ -47,7 +48,7 @@ module MuchRails::Layout
       assert_that(subject.page_title).equals("Some Resource attribute1")
     end
 
-    should "know its #application_page_title" do
+    should "know its application page title" do
       assert_that(subject.application_page_title).is_nil
 
       receiver_class.application_page_title{ "Some App" }
@@ -56,12 +57,12 @@ module MuchRails::Layout
       assert_that(subject.application_page_title).equals("Some App attribute1")
     end
 
-    should "know its #full_page_title "\
+    should "know its full page title "\
            "given no application page title or page title segments" do
       assert_that(subject.full_page_title).is_nil
     end
 
-    should "know its #full_page_title "\
+    should "know its full page title "\
            "given an application page title but no page title segments" do
       receiver_class.application_page_title{ "Some App" }
 
@@ -69,7 +70,7 @@ module MuchRails::Layout
         .equals(subject.application_page_title)
     end
 
-    should "know its #full_page_title "\
+    should "know its full page title "\
            "given no application page title but page title segments" do
       receiver_class.page_title{ "Some Portal" }
       receiver_class.page_title{ "Some Resource #{attribute1}" }
@@ -78,7 +79,7 @@ module MuchRails::Layout
         .equals("Some Resource attribute1 - Some Portal")
     end
 
-    should "know its #full_page_title "\
+    should "know its full page title "\
            "given both an application page title and page title segments" do
       receiver_class.application_page_title{ "Some App" }
       receiver_class.page_title{ "Some Portal" }
@@ -88,13 +89,14 @@ module MuchRails::Layout
         .equals("Some Resource attribute1 - Some Portal | Some App")
     end
 
-    should "know its #breadcrumbs" do
+    should "know its breadcrumbs" do
       receiver = receiver_class.new
+      assert_that(receiver.any_breadcrumbs?).is_false
       assert_that(receiver.breadcrumbs).is_empty
 
       receiver_class.breadcrumb{ ["Item1", "item1-url"] }
       receiver_class.breadcrumb{ "Item2" }
-
+      assert_that(subject.any_breadcrumbs?).is_true
       assert_that(subject.breadcrumbs)
         .equals([
           MuchRails::ViewModels::Breadcrumb.new("Item1", "item1-url"),
@@ -102,7 +104,7 @@ module MuchRails::Layout
         ])
     end
 
-    should "know its #stylesheets" do
+    should "know its stylesheets" do
       receiver = receiver_class.new
       assert_that(receiver.stylesheets).is_empty
 
@@ -116,7 +118,7 @@ module MuchRails::Layout
         ])
     end
 
-    should "know its #javascripts" do
+    should "know its javascripts" do
       receiver = receiver_class.new
       assert_that(receiver.javascripts).is_empty
 
@@ -134,12 +136,16 @@ module MuchRails::Layout
         ])
     end
 
-    should "know its #any_breadcrumbs?" do
+    should "know its head links" do
       receiver = receiver_class.new
-      assert_that(receiver.any_breadcrumbs?).is_false
+      assert_that(receiver.head_links).is_empty
 
-      receiver_class.breadcrumb{ "Item2" }
-      assert_that(subject.any_breadcrumbs?).is_true
+      url1 = Factory.url
+      attributes1 = { some_attribute: Factory.string }
+      receiver_class.head_link(url1, **attributes1)
+
+      assert_that(subject.head_links)
+        .equals([unit_module::HeadLink.new(url1, **attributes1)])
     end
 
     should "know its #layouts" do

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