much-rails 0.0.1 → 0.2.0

data/test/unit/destroy_service_tests.rb

@@ -0,0 +1,238 @@
+# frozen_string_literal: true
+
+require "assert"
+require "much-rails/destroy_service"
+
+module MuchRails::DestroyService
+  class UnitTests < Assert::Context
+    desc "MuchRails::DestroyService"
+    subject{ unit_class }
+
+    let(:unit_class){ MuchRails::DestroyService }
+
+    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 do
+        include MuchRails::DestroyService
+
+        def initialize(exception: nil)
+          @exception = exception
+        end
+
+        def on_call
+          raise @exception if @exception
+
+          MuchRails::Result.success
+        end
+      end
+    end
+
+    should "include MuchRails::Service" do
+      assert_that(subject).includes(MuchRails::Service)
+    end
+
+    should "return success" do
+      assert_that(subject.call.success?).is_true
+    end
+  end
+
+  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(
+        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 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.errors.to_h)
+      assert_that(result.validation_error_messages)
+        .equals(exception.error_full_messages.to_a)
+    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 destruction_error_messages
+      ["ERROR1", "ERROR2"]
+    end
+  end
+end

data/test/unit/has_slug_tests.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require "assert"
+require "much-rails/has_slug"
+
+module MuchRails::HasSlug
+  class UnitTests < Assert::Context
+    desc "MuchRails::HasSlug"
+    subject{ unit_class }
+
+    let(:unit_class){ MuchRails::HasSlug }
+
+    should "be MuchSlug" do
+      assert_that(unit_class).is(MuchSlug)
+    end
+  end
+end

data/test/unit/input_value_tests.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require "assert"
+require "much-rails/input_value"
+
+module MuchRails::InputValue
+  class UnitTests < Assert::Context
+    desc "MuchRails::InputValue"
+    subject{ unit_class }
+
+    let(:unit_class){ MuchRails::InputValue }
+
+    should have_imeths :strip, :strip_all
+
+    should "know its attributes" do
+      # strip
+      input_value = [nil, "", " "].sample
+      assert_that(subject.strip(input_value)).is_nil
+
+      input_value = [" VALUE  ", "\r VALUE\n"].sample
+      assert_that(subject.strip(input_value)).equals("VALUE")
+
+      assert_that(subject.strip([])).is_nil
+      assert_that(subject.strip({})).is_nil
+
+      # strip_all
+      input_values = [nil, "", " ", " VALUE  "]
+      assert_that(subject.strip_all(input_values)).equals(["VALUE"])
+
+      input_values = [" VALUE1  ", "\r VALUE2\n"]
+      assert_that(subject.strip_all(input_values)).equals(["VALUE1", "VALUE2"])
+    end
+  end
+end

data/test/unit/json_tests.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require "assert"
+require "much-rails/json"
+
+module MuchRails::JSON
+  class UnitTests < Assert::Context
+    desc "MuchRails::JSON"
+    subject{ unit_class }
+
+    let(:unit_class){ MuchRails::JSON }
+
+    let(:object){ { some_key: "SOME VALUE" } }
+
+    should have_imeths :default_mode, :encode, :decode
+
+    should "know its attributes" do
+      # default_mode
+      assert_that(subject.default_mode).equals(:strict)
+
+      # encode
+      assert_that(subject.encode(object))
+        .equals(Oj.dump(object, mode: subject.default_mode))
+
+      options = { ascii_only: true }
+      assert_that(subject.encode(object, **options))
+        .equals(Oj.dump(object, mode: subject.default_mode, **options))
+
+      time_object = { some_key: Time.now }
+      mode = :null
+      assert_that{ subject.encode(time_object) }.raises(TypeError)
+      assert_that(subject.encode(time_object, mode: mode))
+        .equals(Oj.dump(time_object, mode: mode))
+
+      # decode
+      encoded_object = subject.encode(object)
+      assert_that(subject.decode(encoded_object))
+        .equals(Oj.load(encoded_object, mode: subject.default_mode))
+
+      numeric_object = { some_key: 1.25 }
+      options = { bigdecimal_load: :bigdecimal }
+      encoded_object = subject.encode(numeric_object)
+      decoded_object = subject.decode(encoded_object, **options)
+      assert_that(decoded_object)
+        .equals(Oj.load(encoded_object, mode: subject.default_mode, **options))
+      assert_that(decoded_object["some_key"].class).equals(BigDecimal)
+
+      encoded_object = "some-rando-string-that-isnt-JSON"
+      ex =
+        assert_that{ subject.decode(encoded_object) }
+          .raises(unit_class::InvalidError)
+      assert_that(ex.message).includes("Oj::ParseError")
+    end
+  end
+end

data/test/unit/layout_tests.rb

@@ -0,0 +1,155 @@
+# frozen_string_literal: true
+
+require "assert"
+require "much-rails/layout"
+
+module MuchRails::Layout
+  class UnitTests < Assert::Context
+    desc "MuchRails::Layout"
+    subject{ unit_module }
+
+    let(:unit_module){ MuchRails::Layout }
+
+    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 do
+        include MuchRails::Layout
+
+        def attribute1
+          "attribute1"
+        end
+      end
+    end
+
+    should have_imeths :page_title, :page_titles, :application_page_title
+    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
+      assert_that(subject.page_title).is_nil
+
+      receiver_class.page_title{ "Some Portal" }
+      receiver_class.page_title{ "Some Resource #{attribute1}" }
+
+      assert_that(subject.page_title).equals("Some Resource attribute1")
+    end
+
+    should "know its application page title" do
+      assert_that(subject.application_page_title).is_nil
+
+      receiver_class.application_page_title{ "Some App" }
+      receiver_class.application_page_title{ "Some App #{attribute1}" }
+
+      assert_that(subject.application_page_title).equals("Some App attribute1")
+    end
+
+    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 "\
+           "given an application page title but no page title segments" do
+      receiver_class.application_page_title{ "Some App" }
+
+      assert_that(subject.full_page_title)
+        .equals(subject.application_page_title)
+    end
+
+    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}" }
+
+      assert_that(subject.full_page_title)
+        .equals("Some Resource attribute1 - Some Portal")
+    end
+
+    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" }
+      receiver_class.page_title{ "Some Resource #{attribute1}" }
+
+      assert_that(subject.full_page_title)
+        .equals("Some Resource attribute1 - Some Portal | Some App")
+    end
+
+    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"),
+          MuchRails::ViewModels::Breadcrumb.new("Item2"),
+        ])
+    end
+
+    should "know its stylesheets" do
+      receiver = receiver_class.new
+      assert_that(receiver.stylesheets).is_empty
+
+      receiver_class.stylesheet("some/stylesheet.css")
+      receiver_class.stylesheet{ "some/other-stylesheet.css" }
+
+      assert_that(subject.stylesheets)
+        .equals([
+          "some/stylesheet.css",
+          "some/other-stylesheet.css",
+        ])
+    end
+
+    should "know its javascripts" do
+      receiver = receiver_class.new
+      assert_that(receiver.javascripts).is_empty
+
+      receiver_class.javascript("some/javascript/pack.js")
+      receiver_class.javascript{ "some/other/javascript/pack.js" }
+      receiver_class.javascript("https://some/javascript/file.js")
+      receiver_class.javascript{ "https://some/other/javascript/file.js" }
+
+      assert_that(subject.javascripts)
+        .equals([
+          "some/javascript/pack.js",
+          "some/other/javascript/pack.js",
+          "https://some/javascript/file.js",
+          "https://some/other/javascript/file.js",
+        ])
+    end
+
+    should "know its head links" do
+      receiver = receiver_class.new
+      assert_that(receiver.head_links).is_empty
+
+      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
+      assert_that(subject.layouts).equals(receiver_class.layouts)
+    end
+  end
+end