Merge pull request #4 from matthew-on-git/add_test

feat: add tests made with cursor

Author: matthew-on-git

.github/workflows/test.yml

@@ -0,0 +1,23 @@
+name: Test
+
+on: [push, pull_request]
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python-version: ["3.9", "3.10"]
+    steps:
+      - uses: actions/checkout@v4
+      - name: Set up Python ${{ matrix.python-version }}
+        uses: actions/setup-python@v3
+        with:
+          python-version: ${{ matrix.python-version }}
+      - name: Install dependencies
+        run: |
+          python -m pip install --upgrade pip
+          pip install -r requirements.txt
+      - name: Run unittests
+        run: |
+          python -m unittest discover 

tests/__init__.py

@@ -0,0 +1,74 @@
+"""Unit tests for Bitbucket API logic in manage_bitbucket_env.py."""
+import unittest
+from unittest.mock import patch, Mock
+from typing import Optional
+
+from manage_bitbucket_env import get_environment_uuid, get_variables
+
+class TestAPI(unittest.TestCase):
+    """Test API-related functions."""
+    # pylint: disable=attribute-defined-outside-init
+    logger: Optional[Mock] = None
+    auth: Optional[Mock] = None
+    workspace: Optional[str] = None
+    repo_slug: Optional[str] = None
+    deployment_name: Optional[str] = None
+    env_uuid: Optional[str] = None
+
+    def setUp(self):
+        """Set up test fixtures."""
+        self.logger: Mock = Mock()
+        self.auth: Mock = Mock()
+        self.workspace: str = 'ws'
+        self.repo_slug: str = 'repo'
+        self.deployment_name: str = 'env'
+        self.env_uuid: str = 'uuid-123'
+
+    @patch('manage_bitbucket_env.requests.get')
+    def test_get_environment_uuid_found(self, mock_get):
+        """Test successful environment UUID retrieval."""
+        mock_resp = Mock()
+        mock_resp.json.return_value = {
+            "values": [{"name": "env", "uuid": "uuid-123"}]
+        }
+        mock_resp.raise_for_status.return_value = None
+        mock_get.return_value = mock_resp
+        uuid = get_environment_uuid(
+            self.workspace, self.repo_slug, self.deployment_name,
+            self.auth, self.logger
+        )
+        self.assertEqual(uuid, 'uuid-123')
+        mock_get.assert_called_once()
+
+    @patch('manage_bitbucket_env.requests.get')
+    def test_get_environment_uuid_not_found(self, mock_get):
+        """Test environment UUID retrieval when environment not found."""
+        mock_resp = Mock()
+        mock_resp.json.return_value = {
+            "values": [{"name": "other", "uuid": "uuid-999"}]
+        }
+        mock_resp.raise_for_status.return_value = None
+        mock_get.return_value = mock_resp
+        with self.assertRaises(ValueError):
+            get_environment_uuid(
+                self.workspace, self.repo_slug, self.deployment_name,
+                self.auth, self.logger
+            )
+
+    @patch('manage_bitbucket_env.requests.get')
+    def test_get_variables(self, mock_get):
+        """Test successful variable retrieval."""
+        mock_resp = Mock()
+        mock_resp.json.return_value = {
+            "values": [{"key": "A", "value": "1", "secured": False}]
+        }
+        mock_resp.raise_for_status.return_value = None
+        mock_get.return_value = mock_resp
+        result_vars = get_variables(
+            self.workspace, self.repo_slug, self.env_uuid,
+            self.auth, self.logger
+        )
+        self.assertEqual(result_vars[0]["key"], "A")
+
+if __name__ == '__main__':
+    unittest.main()

tests/test_api.py

@@ -0,0 +1,42 @@
+"""Unit tests for argument parsing in manage_bitbucket_env.py."""
+import unittest
+from unittest.mock import patch
+import sys
+
+from manage_bitbucket_env import arg_parser
+
+class TestArgParser(unittest.TestCase):
+    """Test argument parsing functionality."""
+
+    def test_export_args(self):
+        """Test parsing arguments for exporting variables."""
+        test_args = [
+            'prog', '-w', 'ws', '-r', 'repo', '-d', 'env', '-o', 'out.json'
+        ]
+        with patch.object(sys, 'argv', test_args):
+            args = arg_parser()
+            self.assertEqual(args.workspace, 'ws')
+            self.assertEqual(args.repo_slug, 'repo')
+            self.assertEqual(args.deployment_name, 'env')
+            self.assertEqual(args.output, 'out.json')
+
+    def test_import_args(self):
+        """Test parsing arguments for importing variables."""
+        test_args = [
+            'prog', '-w', 'ws', '-r', 'repo', '-d', 'env', '-i', 'in.json'
+        ]
+        with patch.object(sys, 'argv', test_args):
+            args = arg_parser()
+            self.assertEqual(args.import_file, 'in.json')
+
+    def test_mutually_exclusive(self):
+        """Test that mutually exclusive arguments raise an error."""
+        test_args = [
+            'prog', '-w', 'ws', '-r', 'repo', '-d', 'env'
+        ]
+        with patch.object(sys, 'argv', test_args):
+            with self.assertRaises(SystemExit):
+                arg_parser()
+
+if __name__ == '__main__':
+    unittest.main()

tests/test_arg_parser.py

@@ -0,0 +1,135 @@
+"""Unit tests for export/import logic in manage_bitbucket_env.py."""
+# pylint: disable=duplicate-code
+import unittest
+from unittest.mock import patch, Mock
+import os
+import tempfile
+import json
+from typing import Optional
+
+from manage_bitbucket_env import (
+    export_variables, export_all_variables, export_secure_keys, import_variables
+)
+
+class TestExportImport(unittest.TestCase):
+    """Test export and import functionality."""
+    # pylint: disable=attribute-defined-outside-init
+    logger: Optional[Mock] = None
+    auth: Optional[Mock] = None
+    workspace: Optional[str] = None
+    repo_slug: Optional[str] = None
+    deployment_name: Optional[str] = None
+    env_uuid: Optional[str] = None
+
+    def setUp(self):
+        """Set up test fixtures."""
+        self.logger: Mock = Mock()
+        self.auth: Mock = Mock()
+        self.workspace: str = 'ws'
+        self.repo_slug: str = 'repo'
+        self.deployment_name: str = 'env'
+        self.env_uuid: str = 'uuid-123'
+
+    @patch('manage_bitbucket_env.get_environment_uuid')
+    @patch('manage_bitbucket_env.get_variables')
+    def test_export_variables(self, mock_get_vars, mock_get_uuid):
+        """Test successful export of non-secured variables."""
+        mock_get_uuid.return_value = self.env_uuid
+        mock_get_vars.return_value = [
+            {"key": "A", "value": "1", "secured": False},
+            {"key": "B", "value": "2", "secured": True}
+        ]
+        with tempfile.NamedTemporaryFile(delete=False) as tf:
+            fname = tf.name
+        try:
+            export_variables(
+                self.workspace, self.repo_slug, self.deployment_name,
+                fname, self.auth, self.logger
+            )
+            with open(fname, encoding="utf-8") as f:
+                data = json.load(f)
+            self.assertEqual(len(data), 1)
+            self.assertEqual(data[0]["key"], "A")
+        finally:
+            os.unlink(fname)
+
+    @patch('manage_bitbucket_env.get_environment_uuid')
+    @patch('manage_bitbucket_env.get_variables')
+    def test_export_all_variables(self, mock_get_vars, mock_get_uuid):
+        """Test successful export of all variables."""
+        mock_get_uuid.return_value = self.env_uuid
+        mock_get_vars.return_value = [
+            {"key": "A", "value": "1", "secured": False},
+            {"key": "B", "value": "2", "secured": True}
+        ]
+        with tempfile.NamedTemporaryFile(delete=False) as tf:
+            fname = tf.name
+        try:
+            export_all_variables(
+                self.workspace, self.repo_slug, self.deployment_name,
+                fname, self.auth, self.logger
+            )
+            with open(fname, encoding="utf-8") as f:
+                data = json.load(f)
+            self.assertEqual(len(data), 2)
+            test_var = next(v for v in data if v["key"] == "A")
+            self.assertEqual(test_var["value"], "1")
+            self.assertFalse(test_var["secured"])
+            secure_var = next(v for v in data if v["key"] == "B")
+            self.assertEqual(secure_var["value"], "")
+            self.assertTrue(secure_var["secured"])
+        finally:
+            os.unlink(fname)
+
+    @patch('manage_bitbucket_env.get_environment_uuid')
+    @patch('manage_bitbucket_env.get_variables')
+    def test_export_secure_keys(self, mock_get_vars, mock_get_uuid):
+        """Test successful export of secure keys."""
+        mock_get_uuid.return_value = self.env_uuid
+        mock_get_vars.return_value = [
+            {"key": "A", "secured": False},
+            {"key": "B", "secured": True},
+            {"key": "C", "secured": True}
+        ]
+        with tempfile.NamedTemporaryFile(delete=False) as tf:
+            fname = tf.name
+        try:
+            export_secure_keys(
+                self.workspace, self.repo_slug, self.deployment_name,
+                fname, self.auth, self.logger
+            )
+            with open(fname, encoding="utf-8") as f:
+                data = json.load(f)
+            self.assertIn("B", data)
+            self.assertIn("C", data)
+            self.assertNotIn("A", data)
+        finally:
+            os.unlink(fname)
+
+    @patch('manage_bitbucket_env.get_environment_uuid')
+    @patch('manage_bitbucket_env.get_variables')
+    @patch('manage_bitbucket_env.update_vars')
+    def test_import_variables(self, mock_update, mock_get_vars, mock_get_uuid):
+        """Test successful import of variables."""
+        mock_get_uuid.return_value = self.env_uuid
+        mock_get_vars.return_value = []
+        test_vars = [
+            {"key": "A", "value": "1", "secured": False},
+            {"key": "B", "value": "2", "secured": True}
+        ]
+        with tempfile.NamedTemporaryFile(delete=False, mode='w', encoding="utf-8") as tf:
+            json.dump(test_vars, tf)
+            fname = tf.name
+        try:
+            import_variables(
+                self.workspace, self.repo_slug, self.deployment_name,
+                fname, False, self.auth, self.logger
+            )
+            self.assertEqual(mock_update.call_count, 1)
+            call_args = mock_update.call_args[1]
+            self.assertEqual(call_args['var']["key"], "A")
+        finally:
+            os.unlink(fname)
+
+if __name__ == '__main__':
+    unittest.main()

tests/test_export_import.py

@@ -0,0 +1,63 @@
+"""Unit tests for main function integration in manage_bitbucket_env.py."""
+# pylint: disable=unused-argument
+import unittest
+from unittest.mock import patch, Mock
+from typing import Optional
+
+from manage_bitbucket_env import main
+
+class TestMainFunction(unittest.TestCase):
+    """Test main function integration."""
+    # pylint: disable=attribute-defined-outside-init
+    mock_logger: Optional[Mock] = None
+
+    def setUp(self):
+        """Set up test fixtures."""
+        self.mock_logger = Mock()
+
+    @patch('manage_bitbucket_env.arg_parser')
+    @patch('manage_bitbucket_env.load_dotenv')
+    @patch('os.environ.get')
+    @patch('manage_bitbucket_env.HTTPBasicAuth')
+    @patch('manage_bitbucket_env.export_variables')
+    # pylint: disable=too-many-arguments, too-many-positional-arguments
+    def test_main_export_variables(self, mock_export, mock_auth, mock_env_get,
+                                  mock_load_dotenv, mock_arg_parser):
+        """Test main function with export variables."""
+        mock_args = Mock()
+        mock_args.output = 'test_output.json'
+        mock_args.workspace = 'test-workspace'
+        mock_args.repo_slug = 'test-repo'
+        mock_args.deployment_name = 'test-deployment'
+        mock_arg_parser.return_value = mock_args
+        env_dict = {
+            'BITBUCKET_USERNAME': 'test_user',
+            'BITBUCKET_APP_PASSWORD': 'test_password'
+        }
+        mock_env_get.side_effect = env_dict.get
+        mock_auth_instance = Mock()
+        mock_auth.return_value = mock_auth_instance
+        main(self.mock_logger)
+        mock_export.assert_called_once_with(
+            workspace='test-workspace',
+            repo_slug='test-repo',
+            deployment_name='test-deployment',
+            output_file='test_output.json',
+            auth=mock_auth_instance,
+            logger=self.mock_logger
+        )
+
+    @patch('manage_bitbucket_env.arg_parser')
+    @patch('manage_bitbucket_env.load_dotenv')
+    @patch('os.environ.get')
+    def test_main_missing_credentials(self, mock_env_get, mock_load_dotenv, mock_arg_parser):
+        """Test main function with missing credentials."""
+        mock_args = Mock()
+        mock_args.output = 'test_output.json'
+        mock_arg_parser.return_value = mock_args
+        mock_env_get.return_value = None
+        with self.assertRaises(SystemExit):
+            main(self.mock_logger)
+
+if __name__ == '__main__':
+    unittest.main()