much-rails 0.0.1 → 0.2.0

data/lib/much-rails/time.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require "much-rails"
+
+module MuchRails; end
+
+module MuchRails::Time
+  InvalidError = Class.new(TypeError)
+
+  # @example
+  #   MuchRails::Time(nil) # => nil
+  #   MuchRails::Time(" ") # => nil
+  #   MuchRails::Time(Time.current) # => Time
+  #   MuchRails::Time(DateTime.current) # => Time
+  #   MuchRails::Time(Date.zone.today) # => Time
+  #   MuchRails::Time("2020-07-04T08:15:00Z") # => Time
+  def self.for(value)
+    return if value.blank?
+
+    if value.respond_to?(:to_time) && !value.is_a?(::String)
+      value.to_time.utc
+    else
+      ::Time.iso8601(value.to_s).utc
+    end
+  rescue
+    raise MuchRails::Time::InvalidError, "Invalid Time: #{value.inspect}."
+  end
+end

data/lib/much-rails/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module MuchRails
-  VERSION = "0.0.1"
+  VERSION = "0.2.0"
 end

data/lib/much-rails/view_models.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require "much-rails/view_models/breadcrumb"

data/lib/much-rails/view_models/breadcrumb.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module MuchRails; end
+
+module MuchRails::ViewModels; end
+MuchRails::ViewModels::Breadcrumb =
+  Struct.new(:name, :url) do
+    def render_as_link?
+      url.present?
+    end
+  end

data/lib/much-rails/wrap_and_call_method.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require "much-rails/call_method"
+require "much-rails/mixin"
+require "much-rails/result"
+require "much-rails/wrap_method"
+
+module MuchRails; end
+
+# MuchRails::WrapAndCallMethod is a mix-in to implement the `wrap_and_call`
+# and `wrap_and_map_call` class/instance method pattern.
+module MuchRails::WrapAndCallMethod
+  include MuchRails::Mixin
+
+  mixin_included do
+    include MuchRails::CallMethod
+    include MuchRails::WrapMethod
+  end
+
+  mixin_class_methods do
+    def wrap_and_call(objects, *args)
+      wrap(objects, *args).each(&:call)
+    end
+
+    def wrap_and_map_call(objects, *args)
+      wrap(objects, *args).map(&:call)
+    end
+
+    def wrap_and_capture_call(objects, *args, capturing_result:, **kargs)
+      capturing_result.capture_for_all(
+        wrap_and_map_call(objects, *args, **kargs),
+      )
+    end
+
+    def wrap_and_capture_call!(objects, *args, capturing_result:, **kargs)
+      capturing_result.capture_for_all!(
+        wrap_and_map_call(objects, *args, **kargs),
+      )
+    end
+  end
+end

data/lib/much-rails/wrap_method.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require "much-rails/config"
+require "much-rails/mixin"
+
+module MuchRails; end
+
+# MuchRails::WrapMethod is a mix-in to implement the `wrap` class/instance
+# method pattern used in service objects, etc.
+module MuchRails::WrapMethod
+  include MuchRails::Mixin
+
+  mixin_included do
+    include MuchRails::Config
+
+    add_config :wrap_method
+  end
+
+  mixin_class_methods do
+    def wrap(objects, *args)
+      Array.wrap(objects).map do |object|
+        public_send(wrap_initializer_method, object, *args)
+      end
+    end
+
+    def wrap_with_index(objects, **kargs)
+      Array.wrap(objects).each_with_index.map do |object, index|
+        public_send(wrap_initializer_method, object, index: index, **kargs)
+      end
+    end
+
+    def wrap_initializer_method(value = nil)
+      wrap_method_config.wrap_initializer_method = value if value
+      wrap_method_config.wrap_initializer_method
+    end
+  end
+
+  class WrapMethodConfig
+    attr_accessor :wrap_initializer_method
+
+    def initialize
+      @wrap_initializer_method = :new
+    end
+  end
+end

data/much-rails.gemspec

@@ -1,5 +1,7 @@
 # -*- encoding: utf-8 -*-
-lib = File.expand_path("../lib", __FILE__)
+# frozen_string_literal: true
+
+lib = File.expand_path("lib", __dir__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require "much-rails/version"
 
@@ -13,14 +15,28 @@ Gem::Specification.new do |gem|
   gem.homepage    = "https://github.com/redding/much-rails"
   gem.license     = "MIT"
 
-  gem.files         = `git ls-files | grep "^[^.]"`.split($/)
+  gem.files = `git ls-files | grep "^[^.]"`.split($INPUT_RECORD_SEPARATOR)
+
   gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
   gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
   gem.require_paths = ["lib"]
 
   gem.required_ruby_version = "~> 2.5"
 
-  gem.add_development_dependency("assert", ["~> 2.18.4"])
+  gem.add_development_dependency("much-style-guide", ["~> 0.6.0"])
+  gem.add_development_dependency("assert",           ["~> 2.19.5"])
+  gem.add_development_dependency("rails",            ["> 5.0", "< 7.0"])
 
-  # TODO: gem.add_dependency("gem-name", ["~> 0.0.0"])
+  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-erubi",  ["~> 0.1.1"])
+  gem.add_dependency("dassets-sass",   ["~> 0.5.1"])
+  gem.add_dependency("much-boolean",   ["~> 0.2.1"])
+  gem.add_dependency("much-decimal",   ["~> 0.1.3"])
+  gem.add_dependency("much-mixin",     ["~> 0.2.4"])
+  gem.add_dependency("much-not-given", ["~> 0.1.2"])
+  gem.add_dependency("much-result",    ["~> 0.1.3"])
+  gem.add_dependency("much-slug",      ["~> 0.1.1"])
+  gem.add_dependency("oj",             ["~> 3.10"])
 end

data/test/helper.rb

@@ -1,12 +1,30 @@
+# frozen_string_literal: true
+
 # this file is automatically required when you run `assert`
 # put any test helpers here
 
 # add the root dir to the load path
-$LOAD_PATH.unshift(File.expand_path("../..", __FILE__))
+$LOAD_PATH.unshift(File.expand_path("..", __dir__))
+TEST_SUPPORT_PATH = File.expand_path("support", __dir__)
 
 # require pry for debugging (`binding.pry`)
 require "pry"
 
 require "test/support/factory"
 
-# TODO: put test helpers here...
+ENV["RAILS_ENV"] ||= "test"
+
+require "rails"
+require "action_mailer/railtie"
+
+module TestRails
+  class Application < Rails::Application
+    # Initialize configuration defaults for originally generated Rails version.
+    config.load_defaults 6.1
+
+    config.eager_load = false
+  end
+end
+
+# Initialize the Rails application.
+Rails.application.initialize!

data/test/support/actions/show.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require "much-rails/action"
+
+module Actions; end
+
+module Actions::Show
+  include MuchRails::Action
+
+  params_root :nested
+end

data/test/support/config/routes/test.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+url :root, "/"

data/test/support/factory.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "assert/factory"
 
 module Factory

data/test/support/fake_action_controller.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require "much-rails/mixin"
+
+module FakeActionController
+  include MuchRails::Mixin
+
+  after_mixin_included do
+    include MuchRails::Action::Controller
+
+    attr_reader :params
+    attr_reader :head_called_with, :render_called_with
+  end
+
+  mixin_class_methods do
+    def before_action(method_name, **)
+      before_actions << method_name
+    end
+
+    def before_actions
+      @before_actions ||= []
+    end
+  end
+
+  mixin_instance_methods do
+    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
+
+    def render(**kargs)
+      @render_called_with = kargs
+    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/base_command_result_tests.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require "assert"
+require "much-rails/action/base_command_result"
+
+class MuchRails::Action::BaseCommandResult
+  class UnitTests < Assert::Context
+    desc "MuchRails::Action::BaseCommandResult"
+    subject{ unit_class }
+
+    let(:unit_class){ MuchRails::Action::BaseCommandResult }
+  end
+
+  class InitTests < UnitTests
+    desc "when init"
+    subject do
+      unit_class.new(
+        :do_something,
+        "VALUE",
+        other_value: "OTHER VALUE",
+      )
+    end
+
+    let(:controller1){ FakeController.new }
+
+    should have_readers :command_name, :command_args
+
+    should "know its attributes" do
+      assert_that(subject.command_name).equals(:do_something)
+      assert_that(subject.command_args)
+        .equals(["VALUE", { other_value: "OTHER VALUE" }])
+
+      assert_that(controller1.instance_exec(subject, &subject.execute_block))
+        .equals(value: "VALUE", other_value: "OTHER VALUE")
+    end
+  end
+
+  class FakeController
+    def do_something(value, other_value:)
+      { value: value, other_value: other_value }
+    end
+  end
+end

data/test/unit/action/base_result_tests.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require "assert"
+require "much-rails/action/base_result"
+
+class MuchRails::Action::BaseResult
+  class UnitTests < Assert::Context
+    desc "MuchRails::Action::BaseResult"
+    subject{ unit_class }
+
+    let(:unit_class){ MuchRails::Action::BaseResult }
+  end
+
+  class InitTests < UnitTests
+    desc "when init"
+    subject{ unit_class.new }
+
+    should "not implement its #execute_block method" do
+      assert_that{ subject.execute_block }.raises(NotImplementedError)
+    end
+  end
+end

data/test/unit/action/base_router_tests.rb

@@ -0,0 +1,530 @@
+# frozen_string_literal: true
+
+require "assert"
+require "much-rails/action/base_router"
+
+class MuchRails::Action::BaseRouter
+  class UnitTests < Assert::Context
+    desc "MuchRails::Action::BaseRouter"
+    subject{ unit_class }
+
+    let(:unit_class){ MuchRails::Action::BaseRouter }
+
+    let(:caller1){ ["TEST CALLER 1"] }
+
+    should have_imeths :url_class
+
+    should "know its constants" do
+      assert_that(subject::DEFAULT_BASE_URL).equals("/")
+      assert_that(subject.url_class).equals(unit_class::BaseURL)
+    end
+  end
+
+  class InitTests < UnitTests
+    desc "when init"
+    subject{ unit_class.new }
+
+    setup do
+      Assert.stub_tap_on_call(unit_class::RequestTypeSet, :new) do |set, _|
+        Assert.stub_tap_on_call(set, :add) do |_, call|
+          @request_type_set_add_call = call
+        end
+      end
+      Assert.stub_tap_on_call(unit_class::URLSet, :new) do |set, call|
+        @url_set_new_call = call
+        Assert.stub_on_call(set, :path_for) do |call|
+          @url_set_path_for_call = call
+          "TEST PATH STRING"
+        end
+        Assert.stub_on_call(set, :url_for) do |call|
+          @url_set_url_for_call = call
+          "TEST URL STRING"
+        end
+        Assert.stub_tap_on_call(set, :add) do |_, call|
+          @url_set_add_call = call
+        end
+      end
+      Assert.stub_tap_on_call(unit_class::Definition, :for_route) do |_, call|
+        @route_definition_call = call
+      end
+    end
+
+    should have_readers :name
+    should have_readers :request_type_set, :url_set, :definitions
+
+    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
+    should have_imeths :get, :post, :put, :patch, :delete
+
+    should "know its default attributes" do
+      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)
+
+      assert_that(@url_set_new_call.args).equals([subject])
+    end
+
+    should "instance_exec any given block" do
+      router = unit_class.new{ base_url "/test" }
+      assert_that(router.base_url).equals("/test")
+    end
+
+    should "not implement #apply_to" do
+      assert_that{ subject.apply_to("TEST SCOPE") }.raises(NotImplementedError)
+    end
+
+    should "build path/URL strings for named URLs" do
+      path_string = subject.path_for(:url1, "TEST PATH ARGS")
+      assert_that(path_string).equals("TEST PATH STRING")
+      assert_that(@url_set_path_for_call.args).equals([:url1, "TEST PATH ARGS"])
+
+      url_string = subject.url_for(:url1, "TEST URL ARGS")
+      assert_that(url_string).equals("TEST URL STRING")
+      assert_that(@url_set_url_for_call.args).equals([:url1, "TEST URL ARGS"])
+    end
+
+    should "define request types" do
+      proc = ->(request){}
+      request_type = subject.request_type(:type1, &proc)
+      assert_that(subject.request_type_set).is_not_empty
+      assert_that(request_type).is_instance_of(unit_class::RequestType)
+      assert_that(@request_type_set_add_call.args).equals([:type1, proc])
+    end
+
+    should "define the base URL" do
+      subject.base_url(new_url = Factory.url)
+      assert_that(subject.base_url).equals(new_url)
+    end
+
+    should "define URLs" do
+      url = subject.url(:url1, path = Factory.url)
+      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) }
+          .raises(ArgumentError)
+      assert_that(ex.message)
+        .equals(
+          "Named URLs must be defined with Symbol names, given `\"url2\"`.",
+        )
+
+      ex =
+        assert_that{ subject.url(:url2, path = Factory.url.to_sym) }
+          .raises(ArgumentError)
+      assert_that(ex.message)
+        .equals(
+          "Named URLs must be defined with String paths, "\
+          "given `#{path.inspect}`.",
+        )
+    end
+
+    should "define HTTP method routes" do
+      request_type_name = Factory.symbol
+      request_type_proc = ->(request){}
+      request_type = subject.request_type(request_type_name, &request_type_proc)
+      request_type_class_name = Factory.string
+      request_type_action =
+        unit_class::RequestTypeAction.new(request_type, request_type_class_name)
+      url_name = Factory.symbol
+      url_path = Factory.url
+      url = subject.url(url_name, url_path)
+      default_class_name = Factory.string
+
+      definition =
+        subject.get(
+          url_name,
+          default_class_name,
+          called_from: caller1,
+          **{ request_type_name => request_type_class_name },
+        )
+      assert_that(subject.definitions.size).equals(1)
+      assert_that(definition).is_instance_of(unit_class::Definition)
+      assert_that(@route_definition_call.kargs)
+        .equals(
+          http_method: :get,
+          url: url,
+          default_action_class_name: default_class_name,
+          request_type_actions: [request_type_action],
+          called_from: caller1,
+        )
+
+      definition =
+        subject.post(url_name, default_class_name, called_from: caller1)
+      assert_that(subject.definitions.size).equals(2)
+      assert_that(definition).is_instance_of(unit_class::Definition)
+      assert_that(@route_definition_call.kargs)
+        .equals(
+          http_method: :post,
+          url: url,
+          default_action_class_name: default_class_name,
+          request_type_actions: [],
+          called_from: caller1,
+        )
+
+      definition =
+        subject.put(url_path, default_class_name, called_from: caller1)
+      assert_that(subject.definitions.size).equals(3)
+      assert_that(definition).is_instance_of(unit_class::Definition)
+      assert_that(@route_definition_call.kargs)
+        .equals(
+          http_method: :put,
+          url: subject.url_class.for(subject, url_path),
+          default_action_class_name: default_class_name,
+          request_type_actions: [],
+          called_from: caller1,
+        )
+
+      definition =
+        subject.patch(url_name, default_class_name, called_from: caller1)
+      assert_that(subject.definitions.size).equals(4)
+      assert_that(definition).is_instance_of(unit_class::Definition)
+      assert_that(@route_definition_call.kargs)
+        .equals(
+          http_method: :patch,
+          url: url,
+          default_action_class_name: default_class_name,
+          request_type_actions: [],
+          called_from: caller1,
+        )
+
+      definition =
+        subject.delete(url_name, default_class_name, called_from: caller1)
+      assert_that(subject.definitions.size).equals(5)
+      assert_that(definition).is_instance_of(unit_class::Definition)
+      assert_that(@route_definition_call.kargs)
+        .equals(
+          http_method: :delete,
+          url: url,
+          default_action_class_name: default_class_name,
+          request_type_actions: [],
+          called_from: caller1,
+        )
+    end
+  end
+
+  class RequestTypeSetUnitTests < UnitTests
+    desc "RequestTypeSet"
+    subject{ request_type_set_class }
+
+    let(:request_type_set_class){ unit_class::RequestTypeSet }
+    let(:request_type_class){ unit_class::RequestType }
+  end
+
+  class RequestTypeSetInitTests < RequestTypeSetUnitTests
+    desc "when init"
+    subject{ request_type_set_class.new }
+
+    setup do
+      Assert.stub_tap_on_call(request_type_class, :new) do |_url, call|
+        @request_type_new_call = call
+      end
+    end
+
+    let(:constraints_lambda1){ ->(request){} }
+
+    should have_imeths :empty?, :add, :get
+
+    should "add request types" do
+      assert_that(subject).is_empty
+
+      request_type = subject.add(:type1.to_s, constraints_lambda1)
+      assert_that(subject).is_not_empty
+      assert_that(request_type).is_instance_of(request_type_class)
+      assert_that(@request_type_new_call.args)
+        .equals([:type1, constraints_lambda1])
+
+      ex =
+        assert_that{ subject.add(:type1, constraints_lambda1) }
+          .raises(ArgumentError)
+      assert_that(ex.message)
+        .equals("There is already a request type named `:type1`.")
+    end
+
+    should "get request types" do
+      ex =
+        assert_that{ subject.get(:type1) }.raises(ArgumentError)
+      assert_that(ex.message).equals("There is no request type named `:type1`.")
+
+      added_request_type = subject.add(:type1.to_s, constraints_lambda1)
+      request_type       = subject.get(:type1)
+      assert_that(request_type).is(added_request_type)
+
+      request_type = subject.get(:type1)
+      assert_that(request_type).is(added_request_type)
+    end
+  end
+
+  class RequestTypeUnitTests < UnitTests
+    desc "RequestType"
+    subject{ request_type_class }
+
+    let(:request_type_class){ unit_class::RequestType }
+  end
+
+  class RequestTypeInitTests < RequestTypeUnitTests
+    desc "when init"
+    subject{ request_type_class.new(name1, constraints_lambda1) }
+
+    let(:name1){ Factory.symbol }
+    let(:constraints_lambda1){ ->(request){} }
+
+    should have_imeths :name, :constraints_lambda
+
+    should "know its attributes" do
+      assert_that(subject.name).equals(name1)
+      assert_that(subject.constraints_lambda).equals(constraints_lambda1)
+    end
+  end
+
+  class RequestTypeActionUnitTests < UnitTests
+    desc "RequestTypeAction"
+    subject{ request_type_action_class }
+
+    let(:request_type_action_class){ unit_class::RequestTypeAction }
+  end
+
+  class RequestTypeActionInitTests < RequestTypeActionUnitTests
+    desc "when init"
+    subject{ request_type_action_class.new(request_type1, action_class_name1) }
+
+    let(:name1){ Factory.symbol }
+    let(:constraints_lambda1){ ->(request){} }
+    let(:request_type1) do
+      unit_class::RequestType.new(name1, constraints_lambda1)
+    end
+    let(:action_class_name1){ Factory.string }
+
+    should have_imeths :request_type, :class_name, :constraints_lambda
+
+    should "know its attributes" do
+      assert_that(subject.request_type).equals(request_type1)
+      assert_that(subject.class_name).equals(action_class_name1)
+      assert_that(subject.constraints_lambda)
+        .equals(request_type1.constraints_lambda)
+    end
+  end
+
+  class URLSetUnitTests < UnitTests
+    desc "URLSet"
+    subject{ url_set_class }
+
+    let(:url_set_class){ unit_class::URLSet }
+  end
+
+  class URLSetInitTests < URLSetUnitTests
+    desc "when init"
+    subject{ url_set_class.new(router1) }
+
+    setup do
+      Assert.stub_tap_on_call(router1.url_class, :new) do |url, call|
+        @url_new_call = call
+        Assert.stub_on_call(url, :path_for) do |call|
+          @url_path_for_call = call
+          "TEST PATH STRING"
+        end
+        Assert.stub_on_call(url, :url_for) do |call|
+          @url_url_for_call = call
+          "TEST URL STRING"
+        end
+      end
+    end
+
+    let(:router1){ unit_class.new }
+
+    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])
+
+      ex =
+        assert_that{ subject.add(:url1, Factory.url) }.raises(ArgumentError)
+      assert_that(ex.message).equals("There is already a URL named `:url1`.")
+    end
+
+    should "fetch URLs" do
+      ex =
+        assert_that{ subject.fetch(:url1) }.raises(ArgumentError)
+      assert_that(ex.message).equals("There is no URL named `:url1`.")
+      assert_that(subject.fetch(:url1, "/url1")).equals("/url1")
+
+      added_url = subject.add(:url1, Factory.url)
+      url       = subject.fetch(:url1)
+      assert_that(url).is(added_url)
+
+      url = subject.fetch(:url1.to_s)
+      assert_that(url).is(added_url)
+    end
+
+    should "build path/URL strings for named URLs" do
+      ex =
+        assert_that{ subject.path_for(:url1) }.raises(ArgumentError)
+      assert_that(ex.message).equals("There is no URL named `:url1`.")
+      ex =
+        assert_that{ subject.url_for(:url1) }.raises(ArgumentError)
+      assert_that(ex.message).equals("There is no URL named `:url1`.")
+
+      subject.add(:url1, Factory.url)
+
+      path_string = subject.path_for(:url1, "TEST PATH ARGS")
+      assert_that(path_string).equals("TEST PATH STRING")
+      assert_that(@url_path_for_call.args).equals(["TEST PATH ARGS"])
+
+      url_string = subject.url_for(:url1, "TEST URL ARGS")
+      assert_that(url_string).equals("TEST URL STRING")
+      assert_that(@url_url_for_call.args).equals(["TEST URL ARGS"])
+    end
+  end
+
+  class BaseURLUnitTests < UnitTests
+    desc "BaseURL"
+    subject{ base_url_class }
+
+    let(:base_url_class){ unit_class::BaseURL }
+
+    let(:router1){ unit_class.new }
+    let(:url_path1){ Factory.url }
+    let(:url_name1){ Factory.symbol }
+
+    should have_imeths :url_name, :url_path, :for
+
+    should "know its URL name" do
+      assert_that(subject.url_name(nil, nil)).is_nil
+      assert_that(subject.url_name(router1, nil)).is_nil
+      assert_that(subject.url_name(nil, url_name1)).equals(url_name1)
+      assert_that(subject.url_name(router1, url_name1)).equals(url_name1)
+
+      router_name = Factory.symbol
+      Assert.stub(router1, :name){ router_name }
+      assert_that(subject.url_name(router1, url_name1))
+        .equals("#{router_name}_#{url_name1}".to_sym)
+    end
+
+    should "know its URL path" do
+      assert_that(subject.url_path(nil, nil)).is_nil
+      assert_that(subject.url_path(router1, nil)).is_nil
+      assert_that(subject.url_path(nil, url_path1)).equals(url_path1)
+      assert_that(subject.url_path(router1, url_path1)).equals(url_path1)
+
+      router_base_url = Factory.url
+      Assert.stub(router1, :base_url){ router_base_url }
+      assert_that(subject.url_path(router1, url_path1))
+        .equals(File.join(router_base_url, url_path1))
+    end
+
+    should "build URLs from an existing URL or a path string" do
+      url1 = base_url_class.new(router1, url_path1, url_name1)
+
+      url = base_url_class.for(router1, url1)
+      assert_that(url).is(url1)
+
+      url = base_url_class.for(router1, url_path1)
+      assert_that(url.path).equals(url1.path)
+    end
+  end
+
+  class BaseURLInitTests < BaseURLUnitTests
+    desc "when init"
+    subject{ base_url_class.new(router1, url_path1, url_name1) }
+
+    should have_readers :router, :url_path, :url_name
+    should have_imeths :name, :path, :path_for, :url_for
+
+    should "know its attributes" do
+      assert_that(subject.name)
+        .equals(base_url_class.url_name(router1, url_name1))
+      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)
+    end
+  end
+
+  class DefinitionUnitTests < UnitTests
+    desc "Definition"
+    subject{ definition_class }
+
+    let(:definition_class){ unit_class::Definition }
+
+    let(:router1){ unit_class.new }
+    let(:http_method1){ Factory.symbol }
+    let(:url1){ unit_class::BaseURL.for(router1, Factory.url) }
+    let(:url_path1){ url1.path }
+    let(:url_name1){ url1.name }
+    let(:default_action_class_name1){ Factory.string }
+    let(:request_type_actions1){ [] }
+
+    should have_imeths :for_route
+
+    should "build definitions given route information" do
+      definition1 =
+        definition_class.new(
+          http_method: http_method1,
+          url: url1,
+          default_action_class_name: default_action_class_name1,
+          request_type_actions: request_type_actions1,
+          called_from: caller1,
+        )
+
+      definition =
+        definition_class.for_route(
+          http_method: http_method1,
+          url: url1,
+          default_action_class_name: default_action_class_name1,
+          request_type_actions: request_type_actions1,
+          called_from: caller1,
+        )
+      assert_that(definition).equals(definition1)
+    end
+  end
+
+  class DefinitionInitTests < DefinitionUnitTests
+    desc "when init"
+    subject do
+      definition_class.new(
+        http_method: http_method1,
+        url: url1,
+        default_action_class_name: default_action_class_name1,
+        request_type_actions: request_type_actions1,
+        default_params: default_params1,
+        called_from: caller1,
+      )
+    end
+
+    let(:default_params1) do
+      { Factory.string => Factory.string }
+    end
+
+    should have_readers :http_method, :url, :default_params
+    should have_readers :default_action_class_name, :request_type_actions
+    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.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