much-rails 0.0.1 → 0.2.0

data/test/unit/action/controller_tests.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+require "assert"
+require "much-rails/action/controller"
+
+require "test/support/actions/show"
+require "test/support/fake_action_controller"
+
+module MuchRails::Action::Controller
+  class UnitTests < Assert::Context
+    desc "MuchRails::Action::Controller"
+    subject{ unit_module }
+
+    let(:unit_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
+    desc "receiver"
+    subject{ receiver_class }
+
+    let(:receiver_class) do
+      Class.new{ include FakeActionController }
+    end
+  end
+
+  class ReceiverInitTests < ReceiverTests
+    desc "when init"
+    subject{ receiver_class.new(params1) }
+
+    let(:params1) do
+      {
+        MuchRails::Action::Router::ACTION_CLASS_PARAM_NAME => "Actions::Show",
+        controller: "actions",
+        action: "show",
+        nested: {
+          value: "VALUE 1",
+        },
+      }
+    end
+
+    should have_readers :much_rails_action_class
+
+    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
+
+    should "know its attributes" do
+      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" },
+          value: "VALUE 1",
+        )
+
+      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
+
+  class ReceiverInitWithUnknownActionClassTests < ReceiverTests
+    desc "when init with an unknown action class"
+    subject{ receiver_class.new(params1) }
+
+    let(:params1) do
+      {
+        MuchRails::Action::Router::ACTION_CLASS_PARAM_NAME =>
+          "Actions::Unknown",
+      }
+    end
+
+    should "return not found when not raising response exceptions" do
+      Assert.stub(MuchRails.config.action, :raise_response_exceptions?){ false }
+
+      assert_that(subject.much_rails_action_class).is_nil
+      assert_that(subject.head_called_with).equals([:not_found])
+    end
+
+    should "raise an exception when raising response exceptions" do
+      Assert.stub(MuchRails.config.action, :raise_response_exceptions?){ true }
+
+      assert_that{ subject.much_rails_action_class }
+        .raises(MuchRails::Action::ActionError)
+    end
+  end
+end

data/test/unit/action/head_result_tests.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require "assert"
+require "much-rails/action/head_result"
+
+class MuchRails::Action::HeadResult
+  class UnitTests < Assert::Context
+    desc "MuchRails::Action::HeadResult"
+    subject{ unit_class }
+
+    let(:unit_class){ MuchRails::Action::HeadResult }
+  end
+
+  class InitTests < UnitTests
+    desc "when init"
+    subject{ unit_class.new(:ok) }
+
+    should "know its attributes" do
+      assert_that(subject.command_name).equals(:head)
+      assert_that(subject.command_args).equals([:ok])
+      assert_that(subject.head_args).equals(subject.command_args)
+    end
+  end
+end

data/test/unit/action/redirect_to_result_tests.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require "assert"
+require "much-rails/action/redirect_to_result"
+
+class MuchRails::Action::RedirectToResult
+  class UnitTests < Assert::Context
+    desc "MuchRails::Action::RedirectToResult"
+    subject{ unit_class }
+
+    let(:unit_class){ MuchRails::Action::RedirectToResult }
+  end
+
+  class InitTests < UnitTests
+    desc "when init"
+    subject{ unit_class.new("URL") }
+
+    should "know its attributes" do
+      assert_that(subject.command_name).equals(:redirect_to)
+      assert_that(subject.command_args).equals(["URL"])
+      assert_that(subject.redirect_to_args).equals(subject.command_args)
+    end
+  end
+end

data/test/unit/action/render_result_tests.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require "assert"
+require "much-rails/action/render_result"
+
+class MuchRails::Action::RenderResult
+  class UnitTests < Assert::Context
+    desc "MuchRails::Action::RenderResult"
+    subject{ unit_class }
+
+    let(:unit_class){ MuchRails::Action::RenderResult }
+  end
+
+  class InitTests < UnitTests
+    desc "when init"
+    subject{ unit_class.new(view_model1, **render_kargs1) }
+
+    let(:controller1){ FakeController.new }
+    let(:view_model1){ Object.new }
+    let(:render_kargs1) do
+      { something: "TEST_VALUE" }
+    end
+
+    should have_readers :render_view_model, :render_kargs
+
+    should "know its attributes" do
+      assert_that(subject.render_view_model).equals(view_model1)
+      assert_that(subject.render_kargs).equals(render_kargs1)
+
+      controller1.instance_exec(subject, &subject.execute_block)
+      assert_that(controller1.view).equals(view_model1)
+      assert_that(controller1.render_called_with).equals(render_kargs1)
+    end
+  end
+
+  class FakeController
+    attr_reader :view, :render_called_with
+
+    def render(**kargs)
+      @render_called_with = kargs
+    end
+  end
+end

data/test/unit/action/router_tests.rb

@@ -0,0 +1,252 @@
+# frozen_string_literal: true
+
+require "assert"
+require "much-rails/action/router"
+
+require "much-rails/rails_routes"
+
+class MuchRails::Action::Router
+  class UnitTests < Assert::Context
+    desc "MuchRails::Action::Router"
+    subject{ unit_class }
+
+    let(:unit_class){ MuchRails::Action::Router }
+
+    let(:caller1){ ["TEST CALLER 1"] }
+
+    should have_imeths :url_class
+
+    should "be a BaseRouter" do
+      assert_that(subject < MuchRails::Action::BaseRouter).is_true
+    end
+
+    should "know its constants" do
+      assert_that(subject::DEFAULT_CONTROLLER_NAME).equals("application")
+      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)
+    end
+  end
+
+  class LoadTests < UnitTests
+    desc ".load"
+
+    setup do
+      Assert.stub(::Rails, :root){ Pathname.new(TEST_SUPPORT_PATH) }
+    end
+
+    should "eval the named routes file" do
+      router = unit_class.load(:test)
+      assert_that(router.url_set).is_not_empty
+      assert_that(router.url_set.fetch(:root).path).equals("/")
+    end
+
+    should "complain if no file name given" do
+      assert_that{ unit_class.load([nil, "", "  "]) }.raises(ArgumentError)
+    end
+
+    should "complain if the named routes file can't be found" do
+      assert_that{ unit_class.load(:unknown) }.raises(ArgumentError)
+    end
+  end
+
+  class InitTests < UnitTests
+    desc "when init"
+    subject{ unit_class.new }
+
+    let(:controller_name1){ Factory.string }
+
+    should have_readers :controller_name, :draw
+
+    should "know its attributes" do
+      assert_that(subject.controller_name)
+        .equals(unit_class::DEFAULT_CONTROLLER_NAME)
+
+      router = unit_class.new(controller_name: controller_name1)
+      assert_that(router.controller_name).equals(controller_name1)
+    end
+
+    should "draw Rails Application routes" do
+      request_type_name = Factory.symbol
+      request_type_proc = ->(request){}
+      subject.request_type(request_type_name, &request_type_proc)
+      request_type_class_name = "Actions::Show"
+      url_name = Factory.symbol
+      url_path = Factory.url
+      subject.url(url_name, url_path)
+      default_class_name = "Actions::Show"
+
+      subject.get(
+        url_name,
+        default_class_name,
+        request_type_name => request_type_class_name,
+      )
+      subject.post(url_name, default_class_name)
+      subject.put(url_path, default_class_name)
+      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_CALL_ACTION_METHOD_NAME}"
+      expected_default_defaults =
+        { unit_class::ACTION_CLASS_PARAM_NAME => default_class_name }
+
+      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,
+          defaults:
+            { unit_class::ACTION_CLASS_PARAM_NAME => request_type_class_name },
+          constraints: request_type_proc,
+        )
+      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])
+      assert_that(application_routes.post_calls.last.kargs)
+        .equals(
+          to: expected_draw_route_to,
+          as: url_name,
+          defaults: expected_default_defaults,
+        )
+
+      assert_that(application_routes.put_calls.size).equals(1)
+      assert_that(application_routes.put_calls.last.pargs).equals([url_path])
+      assert_that(application_routes.put_calls.last.kargs)
+        .equals(
+          to: expected_draw_route_to,
+          as: nil,
+          defaults: expected_default_defaults,
+        )
+
+      assert_that(application_routes.patch_calls.size).equals(1)
+      assert_that(application_routes.patch_calls.last.pargs).equals([url_path])
+      assert_that(application_routes.patch_calls.last.kargs)
+        .equals(
+          to: expected_draw_route_to,
+          as: url_name,
+          defaults: expected_default_defaults,
+        )
+
+      assert_that(application_routes.delete_calls.size).equals(1)
+      assert_that(application_routes.delete_calls.last.pargs).equals([url_path])
+      assert_that(application_routes.delete_calls.last.kargs)
+        .equals(
+          to: expected_draw_route_to,
+          as: url_name,
+          defaults: expected_default_defaults,
+        )
+    end
+
+    should "complain when drawing a route with an unknown Action class" do
+      action_class_name = "Unknown::Action"
+      subject.get(Factory.url, action_class_name, called_from: caller1)
+      application_routes = FakeApplicationRoutes.new
+
+      exception =
+        assert_that{ subject.draw(application_routes) }.raises(NameError)
+      assert_that(exception.backtrace).equals(caller1)
+    end
+  end
+
+  class URLUnitTests < UnitTests
+    desc "URL"
+    subject{ url_class }
+
+    let(:url_class){ unit_class::URL }
+  end
+
+  class URLInitTests < URLUnitTests
+    desc "when init"
+    subject{ url_class.new(router1, url_path1, url_name1) }
+
+    setup do
+      Assert.stub_on_call(
+        MuchRails::RailsRoutes.instance,
+        :method_missing,
+      ) do |call|
+        @rails_routes_method_missing_call = call
+        "TEST PATH OR URL STRING"
+      end
+    end
+
+    let(:url_name1){ Factory.symbol }
+    let(:url_path1){ Factory.url }
+    let(:router1){ unit_class.new }
+
+    should have_imeths :path_for, :url_for
+
+    should "know its attributes" do
+      path_string = subject.path_for("TEST PATH 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"])
+
+      url_string = subject.url_for("TEST URL 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"])
+    end
+  end
+
+  class FakeApplicationRoutes
+    attr_reader :get_calls, :post_calls, :put_calls, :patch_calls, :delete_calls
+
+    def initialize
+      @get_calls    = []
+      @post_calls   = []
+      @put_calls    = []
+      @patch_calls  = []
+      @delete_calls = []
+    end
+
+    def get(*args)
+      @get_calls << Assert::StubCall.new(*args)
+    end
+
+    def post(*args)
+      @post_calls << Assert::StubCall.new(*args)
+    end
+
+    def put(*args)
+      @put_calls << Assert::StubCall.new(*args)
+    end
+
+    def patch(*args)
+      @patch_calls << Assert::StubCall.new(*args)
+    end
+
+    def delete(*args)
+      @delete_calls << Assert::StubCall.new(*args)
+    end
+  end
+end