much-rails 0.0.1 → 0.2.0

data/test/unit/assets_tests.rb

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+require "assert"
+require "much-rails/assets"
+
+module MuchRails::Assets
+  class UnitTests < Assert::Context
+    desc "MuchRails::Assets"
+    subject{ unit_class }
+
+    let(:unit_class){ MuchRails::Assets }
+
+    should have_imeths :configure_for_rails
+
+    should "be Dassets" do
+      assert_that(unit_class).is(Dassets)
+    end
+  end
+
+  class ConfigureTests < UnitTests
+    desc "when configured"
+
+    setup do
+      subject.reset
+
+      in_development_env = Factory.boolean
+      Assert.stub(FakeRails.env, :development?){ in_development_env }
+      Assert.stub(FakeRails.env, :test?){ !in_development_env }
+
+      Assert.stub_on_call(subject, :init) do |call|
+        @init_call = call
+      end
+
+      subject.configure_for_rails(FakeRails)
+    end
+
+    should "configure the fingerprint cache to use a memory 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
+      assert_that(subject.config.content_cache)
+        .is_instance_of(subject::MemCache)
+    end
+
+    should "not configure a file store" do
+      assert_that(subject.config.file_store.root)
+        .is_not_equal_to(FakeRails.root.join("public"))
+    end
+
+    should "configure the app's app/assets folder as a source" do
+      source =
+        subject.config.sources.detect do |source|
+          source.path == FakeRails.root.join("app", "assets").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.engines["scss"].size).equals(2)
+      assert_that(source.engines["scss"].first)
+        .is_instance_of(subject::Erubi::Engine)
+      assert_that(source.engines["scss"].last)
+        .is_instance_of(subject::Sass::Engine)
+    end
+
+    should "initialize itself" do
+      assert_that(@init_call).is_not_nil
+    end
+  end
+
+  class ConfigureNotInDevelopmentOrTestEnvsTests < UnitTests
+    desc "when configured not in development or test environments"
+
+    setup do
+      subject.reset
+
+      Assert.stub_on_call(subject, :init) do |call|
+        @init_call = call
+      end
+
+      subject.configure_for_rails(FakeRails)
+    end
+
+    should "configure the content cache to use no cache" do
+      assert_that(subject.config.content_cache)
+        .is_instance_of(subject::NoCache)
+    end
+
+    should "configure a file store for the app's public folder" do
+      assert_that(subject.config.file_store.root)
+        .equals(FakeRails.root.join("public"))
+    end
+  end
+
+  module FakeRails
+    def self.env
+      @env ||= FakeRailsEnv.new
+    end
+
+    def self.root
+      @root ||= FakeRailsRoot.new
+    end
+  end
+
+  class FakeRailsEnv
+    def development?
+      false
+    end
+
+    def test?
+      false
+    end
+  end
+
+  class FakeRailsRoot
+    def initialize
+      @root_path = Pathname.new(Factory.path)
+    end
+
+    def join(*args)
+      @root_path.join(File.join(*args))
+    end
+  end
+end

data/test/unit/boolean_tests.rb

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

data/test/unit/call_method_callbacks_tests.rb

@@ -0,0 +1,176 @@
+# frozen_string_literal: true
+
+require "assert"
+require "much-rails/call_method_callbacks"
+
+module MuchRails::CallMethodCallbacks
+  class UnitTests < Assert::Context
+    desc "MuchRails::SaveService"
+    subject{ unit_class }
+
+    let(:unit_class){ MuchRails::CallMethodCallbacks }
+
+    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::CallMethodCallbacks
+
+        attr_reader :values
+
+        def initialize
+          @values = []
+        end
+      end
+    end
+
+    let(:proc1){ ->{} }
+    let(:proc2){ ->{} }
+    let(:proc3){ ->{} }
+
+    should have_imeths :before_call, :prepend_before_call, :after_call
+    should have_imeths :prepend_after_call, :around_call, :prepend_around_call
+    should have_imeths :call
+
+    should "be configured as expected" do
+      assert_that(subject).includes(MuchRails::CallMethod)
+      assert_that(subject).includes(MuchRails::Config)
+    end
+
+    should "know its attributes" do
+      # before_callbacks
+      subject.before_call(&proc1)
+
+      assert_that{ subject.before_call(&proc2) }
+        .changes(
+          "subject.much_rails_call_callbacks_config.before_callbacks.dup",
+          from: [proc1],
+          to: [proc1, proc2],
+        )
+
+      assert_that{ subject.prepend_before_call(&proc3) }
+        .changes(
+          "subject.much_rails_call_callbacks_config.before_callbacks.dup",
+          from: [proc1, proc2],
+          to: [proc3, proc1, proc2],
+        )
+
+      # after_callbacks
+      subject.after_call(&proc1)
+
+      assert_that{ subject.after_call(&proc2) }
+        .changes(
+          "subject.much_rails_call_callbacks_config.after_callbacks.dup",
+          from: [proc1],
+          to: [proc1, proc2],
+        )
+
+      assert_that{ subject.prepend_after_call(&proc3) }
+        .changes(
+          "subject.much_rails_call_callbacks_config.after_callbacks.dup",
+          from: [proc1, proc2],
+          to: [proc3, proc1, proc2],
+        )
+
+      # around_callbacks
+      subject.around_call(&proc1)
+
+      assert_that{ subject.around_call(&proc2) }
+        .changes(
+          "subject.much_rails_call_callbacks_config.around_callbacks.dup",
+          from: [proc1],
+          to: [proc1, proc2],
+        )
+
+      assert_that{ subject.prepend_around_call(&proc3) }
+        .changes(
+          "subject.much_rails_call_callbacks_config.around_callbacks.dup",
+          from: [proc1, proc2],
+          to: [proc3, proc1, proc2],
+        )
+    end
+  end
+
+  class CallMethodTests < ReceiverTests
+    desc "#call"
+    subject{ receiver_class }
+
+    setup do
+      subject.before_call do
+        @values << "before 2"
+        true
+      end
+      subject.prepend_before_call do
+        @values << "before 1"
+        true
+      end
+      subject.around_call do |receiver|
+        @values << "start around 2"
+        receiver.call
+        @values << "end around 2"
+        true
+      end
+      subject.prepend_around_call do |receiver|
+        @values << "start around 1"
+        receiver.call
+        @values << "end around 1"
+        true
+      end
+      subject.after_call do
+        @values << "after 2"
+        true
+      end
+      subject.prepend_after_call do
+        @values << "after 1"
+        true
+      end
+
+      subject.class_eval do
+        def on_call
+          @values << "on call"
+          self
+        end
+      end
+    end
+
+    should "execute its callbacks" do
+      return_value = subject.call
+
+      assert_that(return_value).is_instance_of(receiver_class)
+      assert_that(return_value.values)
+        .equals([
+          "before 1",
+          "before 2",
+          "start around 1",
+          "start around 2",
+          "on call",
+          "end around 2",
+          "end around 1",
+          "after 1",
+          "after 2",
+        ])
+    end
+  end
+
+  class MuchRailsCallCallbacksConfigTests < UnitTests
+    desc "unit_class::MuchRailsCallCallbacksConfig"
+    subject{ config_class.new }
+
+    let(:config_class){ unit_class::MuchRailsCallCallbacksConfig }
+
+    should have_accessors :before_callbacks, :after_callbacks, :around_callbacks
+
+    should "know its attribute values" do
+      assert_that(subject.before_callbacks).equals([])
+      assert_that(subject.after_callbacks).equals([])
+      assert_that(subject.around_callbacks).equals([])
+    end
+  end
+end

data/test/unit/call_method_tests.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require "assert"
+require "much-rails/call_method"
+
+module MuchRails::CallMethodTest
+  class UnitTests < Assert::Context
+    desc "MuchRails::CallMethod"
+    subject{ unit_class }
+
+    let(:unit_class){ MuchRails::CallMethod }
+
+    should "include MuchRails::Mixin" do
+      assert_that(subject).includes(MuchRails::Mixin)
+    end
+  end
+
+  class ReceiverTests < UnitTests
+    desc "receiver"
+    subject{ receiver_class }
+
+    setup do
+      Assert.stub_tap(subject, :new) do |new_object|
+        @new_class_method_called = true
+
+        Assert.stub(new_object, :on_call) do
+          @on_call_instance_method_called = true
+        end
+      end
+    end
+
+    let(:receiver_class) do
+      Class.new do
+        include MuchRails::CallMethod
+      end
+    end
+
+    should have_imeths :call
+
+    should "call #new and #call" do
+      subject.call
+
+      assert_that(@new_class_method_called).is_true
+      assert_that(@on_call_instance_method_called).is_true
+    end
+  end
+
+  class ReceiverWithOnCallNotImplemented < UnitTests
+    desc "with the #on_call method not implemented"
+    subject{ receiver_class }
+
+    let(:receiver_class) do
+      Class.new do
+        include MuchRails::CallMethod
+      end
+    end
+
+    should "not implement its #call method" do
+      assert_that(->{ subject.call }).raises(NotImplementedError)
+    end
+  end
+end

data/test/unit/change_action_result_tests.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+require "assert"
+require "much-rails/change_action_result"
+
+class MuchRails::ChangeActionResult
+  class UnitTests < Assert::Context
+    desc "MuchRails::ChangeActionResult"
+    subject{ unit_class }
+
+    let(:unit_class){ MuchRails::ChangeActionResult }
+
+    let(:value1){ "VALUE1" }
+
+    should have_imeths :success, :failure
+
+    should "know its attributes" do
+      result = unit_class.success(value: value1)
+
+      assert_that(result.success?).is_true
+      assert_that(result.failure?).is_false
+      assert_that(result.value).equals(value1)
+
+      result = unit_class.failure(value: value1)
+
+      assert_that(result.success?).is_false
+      assert_that(result.failure?).is_true
+      assert_that(result.value).equals(value1)
+    end
+  end
+
+  class InitTests < UnitTests
+    desc "when init"
+    subject{ unit_class.success(value: value1) }
+
+    let(:save_service_result) do
+      [
+        MuchRails::Result.success,
+        MuchRails::Result.failure,
+      ].sample
+    end
+
+    should have_readers :service_result
+
+    should have_imeths :validation_errors, :validation_error_messages
+    should have_imeths :extract_validation_error
+    should have_imeths :any_unextracted_validation_errors?
+
+    should "know its service_result" do
+      service_result = subject.service_result
+
+      assert_that(service_result).is_instance_of(MuchRails::Result)
+      assert_that(service_result.success?).is_true
+      assert_that(service_result.value).equals(value1)
+      assert_that(service_result.validation_errors).equals({})
+    end
+
+    should "raise a TypeError when given a non-MuchRails::Result" do
+      assert_that{ unit_class.new(["INVALID TYPE", nil, -9].sample) }
+        .raises(TypeError)
+    end
+  end
+
+  class ValidationMethodsTests < UnitTests
+    desc "validation methods"
+    subject do
+      unit_class.failure(validation_errors: {
+        name: ["NAME ERROR"],
+        other: ["OTHER ERROR"],
+      })
+    end
+
+    should "know its attributes" do
+      # validation_errors
+      assert_that(subject.validation_errors)
+        .equals({
+          name: ["NAME ERROR"],
+          other: ["OTHER ERROR"],
+        })
+
+      # validation_error_messages
+      assert_that(subject.validation_error_messages)
+        .equals([
+          "NAME ERROR",
+          "OTHER ERROR",
+        ])
+
+      # extract_validation_error
+      assert_that(subject.extract_validation_error(:name))
+        .equals(["NAME ERROR"])
+      assert_that(subject.extract_validation_error(:other))
+        .equals(["OTHER ERROR"])
+      assert_that(subject.validation_errors).is_empty
+
+      # any_unextracted_validation_errors?
+      Assert.stub(subject, :failure?){ true }
+      Assert.stub(subject, :validation_errors){ { name: "NAME ERROR" } }
+      assert_that(subject.any_unextracted_validation_errors?).is_true
+
+      Assert.stub(subject, :failure?){ true }
+      Assert.stub(subject, :validation_errors){ {} }
+      assert_that(subject.any_unextracted_validation_errors?).is_false
+
+      Assert.stub(subject, :failure?){ false }
+      Assert.stub(subject, :validation_errors){ { name: "NAME ERROR" } }
+      assert_that(subject.any_unextracted_validation_errors?).is_false
+
+      Assert.stub(subject, :failure?){ false }
+      Assert.stub(subject, :validation_errors){ {} }
+      assert_that(subject.any_unextracted_validation_errors?).is_false
+    end
+  end
+end