# Copyright 2020 The Fuchsia Authors. All rights reserved.
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.

import("//build/testing/host_test.gni")
import("//build/testing/host_test_data.gni")

# Declares a golden test.
#
# This template creates a test to verify that certain generated files match
# golden copies checked into the source tree. When invoked with the --regen
# flag, the test instead overwrites the golden files with freshly generated
# copies, guaranteeing that the next test run will pass.
#
# For simpler, single-file golden testing that executes during the build, see
# //build/testing/golden_file.gni.
#
# Example
# ```
# golden_test("foo_golden_tests") {
#   goldens_dir = "goldens"
#   deps = [ ":generate_json" ]
#   entries = [
#     {
#       golden = "out.json.golden"
#       generated = "$target_gen_dir/foo_out.json"
#     },
#   ]
# }
# ```
#
# Setup
# ```
# $ $EDITOR BUILD.gn  # add the example code above
# $ mkdir goldens
# $ touch goldens/goldens.txt
# $ fx test foo_golden_tests -- --regen
# Regenerating goldens in /path/to/your/goldens
# ...
# $ fx test foo_golden_tests
# ...
# PASS
# ```
#
# Parameters
#
#   goldens_dir (required)
#     Directory of golden files, relative to the invoking BUILD.gn file. Must
#     contain a goldens.txt file. Each file path listed in goldens.txt must
#     exist, otherwise a gen-time error is produced.
#
#   entries (required)
#     List of scopes, each with `golden` and `generated` fields. The `golden`
#     field is a file path relative to `goldens_dir`. The `generated` field is
#     an absolute path to the corresponding generated file, which must be
#     produced by one of the targets in `deps`.
#
#   reformat_goldens_command (optional)
#     A command that will reformat from stdin to stdout.
#     The command will be invoked for each golden file checked into the tree
#     before comparing it to the newly generated version. This allows changes
#     to source formatting tools to not cause goldens tests to fail.
#
#   deps (required)
#   visibility
#
template("golden_test") {
  not_needed(invoker,
             [
               "testonly",
               "public_deps",
             ])
  assert(defined(invoker.goldens_dir))
  assert(defined(invoker.entries))
  assert(defined(invoker.deps))

  reformat_goldens = "cat"
  if (defined(invoker.reformat_goldens_command)) {
    reformat_goldens = invoker.reformat_goldens_command
  }

  copied_goldens_dir = "${target_gen_dir}/${target_name}"
  manifest_file = "${target_gen_dir}/${target_name}_manifest.json"

  # read the checked-in list of golden files
  goldens_list = read_file("${invoker.goldens_dir}/goldens.txt", "list lines")
  assert(goldens_list ==
             process_file_template(goldens_list, "{{source_file_part}}"),
         "Subdirectories are not allowed in goldens.txt")

  # Copy the goldens.txt list and make it available to the test at runtime.
  target_test_data_goldens_list = "${target_name}_test_data_goldens_list"
  host_test_data(target_test_data_goldens_list) {
    visibility = [ ":*" ]
    sources = [ "${invoker.goldens_dir}/goldens.txt" ]
    outputs = [ "${copied_goldens_dir}/goldens.txt" ]
  }

  # Reformat or copy the goldens from the source directory by piping each
  # golden file through `reformat_goldens`.
  target_reformat_goldens = "${target_name}_reformat_goldens"
  action_foreach(target_reformat_goldens) {
    hermetic_deps = false

    testonly = true
    visibility = [ ":*" ]

    # Always copy & format the goldens when the generated files change to avoid
    # comparing stale goldens.
    deps = invoker.deps

    script = "/bin/sh"
    sources = rebase_path(goldens_list, ".", invoker.goldens_dir)
    outputs = [ "${copied_goldens_dir}/{{source_file_part}}" ]
    output_dir = rebase_path(copied_goldens_dir, root_build_dir)
    args = [
      "-c",
      "${reformat_goldens} < '{{source}}' > " +
          "'${output_dir}/{{source_file_part}}'",
    ]
  }

  # Make the copy of the goldens available to the test at runtime.
  target_test_data_goldens = "${target_name}_test_data_goldens"
  host_test_data(target_test_data_goldens) {
    visibility = [ ":*" ]
    deps = [ ":${target_reformat_goldens}" ]
    sources = []
    foreach(golden, goldens_list) {
      sources += [ "${copied_goldens_dir}/${golden}" ]
    }
  }

  # Generate the manifest file.
  target_generate_manifest = "${target_name}_generate_manifest"
  generated_file(target_generate_manifest) {
    visibility = [ ":*" ]
    testonly = true
    contents = {
      test_goldens_dir = rebase_path(copied_goldens_dir, root_build_dir)
      regen_goldens_dir = rebase_path(invoker.goldens_dir, root_build_dir)
      entries = []
    }
    foreach(entry, invoker.entries) {
      assert(get_path_info(entry.golden, "extension") == "golden",
             "Golden filename '${entry.golden}' does not end in '.golden'")
      contents.entries += [
        {
          golden = entry.golden
          generated = rebase_path(entry.generated, root_build_dir)
        },
      ]
    }
    outputs = [ manifest_file ]
    output_conversion = "json"
  }

  # Allow the test to access the manifest file and generated files.
  target_generated_files = "${target_name}_generated_files"
  host_test_data(target_generated_files) {
    visibility = [ ":*" ]
    sources = [ manifest_file ]
    foreach(entry, invoker.entries) {
      sources += [ entry.generated ]
    }
    deps = [ ":${target_generate_manifest}" ] + invoker.deps
  }

  # Generate a test target, so that this test can be executed with `fx test`.
  host_test(target_name) {
    forward_variables_from(invoker, [ "visibility" ])
    binary_path = "${root_out_dir}/golden-util"
    args = [
      "--manifest",
      rebase_path(manifest_file, root_build_dir),
    ]
    deps = [
      ":${target_generated_files}",
      ":${target_test_data_goldens_list}",
      ":${target_test_data_goldens}",
      "//tools/golden-util",
    ]
  }
}