# pylint: disable=g-bad-file-header # Copyright 2019 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. from __future__ import print_function import os import subprocess import textwrap import unittest from src.test.py.bazel import test_base class MockPythonLines(object): NORMAL = textwrap.dedent(r"""\ if [ "$1" = "-V" ]; then echo "Mock Python 2.xyz!" else echo "I am mock Python!" fi """).split("\n") FAIL = textwrap.dedent(r"""\ echo "Mock failure!" exit 1 """).split("\n") WRONG_VERSION = textwrap.dedent(r"""\ if [ "$1" = "-V" ]; then echo "Mock Python 3.xyz!" else echo "I am mock Python!" fi """).split("\n") VERSION_ERROR = textwrap.dedent(r"""\ if [ "$1" = "-V" ]; then echo "Error!" exit 1 else echo "I am mock Python!" fi """).split("\n") # TODO(brandjon): Switch to shutil.which when the test is moved to PY3. def which(cmd): """A poor man's approximation of `shutil.which()` or the `which` command. Args: cmd: The command (executable) name to lookup; should not contain path separators Returns: The absolute path to the first match in PATH, or None if not found. """ for p in os.environ["PATH"].split(os.pathsep): fullpath = os.path.abspath(os.path.join(p, cmd)) if os.path.exists(fullpath): return fullpath return None # TODO(brandjon): Move this test to PY3. Blocked (ironically!) on the fix for # #4815 being available in the host version of Bazel used to run this test. class PywrapperTest(test_base.TestBase): """Unit tests for pywrapper_template.txt. These tests are based on the instantiation of the template for Python 2. They ensure that the wrapper can locate, validate, and launch a Python 2 executable on PATH. To ensure hermeticity, the tests launch the wrapper with PATH restricted to the scratch directory. Unix only. """ def setup_tool(self, cmd): """Copies a command from its system location to the test directory.""" path = which(cmd) self.assertIsNotNone( path, msg="Could not locate '%s' command on PATH" % cmd) self.CopyFile(path, os.path.join("dir", cmd), executable=True) def locate_runfile(self, runfile_path): resolved_path = self.Rlocation(runfile_path) self.assertIsNotNone( resolved_path, msg="Could not locate %s in runfiles" % runfile_path) return resolved_path def setUp(self): super(PywrapperTest, self).setUp() # Locate scripts under test. self.wrapper_path = \ self.locate_runfile("io_bazel/tools/python/py2wrapper.sh") self.nonstrict_wrapper_path = \ self.locate_runfile("io_bazel/tools/python/py2wrapper_nonstrict.sh") # Setup scratch directory with all executables the script depends on. # # This is brittle, but we need to make sure we can run the script when only # the scratch directory is on PATH, so that we can control whether or not # the python executables exist on PATH. self.setup_tool("which") self.setup_tool("echo") self.setup_tool("grep") def run_with_restricted_path(self, program, title_for_logging=None): new_env = dict(os.environ) new_env["PATH"] = self.Path("dir") proc = subprocess.Popen([program], stdout=subprocess.PIPE, stderr=subprocess.PIPE, universal_newlines=True, cwd=self.Path("dir"), env=new_env) # TODO(brandjon): Add a timeout arg here when upgraded to PY3. out, err = proc.communicate() if title_for_logging is not None: print(textwrap.dedent("""\ ---------------- %s Exit code: %d stdout: %s stderr: %s ---------------- """) % (title_for_logging, proc.returncode, out, err)) return proc.returncode, out, err def run_wrapper(self, title_for_logging): return self.run_with_restricted_path(self.wrapper_path, title_for_logging) def run_nonstrict_wrapper(self, title_for_logging): return self.run_with_restricted_path(self.nonstrict_wrapper_path, title_for_logging) def assert_wrapper_success(self, returncode, out, err): self.assertEqual(returncode, 0, msg="Expected to exit without error") self.assertEqual( out, "I am mock Python!\n", msg="stdout was not as expected") self.assertEqual(err, "", msg="Expected to produce no stderr output") def assert_wrapper_failure(self, returncode, out, err, message): self.assertEqual(returncode, 1, msg="Expected to exit with error code 1") self.assertRegexpMatches( err, message, msg="stderr did not contain expected string") def test_finds_python2(self): self.ScratchFile("dir/python2", MockPythonLines.NORMAL, executable=True) returncode, out, err = self.run_wrapper("test_finds_python2") self.assert_wrapper_success(returncode, out, err) def test_finds_python(self): self.ScratchFile("dir/python", MockPythonLines.NORMAL, executable=True) returncode, out, err = self.run_wrapper("test_finds_python") self.assert_wrapper_success(returncode, out, err) def test_prefers_python2(self): self.ScratchFile("dir/python2", MockPythonLines.NORMAL, executable=True) self.ScratchFile("dir/python", MockPythonLines.FAIL, executable=True) returncode, out, err = self.run_wrapper("test_prefers_python2") self.assert_wrapper_success(returncode, out, err) def test_no_interpreter_found(self): returncode, out, err = self.run_wrapper("test_no_interpreter_found") self.assert_wrapper_failure(returncode, out, err, "Neither 'python2' nor 'python' were found") def test_wrong_version(self): self.ScratchFile( "dir/python2", MockPythonLines.WRONG_VERSION, executable=True) returncode, out, err = self.run_wrapper("test_wrong_version") self.assert_wrapper_failure( returncode, out, err, "version is 'Mock Python 3.xyz!', but we need version 2") def test_error_getting_version(self): self.ScratchFile( "dir/python2", MockPythonLines.VERSION_ERROR, executable=True) returncode, out, err = self.run_wrapper("test_error_getting_version") self.assert_wrapper_failure(returncode, out, err, "Could not get interpreter version") def test_interpreter_not_executable(self): self.ScratchFile( "dir/python2", MockPythonLines.VERSION_ERROR, executable=False) returncode, out, err = self.run_wrapper("test_interpreter_not_executable") self.assert_wrapper_failure(returncode, out, err, "Neither 'python2' nor 'python' were found") def test_wrong_version_ok_for_nonstrict(self): self.ScratchFile( "dir/python2", MockPythonLines.WRONG_VERSION, executable=True) returncode, out, err = \ self.run_nonstrict_wrapper("test_wrong_version_ok_for_nonstrict") self.assert_wrapper_success(returncode, out, err) if __name__ == "__main__": unittest.main()