scripts/tricium_cargo_clippy_unittest.py

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

"""Unit tests for tricium_cargo_tidy.py."""

import json

from chromite.lib import cros_test_lib
from chromite.scripts import tricium_cargo_clippy


# These test cases were made by:
#   1) modifying trace_events to lint poorly
#   2) running USE="rust_clippy" emerge trace_events
#   3) removing null fields
#   4) replacing strings with shorter test strings
valid_test_cases = {
    json.dumps(
        {
            "reason": "compiler-message",
            "package_id": "pkg 0.1.0 (path+file:///path/to/repo/pkg)",
            "target": {
                "kind": ["lib"],
                "crate_types": ["lib"],
                "name": "trace_events",
                "src_path": "/path/to/repo/pkg/src/main_file",
                "edition": "2018",
                "doctest": True,
                "test": True,
            },
            "message": {
                "rendered": "warning: rendered message 1",
                "children": [
                    {
                        "children": [],
                        "level": "note",
                        "message": "`#[warn(bare_trait_objects)]` message 1",
                        "spans": [],
                    },
                    {
                        "children": [],
                        "level": "help",
                        "message": "sub message 1",
                        "spans": [
                            {
                                "file_name": "src/file_name_1",
                                "byte_end": 7342,
                                "byte_start": 7336,
                                "column_end": 35,
                                "column_start": 29,
                                "is_primary": True,
                                "line_end": 262,
                                "line_start": 262,
                                "suggested_replacement": "dyn Tracer",
                                "suggestion_applicability": "MachineApplicable",
                                "text": [
                                    {
                                        "highlight_end": 35,
                                        "highlight_start": 29,
                                        "text": "highlight 1",
                                    }
                                ],
                            }
                        ],
                    },
                ],
                "code": {"code": "bare_trait_objects"},
                "level": "warning",
                "message": "message 1",
                "spans": [
                    {
                        "byte_end": 7342,
                        "byte_start": 7336,
                        "column_end": 35,
                        "column_start": 29,
                        "file_name": "src/file_name_1",
                        "is_primary": True,
                        "line_end": 262,
                        "line_start": 262,
                        "text": [
                            {
                                "highlight_end": 35,
                                "highlight_start": 29,
                                "text": "highlight 1",
                            }
                        ],
                    }
                ],
            },
        }
    ): {
        "locations": [
            tricium_cargo_clippy.CodeLocation(
                file_path="pkg/src/file_name_1",
                line_start=262,
                line_end=262,
                column_start=29,
                column_end=35,
            )
        ],
        "level": "warning",
        "message": "warning: rendered message 1",
    },
    json.dumps(
        {
            "reason": "compiler-message",
            "package_id": "pkg 1.2.3 (path+file:///path/to/repo/pkg)",
            "target": {
                "kind": ["lib"],
                "crate_types": ["lib"],
                "name": "trace_events",
                "src_path": "/path/to/repo/pkg/src/main",
                "edition": "2018",
                "doctest": True,
                "test": True,
            },
            "message": {
                "rendered": "warning: rendered message 2",
                "children": [
                    {
                        "level": "note",
                        "children": [],
                        "message": "submessage 2.1",
                        "spans": [],
                    },
                    {
                        "level": "help",
                        "children": [],
                        "message": "submessage 2.2",
                        "spans": [],
                    },
                    {
                        "level": "help",
                        "children": [],
                        "message": "submessage 2.3",
                        "spans": [
                            {
                                "file_name": "src/file_name_2",
                                "byte_end": 7342,
                                "byte_start": 7327,
                                "column_end": 35,
                                "column_start": 20,
                                "line_end": 262,
                                "line_start": 262,
                                "is_primary": True,
                                "suggested_replacement": "&Tracer",
                                "suggestion_applicability": "MachineApplicable",
                                "text": [
                                    {
                                        "highlight_end": 35,
                                        "highlight_start": 20,
                                        "text": "highlight 2",
                                    }
                                ],
                            }
                        ],
                    },
                ],
                "code": {"code": "clippy::redundant_static_lifetimes"},
                "level": "warning",
                "message": "message 2",
                "spans": [
                    {
                        "file_name": "src/file_name_2",
                        "byte_end": 7335,
                        "byte_start": 7328,
                        "column_end": 28,
                        "column_start": 21,
                        "line_end": 262,
                        "line_start": 262,
                        "is_primary": True,
                        "text": [
                            {
                                "highlight_end": 28,
                                "highlight_start": 21,
                                "text": "highlight 2",
                            }
                        ],
                    }
                ],
            },
        }
    ): {
        "locations": [
            tricium_cargo_clippy.CodeLocation(
                file_path="pkg/src/file_name_2",
                line_start=262,
                line_end=262,
                column_start=21,
                column_end=28,
            ),
            tricium_cargo_clippy.CodeLocation(
                file_path="pkg/src/file_name_2",
                line_start=262,
                line_end=262,
                column_start=20,
                column_end=35,
            ),
        ],
        "level": "warning",
        "message": "warning: rendered message 2",
    },
    json.dumps(
        {
            "reason": "compiler-message",
            "package_id": "pkg 0.1.0 (path+file:///path/to/repo/pkg)",
            "target": {
                "kind": ["lib"],
                "crate_types": ["lib"],
                "name": "trace_events",
                "src_path": "/path/to/repo/pkg/path/to/main",
                "edition": "2018",
                "doctest": True,
                "test": True,
            },
            "message": {
                "rendered": "warning: rendered message 3",
                "children": [
                    {
                        "children": [],
                        "level": "note",
                        "message": "submessage 3.1",
                        "spans": [],
                    },
                    {
                        "children": [],
                        "level": "help",
                        "message": "submessage 3.2",
                        "spans": [
                            {
                                "file_name": "path/to/file_name_3",
                                "byte_end": 448,
                                "byte_start": 447,
                                "column_end": 8,
                                "column_start": 7,
                                "line_end": 14,
                                "line_start": 14,
                                "is_primary": True,
                                "suggested_replacement": "_x",
                                "suggestion_applicability": "MachineApplicable",
                                "text": [
                                    {
                                        "highlight_end": 8,
                                        "highlight_start": 7,
                                        "text": "highlight 3",
                                    }
                                ],
                            }
                        ],
                    },
                ],
                "code": {"code": "unused_variables"},
                "level": "warning",
                "message": "message 3",
                "spans": [
                    {
                        "file_name": "path/to/file_name_3",
                        "byte_end": 448,
                        "byte_start": 447,
                        "column_end": 8,
                        "column_start": 7,
                        "line_end": 14,
                        "line_start": 14,
                        "is_primary": True,
                        "text": [
                            {
                                "highlight_end": 8,
                                "highlight_start": 7,
                                "text": "highlight 3",
                            }
                        ],
                    }
                ],
            },
        }
    ): {
        "locations": [
            tricium_cargo_clippy.CodeLocation(
                file_path="pkg/path/to/file_name_3",
                line_start=14,
                line_end=14,
                column_start=7,
                column_end=8,
            )
        ],
        "level": "warning",
        "message": "warning: rendered message 3",
    },
    json.dumps({"reason": "build-script-executed"}): {"skipped": True},
    json.dumps({"reason": "compiler-artifact"}): {"skipped": True},
}

invalid_test_cases = {
    "not json": ["json"],
    r"{}": ["reason"],
    json.dumps(
        {
            "reason": "compiler-message",
        }
    ): ["level", "message"],
    json.dumps(
        {
            "reason": "compiler-message",
            "target": {"src_path": "file path"},
            "message": {"rendered": "warning: a message"},
        }
    ): ["level"],
    json.dumps(
        {
            "reason": "compiler-message",
            "level": "warning",
            "target": {"src_path": "file path"},
        }
    ): ["message"],
}

test_git_repo = "/path/to/repo"
test_package_path = "/path/to/repo/pkg"


class TriciumCargoClippyTests(cros_test_lib.LoggingTestCase):
    """Tests for Cargo Clippy."""

    def test_parse_locations(self):
        """Tests that parse_locations is as expected."""
        for test_case, exp_results in valid_test_cases.items():
            if "locations" not in exp_results:
                continue
            test_json = json.loads(test_case)
            locations = list(
                tricium_cargo_clippy.parse_locations(
                    test_json, test_package_path, test_git_repo
                )
            )
            self.assertEqual(locations, exp_results["locations"])

    def test_parse_locations_ebuild_directories(self):
        """Tests that parse_locations strips ebuild work directories."""
        expected_location = "src/foo"
        example_finding = json.dumps(
            {
                "reason": "compiler-message",
                "level": "warning",
                "message": {
                    "rendered": "warning: a message",
                    "spans": [
                        {
                            "file_name": expected_location,
                            "column_end": 1,
                            "column_start": 2,
                            "line_end": 3,
                            "line_start": 4,
                        }
                    ],
                },
            }
        )
        for work_dir in (
            "/build/atlas/tmp/portage/dev-rust/pkg-0.12.3-r3/work/pkg-0.12.3",
            "/build/atlas/tmp/portage/dev-rust/pkg-99999/work/pkg-9999",
        ):
            inputs = [json.dumps({"package_path": work_dir}), example_finding]
            diagnostic = next(
                tricium_cargo_clippy.parse_diagnostics("", inputs, "")
            )
            self.assertEqual(
                next(diagnostic.locations).file_path, expected_location
            )

    def test_parse_level(self):
        """Tests that parse_level is as expected."""
        for i, (test_case, exp_results) in enumerate(valid_test_cases.items()):
            if "level" not in exp_results:
                continue
            test_json = json.loads(test_case)
            level = tricium_cargo_clippy.parse_level("valid", i, test_json)
            self.assertEqual(level, exp_results["level"])

    def test_parse_message(self):
        """Tests that parse_message is as expected."""
        for i, (test_case, exp_results) in enumerate(valid_test_cases.items()):
            if "message" not in exp_results:
                continue
            test_json = json.loads(test_case)
            message = tricium_cargo_clippy.parse_message("valid", i, test_json)
            self.assertEqual(message, exp_results["message"])

    def test_parse_diagnostics(self):
        """Tests that parse_diagnostics yields correct diagnostics."""
        package_path_json = json.dumps({"package_path": test_package_path})
        orig_jsons = [package_path_json] + list(valid_test_cases.keys())
        diags = list(
            tricium_cargo_clippy.parse_diagnostics(
                "valid_test_cases", orig_jsons, test_git_repo
            )
        )

        # Verify parse_diagnostics retrieved correct amount of diagnostics
        exp_len = len(
            [
                values
                for values in valid_test_cases.values()
                if not values.get("skipped")
            ]
        )
        self.assertEqual(len(diags), exp_len)

        # Verify diagnostics are from correct source
        for i, diag in enumerate(diags):
            locations = list(diag.locations)
            expected_locations = list(valid_test_cases.values())[i].get(
                "locations"
            )
            self.assertEqual(locations, expected_locations)

    def test_logs_invalid_parse_diagnostic_cases(self):
        """Tests that parse_diagnostics logs proper exceptions."""
        package_path_json = json.dumps({"package_path": test_package_path})
        for invalid_case, exp_errors in invalid_test_cases.items():
            with self.assertRaises(
                tricium_cargo_clippy.Error,
                msg=f"Expected error parsing {invalid_case} but got none.",
            ) as ctx:
                list(
                    tricium_cargo_clippy.parse_diagnostics(
                        "invalid",
                        [package_path_json, invalid_case],
                        test_git_repo,
                    )
                )
            if "json" in exp_errors:
                exp_error = tricium_cargo_clippy.CargoClippyJSONError(
                    "invalid", 1
                )
            elif "reason" in exp_errors:
                exp_error = tricium_cargo_clippy.CargoClippyReasonError(
                    "invalid", 1
                )
            else:
                for field in ("locations", "level", "message"):
                    if field in exp_errors:
                        exp_error = tricium_cargo_clippy.CargoClippyFieldError(
                            "invalid", 1, field
                        )
                        break
            self.assertIs(type(ctx.exception), type(exp_error))
            self.assertEqual(ctx.exception.args, exp_error.args)

    def test_filter_diagnostics(self):
        file_path = "some_filepath.json"
        example_code_location = tricium_cargo_clippy.CodeLocation(
            file_path=file_path,
            line_start=1,
            line_end=4,
            column_start=0,
            column_end=12,
        )
        accepted_diags = [
            tricium_cargo_clippy.ClippyDiagnostic(
                locations=[example_code_location],
                level="warning",
                message="warning: be warned.",
            )
        ]
        ignored_diags = [
            # "aborting due to previous error" messages
            tricium_cargo_clippy.ClippyDiagnostic(
                locations=[example_code_location],
                level="warning",
                message="warning: aborting due to previous error...",
            ),
            # No locations provided
            tricium_cargo_clippy.ClippyDiagnostic(
                locations=[],
                level="warning",
                message="warning: 6 warnings emitted.",
            ),
        ]
        filtered_diags = list(
            tricium_cargo_clippy.filter_diagnostics(
                accepted_diags + ignored_diags
            )
        )
        self.assertEqual(filtered_diags, accepted_diags)