build/rbe/relativize_args_test.py

#!/usr/bin/env fuchsia-vendored-python
# 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 os
import unittest
from pathlib import Path
from unittest import mock

import relativize_args


class SplitTransformJoinTest(unittest.TestCase):
    def test_no_change(self):
        self.assertEqual(
            relativize_args.split_transform_join("text", "=", lambda x: x),
            "text",
        )

    def test_repeat(self):
        self.assertEqual(
            relativize_args.split_transform_join("text", "=", lambda x: x + x),
            "texttext",
        )

    def test_with_split(self):
        self.assertEqual(
            relativize_args.split_transform_join("a=b", "=", lambda x: x + x),
            "aa=bb",
        )

    def test_with_split_recorded(self):
        renamed_tokens = {}

        def recorded_transform(x):
            new_text = x + x
            renamed_tokens[x] = new_text
            return new_text

        self.assertEqual(
            relativize_args.split_transform_join(
                "a=b", "=", recorded_transform
            ),
            "aa=bb",
        )
        self.assertEqual(renamed_tokens, {"a": "aa", "b": "bb"})


class LexicallyRewriteTokenTest(unittest.TestCase):
    def test_repeat_text(self):
        self.assertEqual(
            relativize_args.lexically_rewrite_token("foo", lambda x: x + x),
            "foofoo",
        )

    def test_delimters_only(self):
        self.assertEqual(
            relativize_args.lexically_rewrite_token(
                ",,==,=,=,", lambda x: x + x
            ),
            ",,==,=,=,",
        )

    def test_flag_with_value(self):
        def transform(x):
            if x.startswith("file"):
                return "tmp-" + x
            else:
                return x

        self.assertEqual(
            relativize_args.lexically_rewrite_token("--foo=file1", transform),
            "--foo=tmp-file1",
        )
        self.assertEqual(
            relativize_args.lexically_rewrite_token(
                "notfile,file1,file2,notfile", transform
            ),
            "notfile,tmp-file1,tmp-file2,notfile",
        )
        self.assertEqual(
            relativize_args.lexically_rewrite_token(
                "--foo=file1,file2", transform
            ),
            "--foo=tmp-file1,tmp-file2",
        )


class GreatestPathParentTest(unittest.TestCase):
    def test_one_component(self):
        self.assertEqual(
            relativize_args.greatest_path_parent(Path("/root")), Path("/root")
        )

    def test_multiple_components(self):
        self.assertEqual(
            relativize_args.greatest_path_parent(
                Path("/root/for/the/home/team")
            ),
            Path("/root"),
        )


class RelativizePathTest(unittest.TestCase):
    def test_abspath(self):
        with mock.patch.object(
            Path, "exists", return_value=True
        ) as mock_exists:
            self.assertEqual(
                relativize_args.relativize_path("/a/b/c", Path("/a/d")),
                "../b/c",
            )
        mock_exists.assert_called_with()

    def test_relpath(self):
        with mock.patch.object(
            Path, "exists", return_value=True
        ) as mock_exists:
            self.assertEqual(
                relativize_args.relativize_path("x/y/z", Path("/a/d")), "x/y/z"
            )
        mock_exists.assert_not_called()  # no absolute path in arg

    def test_cxx_Iflag(self):
        with mock.patch.object(
            Path, "exists", return_value=True
        ) as mock_exists:
            self.assertEqual(
                relativize_args.relativize_path("-I/j/k", Path("/j/a/d")),
                "-I../../k",
            )
        mock_exists.assert_called_with()

    def test_cxx_Lflag(self):
        with mock.patch.object(
            Path, "exists", return_value=True
        ) as mock_exists:
            self.assertEqual(
                relativize_args.relativize_path("-L/p/q/r", Path("/p/q/z")),
                "-L../r",
            )
        mock_exists.assert_called_with()

    def test_cxx_isystemflag(self):
        with mock.patch.object(
            Path, "exists", return_value=True
        ) as mock_exists:
            self.assertEqual(
                relativize_args.relativize_path(
                    "-isystem/r/s/t", Path("/r/v/w")
                ),
                "-isystem../../s/t",
            )
        mock_exists.assert_called_with()

    def test_windows_style_flag(self):
        with mock.patch.object(
            Path, "exists", return_value=False
        ) as mock_exists:
            self.assertEqual(
                relativize_args.relativize_path("/Foo", Path("/p/q/z")), "/Foo"
            )
        mock_exists.assert_called_with()


class RelativizeCommandTest(unittest.TestCase):
    def test_no_transform(self):
        with mock.patch.object(
            Path, "exists", return_value=True
        ) as mock_exists:
            self.assertEqual(
                relativize_args.relativize_command(
                    ["echo", "hello"], Path("/home/sweet/home")
                ),
                ["echo", "hello"],
            )
        mock_exists.assert_not_called()  # nothing looks like an absolute path

    def test_with_env(self):
        with mock.patch.object(
            Path, "exists", return_value=True
        ) as mock_exists:
            self.assertEqual(
                relativize_args.relativize_command(
                    ["HOME=/home", "echo"], Path("/home/subdir")
                ),
                ["/usr/bin/env", "HOME=..", "echo"],
            )
        mock_exists.assert_called_with()

    def test_relativize(self):
        with mock.patch.object(
            Path, "exists", return_value=True
        ) as mock_exists:
            self.assertEqual(
                relativize_args.relativize_command(
                    ["cat", "/meow/foo.txt"], Path("/meow/subdir")
                ),
                ["cat", "../foo.txt"],
            )
        mock_exists.assert_called_with()


class MainArgParserTest(unittest.TestCase):
    def test_no_flags(self):
        parser = relativize_args.main_arg_parser()
        args = parser.parse_args([])
        self.assertFalse(args.verbose)
        self.assertFalse(args.dry_run)
        self.assertTrue(args.enable)

    def test_verbose(self):
        parser = relativize_args.main_arg_parser()
        args = parser.parse_args(["--verbose"])
        self.assertTrue(args.verbose)

    def test_dry_run(self):
        parser = relativize_args.main_arg_parser()
        args = parser.parse_args(["--dry-run"])
        self.assertTrue(args.dry_run)

    def test_disable(self):
        parser = relativize_args.main_arg_parser()
        args = parser.parse_args(["--disable"])
        self.assertFalse(args.enable)

    def test_cwd(self):
        parser = relativize_args.main_arg_parser()
        args = parser.parse_args(["--cwd", "/home/foo"])
        self.assertEqual(args.cwd, Path("/home/foo"))

    def test_command(self):
        parser = relativize_args.main_arg_parser()
        args = parser.parse_args(["--", "echo", "bye"])
        self.assertEqual(args.command, ["echo", "bye"])


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