| # pylint: disable=g-bad-file-header |
| # Copyright 2018 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 |
| import tempfile |
| import unittest |
| |
| from tools.python.runfiles import runfiles |
| |
| |
| class RunfilesTest(unittest.TestCase): |
| # """Unit tests for `runfiles.Runfiles`.""" |
| |
| def testRlocationArgumentValidation(self): |
| r = runfiles.Create({"RUNFILES_DIR": "whatever"}) |
| self.assertRaises(ValueError, lambda: r.Rlocation(None)) |
| self.assertRaises(ValueError, lambda: r.Rlocation("")) |
| self.assertRaises(TypeError, lambda: r.Rlocation(1)) |
| self.assertRaisesRegexp(ValueError, "is not normalized", |
| lambda: r.Rlocation("../foo")) |
| self.assertRaisesRegexp(ValueError, "is not normalized", |
| lambda: r.Rlocation("foo/..")) |
| self.assertRaisesRegexp(ValueError, "is not normalized", |
| lambda: r.Rlocation("foo/../bar")) |
| self.assertRaisesRegexp(ValueError, "is not normalized", |
| lambda: r.Rlocation("./foo")) |
| self.assertRaisesRegexp(ValueError, "is not normalized", |
| lambda: r.Rlocation("foo/.")) |
| self.assertRaisesRegexp(ValueError, "is not normalized", |
| lambda: r.Rlocation("foo/./bar")) |
| self.assertRaisesRegexp(ValueError, "is not normalized", |
| lambda: r.Rlocation("//foobar")) |
| self.assertRaisesRegexp(ValueError, "is not normalized", |
| lambda: r.Rlocation("foo//")) |
| self.assertRaisesRegexp(ValueError, "is not normalized", |
| lambda: r.Rlocation("foo//bar")) |
| self.assertRaisesRegexp(ValueError, "is absolute without a drive letter", |
| lambda: r.Rlocation("\\foo")) |
| |
| def testCreatesManifestBasedRunfiles(self): |
| with _MockFile(contents=["a/b c/d"]) as mf: |
| r = runfiles.Create({ |
| "RUNFILES_MANIFEST_FILE": mf.Path(), |
| "RUNFILES_DIR": "ignored when RUNFILES_MANIFEST_FILE has a value", |
| "TEST_SRCDIR": "always ignored", |
| }) |
| self.assertEqual(r.Rlocation("a/b"), "c/d") |
| self.assertIsNone(r.Rlocation("foo")) |
| |
| def testManifestBasedRunfilesEnvVars(self): |
| with _MockFile(name="MANIFEST") as mf: |
| r = runfiles.Create({ |
| "RUNFILES_MANIFEST_FILE": mf.Path(), |
| "TEST_SRCDIR": "always ignored", |
| }) |
| self.assertDictEqual( |
| r.EnvVars(), { |
| "RUNFILES_MANIFEST_FILE": mf.Path(), |
| "RUNFILES_DIR": mf.Path()[:-len("/MANIFEST")], |
| "JAVA_RUNFILES": mf.Path()[:-len("/MANIFEST")], |
| }) |
| |
| with _MockFile(name="foo.runfiles_manifest") as mf: |
| r = runfiles.Create({ |
| "RUNFILES_MANIFEST_FILE": mf.Path(), |
| "TEST_SRCDIR": "always ignored", |
| }) |
| self.assertDictEqual( |
| r.EnvVars(), { |
| "RUNFILES_MANIFEST_FILE": |
| mf.Path(), |
| "RUNFILES_DIR": ( |
| mf.Path()[:-len("foo.runfiles_manifest")] + "foo.runfiles"), |
| "JAVA_RUNFILES": ( |
| mf.Path()[:-len("foo.runfiles_manifest")] + "foo.runfiles"), |
| }) |
| |
| with _MockFile(name="x_manifest") as mf: |
| r = runfiles.Create({ |
| "RUNFILES_MANIFEST_FILE": mf.Path(), |
| "TEST_SRCDIR": "always ignored", |
| }) |
| self.assertDictEqual( |
| r.EnvVars(), { |
| "RUNFILES_MANIFEST_FILE": mf.Path(), |
| "RUNFILES_DIR": "", |
| "JAVA_RUNFILES": "", |
| }) |
| |
| def testCreatesDirectoryBasedRunfiles(self): |
| r = runfiles.Create({ |
| "RUNFILES_DIR": "runfiles/dir", |
| "TEST_SRCDIR": "always ignored", |
| }) |
| self.assertEqual(r.Rlocation("a/b"), "runfiles/dir/a/b") |
| self.assertEqual(r.Rlocation("foo"), "runfiles/dir/foo") |
| |
| def testDirectoryBasedRunfilesEnvVars(self): |
| r = runfiles.Create({ |
| "RUNFILES_DIR": "runfiles/dir", |
| "TEST_SRCDIR": "always ignored", |
| }) |
| self.assertDictEqual(r.EnvVars(), { |
| "RUNFILES_DIR": "runfiles/dir", |
| "JAVA_RUNFILES": "runfiles/dir", |
| }) |
| |
| def testFailsToCreateManifestBasedBecauseManifestDoesNotExist(self): |
| |
| def _Run(): |
| runfiles.Create({"RUNFILES_MANIFEST_FILE": "non-existing path"}) |
| |
| self.assertRaisesRegexp(IOError, "non-existing path", _Run) |
| |
| def testFailsToCreateAnyRunfilesBecauseEnvvarsAreNotDefined(self): |
| with _MockFile(contents=["a b"]) as mf: |
| runfiles.Create({ |
| "RUNFILES_MANIFEST_FILE": mf.Path(), |
| "RUNFILES_DIR": "whatever", |
| "TEST_SRCDIR": "always ignored", |
| }) |
| runfiles.Create({ |
| "RUNFILES_DIR": "whatever", |
| "TEST_SRCDIR": "always ignored", |
| }) |
| self.assertIsNone(runfiles.Create({"TEST_SRCDIR": "always ignored"})) |
| self.assertIsNone(runfiles.Create({"FOO": "bar"})) |
| |
| def testManifestBasedRlocation(self): |
| with _MockFile(contents=[ |
| "Foo/runfile1", "Foo/runfile2 C:/Actual Path\\runfile2", |
| "Foo/Bar/runfile3 D:\\the path\\run file 3.txt" |
| ]) as mf: |
| r = runfiles.CreateManifestBased(mf.Path()) |
| self.assertEqual(r.Rlocation("Foo/runfile1"), "Foo/runfile1") |
| self.assertEqual(r.Rlocation("Foo/runfile2"), "C:/Actual Path\\runfile2") |
| self.assertEqual( |
| r.Rlocation("Foo/Bar/runfile3"), "D:\\the path\\run file 3.txt") |
| self.assertIsNone(r.Rlocation("unknown")) |
| if RunfilesTest.IsWindows(): |
| self.assertEqual(r.Rlocation("c:/foo"), "c:/foo") |
| self.assertEqual(r.Rlocation("c:\\foo"), "c:\\foo") |
| else: |
| self.assertEqual(r.Rlocation("/foo"), "/foo") |
| |
| def testDirectoryBasedRlocation(self): |
| # The _DirectoryBased strategy simply joins the runfiles directory and the |
| # runfile's path on a "/". This strategy does not perform any normalization, |
| # nor does it check that the path exists. |
| r = runfiles.CreateDirectoryBased("foo/bar baz//qux/") |
| self.assertEqual(r.Rlocation("arg"), "foo/bar baz//qux/arg") |
| if RunfilesTest.IsWindows(): |
| self.assertEqual(r.Rlocation("c:/foo"), "c:/foo") |
| self.assertEqual(r.Rlocation("c:\\foo"), "c:\\foo") |
| else: |
| self.assertEqual(r.Rlocation("/foo"), "/foo") |
| |
| def testPathsFromEnvvars(self): |
| # Both envvars have a valid value. |
| mf, dr = runfiles._PathsFrom("argv0", "mock1/MANIFEST", "mock2", |
| lambda path: path == "mock1/MANIFEST", |
| lambda path: path == "mock2") |
| self.assertEqual(mf, "mock1/MANIFEST") |
| self.assertEqual(dr, "mock2") |
| |
| # RUNFILES_MANIFEST_FILE is invalid but RUNFILES_DIR is good and there's a |
| # runfiles manifest in the runfiles directory. |
| mf, dr = runfiles._PathsFrom("argv0", "mock1/MANIFEST", "mock2", |
| lambda path: path == "mock2/MANIFEST", |
| lambda path: path == "mock2") |
| self.assertEqual(mf, "mock2/MANIFEST") |
| self.assertEqual(dr, "mock2") |
| |
| # RUNFILES_MANIFEST_FILE is invalid but RUNFILES_DIR is good, but there's no |
| # runfiles manifest in the runfiles directory. |
| mf, dr = runfiles._PathsFrom("argv0", "mock1/MANIFEST", "mock2", |
| lambda path: False, |
| lambda path: path == "mock2") |
| self.assertEqual(mf, "") |
| self.assertEqual(dr, "mock2") |
| |
| # RUNFILES_DIR is invalid but RUNFILES_MANIFEST_FILE is good, and it is in |
| # a valid-looking runfiles directory. |
| mf, dr = runfiles._PathsFrom("argv0", "mock1/MANIFEST", "mock2", |
| lambda path: path == "mock1/MANIFEST", |
| lambda path: path == "mock1") |
| self.assertEqual(mf, "mock1/MANIFEST") |
| self.assertEqual(dr, "mock1") |
| |
| # RUNFILES_DIR is invalid but RUNFILES_MANIFEST_FILE is good, but it is not |
| # in any valid-looking runfiles directory. |
| mf, dr = runfiles._PathsFrom("argv0", "mock1/MANIFEST", "mock2", |
| lambda path: path == "mock1/MANIFEST", |
| lambda path: False) |
| self.assertEqual(mf, "mock1/MANIFEST") |
| self.assertEqual(dr, "") |
| |
| # Both envvars are invalid, but there's a manifest in a runfiles directory |
| # next to argv0, however there's no other content in the runfiles directory. |
| mf, dr = runfiles._PathsFrom("argv0", "mock1/MANIFEST", "mock2", |
| lambda path: path == "argv0.runfiles/MANIFEST", |
| lambda path: False) |
| self.assertEqual(mf, "argv0.runfiles/MANIFEST") |
| self.assertEqual(dr, "") |
| |
| # Both envvars are invalid, but there's a manifest next to argv0. There's |
| # no runfiles tree anywhere. |
| mf, dr = runfiles._PathsFrom("argv0", "mock1/MANIFEST", "mock2", |
| lambda path: path == "argv0.runfiles_manifest", |
| lambda path: False) |
| self.assertEqual(mf, "argv0.runfiles_manifest") |
| self.assertEqual(dr, "") |
| |
| # Both envvars are invalid, but there's a valid manifest next to argv0, and |
| # a valid runfiles directory (without a manifest in it). |
| mf, dr = runfiles._PathsFrom("argv0", "mock1/MANIFEST", "mock2", |
| lambda path: path == "argv0.runfiles_manifest", |
| lambda path: path == "argv0.runfiles") |
| self.assertEqual(mf, "argv0.runfiles_manifest") |
| self.assertEqual(dr, "argv0.runfiles") |
| |
| # Both envvars are invalid, but there's a valid runfiles directory next to |
| # argv0, though no manifest in it. |
| mf, dr = runfiles._PathsFrom("argv0", "mock1/MANIFEST", "mock2", |
| lambda path: False, |
| lambda path: path == "argv0.runfiles") |
| self.assertEqual(mf, "") |
| self.assertEqual(dr, "argv0.runfiles") |
| |
| # Both envvars are invalid, but there's a valid runfiles directory next to |
| # argv0 with a valid manifest in it. |
| mf, dr = runfiles._PathsFrom("argv0", "mock1/MANIFEST", "mock2", |
| lambda path: path == "argv0.runfiles/MANIFEST", |
| lambda path: path == "argv0.runfiles") |
| self.assertEqual(mf, "argv0.runfiles/MANIFEST") |
| self.assertEqual(dr, "argv0.runfiles") |
| |
| # Both envvars are invalid and there's no runfiles directory or manifest |
| # next to the argv0. |
| mf, dr = runfiles._PathsFrom("argv0", "mock1/MANIFEST", "mock2", |
| lambda path: False, lambda path: False) |
| self.assertEqual(mf, "") |
| self.assertEqual(dr, "") |
| |
| @staticmethod |
| def IsWindows(): |
| return os.name == "nt" |
| |
| |
| class _MockFile(object): |
| |
| def __init__(self, name=None, contents=None): |
| self._contents = contents or [] |
| self._name = name or "x" |
| self._path = None |
| |
| def __enter__(self): |
| tmpdir = os.environ.get("TEST_TMPDIR") |
| self._path = os.path.join(tempfile.mkdtemp(dir=tmpdir), self._name) |
| with open(self._path, "wt") as f: |
| f.writelines(l + "\n" for l in self._contents) |
| return self |
| |
| def __exit__(self, exc_type, exc_value, traceback): |
| os.remove(self._path) |
| os.rmdir(os.path.dirname(self._path)) |
| |
| def Path(self): |
| return self._path |
| |
| |
| if __name__ == "__main__": |
| unittest.main() |
