feat: pylint errors

Author: matthew-on-git

tests/test_api.py

@@ -1,3 +1,4 @@
+"""Unit tests for Bitbucket API logic in manage_bitbucket_env.py."""
 import unittest
 from unittest.mock import patch, Mock
 import sys
@@ -6,7 +7,16 @@
 from manage_bitbucket_env import get_environment_uuid, get_variables
 
 class TestAPI(unittest.TestCase):
+    """Test API-related functions."""
+    logger = None
+    auth = None
+    workspace = None
+    repo_slug = None
+    deployment_name = None
+    env_uuid = None
+
     def setUp(self):
+        """Set up test fixtures."""
         self.logger = Mock()
         self.auth = Mock()
         self.workspace = 'ws'
@@ -16,31 +26,49 @@ def setUp(self):
 
     @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.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)
+        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.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)
+            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.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")
+        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_arg_parser.py

@@ -1,3 +1,4 @@
+"""Unit tests for argument parsing in manage_bitbucket_env.py."""
 import unittest
 from unittest.mock import patch
 import sys
@@ -6,7 +7,10 @@
 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'
         ]
@@ -18,6 +22,7 @@ def test_export_args(self):
             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'
         ]
@@ -26,6 +31,7 @@ def test_import_args(self):
             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'
         ]

tests/test_export_import.py

@@ -1,14 +1,27 @@
+"""Unit tests for export/import logic in manage_bitbucket_env.py."""
+# pylint: disable=duplicate-code
 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
+from manage_bitbucket_env import (
+    export_variables, export_all_variables, export_secure_keys, import_variables
+)
 
 class TestExportImport(unittest.TestCase):
+    """Test export and import functionality."""
+    logger = None
+    auth = None
+    workspace = None
+    repo_slug = None
+    deployment_name = None
+    env_uuid = None
+
     def setUp(self):
+        """Set up test fixtures."""
         self.logger = Mock()
         self.auth = Mock()
         self.workspace = 'ws'
@@ -19,6 +32,7 @@ def setUp(self):
     @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},
@@ -27,8 +41,11 @@ def test_export_variables(self, mock_get_vars, mock_get_uuid):
         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:
+            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")
@@ -38,6 +55,7 @@ def test_export_variables(self, mock_get_vars, mock_get_uuid):
     @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},
@@ -46,8 +64,11 @@ def test_export_all_variables(self, mock_get_vars, mock_get_uuid):
         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:
+            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")
@@ -62,6 +83,7 @@ def test_export_all_variables(self, mock_get_vars, mock_get_uuid):
     @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},
@@ -71,8 +93,11 @@ def test_export_secure_keys(self, mock_get_vars, mock_get_uuid):
         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:
+            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)
@@ -84,17 +109,21 @@ def test_export_secure_keys(self, mock_get_vars, mock_get_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') as tf:
+        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)
+            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")

tests/test_main.py

@@ -1,3 +1,4 @@
+"""Unit tests for main function integration in manage_bitbucket_env.py."""
 import unittest
 from unittest.mock import patch, Mock
 import sys
@@ -6,15 +7,22 @@
 from manage_bitbucket_env import main
 
 class TestMainFunction(unittest.TestCase):
+    """Test main function integration."""
+    mock_logger = 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')
-    def test_main_export_variables(self, mock_export, mock_auth, mock_env_get, mock_load_dotenv, mock_arg_parser):
+    # 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'
@@ -41,6 +49,7 @@ def test_main_export_variables(self, mock_export, mock_auth, mock_env_get, mock_
     @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

tests/test_update_vars.py

@@ -1,3 +1,5 @@
+"""Unit tests for update_vars logic in manage_bitbucket_env.py."""
+# pylint: disable=duplicate-code
 import unittest
 from unittest.mock import patch, Mock
 import sys
@@ -6,7 +8,15 @@
 from manage_bitbucket_env import update_vars
 
 class TestUpdateVars(unittest.TestCase):
+    """Test variable update functionality."""
+    logger = None
+    auth = None
+    workspace = None
+    repo_slug = None
+    env_uuid = None
+
     def setUp(self):
+        """Set up test fixtures."""
         self.logger = Mock()
         self.auth = Mock()
         self.workspace = 'ws'
@@ -15,24 +25,32 @@ def setUp(self):
 
     @patch('manage_bitbucket_env.requests.put')
     def test_update_existing(self, mock_put):
+        """Test updating an existing variable."""
         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)
+        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):
+        """Test creating a new variable."""
         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)
+        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__':