fix _validate_cpg_async to return false in case of empty CPG

Author: Lekssays

src/services/cpg_generator.py

@@ -203,29 +203,78 @@ async def _find_joern_executable(self, container, base_command: str) -> str:
         return f"/opt/joern/joern-cli/{base_command}"
 
     async def _validate_cpg_async(self, container, cpg_path: str) -> bool:
-        """Validate that CPG file was created successfully"""
+        """Validate that CPG file was created successfully and is not empty"""
         try:
             loop = asyncio.get_event_loop()
 
             def _check_file():
-                # Check if file exists and get size using a more compatible command
-                result = container.exec_run(f"ls -la {cpg_path}")
+                # Check if file exists and get size using stat command
+                result = container.exec_run(f"stat {cpg_path}")
                 return result.output.decode('utf-8', errors='ignore').strip()
 
-            ls_result = await loop.run_in_executor(None, _check_file)
+            stat_result = await loop.run_in_executor(None, _check_file)
 
-            # If ls succeeded and doesn't show "No such file", the file exists
-            if "No such file" not in ls_result and cpg_path in ls_result:
-                logger.info(f"CPG file created: {ls_result}")
-                return True
-            else:
-                logger.error(f"CPG file not found: {ls_result}")
+            # Check if stat was successful (file exists)
+            if "No such file" in stat_result or "cannot stat" in stat_result:
+                logger.error(f"CPG file not found: {stat_result}")
                 return False
 
+            # Extract file size from stat output
+            # stat output format contains "Size: <bytes>" line
+            file_size = await self._extract_file_size_async(container, cpg_path)
+            
+            if file_size is None:
+                logger.error("Could not determine CPG file size")
+                return False
+            
+            # Check if file is too small (empty or nearly empty)
+            # Joern CPGs typically have a minimum size; even small projects generate CPGs > 1KB
+            min_cpg_size = 1024  # 1KB minimum
+            
+            if file_size < min_cpg_size:
+                logger.error(
+                    f"CPG file is too small ({file_size} bytes), likely empty or corrupted. "
+                    f"Minimum expected size: {min_cpg_size} bytes"
+                )
+                return False
+            
+            logger.info(f"CPG file created successfully: {cpg_path} (size: {file_size} bytes)")
+            return True
+            
         except Exception as e:
             logger.error(f"CPG validation failed: {e}")
             return False
 
+    async def _extract_file_size_async(self, container, cpg_path: str) -> Optional[int]:
+        """Extract file size from a file in the container"""
+        try:
+            loop = asyncio.get_event_loop()
+            
+            def _get_size():
+                # Use a more reliable method to get file size
+                result = container.exec_run(f"stat -c%s {cpg_path}")
+                return result.output.decode('utf-8', errors='ignore').strip()
+            
+            size_str = await loop.run_in_executor(None, _get_size)
+            
+            # Try to parse the size
+            try:
+                return int(size_str)
+            except ValueError:
+                # Fallback: try alternative command if stat -c doesn't work
+                logger.debug(f"stat -c command returned: {size_str}, trying alternative method")
+                
+                def _get_size_wc():
+                    result = container.exec_run(f"wc -c < {cpg_path}")
+                    return result.output.decode('utf-8', errors='ignore').strip()
+                
+                size_str = await loop.run_in_executor(None, _get_size_wc)
+                return int(size_str)
+                
+        except Exception as e:
+            logger.error(f"Failed to extract file size: {e}")
+            return None
+
     async def get_container_id(self, session_id: str) -> Optional[str]:
         """Get container ID for session"""
         return self.session_containers.get(session_id)

tests/test_cpg_generator.py

@@ -236,28 +236,120 @@ async def test_find_joern_executable_not_found(self, cpg_generator):
 
     @pytest.mark.asyncio
     async def test_validate_cpg_success(self, cpg_generator):
-        """Test successful CPG validation"""
+        """Test successful CPG validation with valid file size"""
         mock_container = MagicMock()
-        mock_exec_result = MagicMock()
-        mock_exec_result.output = b"-rw-r--r-- 1 user user 1024 Jan 1 12:00 /playground/cpgs/session-123.cpg"
-        mock_container.exec_run = MagicMock(return_value=mock_exec_result)
-
-        result = await cpg_generator._validate_cpg_async(mock_container, "/playground/cpgs/session-123.cpg")
+        
+        # Mock stat command to return file exists
+        def mock_exec_run(cmd):
+            mock_result = MagicMock()
+            if "stat -c%s" in cmd:
+                # Return file size > 1KB
+                mock_result.output = b"5242880"  # 5MB
+            else:
+                mock_result.output = b"stat output..."
+            return mock_result
+        
+        mock_container.exec_run = mock_exec_run
+
+        result = await cpg_generator._validate_cpg_async(mock_container, "/workspace/cpg.bin")
 
         assert result is True
 
     @pytest.mark.asyncio
-    async def test_validate_cpg_failure(self, cpg_generator):
-        """Test CPG validation failure"""
+    async def test_validate_cpg_failure_file_not_found(self, cpg_generator):
+        """Test CPG validation failure when file doesn't exist"""
         mock_container = MagicMock()
         mock_exec_result = MagicMock()
-        mock_exec_result.output = b"ls: cannot access '/playground/cpgs/session-123.cpg': No such file or directory"
+        mock_exec_result.output = b"stat: cannot stat '/workspace/cpg.bin': No such file or directory"
         mock_container.exec_run = MagicMock(return_value=mock_exec_result)
 
-        result = await cpg_generator._validate_cpg_async(mock_container, "/playground/cpgs/session-123.cpg")
+        result = await cpg_generator._validate_cpg_async(mock_container, "/workspace/cpg.bin")
 
         assert result is False
 
+    @pytest.mark.asyncio
+    async def test_validate_cpg_failure_empty_file(self, cpg_generator):
+        """Test CPG validation failure when file is too small (empty or nearly empty)"""
+        mock_container = MagicMock()
+        
+        # Mock exec_run to return small file size
+        def mock_exec_run(cmd):
+            mock_result = MagicMock()
+            if "stat -c%s" in cmd:
+                # Return file size < 1KB (empty)
+                mock_result.output = b"0"
+            else:
+                mock_result.output = b"stat output..."
+            return mock_result
+        
+        mock_container.exec_run = mock_exec_run
+
+        result = await cpg_generator._validate_cpg_async(mock_container, "/workspace/cpg.bin")
+
+        assert result is False
+
+    @pytest.mark.asyncio
+    async def test_validate_cpg_failure_too_small(self, cpg_generator):
+        """Test CPG validation failure when file is smaller than minimum threshold"""
+        mock_container = MagicMock()
+        
+        # Mock exec_run to return very small file size
+        def mock_exec_run(cmd):
+            mock_result = MagicMock()
+            if "stat -c%s" in cmd:
+                # Return file size < 1KB
+                mock_result.output = b"512"  # 512 bytes
+            else:
+                mock_result.output = b"stat output..."
+            return mock_result
+        
+        mock_container.exec_run = mock_exec_run
+
+        result = await cpg_generator._validate_cpg_async(mock_container, "/workspace/cpg.bin")
+
+        assert result is False
+
+    @pytest.mark.asyncio
+    async def test_extract_file_size_success(self, cpg_generator):
+        """Test successful file size extraction"""
+        mock_container = MagicMock()
+        
+        def mock_exec_run(cmd):
+            mock_result = MagicMock()
+            if "stat -c%s" in cmd:
+                mock_result.output = b"5242880"  # 5MB
+            return mock_result
+        
+        mock_container.exec_run = mock_exec_run
+
+        result = await cpg_generator._extract_file_size_async(mock_container, "/workspace/cpg.bin")
+
+        assert result == 5242880
+
+    @pytest.mark.asyncio
+    async def test_extract_file_size_fallback(self, cpg_generator):
+        """Test file size extraction with fallback to wc command"""
+        mock_container = MagicMock()
+        
+        call_count = 0
+        def mock_exec_run(cmd):
+            nonlocal call_count
+            mock_result = MagicMock()
+            
+            if "stat -c%s" in cmd:
+                # First call fails with non-numeric output
+                mock_result.output = b"invalid"
+            elif "wc -c" in cmd:
+                # Fallback to wc
+                mock_result.output = b"1048576"  # 1MB
+            return mock_result
+        
+        mock_container.exec_run = mock_exec_run
+
+        result = await cpg_generator._extract_file_size_async(mock_container, "/workspace/cpg.bin")
+
+        assert result == 1048576
+
     @pytest.mark.asyncio
     async def test_get_container_id(self, cpg_generator):
         """Test getting container ID for session"""