remove not used code

Author: nammn

…ease/agent/detect_ops_manager_changes.py …ripts/release/agent/agents_to_rebuild.pyscripts/release/agent/detect_ops_manager_changes.py renamed to scripts/release/agent/agents_to_rebuild.py scripts/release/agent/detect_ops_manager_changes.py renamed to scripts/release/agent/agents_to_rebuild.py

@@ -19,32 +19,6 @@
 logger = logging.getLogger(__name__)
 
 
-def get_content_from_git(commit: str, file_path: str) -> Optional[str]:
-    try:
-        result = subprocess.run(
-            ["git", "show", f"{commit}:{file_path}"], capture_output=True, text=True, check=True, timeout=30
-        )
-        return result.stdout
-    except (subprocess.CalledProcessError, subprocess.TimeoutExpired) as e:
-        logger.error(f"Failed to get {file_path} from git commit {commit}: {e}")
-        return None
-
-
-def load_release_json_from_master() -> Optional[Dict]:
-    base_revision = "origin/master"
-
-    content = get_content_from_git(base_revision, "release.json")
-    if not content:
-        logger.error(f"Could not retrieve release.json from {base_revision}")
-        return None
-
-    try:
-        return json.loads(content)
-    except json.JSONDecodeError as e:
-        logger.error(f"Invalid JSON in base release.json: {e}")
-        return None
-
-
 def load_current_release_json() -> Optional[Dict]:
     try:
         with open("release.json", "r") as f:
@@ -60,28 +34,6 @@ def extract_ops_manager_mapping(release_data: Dict) -> Dict:
     return release_data.get("supportedImages", {}).get("mongodb-agent", {}).get("opsManagerMapping", {})
 
 
-def get_changed_agents(current_mapping: Dict, base_mapping: Dict) -> List[Tuple[str, str]]:
-    """Returns list of (agent_version, tools_version) tuples for added/changed agents"""
-    added_agents = []
-
-    current_om_mapping = current_mapping.get("ops_manager", {})
-    master_om_mapping = base_mapping.get("ops_manager", {})
-
-    for om_version, agent_tools_version in current_om_mapping.items():
-        if om_version not in master_om_mapping or master_om_mapping[om_version] != agent_tools_version:
-            added_agents.append((agent_tools_version["agent_version"], agent_tools_version["tools_version"]))
-
-    current_cm = current_mapping.get("cloud_manager")
-    master_cm = base_mapping.get("cloud_manager")
-    current_cm_tools = current_mapping.get("cloud_manager_tools")
-    master_cm_tools = base_mapping.get("cloud_manager_tools")
-
-    if current_cm != master_cm or current_cm_tools != master_cm_tools:
-        added_agents.append((current_cm, current_cm_tools))
-
-    return list(set(added_agents))
-
-
 def get_tools_version_for_agent(agent_version: str) -> str:
     """Get tools version for a given agent version from release.json"""
     release_data = load_current_release_json()
@@ -206,26 +158,3 @@ def get_currently_used_agents() -> List[Tuple[str, str]]:
     except Exception as e:
         logger.error(f"Error getting currently used agents: {e}")
         return []
-
-
-def detect_ops_manager_changes() -> List[Tuple[str, str]]:
-    """Returns (has_changes, changed_agents_list)"""
-    logger.info("=== Detecting OM Mapping Changes (Local vs Base) ===")
-
-    current_release = load_current_release_json()
-    if not current_release:
-        logger.error("Could not load current local release.json")
-        return []
-
-    master_release = load_release_json_from_master()
-    if not master_release:
-        logger.warning("Could not load base release.json, assuming changes exist")
-        return []
-
-    current_mapping = extract_ops_manager_mapping(current_release)
-    base_mapping = extract_ops_manager_mapping(master_release)
-
-    if current_mapping != base_mapping:
-        return get_changed_agents(current_mapping, base_mapping)
-    else:
-        return []

scripts/release/atomic_pipeline.py

@@ -15,7 +15,7 @@
 from opentelemetry import trace
 
 from lib.base_logger import logger
-from scripts.release.agent.detect_ops_manager_changes import (
+from scripts.release.agent.agents_to_rebuild import (
     get_all_agents_for_rebuild,
     get_currently_used_agents,
 )

scripts/release/tests/test_agents_to_rebuild.py

@@ -0,0 +1,197 @@
+#!/usr/bin/env python3
+"""
+Tests for scripts.release.agent.agents_to_rebuild.py
+"""
+import json
+import unittest
+from unittest.mock import mock_open, patch
+
+from scripts.release.agent.agents_to_rebuild import (
+    extract_ops_manager_mapping,
+    get_all_agents_for_rebuild,
+    get_currently_used_agents,
+    get_tools_version_for_agent,
+    load_current_release_json,
+)
+
+
+class TestDetectOpsManagerChanges(unittest.TestCase):
+
+    def setUp(self):
+        """Set up test fixtures"""
+        self.master_release_data = {
+            "supportedImages": {
+                "mongodb-agent": {
+                    "opsManagerMapping": {
+                        "cloud_manager": "13.37.0.9590-1",
+                        "cloud_manager_tools": "100.12.2",
+                        "ops_manager": {
+                            "6.0.26": {"agent_version": "12.0.34.7888-1", "tools_version": "100.10.0"},
+                            "7.0.11": {"agent_version": "107.0.11.8645-1", "tools_version": "100.10.0"},
+                        },
+                    }
+                }
+            }
+        }
+
+        self.current_release_data = {
+            "supportedImages": {
+                "mongodb-agent": {
+                    "opsManagerMapping": {
+                        "cloud_manager": "13.37.0.9590-1",
+                        "cloud_manager_tools": "100.12.2",
+                        "ops_manager": {
+                            "6.0.26": {"agent_version": "12.0.34.7888-1", "tools_version": "100.10.0"},
+                            "7.0.11": {"agent_version": "107.0.11.8645-1", "tools_version": "100.10.0"},
+                        },
+                    }
+                }
+            }
+        }
+
+        self.evergreen_content = """
+variables:
+  - &ops_manager_60_latest 6.0.27 # The order/index is important
+  - &ops_manager_70_latest 7.0.17 # The order/index is important
+  - &ops_manager_80_latest 8.0.12 # The order/index is important
+"""
+
+    def test_extract_ops_manager_mapping_valid(self):
+        """Test extracting opsManagerMapping from valid release data"""
+        mapping = extract_ops_manager_mapping(self.master_release_data)
+        expected = {
+            "cloud_manager": "13.37.0.9590-1",
+            "cloud_manager_tools": "100.12.2",
+            "ops_manager": {
+                "6.0.26": {"agent_version": "12.0.34.7888-1", "tools_version": "100.10.0"},
+                "7.0.11": {"agent_version": "107.0.11.8645-1", "tools_version": "100.10.0"},
+            },
+        }
+        self.assertEqual(mapping, expected)
+
+    def test_extract_ops_manager_mapping_empty(self):
+        """Test extracting from empty/invalid data"""
+        self.assertEqual(extract_ops_manager_mapping({}), {})
+        self.assertEqual(extract_ops_manager_mapping(None), {})
+
+    def test_extract_ops_manager_mapping_missing_keys(self):
+        """Test extracting when keys are missing"""
+        incomplete_data = {"supportedImages": {}}
+        self.assertEqual(extract_ops_manager_mapping(incomplete_data), {})
+
+    @patch("builtins.open", new_callable=mock_open)
+    @patch("os.path.exists", return_value=True)
+    def test_load_current_release_json_success(self, mock_exists, mock_file):
+        """Test successfully loading current release.json"""
+        mock_file.return_value.read.return_value = json.dumps(self.current_release_data)
+
+        result = load_current_release_json()
+        self.assertEqual(result, self.current_release_data)
+
+    @patch("builtins.open", side_effect=FileNotFoundError)
+    def test_load_current_release_json_not_found(self, mock_file):
+        """Test handling missing release.json"""
+        result = load_current_release_json()
+        self.assertIsNone(result)
+
+    @patch("builtins.open", new_callable=mock_open)
+    @patch("os.path.exists", return_value=True)
+    def test_load_current_release_json_invalid_json(self, mock_exists, mock_file):
+        """Test handling invalid JSON in release.json"""
+        mock_file.return_value.read.return_value = "invalid json"
+
+        result = load_current_release_json()
+        self.assertIsNone(result)
+
+    @patch("scripts.release.agent.agents_to_rebuild.load_current_release_json")
+    def test_get_tools_version_for_agent_found(self, mock_load):
+        """Test getting tools version for a known agent version"""
+        mock_load.return_value = self.current_release_data
+        result = get_tools_version_for_agent("12.0.34.7888-1")
+        self.assertEqual(result, "100.10.0")
+
+    @patch("scripts.release.agent.agents_to_rebuild.load_current_release_json")
+    def test_get_tools_version_for_agent_not_found(self, mock_load):
+        """Test getting tools version for unknown agent falls back to cloud_manager_tools"""
+        mock_load.return_value = self.current_release_data
+        result = get_tools_version_for_agent("unknown-agent-version")
+        self.assertEqual(result, "100.12.2")
+
+    @patch("scripts.release.agent.agents_to_rebuild.load_current_release_json")
+    def test_get_tools_version_for_agent_no_release_data(self, mock_load):
+        """Test getting tools version when release.json cannot be loaded"""
+        mock_load.return_value = None
+        result = get_tools_version_for_agent("any-version")
+        self.assertEqual(result, "100.12.2")
+
+    @patch("scripts.release.agent.agents_to_rebuild.load_current_release_json")
+    def test_get_all_agents_for_rebuild(self, mock_load):
+        """Test getting all agents for rebuild from release.json"""
+        release_data = {
+            "agentVersion": "13.37.0.9590-1",
+            "supportedImages": {
+                "mongodb-agent": {
+                    "opsManagerMapping": {
+                        "cloud_manager": "13.37.0.9590-1",
+                        "cloud_manager_tools": "100.12.2",
+                        "ops_manager": {
+                            "6.0.26": {"agent_version": "12.0.34.7888-1", "tools_version": "100.10.0"},
+                            "7.0.11": {"agent_version": "107.0.11.8645-1", "tools_version": "100.10.0"},
+                        },
+                    }
+                }
+            },
+        }
+        mock_load.return_value = release_data
+        result = get_all_agents_for_rebuild()
+
+        # Should contain ops_manager agents, cloud_manager agent, and main agent
+        self.assertIn(("12.0.34.7888-1", "100.10.0"), result)
+        self.assertIn(("107.0.11.8645-1", "100.10.0"), result)
+        self.assertIn(("13.37.0.9590-1", "100.12.2"), result)
+
+    @patch("scripts.release.agent.agents_to_rebuild.load_current_release_json")
+    def test_get_all_agents_for_rebuild_no_release_data(self, mock_load):
+        """Test getting all agents when release.json cannot be loaded"""
+        mock_load.return_value = None
+        result = get_all_agents_for_rebuild()
+        self.assertEqual(result, [])
+
+    @patch("scripts.release.agent.agents_to_rebuild.glob.glob")
+    @patch("scripts.release.agent.agents_to_rebuild.load_current_release_json")
+    def test_get_currently_used_agents_no_release_data(self, mock_load, mock_glob):
+        """Test getting currently used agents when release.json cannot be loaded"""
+        mock_load.return_value = None
+        result = get_currently_used_agents()
+        self.assertEqual(result, [])
+
+    @patch("scripts.release.agent.agents_to_rebuild.glob.glob")
+    @patch("scripts.release.agent.agents_to_rebuild.load_current_release_json")
+    @patch("builtins.open", new_callable=mock_open)
+    @patch("os.path.isfile", return_value=True)
+    def test_get_currently_used_agents_with_context_files(self, mock_isfile, mock_file, mock_load, mock_glob):
+        """Test getting currently used agents from context files"""
+        release_data = {
+            "agentVersion": "13.37.0.9590-1",
+            "supportedImages": {
+                "mongodb-agent": {
+                    "opsManagerMapping": {
+                        "cloud_manager": "13.37.0.9590-1",
+                        "cloud_manager_tools": "100.12.2",
+                        "ops_manager": {},
+                    }
+                }
+            },
+        }
+        mock_load.return_value = release_data
+        mock_glob.return_value = ["scripts/dev/contexts/test_context"]
+        mock_file.return_value.read.return_value = "export AGENT_VERSION=12.0.34.7888-1\n"
+
+        result = get_currently_used_agents()
+
+        self.assertIn(("12.0.34.7888-1", "100.12.2"), result)  # falls back to cloud_manager_tools
+        self.assertIn(("13.37.0.9590-1", "100.12.2"), result)
+
+
+if __name__ == "__main__":
+    unittest.main()