test_env.py

"""Test the get_env_vars function"""

import os
import unittest
from unittest.mock import patch

from env import get_env_vars, get_int_env_var

BODY = "Consider these updates to the CODEOWNERS file to remove users no longer in this organization."
COMMIT_MESSAGE = "Remove users no longer in this organization from CODEOWNERS file"
ORGANIZATION = "Organization01"
TITLE = "Clean up CODEOWNERS file"
TOKEN = "Token01"


class TestEnv(unittest.TestCase):
    """Test the get_env_vars function"""

    def setUp(self):
        env_keys = [
            "BODY",
            "COMMIT_MESSAGE",
            "DRY_RUN",
            "ENABLE_GITHUB_ACTIONS_STEP_SUMMARY",
            "EXEMPT_REPOS",
            "GH_APP_ID",
            "GH_ENTERPRISE_URL",
            "GH_APP_INSTALLATION_ID",
            "GH_APP_PRIVATE_KEY",
            "GH_TOKEN",
            "ORGANIZATION",
            "REPOSITORY",
            "TITLE",
            "ISSUE_REPORT",
        ]
        for key in env_keys:
            if key in os.environ:
                del os.environ[key]

    @patch.dict(
        os.environ,
        {
            "BODY": BODY,
            "COMMIT_MESSAGE": COMMIT_MESSAGE,
            "DRY_RUN": "false",
            "EXEMPT_REPOS": "repo4,repo5",
            "GH_APP_ID": "",
            "GH_ENTERPRISE_URL": "",
            "GH_APP_INSTALLATION_ID": "",
            "GH_APP_PRIVATE_KEY": "",
            "GH_TOKEN": TOKEN,
            "ORGANIZATION": ORGANIZATION,
            "REPOSITORY": "org/repo1,org2/repo2",
            "TITLE": TITLE,
        },
    )
    def test_get_env_vars_with_org(self):
        """Test that all environment variables are set correctly using an organization"""
        expected_result = (
            ORGANIZATION,
            ["org/repo1", "org2/repo2"],
            None,
            None,
            b"",
            False,
            TOKEN,
            "",
            ["repo4", "repo5"],
            False,
            TITLE,
            BODY,
            COMMIT_MESSAGE,
            False,
            True,
        )
        result = get_env_vars(True)
        self.assertEqual(result, expected_result)

    @patch.dict(
        os.environ,
        {
            "BODY": BODY,
            "COMMIT_MESSAGE": COMMIT_MESSAGE,
            "DRY_RUN": "true",
            "EXEMPT_REPOS": "repo4,repo5",
            "GH_APP_ID": "12345",
            "GH_ENTERPRISE_URL": "",
            "GH_APP_INSTALLATION_ID": "678910",
            "GH_APP_PRIVATE_KEY": "hello",
            "GH_TOKEN": "",
            "ORGANIZATION": "",
            "REPOSITORY": "org/repo1,org2/repo2",
            "TITLE": TITLE,
        },
        clear=True,
    )
    def test_get_env_vars_with_github_app_and_repos(self):
        """Test that all environment variables are set correctly using a list of repositories"""
        expected_result = (
            "",
            ["org/repo1", "org2/repo2"],
            12345,
            678910,
            b"hello",
            False,
            "",
            "",
            ["repo4", "repo5"],
            True,
            TITLE,
            BODY,
            COMMIT_MESSAGE,
            False,
            True,
        )
        result = get_env_vars(True)
        self.assertEqual(result, expected_result)

    @patch.dict(
        os.environ,
        {
            "ORGANIZATION": "my_organization",
            "GH_APP_ID": "12345",
            "GH_APP_INSTALLATION_ID": "",
            "GH_APP_PRIVATE_KEY": "",
            "GH_TOKEN": "",
        },
        clear=True,
    )
    def test_get_env_vars_auth_with_github_app_installation_missing_inputs(self):
        """Test that an error is raised there are missing inputs for the gh app"""
        with self.assertRaises(ValueError) as context_manager:
            get_env_vars(True)
        the_exception = context_manager.exception
        self.assertEqual(
            str(the_exception),
            "GH_APP_ID set and GH_APP_INSTALLATION_ID or GH_APP_PRIVATE_KEY variable not set",
        )

    @patch.dict(
        os.environ,
        {
            "BODY": BODY,
            "COMMIT_MESSAGE": COMMIT_MESSAGE,
            "DRY_RUN": "true",
            "EXEMPT_REPOS": "repo4,repo5",
            "GH_APP_ID": "",
            "GH_ENTERPRISE_URL": "",
            "GH_APP_INSTALLATION_ID": "",
            "GH_APP_PRIVATE_KEY": "",
            "GH_TOKEN": TOKEN,
            "ORGANIZATION": "",
            "REPOSITORY": "org/repo1,org2/repo2",
            "TITLE": TITLE,
        },
        clear=True,
    )
    def test_get_env_vars_with_token_and_repos(self):
        """Test that all environment variables are set correctly using a list of repositories"""
        expected_result = (
            "",
            ["org/repo1", "org2/repo2"],
            None,
            None,
            b"",
            False,
            TOKEN,
            "",
            ["repo4", "repo5"],
            True,
            TITLE,
            BODY,
            COMMIT_MESSAGE,
            False,
            True,
        )
        result = get_env_vars(True)
        self.assertEqual(result, expected_result)

    @patch.dict(
        os.environ,
        {
            "BODY": BODY,
            "COMMIT_MESSAGE": COMMIT_MESSAGE,
            "GH_APP_ID": "",
            "GH_APP_INSTALLATION_ID": "",
            "GH_APP_PRIVATE_KEY": "",
            "GH_TOKEN": TOKEN,
            "ORGANIZATION": ORGANIZATION,
            "TITLE": TITLE,
            "ISSUE_REPORT": "true",
        },
    )
    def test_get_env_vars_optional_values(self):
        """Test that optional values are set to their default values if not provided"""
        expected_result = (
            ORGANIZATION,
            [],
            None,
            None,
            b"",
            False,
            TOKEN,
            "",
            [],
            False,
            TITLE,
            BODY,
            COMMIT_MESSAGE,
            True,
            True,
        )
        result = get_env_vars(True)
        self.assertEqual(result, expected_result)

    @patch.dict(
        os.environ,
        {
            "GH_APP_ID": "",
            "GH_APP_INSTALLATION_ID": "",
            "GH_APP_PRIVATE_KEY": "",
            "GH_TOKEN": TOKEN,
            "ORGANIZATION": ORGANIZATION,
            "ENABLE_GITHUB_ACTIONS_STEP_SUMMARY": "false",
        },
        clear=True,
    )
    def test_get_env_vars_with_step_summary_disabled(self):
        """Test that ENABLE_GITHUB_ACTIONS_STEP_SUMMARY can be explicitly disabled"""
        expected_result = (
            ORGANIZATION,
            [],
            None,
            None,
            b"",
            False,
            TOKEN,
            "",
            [],
            False,
            "Clean up CODEOWNERS file",
            "Consider these updates to the CODEOWNERS file to remove users no longer in this organization.",
            "Remove users no longer in this organization from CODEOWNERS file",
            False,
            False,
        )
        result = get_env_vars(True)
        self.assertEqual(result, expected_result)

    @patch.dict(os.environ, {})
    def test_get_env_vars_missing_org_or_repo(self):
        """Test that an error is raised if required environment variables are not set"""
        with self.assertRaises(ValueError):
            get_env_vars(True)

    @patch.dict(
        os.environ,
        {
            "ORGANIZATION": ORGANIZATION,
        },
        clear=True,
    )
    def test_get_env_vars_missing_token(self):
        """Test that an error is raised if required environment variables are not set"""
        with self.assertRaises(ValueError):
            get_env_vars(True)

    @patch.dict(
        os.environ,
        {
            "GH_APP_ID": "",
            "GH_APP_INSTALLATION_ID": "",
            "GH_APP_PRIVATE_KEY": "",
            "GH_TOKEN": TOKEN,
            "ORGANIZATION": ORGANIZATION,
        },
        clear=True,
    )
    def test_get_env_vars_with_repos_no_dry_run(self):
        """Test that all environment variables are set correctly when DRY_RUN is false"""
        expected_result = (
            ORGANIZATION,
            [],
            None,
            None,
            b"",
            False,
            TOKEN,
            "",
            [],
            False,
            "Clean up CODEOWNERS file",
            "Consider these updates to the CODEOWNERS file to remove users no longer in this organization.",
            "Remove users no longer in this organization from CODEOWNERS file",
            False,
            True,
        )
        result = get_env_vars(True)
        self.assertEqual(result, expected_result)

    def test_get_int_env_var_returns_none_for_non_integer(self):
        """Test that get_int_env_var returns None when the value is not an integer."""
        with patch.dict(os.environ, {"TEST_VAR": "not_a_number"}):
            result = get_int_env_var("TEST_VAR")
        self.assertIsNone(result)

    @patch("env.load_dotenv")
    @patch.dict(
        os.environ,
        {
            "GH_TOKEN": TOKEN,
            "ORGANIZATION": ORGANIZATION,
        },
        clear=True,
    )
    def test_get_env_vars_loads_dotenv_when_not_test(self, mock_load_dotenv):
        """Test that get_env_vars loads from .env file when test=False."""
        result = get_env_vars(False)
        self.assertEqual(result[0], ORGANIZATION)
        mock_load_dotenv.assert_called_once()

    @patch.dict(
        os.environ,
        {
            "GH_TOKEN": TOKEN,
            "REPOSITORY": "/invalid-repo",
        },
        clear=True,
    )
    def test_get_env_vars_raises_for_repository_starting_with_slash(self):
        """Test that REPOSITORY starting with / raises ValueError."""
        with self.assertRaises(ValueError):
            get_env_vars(True)

    @patch.dict(
        os.environ,
        {
            "GH_TOKEN": TOKEN,
            "ORGANIZATION": ORGANIZATION,
            "TITLE": "x" * 71,
        },
        clear=True,
    )
    def test_get_env_vars_raises_for_title_too_long(self):
        """Test that TITLE longer than 70 characters raises ValueError."""
        with self.assertRaises(ValueError):
            get_env_vars(True)

    @patch.dict(
        os.environ,
        {
            "GH_TOKEN": TOKEN,
            "ORGANIZATION": ORGANIZATION,
            "BODY": "x" * 65537,
        },
        clear=True,
    )
    def test_get_env_vars_raises_for_body_too_long(self):
        """Test that BODY longer than 65536 characters raises ValueError."""
        with self.assertRaises(ValueError):
            get_env_vars(True)

    @patch.dict(
        os.environ,
        {
            "GH_TOKEN": TOKEN,
            "ORGANIZATION": ORGANIZATION,
            "COMMIT_MESSAGE": "x" * 65537,
        },
        clear=True,
    )
    def test_get_env_vars_raises_for_commit_message_too_long(self):
        """Test that COMMIT_MESSAGE longer than 65536 characters raises ValueError."""
        with self.assertRaises(ValueError):
            get_env_vars(True)


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