# pylint: disable=g-bad-file-header
# Copyright 2017 The Bazel Authors. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#    http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

import os
from absl.testing import absltest
from src.test.py.bazel import test_base


class RunfilesTest(test_base.TestBase):

  def _AssertRunfilesLibraryInBazelToolsRepo(self, family, lang_name):
    for s, t, exe in [("MODULE.bazel.mock", "MODULE.bazel",
                       False), ("foo/BUILD.mock", "foo/BUILD",
                                False), ("foo/foo.py", "foo/foo.py", True),
                      ("foo/Foo.java", "foo/Foo.java",
                       False), ("foo/foo.sh", "foo/foo.sh",
                                True), ("foo/foo.cc", "foo/foo.cc", False),
                      ("foo/datadep/hello.txt", "foo/datadep/hello.txt",
                       False), ("bar/BUILD.mock", "bar/BUILD",
                                False), ("bar/bar.py", "bar/bar.py", True),
                      ("bar/bar-py-data.txt", "bar/bar-py-data.txt",
                       False), ("bar/Bar.java", "bar/Bar.java",
                                False), ("bar/bar-java-data.txt",
                                         "bar/bar-java-data.txt", False),
                      ("bar/bar.sh", "bar/bar.sh",
                       True), ("bar/bar-sh-data.txt", "bar/bar-sh-data.txt",
                               False), ("bar/bar.cc", "bar/bar.cc",
                                        False), ("bar/bar-cc-data.txt",
                                                 "bar/bar-cc-data.txt", False)]:
      self.CopyFile(
          self.Rlocation("io_bazel/src/test/py/bazel/testdata/runfiles_test/" +
                         s), t, exe)

    _, stdout, _ = self.RunBazel(["info", "bazel-bin"])
    bazel_bin = stdout[0]

    self.RunBazel(["build", "--verbose_failures", "//foo:runfiles-" + family])

    if test_base.TestBase.IsWindows():
      bin_path = os.path.join(bazel_bin, "foo/runfiles-%s.exe" % family)
    else:
      bin_path = os.path.join(bazel_bin, "foo/runfiles-" + family)

    self.assertTrue(os.path.exists(bin_path))

    _, stdout, _ = self.RunProgram(
        [bin_path], env_add={"TEST_SRCDIR": "__ignore_me__"}
    )
    # 10 output lines: 2 from foo-<family>, and 2 from each of bar-<lang>.
    if len(stdout) != 10:
      self.fail("stdout: %s" % stdout)

    self.assertEqual(stdout[0], "Hello %s Foo!" % lang_name)
    self.assertRegex(stdout[1], "^rloc=.*/foo/datadep/hello.txt")
    self.assertNotIn("__ignore_me__", stdout[1])

    with open(stdout[1].split("=", 1)[1], "r") as f:
      lines = [l.strip() for l in f.readlines()]
    if len(lines) != 1:
      self.fail("lines: %s" % lines)
    self.assertEqual(lines[0], "world")

    i = 2
    for lang in [("py", "Python", "bar.py"), ("java", "Java", "Bar.java"),
                 ("sh", "Bash", "bar.sh"), ("cc", "C++", "bar.cc")]:
      self.assertEqual(stdout[i], "Hello %s Bar!" % lang[1])
      self.assertRegex(stdout[i + 1], "^rloc=.*/bar/bar-%s-data.txt" % lang[0])
      self.assertNotIn("__ignore_me__", stdout[i + 1])

      with open(stdout[i + 1].split("=", 1)[1], "r") as f:
        lines = [l.strip() for l in f.readlines()]
      if len(lines) != 1:
        self.fail("lines(%s): %s" % (lang[0], lines))
      self.assertEqual(lines[0], "data for " + lang[2])

      i += 2

  def testPythonRunfilesLibraryInBazelToolsRepo(self):
    self._AssertRunfilesLibraryInBazelToolsRepo("py", "Python")

  def testJavaRunfilesLibraryInBazelToolsRepo(self):
    self._AssertRunfilesLibraryInBazelToolsRepo("java", "Java")

  def testBashRunfilesLibraryInBazelToolsRepo(self):
    self._AssertRunfilesLibraryInBazelToolsRepo("sh", "Bash")

  def testCppRunfilesLibraryInBazelToolsRepo(self):
    self._AssertRunfilesLibraryInBazelToolsRepo("cc", "C++")

  def testRunfilesLibrariesFindRunfilesWithoutEnvvars(self):
    for s, t, exe in [
        ("MODULE.bazel.mock", "MODULE.bazel", False),
        ("bar/BUILD.mock", "bar/BUILD", False),
        ("bar/bar.py", "bar/bar.py", True),
        ("bar/bar-py-data.txt", "bar/bar-py-data.txt", False),
        ("bar/Bar.java", "bar/Bar.java", False),
        ("bar/bar-java-data.txt", "bar/bar-java-data.txt", False),
        ("bar/bar.sh", "bar/bar.sh", True),
        ("bar/bar-sh-data.txt", "bar/bar-sh-data.txt", False),
        ("bar/bar.cc", "bar/bar.cc", False),
        ("bar/bar-cc-data.txt", "bar/bar-cc-data.txt", False),
    ]:
      self.CopyFile(
          self.Rlocation("io_bazel/src/test/py/bazel/testdata/runfiles_test/" +
                         s), t, exe)

    _, stdout, _ = self.RunBazel(["info", "bazel-bin"])
    bazel_bin = stdout[0]

    self.RunBazel([
        "build",
        "--verbose_failures",
        "//bar:bar-py",
        "//bar:bar-java",
        "//bar:bar-sh",
        "//bar:bar-cc",
    ])

    for lang in [("py", "Python", "bar.py"), ("java", "Java", "Bar.java"),
                 ("sh", "Bash", "bar.sh"), ("cc", "C++", "bar.cc")]:
      if test_base.TestBase.IsWindows():
        bin_path = os.path.join(bazel_bin, "bar/bar-%s.exe" % lang[0])
      else:
        bin_path = os.path.join(bazel_bin, "bar/bar-" + lang[0])

      self.assertTrue(os.path.exists(bin_path))

      _, stdout, _ = self.RunProgram(
          [bin_path],
          env_remove=set([
              "RUNFILES_MANIFEST_FILE",
              "RUNFILES_MANIFEST_ONLY",
              "RUNFILES_DIR",
              "JAVA_RUNFILES",
          ]),
          env_add={"TEST_SRCDIR": "__ignore_me__"},
      )
      if len(stdout) < 2:
        self.fail("stdout(%s): %s" % (lang[0], stdout))
      self.assertEqual(stdout[0], "Hello %s Bar!" % lang[1])
      self.assertRegex(stdout[1], "^rloc=.*/bar/bar-%s-data.txt" % lang[0])
      self.assertNotIn("__ignore_me__", stdout[1])

      with open(stdout[1].split("=", 1)[1], "r") as f:
        lines = [l.strip() for l in f.readlines()]
      if len(lines) != 1:
        self.fail("lines(%s): %s" % (lang[0], lines))
      self.assertEqual(lines[0], "data for " + lang[2])

  def testRunfilesLibrariesFindRunfilesWithRunfilesManifestEnvvar(self):
    for s, t, exe in [
        ("MODULE.bazel.mock", "MODULE.bazel", False),
        ("bar/BUILD.mock", "bar/BUILD", False),
        # Note: do not test Python here, because py_binary always needs a
        # runfiles tree, even on Windows, because it needs __init__.py files in
        # every directory where there may be importable modules, so Bazel always
        # needs to create a runfiles tree for py_binary.
        ("bar/Bar.java", "bar/Bar.java", False),
        ("bar/bar-java-data.txt", "bar/bar-java-data.txt", False),
        ("bar/bar.sh", "bar/bar.sh", True),
        ("bar/bar-sh-data.txt", "bar/bar-sh-data.txt", False),
        ("bar/bar.cc", "bar/bar.cc", False),
        ("bar/bar-cc-data.txt", "bar/bar-cc-data.txt", False),
    ]:
      self.CopyFile(
          self.Rlocation("io_bazel/src/test/py/bazel/testdata/runfiles_test/" +
                         s), t, exe)

    _, stdout, _ = self.RunBazel(["info", "bazel-bin"])
    bazel_bin = stdout[0]

    for lang in [("java", "Java"), ("sh", "Bash"), ("cc", "C++")]:
      self.RunBazel([
          "build",
          "--verbose_failures",
          "--enable_runfiles=no",
          "//bar:bar-" + lang[0],
      ])

      if test_base.TestBase.IsWindows():
        bin_path = os.path.join(bazel_bin, "bar/bar-%s.exe" % lang[0])
      else:
        bin_path = os.path.join(bazel_bin, "bar/bar-" + lang[0])

      manifest_path = bin_path + ".runfiles_manifest"
      self.assertTrue(os.path.exists(bin_path))
      self.assertTrue(os.path.exists(manifest_path))

      # Create a copy of the runfiles manifest, replacing
      # "bar/bar-<lang>-data.txt" with a custom file.
      mock_bar_dep = self.ScratchFile("bar-%s-mockdata.txt" % lang[0],
                                      ["mock %s data" % lang[0]])
      if test_base.TestBase.IsWindows():
        # Runfiles manifests use forward slashes as path separators, even on
        # Windows.
        mock_bar_dep = mock_bar_dep.replace("\\", "/")
      manifest_key = "_main/bar/bar-%s-data.txt" % lang[0]
      mock_manifest_line = manifest_key + " " + mock_bar_dep
      with open(manifest_path, "rt") as f:
        # Only rstrip newlines. Do not rstrip() completely, because that would
        # remove spaces too. This is necessary in order to have at least one
        # space in every manifest line.
        # Some manifest entries don't have any path after this space, namely the
        # "__init__.py" entries. (Bazel writes such manifests on every
        # platform). The reason is that these files are never symlinks in the
        # runfiles tree, Bazel actually creates empty __init__.py files (again
        # on every platform). However to keep these manifest entries correct,
        # they need to have a space character.
        # We could probably strip these lines completely, but this test doesn't
        # aim to exercise what would happen in that case.
        mock_manifest_data = [
            mock_manifest_line
            if line.split(" ", 1)[0] == manifest_key else line.rstrip("\n\r")
            for line in f
        ]

      substitute_manifest = self.ScratchFile(
          "mock-%s.runfiles/MANIFEST" % lang[0], mock_manifest_data)

      _, stdout, _ = self.RunProgram(
          [bin_path],
          env_remove=set(["RUNFILES_DIR"]),
          env_add={
              # On Linux/macOS, the Java launcher picks up JAVA_RUNFILES and
              # ignores RUNFILES_MANIFEST_FILE.
              "JAVA_RUNFILES": substitute_manifest[: -len("/MANIFEST")],
              # On Windows, the Java launcher picks up RUNFILES_MANIFEST_FILE.
              # The C++ runfiles library picks up RUNFILES_MANIFEST_FILE on all
              # platforms.
              "RUNFILES_MANIFEST_FILE": substitute_manifest,
              "RUNFILES_MANIFEST_ONLY": "1",
              "TEST_SRCDIR": "__ignore_me__",
          },
      )

      if len(stdout) < 2:
        self.fail("stdout: %s" % stdout)
      self.assertEqual(stdout[0], "Hello %s Bar!" % lang[1])
      self.assertRegex(stdout[1], "^rloc=" + mock_bar_dep)
      self.assertNotIn("__ignore_me__", stdout[1])

      with open(stdout[1].split("=", 1)[1], "r") as f:
        lines = [l.strip() for l in f.readlines()]
      if len(lines) != 1:
        self.fail("lines: %s" % lines)
      self.assertEqual(lines[0], "mock %s data" % lang[0])

  def testRunfilesLibrariesFindRlocationpathExpansion(self):
    self.ScratchDir("A")
    self.ScratchFile("A/REPO.bazel")
    self.ScratchFile("A/p/BUILD", ["exports_files(['foo.txt'])"])
    self.ScratchFile("A/p/foo.txt", ["Hello, World!"])
    self.ScratchFile(
        "MODULE.bazel",
        [
            'bazel_dep(name = "rules_python", version = "0.40.0")',
            "local_repository = use_repo_rule(",
            '    "@bazel_tools//tools/build_defs/repo:local.bzl",',
            '    "local_repository")',
            'local_repository(name = "A", path = "A")',
        ],
    )
    self.ScratchFile(
        "pkg/BUILD",
        [
            'load("@rules_python//python:py_binary.bzl", "py_binary")',
            "py_binary(",
            "  name = 'bin',",
            "  srcs = ['bin.py'],",
            "  args = [",
            "    '$(rlocationpath bar.txt)',",
            "    '$(rlocationpath @A//p:foo.txt)',",
            "  ],",
            "  data = [",
            "    'bar.txt',",
            "    '@A//p:foo.txt'",
            "  ],",
            "  deps = ['@bazel_tools//tools/python/runfiles'],",
            ")",
        ],
    )
    self.ScratchFile("pkg/bar.txt", ["Hello, Bazel!"])
    self.ScratchFile("pkg/bin.py", [
        "import sys",
        "from tools.python.runfiles import runfiles",
        "r = runfiles.Create()",
        "for arg in sys.argv[1:]:",
        "  print(open(r.Rlocation(arg)).read().strip())",
    ])
    _, stdout, _ = self.RunBazel(["run", "//pkg:bin"])
    if len(stdout) != 2:
      self.fail("stdout: %s" % stdout)
    self.assertEqual(stdout[0], "Hello, Bazel!")
    self.assertEqual(stdout[1], "Hello, World!")

  def setUpRunfilesDirectoryIncrementalityTest(self):
    self.ScratchFile(
        "MODULE.bazel", ['bazel_dep(name = "rules_shell", version = "0.3.0")']
    )
    self.ScratchFile(
        "BUILD",
        [
            'load("@rules_shell//shell:sh_test.bzl", "sh_test")',
            "sh_test(",
            "  name = 'test',",
            "  srcs = ['test.sh'],",
            "  data = ['data.txt'],",
            ")",
        ],
    )
    self.ScratchFile("data.txt")
    self.ScratchFile("test.sh", ["[[ -f data.txt ]]"], executable=True)
    self.ScratchFile(
        ".bazelrc",
        [
            "startup --nowindows_enable_symlinks",
            "common --spawn_strategy=local",
        ],
    )

  def testRunfilesDirectoryIncrementalityEnableRunfilesFlippedOn(self):
    self.setUpRunfilesDirectoryIncrementalityTest()

    exit_code, _, _ = self.RunBazel(
        ["test", ":test", "--noenable_runfiles"], allow_failure=True
    )
    self.assertEqual(exit_code, 3)
    exit_code, _, _ = self.RunBazel(["test", ":test", "--enable_runfiles"])
    self.assertEqual(exit_code, 0)

  def testRunfilesDirectoryIncrementalityEnableRunfilesFlippedOff(self):
    self.setUpRunfilesDirectoryIncrementalityTest()

    exit_code, _, _ = self.RunBazel(["test", ":test", "--enable_runfiles"])
    self.assertEqual(exit_code, 0)
    exit_code, _, _ = self.RunBazel(
        ["test", ":test", "--noenable_runfiles"], allow_failure=True
    )
    self.assertEqual(exit_code, 3)

  def testRunfilesDirectoryIncrementalityNoBuildRunfileLinksEnableRunfilesFlippedOn(
      self,
  ):
    self.setUpRunfilesDirectoryIncrementalityTest()

    exit_code, _, _ = self.RunBazel(
        ["test", ":test", "--nobuild_runfile_links", "--noenable_runfiles"],
        allow_failure=True,
    )
    self.assertEqual(exit_code, 3)
    exit_code, _, _ = self.RunBazel(
        ["test", ":test", "--nobuild_runfile_links", "--enable_runfiles"]
    )
    self.assertEqual(exit_code, 0)

  def testRunfilesDirectoryIncrementalityNoBuildRunfileLinksEnableRunfilesFlippedOff(
      self,
  ):
    self.setUpRunfilesDirectoryIncrementalityTest()

    exit_code, _, _ = self.RunBazel(
        ["test", ":test", "--nobuild_runfile_links", "--enable_runfiles"]
    )
    self.assertEqual(exit_code, 0)
    exit_code, _, _ = self.RunBazel(
        ["test", ":test", "--nobuild_runfile_links", "--noenable_runfiles"],
        allow_failure=True,
    )
    self.assertEqual(exit_code, 3)

  def testRunfilesDirectoryIncrementalityEnableRunfilesFlippedOnRun(self):
    self.setUpRunfilesDirectoryIncrementalityTest()

    exit_code, _, _ = self.RunBazel(
        ["run", ":test", "--noenable_runfiles"], allow_failure=True
    )
    self.assertNotEqual(exit_code, 0)
    exit_code, _, _ = self.RunBazel(["run", ":test", "--enable_runfiles"])
    self.assertEqual(exit_code, 0)

  def testRunfilesDirectoryIncrementalityEnableRunfilesFlippedOffRun(self):
    self.setUpRunfilesDirectoryIncrementalityTest()

    exit_code, _, _ = self.RunBazel(["run", ":test", "--enable_runfiles"])
    self.assertEqual(exit_code, 0)
    exit_code, _, _ = self.RunBazel(
        ["run", ":test", "--noenable_runfiles"], allow_failure=True
    )
    self.assertNotEqual(exit_code, 0)

  def testRunfilesDirectoryIncrementalityNoBuildRunfileLinksEnableRunfilesFlippedOnRun(
      self,
  ):
    self.setUpRunfilesDirectoryIncrementalityTest()

    exit_code, _, _ = self.RunBazel(
        ["run", ":test", "--nobuild_runfile_links", "--noenable_runfiles"],
        allow_failure=True,
    )
    self.assertNotEqual(exit_code, 0)
    exit_code, _, _ = self.RunBazel(
        ["run", ":test", "--nobuild_runfile_links", "--enable_runfiles"]
    )
    self.assertEqual(exit_code, 0)

  def testRunfilesDirectoryIncrementalityNoBuildRunfileLinksEnableRunfilesFlippedOffRun(
      self,
  ):
    self.setUpRunfilesDirectoryIncrementalityTest()

    exit_code, _, _ = self.RunBazel(
        ["run", ":test", "--nobuild_runfile_links", "--enable_runfiles"]
    )
    self.assertEqual(exit_code, 0)
    exit_code, _, _ = self.RunBazel(
        ["run", ":test", "--nobuild_runfile_links", "--noenable_runfiles"],
        allow_failure=True,
    )
    self.assertNotEqual(exit_code, 0)

  def testTestsRunWithNoBuildRunfileLinksAndNoEnableRunfiles(self):
    self.ScratchFile(
        "MODULE.bazel", ['bazel_dep(name = "rules_shell", version = "0.3.0")']
    )
    self.ScratchFile(
        "BUILD",
        [
            'load("@rules_shell//shell:sh_test.bzl", "sh_test")',
            "sh_test(",
            "  name = 'test',",
            "  srcs = ['test.sh'],",
            ")",
        ],
    )
    self.ScratchFile("test.sh", executable=True)
    self.ScratchFile(".bazelrc", ["common --spawn_strategy=local"])
    self.RunBazel(
        ["test", ":test", "--nobuild_runfile_links", "--noenable_runfiles"]
    )

  def testWrappedShBinary(self):
    self.writeWrapperRule()
    self.ScratchFile(
        "MODULE.bazel", ['bazel_dep(name = "rules_shell", version = "0.3.0")']
    )
    self.ScratchFile(
        "BUILD",
        [
            'load("@rules_shell//shell:sh_binary.bzl", "sh_binary")',
            "sh_binary(",
            "  name = 'binary',",
            "  srcs = ['binary.sh'],",
            "  visibility = ['//visibility:public'],",
            ")",
        ],
    )
    self.ScratchFile(
        "binary.sh",
        [
            "echo Hello, World!",
        ],
        executable=True,
    )

    _, stdout, _ = self.RunBazel(["run", "//wrapped"])
    self.assertEqual(stdout, ["Hello, World!"])

  def disabledWrappedPyBinary(self):
    # https://github.com/bazelbuild/rules_python/issues/2250
    # wrapping py_binary fails with rules_python 0.36.0 on Windows
    self.writeWrapperRule()
    self.ScratchFile("MODULE.bazel")
    self.ScratchFile(
        "BUILD",
        [
            'load("@rules_python//python:py_binary.bzl", "py_binary")',
            "py_binary(",
            "  name = 'binary',",
            "  srcs = ['binary.py'],",
            "  visibility = ['//visibility:public'],",
            ")",
        ],
    )
    self.ScratchFile(
        "binary.py",
        [
            "print('Hello, World!')",
        ],
    )

    _, stdout, _ = self.RunBazel(["run", "//wrapped"])
    self.assertEqual(stdout, ["Hello, World!"])

  def testWrappedJavaBinary(self):
    self.writeWrapperRule()
    self.ScratchFile(
        "MODULE.bazel", ['bazel_dep(name = "rules_java", version = "8.12.0")']
    )
    self.ScratchFile(
        "BUILD",
        [
            'load("@rules_java//java:java_binary.bzl", "java_binary")',
            "java_binary(",
            "  name = 'binary',",
            "  srcs = ['Binary.java'],",
            "  main_class = 'Binary',",
            "  visibility = ['//visibility:public'],",
            ")",
        ],
    )
    self.ScratchFile(
        "Binary.java",
        [
            "public class Binary {",
            "  public static void main(String[] args) {",
            '    System.out.println("Hello, World!");',
            "  }",
            "}",
        ],
    )

    _, stdout, _ = self.RunBazel(["run", "//wrapped"])
    self.assertEqual(stdout, ["Hello, World!"])

  def writeWrapperRule(self):
    self.ScratchFile("rules/BUILD")
    self.ScratchFile(
        "rules/wrapper.bzl",
        [
            "def _wrapper_impl(ctx):",
            "    target = ctx.attr.target",
            "    original_executable = (",
            "       target[DefaultInfo].files_to_run.executable)",
            "    executable = ctx.actions.declare_file(",
            "       original_executable.basename)",
            "    ctx.actions.symlink(output = executable,",
            "       target_file = original_executable)",
            "    data_runfiles = ctx.runfiles([executable]).merge(",
            "       target[DefaultInfo].data_runfiles)",
            "    default_runfiles = ctx.runfiles([executable]).merge(",
            "       target[DefaultInfo].default_runfiles)",
            "    return [",
            "        DefaultInfo(",
            "            executable = executable,",
            "            files = target[DefaultInfo].files,",
            "            data_runfiles = data_runfiles,",
            "            default_runfiles = default_runfiles,",
            "        ),    ]",
            "wrapper = rule(",
            "    implementation = _wrapper_impl,",
            "    attrs = {",
            "        'target': attr.label(",
            "            cfg = 'target',",
            "            executable = True,",
            "        ),",
            "    },",
            "    executable = True,",
            ")",
        ],
    )
    self.ScratchFile(
        "wrapped/BUILD",
        [
            "load('//rules:wrapper.bzl', 'wrapper')",
            "wrapper(",
            "  name = 'wrapped',",
            "  target = '//:binary',",
            ")",
        ],
    )


if __name__ == "__main__":
  absltest.main()