feat: add tests

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 @@
+ 

tests/test_api.py

@@ -0,0 +1,46 @@
+import unittest
+from unittest.mock import patch, Mock
+import sys
+import os
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+from manage_bitbucket_env import get_environment_uuid, get_variables
+
+class TestAPI(unittest.TestCase):
+    def setUp(self):
+        self.logger = Mock()
+        self.auth = Mock()
+        self.workspace = 'ws'
+        self.repo_slug = 'repo'
+        self.deployment_name = 'env'
+        self.env_uuid = 'uuid-123'
+
+    @patch('manage_bitbucket_env.requests.get')
+    def test_get_environment_uuid_found(self, mock_get):
+        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):
+        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):
+        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
+        vars = get_variables(self.workspace, self.repo_slug, self.env_uuid, self.auth, self.logger)
+        self.assertEqual(vars[0]["key"], "A")
+
+if __name__ == '__main__':
+    unittest.main() 

tests/test_arg_parser.py

@@ -0,0 +1,37 @@
+import unittest
+from unittest.mock import patch
+import sys
+import os
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+from manage_bitbucket_env import arg_parser
+
+class TestArgParser(unittest.TestCase):
+    def test_export_args(self):
+        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_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_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_export_import.py

@@ -0,0 +1,105 @@
+import unittest
+from unittest.mock import patch, Mock
+import sys
+import os
+import tempfile
+import json
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+from manage_bitbucket_env import export_variables, export_all_variables, export_secure_keys, import_variables
+
+class TestExportImport(unittest.TestCase):
+    def setUp(self):
+        self.logger = Mock()
+        self.auth = Mock()
+        self.workspace = 'ws'
+        self.repo_slug = 'repo'
+        self.deployment_name = 'env'
+        self.env_uuid = '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):
+        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) 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):
+        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) 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):
+        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) 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):
+        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') 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_main.py

@@ -0,0 +1,52 @@
+import unittest
+from unittest.mock import patch, Mock
+import sys
+import os
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+from manage_bitbucket_env import main
+
+class TestMainFunction(unittest.TestCase):
+    def setUp(self):
+        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')
+    def test_main_export_variables(self, mock_export, mock_auth, mock_env_get, mock_load_dotenv, mock_arg_parser):
+        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
+        mock_env_get.side_effect = lambda x: {
+            'BITBUCKET_USERNAME': 'test_user',
+            'BITBUCKET_APP_PASSWORD': 'test_password'
+        }.get(x)
+        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):
+        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() 

tests/test_update_vars.py

@@ -0,0 +1,39 @@
+import unittest
+from unittest.mock import patch, Mock
+import sys
+import os
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+from manage_bitbucket_env import update_vars
+
+class TestUpdateVars(unittest.TestCase):
+    def setUp(self):
+        self.logger = Mock()
+        self.auth = Mock()
+        self.workspace = 'ws'
+        self.repo_slug = 'repo'
+        self.env_uuid = 'uuid-123'
+
+    @patch('manage_bitbucket_env.requests.put')
+    def test_update_existing(self, mock_put):
+        mock_resp = Mock()
+        mock_resp.raise_for_status.return_value = None
+        mock_put.return_value = mock_resp
+        existing_vars = [{"key": "A", "uuid": "u1", "value": "old", "secured": False}]
+        new_var = {"key": "A", "value": "new", "secured": False}
+        update_vars(self.workspace, self.repo_slug, self.env_uuid, existing_vars, new_var, self.auth, self.logger)
+        mock_put.assert_called_once()
+        call_args = mock_put.call_args
+        self.assertIn("u1", call_args[0][0])
+
+    @patch('manage_bitbucket_env.requests.post')
+    def test_update_new(self, mock_post):
+        mock_resp = Mock()
+        mock_resp.raise_for_status.return_value = None
+        mock_post.return_value = mock_resp
+        existing_vars = []
+        new_var = {"key": "B", "value": "val", "secured": False}
+        update_vars(self.workspace, self.repo_slug, self.env_uuid, existing_vars, new_var, self.auth, self.logger)
+        mock_post.assert_called_once()
+
+if __name__ == '__main__':
+    unittest.main()