much-rails 0.1.0 → 0.2.1

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.0"
+  VERSION = "0.2.1"
 end

data/much-rails.gemspec

@@ -24,7 +24,7 @@ Gem::Specification.new do |gem|
   gem.required_ruby_version = "~> 2.5"
 
   gem.add_development_dependency("much-style-guide", ["~> 0.6.0"])
-  gem.add_development_dependency("assert",           ["~> 2.19.4"])
+  gem.add_development_dependency("assert",           ["~> 2.19.5"])
   gem.add_development_dependency("rails",            ["> 5.0", "< 7.0"])
 
   gem.add_dependency("activerecord",   ["> 5.0", "< 7.0"])

data/test/support/fake_action_controller.rb

@@ -13,7 +13,7 @@ module FakeActionController
   end
 
   mixin_class_methods do
-    def before_action(method_name)
+    def before_action(method_name, **)
       before_actions << method_name
     end
 

data/test/unit/action/base_router_tests.rb

@@ -52,7 +52,7 @@ class MuchRails::Action::BaseRouter
     should have_readers :name
     should have_readers :request_type_set, :url_set, :definitions
 
-    should have_imeths :url_class, :apply_to
+    should have_imeths :url_class, :unrouted_urls, :apply_to
     should have_imeths :path_for, :url_for
     should have_imeths :request_type
     should have_imeths :base_url, :url
@@ -62,6 +62,7 @@ class MuchRails::Action::BaseRouter
       assert_that(subject.name).is_nil
       assert_that(subject.request_type_set).is_empty
       assert_that(subject.url_set).is_empty
+      assert_that(subject.unrouted_urls).is_empty
       assert_that(subject.definitions).is_empty
       assert_that(subject.base_url).equals(unit_class::DEFAULT_BASE_URL)
       assert_that(subject.url_class).equals(unit_class.url_class)
@@ -106,6 +107,7 @@ class MuchRails::Action::BaseRouter
       assert_that(subject.url_set).is_not_empty
       assert_that(url).is_kind_of(subject.url_class)
       assert_that(@url_set_add_call.args).equals([:url1, path])
+      assert_that(subject.unrouted_urls).equals([url])
 
       ex =
         assert_that{ subject.url(:url2.to_s, Factory.url) }
@@ -338,13 +340,14 @@ class MuchRails::Action::BaseRouter
 
     let(:router1){ unit_class.new }
 
-    should have_imeths :empty?, :add, :fetch, :path_for, :url_for
+    should have_imeths :empty?, :urls, :add, :fetch, :path_for, :url_for
 
     should "add URLs" do
       assert_that(subject).is_empty
 
       url = subject.add(:url1.to_s, path = Factory.url)
       assert_that(subject).is_not_empty
+      assert_that(subject.urls).equals([url])
       assert_that(url).is_kind_of(router1.url_class)
       assert_that(@url_new_call.args).equals([router1, path, :url1])
 
@@ -472,8 +475,7 @@ class MuchRails::Action::BaseRouter
       definition1 =
         definition_class.new(
           http_method: http_method1,
-          path: url_path1,
-          name: url_name1,
+          url: url1,
           default_action_class_name: default_action_class_name1,
           request_type_actions: request_type_actions1,
           called_from: caller1,
@@ -496,8 +498,7 @@ class MuchRails::Action::BaseRouter
     subject do
       definition_class.new(
         http_method: http_method1,
-        path: url_path1,
-        name: url_name1,
+        url: url1,
         default_action_class_name: default_action_class_name1,
         request_type_actions: request_type_actions1,
         default_params: default_params1,
@@ -509,19 +510,21 @@ class MuchRails::Action::BaseRouter
       { Factory.string => Factory.string }
     end
 
-    should have_readers :http_method, :path, :name, :default_params
+    should have_readers :http_method, :url, :default_params
     should have_readers :default_action_class_name, :request_type_actions
-    should have_reader :called_from
+    should have_readers :called_from
+    should have_imeths :path, :name, :has_default_action_class_name?
 
     should "know its attributes" do
       assert_that(subject.http_method).equals(http_method1)
-      assert_that(subject.path).equals(url_path1)
-      assert_that(subject.name).equals(url_name1)
+      assert_that(subject.url).equals(url1)
       assert_that(subject.default_params).equals(default_params1)
       assert_that(subject.default_action_class_name)
         .equals(default_action_class_name1)
       assert_that(subject.request_type_actions).equals(request_type_actions1)
       assert_that(subject.called_from).equals(caller1)
+      assert_that(subject.path).equals(url_path1)
+      assert_that(subject.name).equals(url_name1)
     end
   end
 end

data/test/unit/action/controller_tests.rb

@@ -16,6 +16,10 @@ module MuchRails::Action::Controller
     should "include MuchRails::Mixin" do
       assert_that(subject).includes(MuchRails::Mixin)
     end
+
+    should "know its constants" do
+      assert_that(subject::DEFAULT_ACTION_CLASS_FORMAT).equals(:any)
+    end
   end
 
   class ReceiverTests < UnitTests
@@ -44,8 +48,14 @@ module MuchRails::Action::Controller
 
     should have_readers :much_rails_action_class
 
-    should have_imeths MuchRails::Action::Router::CONTROLLER_METHOD_NAME
+    should have_imeths(
+      MuchRails::Action::Router::CONTROLLER_CALL_ACTION_METHOD_NAME,
+    )
+    should have_imeths(
+      MuchRails::Action::Router::CONTROLLER_NOT_FOUND_METHOD_NAME,
+    )
     should have_imeths :much_rails_action_class_name
+    should have_imeths :much_rails_action_class_format
     should have_imeths :much_rails_action_params
     should have_imeths :require_much_rails_action_class
     should have_imeths :permit_all_much_rails_action_params
@@ -54,6 +64,9 @@ module MuchRails::Action::Controller
       assert_that(subject.much_rails_action_class_name)
         .equals("::Actions::Show")
 
+      assert_that(subject.much_rails_action_class_format)
+        .equals(unit_module::DEFAULT_ACTION_CLASS_FORMAT)
+
       assert_that(subject.much_rails_action_params)
         .equals(
           nested: { value: "VALUE 1" },
@@ -61,6 +74,11 @@ module MuchRails::Action::Controller
         )
 
       assert_that(subject.much_rails_action_class).equals(Actions::Show)
+
+      Actions::Show.format(:html)
+      receiver = receiver_class.new(params1)
+      assert_that(receiver.much_rails_action_class_format).equals(:html)
+      Actions::Show.format(nil)
     end
   end
 
@@ -89,49 +107,4 @@ module MuchRails::Action::Controller
         .raises(MuchRails::Action::ActionError)
     end
   end
-
-  class FakeController
-    def self.before_action(method_name)
-      before_actions << method_name
-    end
-
-    def self.before_actions
-      @before_actions ||= []
-    end
-
-    attr_reader :params, :head_called_with
-
-    def initialize(params)
-      @params = FakeParams.new(params)
-      self.class.before_actions.each do |before_action|
-        public_send(before_action)
-      end
-    end
-
-    def head(*args)
-      @head_called_with = args
-      self
-    end
-  end
-
-  class FakeParams
-    def initialize(params)
-      @params = params
-    end
-
-    def permit!
-      @permit_called = true
-      self
-    end
-
-    def [](key)
-      @params[key]
-    end
-
-    def to_h
-      raise "params haven't been permitted" unless @permit_called
-
-      @params
-    end
-  end
 end

data/test/unit/action/router_tests.rb

@@ -22,8 +22,10 @@ class MuchRails::Action::Router
 
     should "know its constants" do
       assert_that(subject::DEFAULT_CONTROLLER_NAME).equals("application")
-      assert_that(subject::CONTROLLER_METHOD_NAME)
+      assert_that(subject::CONTROLLER_CALL_ACTION_METHOD_NAME)
         .equals(:much_rails_call_action)
+      assert_that(subject::CONTROLLER_NOT_FOUND_METHOD_NAME)
+        .equals(:much_rails_not_found)
       assert_that(subject::ACTION_CLASS_PARAM_NAME)
         .equals(:much_rails_action_class_name)
       assert_that(subject.url_class).equals(unit_class::URL)
@@ -88,17 +90,25 @@ class MuchRails::Action::Router
       subject.patch(url_name, default_class_name)
       subject.delete(url_name, default_class_name)
 
+      url2_name = Factory.symbol
+      url2_path = Factory.url
+      subject.url(url2_name, url2_path)
+
       application_routes = FakeApplicationRoutes.new
       subject.draw(application_routes)
 
+      expected_draw_url_to =
+        "#{subject.controller_name}"\
+        "##{unit_class::CONTROLLER_NOT_FOUND_METHOD_NAME}"
       expected_draw_route_to =
-        "#{subject.controller_name}##{unit_class::CONTROLLER_METHOD_NAME}"
+        "#{subject.controller_name}"\
+        "##{unit_class::CONTROLLER_CALL_ACTION_METHOD_NAME}"
       expected_default_defaults =
         { unit_class::ACTION_CLASS_PARAM_NAME => default_class_name }
 
-      assert_that(application_routes.get_calls.size).equals(2)
-      assert_that(application_routes.get_calls.first.pargs).equals([url_path])
-      assert_that(application_routes.get_calls.first.kargs)
+      assert_that(application_routes.get_calls.size).equals(3)
+      assert_that(application_routes.get_calls[0].pargs).equals([url_path])
+      assert_that(application_routes.get_calls[0].kargs)
         .equals(
           to: expected_draw_route_to,
           as: url_name,
@@ -106,13 +116,19 @@ class MuchRails::Action::Router
             { unit_class::ACTION_CLASS_PARAM_NAME => request_type_class_name },
           constraints: request_type_proc,
         )
-      assert_that(application_routes.get_calls.last.pargs).equals([url_path])
-      assert_that(application_routes.get_calls.last.kargs)
+      assert_that(application_routes.get_calls[1].pargs).equals([url_path])
+      assert_that(application_routes.get_calls[1].kargs)
         .equals(
           to: expected_draw_route_to,
           as: url_name,
           defaults: expected_default_defaults,
         )
+      assert_that(application_routes.get_calls[2].pargs).equals([url2_path])
+      assert_that(application_routes.get_calls[2].kargs)
+        .equals(
+          to: expected_draw_url_to,
+          as: url2_name,
+        )
 
       assert_that(application_routes.post_calls.size).equals(1)
       assert_that(application_routes.post_calls.last.pargs).equals([url_path])

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