much-rails 0.1.3 → 0.2.4

data/lib/much-rails/version.rb

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

data/much-rails.gemspec

@@ -29,7 +29,7 @@ Gem::Specification.new do |gem|
 
   gem.add_dependency("activerecord",   ["> 5.0", "< 7.0"])
   gem.add_dependency("activesupport",  ["> 5.0", "< 7.0"])
-  gem.add_dependency("dassets",        ["~> 0.15.1"])
+  gem.add_dependency("dassets",        ["~> 0.15.2"])
   gem.add_dependency("dassets-erubi",  ["~> 0.1.1"])
   gem.add_dependency("dassets-sass",   ["~> 0.5.1"])
   gem.add_dependency("much-boolean",   ["~> 0.2.1"])

data/test/unit/abstract_class_tests.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require "assert"
+require "much-rails/abstract_class"
+
+module MuchRails::AbstractClassTest
+  class UnitTests < Assert::Context
+    desc "MuchRails::AbstractClass"
+    subject{ unit_class }
+
+    let(:unit_class){ MuchRails::AbstractClass }
+
+    should "include MuchRails::Mixin" do
+      assert_that(subject).includes(MuchRails::Mixin)
+    end
+  end
+
+  class ReceiverTests < UnitTests
+    desc "receiver"
+    subject{ receiver_class }
+
+    let(:receiver_class) do
+      Class.new.tap{ |c| c.include unit_class }
+    end
+    let(:receiver_subclass) do
+      Class.new(receiver_class)
+    end
+
+    should have_accessor :abstract_class
+    should have_imeths :new, :abstract_class?
+
+    should "know if it is an abstract class or not" do
+      assert_that(subject.abstract_class?).equals(true)
+      assert_that(receiver_subclass.abstract_class?).equals(false)
+    end
+
+    should "prevent calling .new on the receiver" do
+      assert_that{ subject.new }.raises(NotImplementedError)
+    end
+
+    should "allow calling .new on subclasses of the receiver" do
+      assert_that(receiver_subclass.new).is_a?(subject)
+    end
+  end
+end

data/test/unit/action/base_router_tests.rb

@@ -80,13 +80,13 @@ class MuchRails::Action::BaseRouter
     end
 
     should "build path/URL strings for named URLs" do
-      path_string = subject.path_for(:url1, "TEST PATH ARGS")
+      path_string = subject.path_for(:url1, test: "args")
       assert_that(path_string).equals("TEST PATH STRING")
-      assert_that(@url_set_path_for_call.args).equals([:url1, "TEST PATH ARGS"])
+      assert_that(@url_set_path_for_call.args).equals([:url1, { test: "args" }])
 
-      url_string = subject.url_for(:url1, "TEST URL ARGS")
+      url_string = subject.url_for(:url1, test: "args")
       assert_that(url_string).equals("TEST URL STRING")
-      assert_that(@url_set_url_for_call.args).equals([:url1, "TEST URL ARGS"])
+      assert_that(@url_set_url_for_call.args).equals([:url1, { test: "args" }])
     end
 
     should "define request types" do
@@ -380,13 +380,13 @@ class MuchRails::Action::BaseRouter
 
       subject.add(:url1, Factory.url)
 
-      path_string = subject.path_for(:url1, "TEST PATH ARGS")
+      path_string = subject.path_for(:url1, test: "args")
       assert_that(path_string).equals("TEST PATH STRING")
-      assert_that(@url_path_for_call.args).equals(["TEST PATH ARGS"])
+      assert_that(@url_path_for_call.args).equals([{ test: "args" }])
 
-      url_string = subject.url_for(:url1, "TEST URL ARGS")
+      url_string = subject.url_for(:url1, test: "args")
       assert_that(url_string).equals("TEST URL STRING")
-      assert_that(@url_url_for_call.args).equals(["TEST URL ARGS"])
+      assert_that(@url_url_for_call.args).equals([{ test: "args" }])
     end
   end
 
@@ -450,8 +450,8 @@ class MuchRails::Action::BaseRouter
       assert_that(subject.path)
         .equals(base_url_class.url_path(router1, url_path1))
 
-      assert_that{ subject.path_for("TEST ARGS") }.raises(NotImplementedError)
-      assert_that{ subject.url_for("TEST ARGS") }.raises(NotImplementedError)
+      assert_that{ subject.path_for(test: "args") }.raises(NotImplementedError)
+      assert_that{ subject.url_for(test: "args") }.raises(NotImplementedError)
     end
   end
 

data/test/unit/action/router_tests.rb

@@ -206,15 +206,15 @@ class MuchRails::Action::Router
     should have_imeths :path_for, :url_for
 
     should "know its attributes" do
-      path_string = subject.path_for("TEST PATH ARGS")
+      path_string = subject.path_for(test: "args")
       assert_that(path_string).equals("TEST PATH OR URL STRING")
       assert_that(@rails_routes_method_missing_call.args)
-        .equals(["#{url_name1}_path".to_sym, "TEST PATH ARGS"])
+        .equals(["#{url_name1}_path".to_sym, { test: "args" }])
 
-      url_string = subject.url_for("TEST URL ARGS")
+      url_string = subject.url_for(test: "args")
       assert_that(url_string).equals("TEST PATH OR URL STRING")
       assert_that(@rails_routes_method_missing_call.args)
-        .equals(["#{url_name1}_url".to_sym, "TEST URL ARGS"])
+        .equals(["#{url_name1}_url".to_sym, { test: "args" }])
     end
   end
 

data/test/unit/assets_tests.rb

@@ -23,7 +23,7 @@ module MuchRails::Assets
     setup do
       subject.reset
 
-      in_development_env = Factory.boolean
+      in_development_env = true
       Assert.stub(FakeRails.env, :development?){ in_development_env }
       Assert.stub(FakeRails.env, :test?){ !in_development_env }
 
@@ -34,14 +34,11 @@ module MuchRails::Assets
       subject.configure_for_rails(FakeRails)
     end
 
-    should "configure the fingerprint cache to use a memory cache" do
+    should "configure the fingerprint/content cache to use no cache" do
       assert_that(subject.config.fingerprint_cache)
-        .is_instance_of(subject::MemCache)
-    end
-
-    should "configure the content cache to use a memory cache" do
+        .is_instance_of(subject::NoCache)
       assert_that(subject.config.content_cache)
-        .is_instance_of(subject::MemCache)
+        .is_instance_of(subject::NoCache)
     end
 
     should "not configure a file store" do
@@ -49,16 +46,14 @@ module MuchRails::Assets
         .is_not_equal_to(FakeRails.root.join("public"))
     end
 
-    should "configure the app's app/assets folder as a source" do
+    should "configure the app's app/assets/css folder as a source" do
       source =
         subject.config.sources.detect do |source|
-          source.path == FakeRails.root.join("app", "assets").to_s
+          source.path == FakeRails.root.join("app", "assets", "css").to_s
         end
 
       assert_that(source).is_not_nil
-      assert_that(source.engines["js"].size).equals(1)
-      assert_that(source.engines["js"].first)
-        .is_instance_of(subject::Erubi::Engine)
+      assert_that(source.base_path).equals("css")
       assert_that(source.engines["scss"].size).equals(2)
       assert_that(source.engines["scss"].first)
         .is_instance_of(subject::Erubi::Engine)
@@ -66,6 +61,41 @@ module MuchRails::Assets
         .is_instance_of(subject::Sass::Engine)
     end
 
+    should "configure the app's app/assets/img folder as a source" do
+      source =
+        subject.config.sources.detect do |source|
+          source.path == FakeRails.root.join("app", "assets", "img").to_s
+        end
+
+      assert_that(source).is_not_nil
+      assert_that(source.base_path).equals("img")
+      assert_that(source.engines.empty?).is_true
+    end
+
+    should "configure the app's app/assets/js folder as a source" do
+      source =
+        subject.config.sources.detect do |source|
+          source.path == FakeRails.root.join("app", "assets", "js").to_s
+        end
+
+      assert_that(source).is_not_nil
+      assert_that(source.base_path).equals("js")
+      assert_that(source.engines["js"].size).equals(1)
+      assert_that(source.engines["js"].first)
+        .is_instance_of(subject::Erubi::Engine)
+    end
+
+    should "configure the app's app/assets/vendor folder as a source" do
+      source =
+        subject.config.sources.detect do |source|
+          source.path == FakeRails.root.join("app", "assets", "vendor").to_s
+        end
+
+      assert_that(source).is_not_nil
+      assert_that(source.base_path).equals("vendor")
+      assert_that(source.engines.empty?).is_true
+    end
+
     should "initialize itself" do
       assert_that(@init_call).is_not_nil
     end
@@ -84,9 +114,11 @@ module MuchRails::Assets
       subject.configure_for_rails(FakeRails)
     end
 
-    should "configure the content cache to use no cache" do
+    should "configure the fingerprint/content cache to use a memory cache" do
+      assert_that(subject.config.fingerprint_cache)
+        .is_instance_of(subject::MemCache)
       assert_that(subject.config.content_cache)
-        .is_instance_of(subject::NoCache)
+        .is_instance_of(subject::MemCache)
     end
 
     should "configure a file store for the app's public folder" do

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