# Copyright 2025 The Chromium Authors
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.
"""Tests for resultdb tools."""

import json
import os
import pathlib
import subprocess
import sys
import unittest
from unittest import mock

sys.path.insert(
    0,
    os.path.abspath(
        pathlib.Path(__file__)
        .resolve()
        .parent.parent.joinpath(pathlib.Path("infra_lib"))
    ),
)
import requests

import resultdb


class GetNonExoneratedUnexpectedResultsFromBuildTest(
    unittest.IsolatedAsyncioTestCase
):
    def setUp(self):
        self.mock_context = mock.AsyncMock()
        self.mock_context.info = mock.AsyncMock()

    @mock.patch("subprocess.run")
    async def test_get_non_exonerated_unexpected_results_from_build_success(
        self, mock_subprocess_run
    ):
        build_id = "12345"
        expected_output = '{"testResults": []}'
        mock_subprocess_run.return_value = subprocess.CompletedProcess(
            args=[],
            returncode=0,
            stdout=expected_output,
            stderr="",
        )

        output = await (
            resultdb.get_non_exonerated_unexpected_results_from_build(
                self.mock_context,
                build_id,
            )
        )

        self.assertEqual(output, expected_output)
        expected_command = [
            "prpc",
            "call",
            "results.api.luci.app",
            "luci.resultdb.v1.ResultDB.QueryTestResults",
        ]
        expected_request = {
            "invocations": [
                "invocations/build-12345",
            ],
            "predicate": {
                "expectancy": "VARIANTS_WITH_UNEXPECTED_RESULTS",
                "exclude_exonerated": True,
            },
            "read_mask": (
                "name,resultId,variant,status,statusV2,duration,"
                "failureReason,summary_html"
            ),
        }
        mock_subprocess_run.assert_called_once_with(
            expected_command,
            capture_output=True,
            input=json.dumps(expected_request),
            check=True,
            text=True,
        )

    @mock.patch("subprocess.run")
    async def test_get_non_exonerated_unexpected_results_from_build_exception(
        self, mock_subprocess_run
    ):
        build_id = "12345"
        mock_subprocess_run.side_effect = Exception("PRPC call failed")

        with self.assertRaisesRegex(Exception, "PRPC call failed"):
            await resultdb.get_non_exonerated_unexpected_results_from_build(
                self.mock_context, build_id
            )

    async def test_get_non_exonerated_unexpected_results_from_build_invalid_id(
        self,
    ):
        with self.assertRaisesRegex(
            ValueError,
            "Provided build_id b-12345 contains non-numeric characters",
        ):
            await resultdb.get_non_exonerated_unexpected_results_from_build(
                self.mock_context, "b-12345"
            )


class ExpandSummaryHtmlTest(unittest.IsolatedAsyncioTestCase):
    def setUp(self):
        self.mock_context = mock.AsyncMock()

    @mock.patch(
        "resultdb.get_test_level_text_artifact", new_callable=mock.AsyncMock
    )
    async def test_expand_summary_html_success(self, mock_get_artifact):
        result_name = "invocations/build-123/tests/test_id/results/result_id"
        summary_html = (
            "<p>Failure</p><text-artifact "
            'artifact-id="artifact1"></text-artifact>'
        )
        artifact_content = "Detailed failure log."
        mock_get_artifact.return_value = artifact_content

        expanded_html = await resultdb.expand_summary_html(
            self.mock_context, result_name, summary_html
        )

        mock_get_artifact.assert_called_once_with(
            self.mock_context, result_name, "artifact1"
        )
        self.assertEqual(expanded_html, f"<p>Failure</p>{artifact_content}")

    async def test_expand_summary_html_no_artifacts(self):
        result_name = "invocations/build-123/tests/test_id/results/result_id"
        summary_html = "<p>Just a regular summary.</p>"

        expanded_html = await resultdb.expand_summary_html(
            self.mock_context, result_name, summary_html
        )

        self.assertEqual(expanded_html, summary_html)

    @mock.patch(
        "resultdb.get_test_level_text_artifact", new_callable=mock.AsyncMock
    )
    async def test_expand_summary_html_missing_artifact_id(
        self, mock_get_artifact
    ):
        result_name = "invocations/build-123/tests/test_id/results/result_id"
        summary_html = "<p>Failure</p><text-artifact></text-artifact>"

        expanded_html = await resultdb.expand_summary_html(
            self.mock_context, result_name, summary_html
        )

        mock_get_artifact.assert_not_called()
        self.assertEqual(
            expanded_html, "<p>Failure</p><text-artifact></text-artifact>"
        )


class GetTestLevelTextArtifactTest(unittest.IsolatedAsyncioTestCase):
    def setUp(self):
        self.mock_context = mock.AsyncMock()
        self.mock_context.info = mock.AsyncMock()

    @mock.patch("requests.get")
    @mock.patch("subprocess.run")
    async def test_get_test_level_text_artifact_success(
        self, mock_subprocess_run, mock_requests_get
    ):
        result_name = "invocations/build-123/tests/test_id/results/result_id"
        artifact_id = "artifact1"
        fetch_url = "https://example.com/artifact1"
        artifact_content = "This is the artifact content."

        mock_subprocess_run.return_value = subprocess.CompletedProcess(
            args=[],
            returncode=0,
            stdout=json.dumps(
                {"fetchUrl": fetch_url, "contentType": "text/plain"}
            ),
            stderr="",
        )
        mock_response = mock.MagicMock()
        mock_response.text = artifact_content
        mock_response.raise_for_status = mock.MagicMock()
        mock_requests_get.return_value = mock_response

        content = await resultdb.get_test_level_text_artifact(
            self.mock_context, result_name, artifact_id
        )

        self.assertEqual(content, artifact_content)
        expected_command = [
            "prpc",
            "call",
            "results.api.luci.app",
            "luci.resultdb.v1.ResultDB.GetArtifact",
        ]
        expected_artifact_name = (
            "invocations/build-123/tests/test_id/results/result_id/artifacts/"
            "artifact1"
        )
        expected_request = {"name": expected_artifact_name}
        mock_subprocess_run.assert_called_once_with(
            expected_command,
            capture_output=True,
            input=json.dumps(expected_request),
            check=True,
            text=True,
        )
        mock_requests_get.assert_called_once_with(fetch_url)
        mock_response.raise_for_status.assert_called_once()

    @mock.patch("subprocess.run")
    async def test_get_test_level_text_artifact_prpc_exception(
        self, mock_subprocess_run
    ):
        result_name = "invocations/build-123/tests/test_id/results/result_id"
        artifact_id = "artifact1"
        mock_subprocess_run.side_effect = Exception("PRPC call failed")

        with self.assertRaisesRegex(Exception, "PRPC call failed"):
            await resultdb.get_test_level_text_artifact(
                self.mock_context, result_name, artifact_id
            )

    @mock.patch("subprocess.run")
    async def test_get_test_level_text_artifact_wrong_content_type(
        self, mock_subprocess_run
    ):
        result_name = "invocations/build-123/tests/test_id/results/result_id"
        artifact_id = "artifact1"
        fetch_url = "https://example.com/artifact1"

        mock_subprocess_run.return_value = subprocess.CompletedProcess(
            args=[],
            returncode=0,
            stdout=json.dumps(
                {
                    "fetchUrl": fetch_url,
                    "contentType": "application/octet-stream",
                }
            ),
            stderr="",
        )

        with self.assertRaisesRegex(
            ValueError,
            (
                "Expected text artifact, got content type "
                "application/octet-stream"
            ),
        ):
            await resultdb.get_test_level_text_artifact(
                self.mock_context, result_name, artifact_id
            )

    @mock.patch("requests.get")
    @mock.patch("subprocess.run")
    async def test_get_test_level_text_artifact_fetch_fails(
        self, mock_subprocess_run, mock_requests_get
    ):
        result_name = "invocations/build-123/tests/test_id/results/result_id"
        artifact_id = "artifact1"
        fetch_url = "https://example.com/artifact1"

        mock_subprocess_run.return_value = subprocess.CompletedProcess(
            args=[],
            returncode=0,
            stdout=json.dumps(
                {"fetchUrl": fetch_url, "contentType": "text/plain"}
            ),
            stderr="",
        )
        mock_response = mock.MagicMock()
        mock_response.raise_for_status.side_effect = (
            requests.exceptions.HTTPError("404 Not Found")
        )
        mock_requests_get.return_value = mock_response

        with self.assertRaises(requests.exceptions.HTTPError):
            await resultdb.get_test_level_text_artifact(
                self.mock_context, result_name, artifact_id
            )


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