shoulda_matchmakers 0.1.0

data/lib/controller/action_controller/matchmakers/respond_with.rb

@@ -0,0 +1,71 @@
+module ShouldaMatchmakers
+  module Controller
+    module ActionController
+      module Matchmaker
+        module RespondWith
+
+
+          def respond_with_matcher_tests
+            respond_with_occurrences = get_respond_with_occurrences(@app_controller_name)
+            if respond_with_occurrences.present?
+              generate_respond_with_matcher_tests(@app_controller_name, respond_with_occurrences)
+            else
+              []
+            end
+          end
+
+
+          private
+
+          def get_respond_with_occurrences(app_controller_name)
+            respond_with_occurrences = []
+            app_controller_file_path = compose_extended_app_controller_file_path(app_controller_name)
+            if File.exists?(app_controller_file_path)
+              respond_with_occurrences = parse_app_controller_for_respond_with_occurrences(app_controller_file_path)
+            end
+            respond_with_occurrences
+          end
+
+          def parse_app_controller_for_respond_with_occurrences(app_controller_file_path)
+            respond_with_occurrences = []
+            current_app_controller_method = nil
+            File.open(app_controller_file_path, 'r') do |app_controller_file|
+              app_controller_file.each_line do |app_controller_file_line|
+                if app_controller_file_line =~ /\s+def\s[A-Za-z0-9_][A-Za-z0-9_!\?=]+/
+                  current_app_controller_method = app_controller_file_line.scan(/\s+def\s([A-Za-z0-9_][A-Za-z0-9_!\?=]+)/).flatten.first
+                elsif app_controller_file_line.include?(" render status: ")
+                  status_code = app_controller_file_line.scan(/\s+render\sstatus:\s+([0-9:][a-z0-9_]+)/).flatten.first
+                  if current_app_controller_method.present? && status_code.present?
+                    respond_with_occurrences << { controller_action: current_app_controller_method, status_code: status_code }
+                  end
+                end
+              end
+            end
+            respond_with_occurrences
+          end
+
+          def generate_respond_with_matcher_tests(app_controller_name, respond_with_occurrences)
+            respond_with_tests = []
+            respond_with_occurrences.each do |respond_with_occurrence|
+              app_controller_route_controller = compose_route_controller(app_controller_name)
+              app_controller_action_routes = get_app_controller_routes_by_action(app_controller_route_controller, respond_with_occurrence[:controller_action])
+              app_controller_action_routes.each do |app_controller_action_route|
+                respond_with_test = generate_respond_with_test(app_controller_action_route, respond_with_occurrence)
+                respond_with_tests = append_element(respond_with_test, respond_with_tests)
+              end
+            end
+            format_tests(respond_with_tests)
+          end
+
+          def generate_respond_with_test(app_controller_action_route, respond_with_occurrence)
+            app_controller_route_http_method = get_route_http_method(app_controller_action_route)
+            respond_with_test = "  describe '#{ app_controller_route_http_method } ##{ respond_with_occurrence[:controller_action] }' do\n"
+            respond_with_test.concat("    before { #{ app_controller_route_http_method.downcase } :#{ respond_with_occurrence[:controller_action] } }\n\n")
+            respond_with_test.concat("    it { is_expected.to respond_with(#{ respond_with_occurrence[:status_code] }) }\n  end\n")
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/controller/action_controller/matchmakers/route.rb

@@ -0,0 +1,586 @@
+module ShouldaMatchmakers
+  module Controller
+    module ActionController
+      module Matchmaker
+        module Route
+
+
+          def route_matcher_tests
+            if journey_routes_present(@app_controller_name)
+              generate_route_matcher_tests(@app_controller_name)
+            else
+              []
+            end
+          end
+
+
+          private
+
+          def journey_routes_present(app_controller_name)
+            app_controller_journey_routes_present = false
+            app_controller_path = get_app_controller_file_path(app_controller_name)
+            app_controller_name.constantize.action_methods.map do |app_controller_action_method|
+              app_controller_journey_routes = extract_journey_routes(app_controller_path, app_controller_action_method)
+              app_controller_journey_routes_present = true if app_controller_journey_routes.present?
+            end
+            app_controller_journey_routes_present
+          end
+
+          def extract_journey_routes(app_controller_path, app_controller_action_method)
+            Rails.application.routes.routes.routes.select do |route|
+              if route.defaults.present?
+                route.defaults[:controller].to_sym == app_controller_path.to_sym && route.defaults[:action].to_sym == app_controller_action_method.to_sym
+              else
+                false
+              end
+            end
+          end
+
+          def generate_route_matcher_tests(app_controller_name)
+            route_tests = []
+            app_controller_path = get_app_controller_file_path(app_controller_name)
+            app_controller_name.constantize.action_methods.sort.each do |app_controller_action_method|
+              app_controller_journey_routes = extract_journey_routes(app_controller_path, app_controller_action_method)
+              app_controller_journey_routes.each do |app_controller_journey_route|
+                tests_for_one_route = generate_tests_for_one_route(app_controller_journey_route)
+                route_tests = route_tests + tests_for_one_route
+              end
+            end
+            format_tests(route_tests)
+          end
+
+          def generate_tests_for_one_route(app_controller_journey_route)
+            tests_for_one_route = []
+            route_parameters_hash = compose_route_parameters_hash(app_controller_journey_route)
+            route_url = get_route_url(app_controller_journey_route, route_parameters_hash)
+            request_methods = get_request_methods(app_controller_journey_route)
+            # CONFIRMATION TODO: Determine if this is the proper way to handle controller actions with multiple HTTP verbs
+            request_methods.each do |request_method|
+              tests_for_one_route << generate_route_test(app_controller_journey_route, route_url, request_method, route_parameters_hash)
+            end
+            tests_for_one_route
+          end
+
+          def compose_route_parameters_string(route_parameters_hash)
+            route_parameters_string = ""
+            route_parameters_hash.each do |param_key, param_value|
+              if param_key.to_s == "format" && param_value == nil
+                route_parameters_string.concat(", format: nil")
+              else
+                route_parameters_string.concat(", " + param_key.to_s + ": " + param_value.to_s)
+              end
+            end
+            route_parameters_string
+          end
+
+          # IMPLEMENTATION TODO: Determine if possible to utilize 'regexp-examples' gem to provide values
+          def add_dummy_values_to_route_parameters_with_regexp_values(parameters_hash_with_regexp_values_handled)
+            parameters_hash_with_regexp_dummy_values = parameters_hash_with_regexp_values_handled
+            parameters_hash_with_regexp_dummy_values.each do |param_key, param_value|
+              if param_value.is_a?(Regexp)
+                parameters_hash_with_regexp_dummy_values[param_key] = "'<value matching regexp required>'"
+              end
+            end
+            parameters_hash_with_regexp_dummy_values
+          end
+
+          def add_dummy_values_to_route_parameters_with_missing_values(parameters_hash_handled, parameter_keys_with_missing_values_handled)
+            parameters_hash_with_dummy_values = parameters_hash_handled
+            parameter_keys_with_missing_values_handled.each do |key_with_missing_value|
+              parameters_hash_with_dummy_values[key_with_missing_value] = "'<value required>'"
+            end
+            parameters_hash_with_dummy_values
+          end
+
+          def add_test_comment_for_route_parameters_with_regexp_values(parameters_hash_handled)
+            parameters_hash_with_regexp_values_comment_added = parameters_hash_handled
+            parameters_hash_with_regexp_values_comment_added.each do |param_key, param_value|
+              if param_value.is_a?(Regexp)
+                param_regexp_string = param_value.to_s.sub("(?-mix:","").gsub(/\)$/,"")
+                if param_regexp_string.length <= 40
+                  parameters_hash_with_regexp_values_comment_added[:test_comment].concat("# A required value for route parameter ':#{ param_key }' matching regexp '#{ param_regexp_string }' needs to be provided.\n")
+                else
+                  parameters_hash_with_regexp_values_comment_added[:test_comment].concat("# A required value for route parameter ':#{ param_key }' matching a regexp specified in routes.rb needs to be provided.\n")
+                end
+              end
+            end
+            parameters_hash_with_regexp_values_comment_added
+          end
+
+          def add_test_comment_for_route_parameters_with_missing_values(parameters_hash_with_missing_values_handled, parameter_keys_with_missing_values_handled)
+            parameters_hash_with_missing_values_comment_added = parameters_hash_with_missing_values_handled
+            if parameter_keys_with_missing_values_handled.size == 1
+              parameters_hash_with_missing_values_comment_added[:test_comment].concat("# A required value for route parameter ':#{ parameter_keys_with_missing_values_handled[0] }' needs to be provided.\n")
+            else
+              parameters_hash_with_missing_values_comment_added[:test_comment].concat("# Required values for route parameters '#{ parameter_keys_with_missing_values_handled.to_s }' need to be provided.\n")
+            end
+            parameters_hash_with_missing_values_comment_added
+          end
+
+          def compose_route_parameters_hash(journey_route)
+            route_required_parameter_keys_with_missing_values = journey_route.required_keys - journey_route.requirements.keys
+            route_parameters_hash = journey_route.requirements.select { |key, value| journey_route.parts.include? key } || {}
+            if special_handling_of_route_parameters_required(route_parameters_hash, route_required_parameter_keys_with_missing_values)
+              route_parameters_hash = handle_route_parameters_which_require_special_handling(route_parameters_hash, route_required_parameter_keys_with_missing_values)
+           end
+           route_parameters_hash
+          end
+
+          def generate_route_test(journey_route, route_url, request_method, route_parameters_hash)
+            route_test = generate_route_test_single_line(journey_route, route_url, request_method, route_parameters_hash)
+            if route_test.length > @working_generated_code_line_length
+              route_test = generate_route_test_multiple_line(route_test)
+            end
+            route_test
+          end
+
+          def generate_route_test_multiple_line(route_test)
+            route_test.sub("it { ", "it do\n    ").gsub(").to(", ").\n      to(").gsub(/\)\s\}$/, ")\n  end")
+          end
+
+          def generate_route_test_single_line(journey_route, url, request_method, route_parameters_hash)
+            test_comment = route_parameters_hash.extract!(:test_comment)[:test_comment]
+            route_test = "  it { is_expected.to route(#{ request_method }, '#{ url }').to(action: #{ journey_route.defaults[:action] }"
+            route_test.concat(compose_route_parameters_string(route_parameters_hash)).concat(") }")
+            if test_comment.present?
+              route_test.sub!("  it { ", "  xit { ").prepend(test_comment)
+            end
+            route_test
+          end
+
+          def get_request_methods(journey_route)
+            request_method_regexp = journey_route.constraints[:request_method]
+            request_method_regexp.to_s.scan(/[A-Z]+/)
+          end
+
+          def get_route_url(journey_route, route_parameters_hash)
+            route_url_options_hash = { controller: journey_route.defaults[:controller], action: journey_route.defaults[:action], only_path: true }
+            route_url_options_hash = route_url_options_hash.merge(route_parameters_hash)
+            route_parameters_hash[:test_comment].present? ? "<url required>" : url_for(route_url_options_hash)
+          end
+
+          def handle_route_parameters_which_require_special_handling(route_parameters_hash, route_required_parameter_keys_with_missing_values)
+            parameters_hash_handled = route_parameters_hash
+            parameters_hash_handled[:test_comment] = ""
+            parameter_keys_with_missing_values_handled = route_required_parameter_keys_with_missing_values
+            # CONFIRMATION TODO: Determine if this is the proper way to handle route required ':id' parameter when value not provided
+            if parameter_keys_with_missing_values_handled.include? :id
+              parameters_hash_handled[:id] = 1
+              parameter_keys_with_missing_values_handled.delete(:id)
+            end
+            if parameter_keys_with_missing_values_handled.present?
+              parameters_hash_handled = handle_route_parameters_with_missing_values(parameters_hash_handled, parameter_keys_with_missing_values_handled)
+            end
+            if parameters_hash_handled.values.any? { |route_parameter_value| route_parameter_value.is_a?(Regexp) }
+              parameters_hash_handled = handle_route_parameters_with_regexp_values(parameters_hash_handled)
+            end
+            parameters_hash_handled[:test_comment].concat("# Unable to determine URL without values to still be provided.\n" +
+                                                          "# Remove the 'x' from 'xit' once appropriate values have been supplied.\n")
+            parameters_hash_handled
+          end
+
+          def handle_route_parameters_with_regexp_values(parameters_hash_handled)
+            # CONFIRMATION TODO: Determine if this is the proper way to handle route required parameters that have a regexp value provided
+            parameters_hash_with_regexp_values_handled = add_test_comment_for_route_parameters_with_regexp_values(parameters_hash_handled)
+            add_dummy_values_to_route_parameters_with_regexp_values(parameters_hash_with_regexp_values_handled)
+          end
+
+          def handle_route_parameters_with_missing_values(parameters_hash_handled, parameter_keys_with_missing_values_handled)
+            # CONFIRMATION TODO: Determine if this is the proper way to handle route required parameters that have no value provided
+            parameters_hash_with_missing_values_handled = add_dummy_values_to_route_parameters_with_missing_values(parameters_hash_handled, parameter_keys_with_missing_values_handled)
+            add_test_comment_for_route_parameters_with_missing_values(parameters_hash_with_missing_values_handled, parameter_keys_with_missing_values_handled)
+          end
+
+          def special_handling_of_route_parameters_required(route_parameters_hash, route_required_parameter_keys_with_missing_values)
+            route_required_parameter_keys_with_missing_values.present? ||
+              route_parameters_hash.values.any? { |route_parameter_value| route_parameter_value.is_a?(Regexp) }
+          end
+
+        end
+      end
+    end
+  end
+end
+
+
+
+# module ShouldaMatchmakers
+#   module Controller
+#     module ActionController
+#       module Matchmaker
+#         module Route
+#
+#
+#           def route_matcher_tests
+#             if journey_routes_present(@sm_model_action_controller_controller)
+#               generate_route_matcher_tests(@sm_model_action_controller_controller)
+#             else
+#               []
+#             end
+#           end
+#
+#
+#           private
+#
+#           def generate_route_matcher_tests(controller)
+#             route_tests = []
+#             controller_path = get_app_controller_file_path(controller)
+#             controller.constantize.action_methods.sort.each do |action_method|
+#               journey_routes = extract_journey_routes(controller_path, action_method)
+#               journey_routes.each do |journey_route|
+#                 single_route_tests = generate_single_route_tests(journey_route)
+#                 route_tests = route_tests + single_route_tests
+#               end
+#             end
+#             format_tests(route_tests)
+#           end
+#
+#           def generate_single_route_tests(journey_route)
+#             single_route_tests = []
+#             route_parameters_hash = generate_route_parameters_hash(journey_route)
+#             test_comment = route_parameters_hash.extract!(:test_comment)[:test_comment]
+#             url_options_hash = { controller: journey_route.defaults[:controller], action: journey_route.defaults[:action], only_path: true }
+#             url_options_hash = url_options_hash.merge(route_parameters_hash)
+#
+#             ## TRACE.debug "      ROUTE PARAMETERS HASH:"
+#             ## TRACE.debug route_parameters_hash.inspect
+#             ## TRACE.debug "      URL OPTIONS HASH:"
+#             ## TRACE.debug url_options_hash.inspect
+#
+#             if test_comment.present?
+#               url = "<url required>"
+#             else
+#               url = url_for(url_options_hash)
+#             end
+#
+#            # TRACE.debug "      URL:"
+#            # TRACE.debug url.inspect
+#
+#             request_methods = get_request_methods(journey_route)
+#             # CONFIRMATION TODO: Determine if this is the proper way to handle controller actions with multiple HTTP verbs
+#             request_methods.each do |request_method|
+#               single_route_test = generate_route_test_single_line(journey_route, url, request_method, route_parameters_hash, test_comment)
+#               if single_route_test.length > @working_generated_code_line_length
+#                 single_route_test = generate_route_test_multiple_line(single_route_test)
+#               end
+#               single_route_tests << single_route_test
+#             end
+#             single_route_tests
+#           end
+#
+#           def generate_route_test_single_line(journey_route, url, request_method, route_parameters_hash, test_comment)
+#             route_test = "  it { is_expected.to route(#{ request_method }, '#{ url }').to(action: #{ journey_route.defaults[:action] }"
+#             route_parameters_hash.each do |param_key, param_value|
+#
+#               ## TRACE.debug ""
+#               ## TRACE.debug "      ROUTE PARAMETERS HASH KEY:         " + param_key.inspect
+#               ## TRACE.debug "      ROUTE PARAMETERS HASH VALUE:       " + param_value.inspect
+#               ## TRACE.debug "      ROUTE PARAMETERS HASH VALUE CLASS: " + param_value.class.name.to_s
+#
+#               route_test.concat(", " + param_key.to_s + ": " + param_value.to_s )
+#             end
+#             # "#{ route_parameters_hash.to_s.gsub("{", "{ ").gsub("{  ", "{ ").gsub("}", " }").gsub("  }", " }") }")
+#             route_test.concat(") }")
+#             if test_comment.present?
+#               route_test.prepend(test_comment)
+#               route_test.sub!("  it { ", "  xit { ")
+#             end
+#             route_test
+#           end
+#
+#           def generate_route_test_multiple_line(route_test)
+#
+#             ## TRACE.debug ""
+#             ## TRACE.debug " ROUTE TEST:"
+#             ## TRACE.debug route_test.to_s
+#
+#             route_test.sub("it { ", "it do\n    ").gsub(").to(", ").\n      to(").gsub(/\)\s\}$/, ")\n  end")
+#           end
+#
+#           def get_request_methods(journey_route)
+#             request_method_regex = journey_route.constraints[:request_method]
+#             request_method_regex.to_s.scan(/[A-Z]+/)
+#           end
+#
+#           def generate_route_parameters_hash(journey_route)
+#
+#             # if journey_route.required_keys.size > 2
+#               ## TRACE.debug ""
+#               ## TRACE.debug ""
+#               ## TRACE.debug ""
+#               # ## TRACE.debug "      ROUTE APP:"
+#               # ## TRACE.debug journey_route.app.inspect
+#               ## TRACE.debug "      ROUTE CONSTRAINTS:"
+#               ## TRACE.debug journey_route.defaults.inspect
+#               # ## TRACE.debug "      ROUTE DEFAULTS:"
+#               # ## TRACE.debug journey_route.defaults.inspect
+#               # ## TRACE.debug "      ROUTE NAME:"
+#               # ## TRACE.debug journey_route.name.inspect
+#               # ## TRACE.debug "      ROUTE PATH:"
+#               # ## TRACE.debug journey_route.path.inspect
+#               # ## TRACE.debug "      ROUTE PRECENDENCE:"
+#               # ## TRACE.debug journey_route.precedence.inspect
+#               # ## TRACE.debug "      ROUTE OPTIONAL PARTS:"
+#               # ## TRACE.debug journey_route.optional_parts.inspect
+#               # ## TRACE.debug "      ROUTE PARTS:"
+#               # ## TRACE.debug journey_route.parts.inspect
+#               # ## TRACE.debug "      ROUTE REQUIRED DEFAULTS:"
+#               # ## TRACE.debug journey_route.required_defaults.inspect
+#               ## TRACE.debug "      ROUTE REQUIRED KEYS: " + journey_route.required_keys.inspect
+#               # ## TRACE.debug "      ROUTE REQUIRED PARTS:"
+#               # ## TRACE.debug journey_route.required_parts.inspect
+#               # # journey_route.required_parts.each do |rp|
+#               # #  # TRACE.debug "      ROUTE REQUIRED PART:       " + rp.to_s
+#               # #  # TRACE.debug "      ROUTE REQUIRED PART CLASS: " + rp.class.name.to_s
+#               # # end
+#               ## TRACE.debug "      ROUTE REQUIREMENTS:"
+#               ## TRACE.debug journey_route.requirements.inspect
+#               # ## TRACE.debug "      ROUTE REQUIREMENTS KEYS:"
+#               # ## TRACE.debug journey_route.requirements.keys.inspect
+#               # ## TRACE.debug "      ROUTE SEGMENTS:"
+#               # ## TRACE.debug journey_route.segments.inspect
+#               # ## TRACE.debug "      ROUTE VERB:"
+#               # ## TRACE.debug journey_route.verb.inspect
+#               #
+#               ## TRACE.debug ""
+#               ## TRACE.debug "      ROUTE REQUIRED KEYS WITHOUT VALUES:"
+#               # require_keys_with_missing_values = journey_route.required_keys - journey_route.requirements.keys
+#               ## TRACE.debug require_keys_with_missing_values.inspect
+#             # end
+#
+#             route_parameters_hash = journey_route.requirements.select { |key, value| journey_route.parts.include? key } || {}
+#             route_required_keys_with_missing_values = journey_route.required_keys - journey_route.requirements.keys
+#             # CONFIRMATION TODO: Determine if this is the proper way to handle route required ':id' parameter when value not provided
+#             if route_required_keys_with_missing_values.include? :id
+#               route_parameters_hash[:id] = 1
+#               route_required_keys_with_missing_values.delete(:id)
+#             end
+#             # CONFIRMATION TODO: Determine if this is the proper way to handle route required parameters that either have a regex or no value provided
+#             route_parameters_hash[:test_comment] = ""
+#             if route_required_keys_with_missing_values.present?
+#               route_required_keys_with_missing_values.each do |key_without_value|
+#                 route_parameters_hash[key_without_value] = "'<value required>'"
+#               end
+#               if route_required_keys_with_missing_values.size == 1
+#                 route_parameters_hash[:test_comment].concat("# A required value for route parameter ':#{ route_required_keys_with_missing_values[0] }' needs to be provided.\n")
+#               else
+#                 route_parameters_hash[:test_comment].concat("# Required values for route parameters '#{ route_required_keys_with_missing_values.to_s }' need to be provided.\n")
+#               end
+#             end
+#             if route_parameters_hash.values.any? { |route_parameter_value| route_parameter_value.is_a?(Regexp) }
+#               route_parameters_hash.each do |param_key, param_value|
+#                 if param_value.is_a? Regexp
+#                   param_regex_string = param_value.to_s.sub("(?-mix:","").gsub(/\)$/,"")
+#                   route_parameters_hash[:test_comment].concat("# A required value for route parameter ':#{ param_key }' matching regexp '#{ param_regex_string }' needs to be provided.\n")
+#                   route_parameters_hash[param_key] = "'<value matching regex required>'"
+#                 end
+#               end
+#             end
+#             if route_parameters_hash[:test_comment].present?
+#                 # if route_parameters_hash[:test_comment].scan("values").count > 0 || route_parameters_hash[:test_comment].scan("# ").count > 1
+#                   route_parameters_hash[:test_comment].concat("# Unable to determine URL without values to be provided.\n" +
+#                                                               "# Remove the 'x' from 'xit' once you have supplied the appropriate values.\n")
+#                 # else
+#                 #   route_parameters_hash[:test_comment].concat("# Remove the 'x' from 'xit' once you have supplied the appropriate value.\n")
+#                 # end
+#             end
+#
+#             ## TRACE.debug "      ROUTE REQUIREMENTS HASH:"
+#             ## TRACE.debug route_parameters_hash.inspect
+#
+#             route_parameters_hash
+#           end
+#
+#           def extract_journey_routes(controller_path, action_method)
+#             Rails.application.routes.routes.routes.select do |route|
+#               if route.defaults.present?
+#                 route.defaults[:controller].to_sym == controller_path.to_sym && route.defaults[:action].to_sym == action_method.to_sym
+#               else
+#                 false
+#               end
+#             end
+#           end
+#
+#           def journey_routes_present(controller)
+#             journey_routes_are_present = false
+#             controller_path = get_app_controller_file_path(controller)
+#             controller.constantize.action_methods.map do |action_method|
+#               journey_routes = extract_journey_routes(controller_path, action_method)
+#               journey_routes_are_present = true if journey_routes.present?
+#             end
+#             journey_routes_are_present
+#           end
+#
+#         end
+#       end
+#     end
+#   end
+# end
+
+
+# def route_matcher_tests
+#   if journey_routes_present(@sm_model_action_controller_controller)
+#     generate_route_matcher_tests(@sm_model_action_controller_controller)
+#   else
+#     []
+#   end
+# end
+#
+#
+# private
+#
+# def generate_route_matcher_tests(controller)
+#   route_tests = []
+#   controller_path = get_app_controller_file_path(controller)
+#   controller.constantize.action_methods.map do |action_method|
+#     journey_routes = extract_journey_routes(controller_path, action_method)
+#     journey_routes.each do |journey_route|
+#       single_route_tests = generate_single_route_tests(journey_route, controller_path, action_method)
+#       route_tests = route_tests + single_route_tests
+#     end
+#   end
+#   format_tests(route_tests)
+# end
+#
+# def generate_single_route_tests(journey_route, controller_path, action_method)
+#   single_route_tests = []
+#   route_parameters_hash = generate_route_parameters_hash(journey_route)
+#   url = url_for({controller: controller_path, action: action_method, only_path: true}.merge(route_parameters_hash.except(:test_comment)))
+#   if url.present?
+#     request_methods = get_request_methods(journey_route)
+#     # CONFIRMATION TODO: Determine if this is the proper way to handle controller actions with multiple HTTP verbs
+#     request_methods.each do |request_method|
+#       single_route_test = generate_route_test_single_line(journey_route, url, controller_path, action_method, request_method)
+#       if single_route_test.length > @working_generated_code_line_length
+#         single_route_test = generate_route_test_multiple_line(single_route_test)
+#       end
+#       single_route_tests << single_route_test
+#     end
+#   end
+#   single_route_tests
+# end
+#
+# def generate_route_test_single_line(journey_route, url, controller_path, action_method, request_method)
+#   route_parameters_hash = generate_route_parameters_hash(journey_route)
+#   route_test = "  it { is_expected.to route(#{ request_method }, '#{ url }').to('#{ controller_path }##{ action_method }'"
+#   if route_parameters_hash.present?
+#     route_test.concat(", #{ route_parameters_hash.except(:test_comment).to_s.gsub("{", "{ ").gsub("{  ", "{ ").gsub("}", " }").gsub("  }", " }") }")
+#   end
+#   route_test.concat(") }")
+#   if route_parameters_hash[:test_comment] =~ /#\s/
+#     route_test.prepend(route_parameters_hash[:test_comment])
+#   end
+#   route_test
+# end
+#
+# def generate_route_test_multiple_line(route_test)
+#   route_test.gsub!("  it { ", "  it do\n    ").gsub!(").to(", ").\n      to(").gsub!(/\)\s\}$/, ")\n  end")
+# end
+#
+# def get_request_methods(journey_route)
+#   request_method_regex = journey_route.constraints[:request_method]
+#   request_method_regex.to_s.scan(/[A-Z]+/)
+# end
+#
+# def generate_route_parameters_hash(journey_route)
+#
+#   if journey_route.required_keys.size > 2
+#    # TRACE.debug ""
+#    # TRACE.debug ""
+#    # TRACE.debug ""
+#     ## TRACE.debug "      ROUTE APP:"
+#     ## TRACE.debug journey_route.app.inspect
+#    # TRACE.debug "      ROUTE CONSTRAINTS:"
+#    # TRACE.debug journey_route.defaults.inspect
+#     ## TRACE.debug "      ROUTE DEFAULTS:"
+#     ## TRACE.debug journey_route.defaults.inspect
+#     ## TRACE.debug "      ROUTE NAME:"
+#     ## TRACE.debug journey_route.name.inspect
+#     ## TRACE.debug "      ROUTE PATH:"
+#     ## TRACE.debug journey_route.path.inspect
+#     ## TRACE.debug "      ROUTE PRECENDENCE:"
+#     ## TRACE.debug journey_route.precedence.inspect
+#     ## TRACE.debug "      ROUTE OPTIONAL PARTS:"
+#     ## TRACE.debug journey_route.optional_parts.inspect
+#     ## TRACE.debug "      ROUTE PARTS:"
+#     ## TRACE.debug journey_route.parts.inspect
+#     ## TRACE.debug "      ROUTE REQUIRED DEFAULTS:"
+#     ## TRACE.debug journey_route.required_defaults.inspect
+#    # TRACE.debug "      ROUTE REQUIRED KEYS: " + journey_route.required_keys.inspect
+#     ## TRACE.debug "      ROUTE REQUIRED PARTS:"
+#     ## TRACE.debug journey_route.required_parts.inspect
+#     # journey_route.required_parts.each do |rp|
+#     #  # TRACE.debug "      ROUTE REQUIRED PART:       " + rp.to_s
+#     #  # TRACE.debug "      ROUTE REQUIRED PART CLASS: " + rp.class.name.to_s
+#     # end
+#    # TRACE.debug "      ROUTE REQUIREMENTS:"
+#    # TRACE.debug journey_route.requirements.inspect
+#     ## TRACE.debug "      ROUTE REQUIREMENTS KEYS:"
+#     ## TRACE.debug journey_route.requirements.keys.inspect
+#     ## TRACE.debug "      ROUTE SEGMENTS:"
+#     ## TRACE.debug journey_route.segments.inspect
+#     ## TRACE.debug "      ROUTE VERB:"
+#     ## TRACE.debug journey_route.verb.inspect
+#
+#    # TRACE.debug ""
+#    # TRACE.debug "      ROUTE REQUIRED KEYS WITHOUT VALUES:"
+#     require_keys_with_missing_values = journey_route.required_keys - journey_route.requirements.keys
+#    # TRACE.debug require_keys_with_missing_values.inspect
+#
+#
+#   end
+#
+#   route_parameters_hash = journey_route.requirements.select { |key, value| journey_route.parts.include? key }
+#   route_required_keys_with_missing_values = journey_route.required_keys - journey_route.requirements.keys
+#   if route_required_keys_with_missing_values.include? :id
+#     route_parameters_hash[:id] = 1
+#     route_required_keys_with_missing_values.delete(:id)
+#   end
+#   # CONFIRMATION TODO: Determine if this is the proper way to handle route parts that do no have a required value provided
+#   if route_required_keys_with_missing_values.present?
+#     route_required_keys_with_missing_values.each do |key_without_value|
+#       route_parameters_hash[key_without_value] = "<value required>"
+#     end
+#     if route_required_keys_with_missing_values.size == 1
+#       route_parameters_hash[:test_comment] = "# A required value needs to be provided for route part '#{ route_required_keys_with_missing_values[0] }'.\n" +
+#                                              "# Remove the 'x' from 'xit' once you have supplied an appropriate value.\n"
+#     else
+#       route_parameters_hash[:test_comment] = "# Required values need to be provided for route parts '#{ route_required_keys_with_missing_values.to_s }'.\n" +
+#                                              "# Remove the 'x' from 'xit' once you have supplied the appropriate values.\n"
+#     end
+#   else
+#     route_parameters_hash[:test_comment] = ""
+#   end
+#
+#   # journey_route.requirements.each do |req_key, req_value |
+#   #   route_parameters_hash[req_key] = req_value
+#   # end
+#   # if journey_route.defaults[:format]
+#   #   route_parameters_hash.reverse_merge!({ format: journey_route.defaults[:format] })
+#   # end
+#
+#  # TRACE.debug "      ROUTE REQUIREMENTS HASH:"
+#  # TRACE.debug route_parameters_hash.inspect
+#
+#   route_parameters_hash
+# end
+#
+# def extract_journey_routes(controller_path, action_method)
+#   Rails.application.routes.routes.routes.select do |route|
+#     if route.defaults.present?
+#       route.defaults[:controller].to_sym == controller_path.to_sym && route.defaults[:action].to_sym == action_method.to_sym
+#     else
+#       false
+#     end
+#   end
+# end
+#
+# def journey_routes_present(controller)
+#   journey_routes_are_present = false
+#   controller_path = get_app_controller_file_path(controller)
+#   controller.constantize.action_methods.map do |action_method|
+#     journey_routes = extract_journey_routes(controller_path, action_method)
+#     journey_routes_are_present = true if journey_routes.present?
+#   end
+#   journey_routes_are_present
+# end