Merge remote-tracking branch 'upstream/pull/7504'

[rails.git] / test / test_helper.rb

# frozen_string_literal: true

require "simplecov"
require "simplecov-lcov"

# Fix incompatibility of simplecov-lcov with older versions of simplecov that are not expresses in its gemspec.
# https://github.com/fortissimo1997/simplecov-lcov/pull/25
unless SimpleCov.respond_to?(:branch_coverage)
  module SimpleCov
    def self.branch_coverage?
      false
    end
  end
end

SimpleCov::Formatter::LcovFormatter.config do |config|
  config.report_with_single_file = true
  config.single_report_path = "coverage/lcov.info"
end

SimpleCov.formatters = SimpleCov::Formatter::MultiFormatter.new(
  [
    SimpleCov::Formatter::HTMLFormatter,
    SimpleCov::Formatter::LcovFormatter
  ]
)

SimpleCov.start("rails")

require "securerandom"
require "digest/sha1"

ENV["RAILS_ENV"] = "test"
require_relative "../config/environment"
require "rails/test_help"
require "webmock/minitest"
require "minitest/focus"

WebMock.disable_net_connect!(:allow_localhost => true, :allow => %w[selenium-default selenium-de selenium-nolang rails-app])

# Scan each job performed for N+1 queries, in the same way as requests are
# scanned (see config/initializers/prosopite.rb).
#
# Jobs performed during a request, using perform_enqueued_jobs, aren't
# scanned as their queries would otherwise count towards the request's,
# whereas in production each job is performed separately.
ActiveJob::Base.around_perform do |_job, block|
  if Prosopite.scan?
    Prosopite.pause { block.call }
  else
    Prosopite.scan { block.call }
  end
end

module ActiveSupport
  class TestCase
    include FactoryBot::Syntax::Methods
    include ActiveJob::TestHelper
    include LibXML

    if ENV.key?("CAPYBARA_SERVER_PORT")
      # Running in the devcontainer. Can't figure out how
      # to run things in parallel at the moment, so for now
      # we are not doing it.
    elsif Settings.enable_parallel_tests
      # Run tests in parallel with specified workers
      parallelize(:workers => :number_of_processors)

      parallelize_setup do |worker|
        SimpleCov.command_name "#{SimpleCov.command_name}-#{worker}"
      end

      parallelize_teardown do
        SimpleCov.result
      end
    end

    ##
    # takes a block which is executed in the context of a different
    # ActionController instance. this is used so that code can call methods
    # on the node controller whilst testing the old_node controller.
    def with_controller(new_controller)
      controller_save = @controller
      begin
        @controller = new_controller
        yield
      ensure
        @controller = controller_save
      end
    end

    ##
    # execute a block with missing translation exceptions suppressed
    def without_i18n_exceptions
      exception_handler = I18n.exception_handler
      begin
        I18n.exception_handler = nil
        yield
      ensure
        I18n.exception_handler = exception_handler
      end
    end

    ##
    # work round minitest insanity that causes it to tell you
    # to use assert_nil to test for nil, which is fine if you're
    # comparing to a nil constant but not if you're comparing
    # an expression that might be nil sometimes
    def assert_equal_allowing_nil(exp, act, msg = nil)
      if exp.nil?
        assert_nil act, msg
      else
        assert_equal exp, act, msg
      end
    end

    ##
    # for some reason assert_equal a, b fails when the relations are
    # actually equal, so this method manually checks the fields...
    def assert_relations_are_equal(a, b)
      assert_not_nil a, "first relation is not allowed to be nil"
      assert_not_nil b, "second relation #{a.id} is not allowed to be nil"
      assert_equal a.id, b.id, "relation IDs"
      assert_equal a.changeset_id, b.changeset_id, "changeset ID on relation #{a.id}"
      assert_equal a.visible, b.visible, "visible on relation #{a.id}, #{a.visible.inspect} != #{b.visible.inspect}"
      assert_equal a.version, b.version, "version on relation #{a.id}"
      assert_equal a.tags, b.tags, "tags on relation #{a.id}"
      assert_equal a.members, b.members, "member references on relation #{a.id}"
    end

    ##
    # for some reason assert_equal a, b fails when the ways are actually
    # equal, so this method manually checks the fields...
    def assert_ways_are_equal(a, b)
      assert_not_nil a, "first way is not allowed to be nil"
      assert_not_nil b, "second way #{a.id} is not allowed to be nil"
      assert_equal a.id, b.id, "way IDs"
      assert_equal a.changeset_id, b.changeset_id, "changeset ID on way #{a.id}"
      assert_equal a.visible, b.visible, "visible on way #{a.id}, #{a.visible.inspect} != #{b.visible.inspect}"
      assert_equal a.version, b.version, "version on way #{a.id}"
      assert_equal a.tags, b.tags, "tags on way #{a.id}"
      assert_equal a.nds, b.nds, "node references on way #{a.id}"
    end

    ##
    # for some reason a==b is false, but there doesn't seem to be any
    # difference between the nodes, so i'm checking all the attributes
    # manually and blaming it on ActiveRecord
    def assert_nodes_are_equal(a, b)
      assert_equal a.id, b.id, "node IDs"
      assert_equal a.latitude, b.latitude, "latitude on node #{a.id}"
      assert_equal a.longitude, b.longitude, "longitude on node #{a.id}"
      assert_equal a.changeset_id, b.changeset_id, "changeset ID on node #{a.id}"
      assert_equal a.visible, b.visible, "visible on node #{a.id}"
      assert_equal a.version, b.version, "version on node #{a.id}"
      assert_equal a.tags, b.tags, "tags on node #{a.id}"
    end

    ##
    # return request header for HTTP Bearer Authorization
    def bearer_authorization_header(token_or_user = nil, scopes: Oauth::SCOPES)
      token = case token_or_user
              when nil then create(:oauth_access_token, :scopes => scopes).token
              when User then create(:oauth_access_token, :user => token_or_user, :scopes => scopes).token
              when Doorkeeper::AccessToken then token_or_user.token
              when String then token_or_user
              end

      { "Authorization" => "Bearer #{token}" }
    end

    ##
    # return request header for HTTP Accept
    def accept_format_header(format)
      { "Accept" => format }
    end

    ##
    # return request header to ask for a particular error format
    def error_format_header(f)
      { "X-Error-Format" => f }
    end

    ##
    # Used to check that the error header and the forbidden responses are given
    # when the owner of the changeset has their data not marked as public
    def assert_require_public_data(msg = "Shouldn't be able to use API when the user's data is not public")
      assert_response :forbidden, msg
      assert_equal("You must make your edits public to upload new data", @response.headers["Error"], "Wrong error message")
    end

    ##
    # Not sure this is the best response we could give
    def assert_inactive_user(msg = "an inactive user shouldn't be able to access the API")
      assert_response :forbidden, msg
      # assert_equal @response.headers['Error'], ""
    end

    ##
    # Check for missing translations in an HTML response
    def assert_no_missing_translations(msg = "")
      assert_select "span[class=translation_missing]", false, "Missing translation #{msg}"
    end

    ##
    # Check that an email was received on the given email address,
    # with the given subject. Note that it assumes that there's only
    # one recipient and will fail otherwise. If you need a different
    # behaviour, please extend.
    def assert_email_received(expected_address, expected_subject)
      email = ActionMailer::Base.deliveries.find { |e| e.to.first == expected_address }
      assert_not_nil email
      assert_equal 1, email.to.length
      assert_equal expected_address, email.to.first
      assert_equal expected_subject, email.subject
    end

    ##
    # Check that no email was received on the given email address.
    # Note that this assumes that any emails have only one recipient,
    # and may give incorrect results otherwise. If you need a different
    # behaviour, please extend.
    def assert_email_not_received(expected_address)
      email = ActionMailer::Base.deliveries.find { |e| e.to.first == expected_address }
      assert_nil email
    end

    ##
    # execute a block with a given set of HTTP responses stubbed
    def with_http_stubs(stubs_file)
      stubs = YAML.load_file(File.expand_path("../http/#{stubs_file}.yml", __FILE__))
      stubs.each do |url, response|
        stub_request(:get, Regexp.new(Regexp.quote(url))).to_return(:status => response["code"], :body => response["body"])
      end

      yield
    end

    def stub_gravatar_request(email, status = 200, body = nil)
      hash = ::Digest::MD5.hexdigest(email.downcase)
      url = "https://www.gravatar.com/avatar/#{hash}?d=404"
      stub_request(:get, url).and_return(:status => status, :body => body)
    end

    def email_text_parts(message)
      message.parts.each_with_object([]) do |part, text_parts|
        if part.content_type.start_with?("text/")
          text_parts.push(part)
        elsif part.multipart?
          text_parts.concat(email_text_parts(part))
        end
      end
    end

    def session_for(user)
      get login_path
      post login_path, :params => { :username => user.display_name, :password => "s3cr3t" }
      follow_redirect!
    end

    def xml_for_node(node)
      doc = OSM::API.new.xml_doc
      doc.root << xml_node_for_node(node)
      doc
    end

    def xml_node_for_node(node)
      el = XML::Node.new "node"
      el["id"] = node.id.to_s

      add_metadata_to_xml_node(el, node, {}, {})

      if node.visible?
        el["lat"] = node.lat.to_s
        el["lon"] = node.lon.to_s
      end

      add_tags_to_xml_node(el, node.element_tags)

      el
    end

    def xml_for_way(way)
      doc = OSM::API.new.xml_doc
      doc.root << xml_node_for_way(way)
      doc
    end

    def xml_node_for_way(way)
      el = XML::Node.new "way"
      el["id"] = way.id.to_s

      add_metadata_to_xml_node(el, way, {}, {})

      # make sure nodes are output in sequence_id order
      ordered_nodes = []
      way.way_nodes.each do |nd|
        ordered_nodes[nd.sequence_id] = nd.node_id.to_s if nd.node&.visible?
      end

      ordered_nodes.each do |nd_id|
        next unless nd_id && nd_id != "0"

        node_el = XML::Node.new "nd"
        node_el["ref"] = nd_id
        el << node_el
      end

      add_tags_to_xml_node(el, way.element_tags)

      el
    end

    def xml_for_relation(relation)
      doc = OSM::API.new.xml_doc
      doc.root << xml_node_for_relation(relation)
      doc
    end

    def xml_node_for_relation(relation)
      el = XML::Node.new "relation"
      el["id"] = relation.id.to_s

      add_metadata_to_xml_node(el, relation, {}, {})

      relation.relation_members.each do |member|
        member_el = XML::Node.new "member"
        member_el["type"] = member.member_type.downcase
        member_el["ref"] = member.member_id.to_s
        member_el["role"] = member.member_role
        el << member_el
      end

      add_tags_to_xml_node(el, relation.element_tags)

      el
    end

    def add_metadata_to_xml_node(el, osm, changeset_cache, user_display_name_cache)
      el["changeset"] = osm.changeset_id.to_s
      el["redacted"] = osm.redaction.id.to_s if osm.redacted?
      el["timestamp"] = osm.timestamp.xmlschema
      el["version"] = osm.version.to_s
      el["visible"] = osm.visible.to_s

      if changeset_cache.key?(osm.changeset_id)
        # use the cache if available
      else
        changeset_cache[osm.changeset_id] = osm.changeset.user_id
      end

      user_id = changeset_cache[osm.changeset_id]

      if user_display_name_cache.key?(user_id)
        # use the cache if available
      elsif osm.changeset.user.data_public?
        user_display_name_cache[user_id] = osm.changeset.user.display_name
      else
        user_display_name_cache[user_id] = nil
      end

      unless user_display_name_cache[user_id].nil?
        el["user"] = user_display_name_cache[user_id]
        el["uid"] = user_id.to_s
      end
    end

    def add_tags_to_xml_node(el, tags)
      tags.each do |tag|
        tag_el = XML::Node.new("tag")

        tag_el["k"] = tag.k
        tag_el["v"] = tag.v

        el << tag_el
      end
    end

    def with_settings(settings)
      saved_settings = Settings.to_hash.slice(*settings.keys)

      settings.each_key do |key|
        saved_settings[key] = nil unless saved_settings.key?(key)
      end

      Settings.merge!(settings)

      yield
    ensure
      Settings.merge!(saved_settings)
    end

    def with_user_account_deletion_delay(value, &)
      freeze_time

      with_settings(:user_account_deletion_delay => value, &)
    ensure
      unfreeze_time
    end

    # This is a convenience method for checks of resources rendered in a map view sidebar
    # First we check that when we don't have an id, it will correctly return a 404
    # then we check that we get the correct 404 when a non-existent id is passed
    # then we check that it will get a successful response, when we do pass an id
    def sidebar_browse_check(path, id, template)
      path_method = method(path)

      assert_raise ActionController::UrlGenerationError do
        get path_method.call
      end

      assert_raise ActionController::UrlGenerationError do
        get path_method.call(:id => -10) # we won't have an id that's negative
      end

      get path_method.call(:id => 0)
      assert_response :not_found
      assert_template "browse/not_found"
      assert_template :layout => "map"

      get path_method.call(:id => 0), :headers => { "Turbo-Frame" => "sidebar_content_frame" }
      assert_response :not_found
      assert_template "browse/not_found"
      assert_template :layout => "xhr"

      get path_method.call(:id => id)
      assert_response :success
      assert_template template
      assert_template :layout => "map"

      get path_method.call(:id => id), :headers => { "Turbo-Frame" => "sidebar_content_frame" }
      assert_response :success
      assert_template template
      assert_template :layout => "xhr"
    end

    def parse_html(html)
      Rails::Dom::Testing.html_document_fragment.parse(html)
    end

    def read_fixture_file(relpath)
      Rails.root.join("test", "fixtures", relpath).read
    end
  end
end