module ActionDispatch::Assertions::RoutingAssertions

def assert_generates(expected_path, options, defaults={}, extras = {}, message=nil)
  if expected_path =~ %r{://}
    begin
      uri = URI.parse(expected_path)
      expected_path = uri.path.to_s.empty? ? "/" : uri.path
    rescue URI::InvalidURIError => e
      raise ActionController::RoutingError, e.message
    end
  else
    expected_path = "/#{expected_path}" unless expected_path.first == '/'
  end
  # Load routes.rb if it hasn't been loaded.
  generated_path, extra_keys = @routes.generate_extras(options, defaults)
  found_extras = options.reject {|k, v| ! extra_keys.include? k}
  msg = build_message(message, "found extras <?>, not <?>", found_extras, extras)
  assert_equal(extras, found_extras, msg)
  msg = build_message(message, "The generated path <?> did not match <?>", generated_path,
      expected_path)
  assert_equal(expected_path, generated_path, msg)
end

def assert_recognizes(expected_options, path, extras={}, message=nil)
  request = recognized_request_for(path)
  expected_options = expected_options.clone
  extras.each_key { |key| expected_options.delete key } unless extras.nil?
  expected_options.stringify_keys!
  msg = build_message(message, "The recognized options <?> did not match <?>, difference: <?>",
      request.path_parameters, expected_options, expected_options.diff(request.path_parameters))
  assert_equal(expected_options, request.path_parameters, msg)
end

def assert_routing(path, options, defaults={}, extras={}, message=nil)
  assert_recognizes(options, path, extras, message)
  controller, default_controller = options[:controller], defaults[:controller]
  if controller && controller.include?(?/) && default_controller && default_controller.include?(?/)
    options[:controller] = "/#{controller}"
  end
  generate_options = options.dup.delete_if{ |k,v| defaults.key?(k) }
  assert_generates(path.is_a?(Hash) ? path[:path] : path, generate_options, defaults, extras, message)
end

def method_missing(selector, *args, &block)
  if defined?(@controller) && @controller && @routes && @routes.named_routes.helpers.include?(selector)
    @controller.send(selector, *args, &block)
  else
    super
  end
end

def recognized_request_for(path)
  if path.is_a?(Hash)
    method = path[:method]
    path   = path[:path]
  else
    method = :get
  end
  # Assume given controller
  request = ActionController::TestRequest.new
  if path =~ %r{://}
    begin
      uri = URI.parse(path)
      request.env["rack.url_scheme"] = uri.scheme || "http"
      request.host = uri.host if uri.host
      request.port = uri.port if uri.port
      request.path = uri.path.to_s.empty? ? "/" : uri.path
    rescue URI::InvalidURIError => e
      raise ActionController::RoutingError, e.message
    end
  else
    path = "/#{path}" unless path.first == "/"
    request.path = path
  end
  request.request_method = method if method
  params = @routes.recognize_path(path, { :method => method })
  request.path_parameters = params.with_indifferent_access
  request
end

def with_routing
  old_routes, @routes = @routes, ActionDispatch::Routing::RouteSet.new
  if defined?(@controller) && @controller
    old_controller, @controller = @controller, @controller.clone
    _routes = @routes
    # Unfortunately, there is currently an abstraction leak between AC::Base
    # and AV::Base which requires having the URL helpers in both AC and AV.
    # To do this safely at runtime for tests, we need to bump up the helper serial
    # to that the old AV subclass isn't cached.
    #
    # TODO: Make this unnecessary
    @controller.singleton_class.send(:include, _routes.url_helpers)
    @controller.view_context_class = Class.new(@controller.view_context_class) do
      include _routes.url_helpers
    end
  end
  yield @routes
ensure
  @routes = old_routes
  if defined?(@controller) && @controller
    @controller = old_controller
  end
end