debug

Author: KRRT7

codeflash/discovery/discover_unit_tests.py

@@ -297,7 +297,6 @@ def _process_single_test_file(
 
     jedi_project = jedi.Project(path=project_root_path)
     results = []
-    cache_entries = []
 
     try:
         script = jedi.Script(path=test_file, project=jedi_project)
@@ -323,7 +322,7 @@ def _process_single_test_file(
                     reference_names.append((name, m.group(1)))
     except Exception as e:
         logger.debug(f"Failed to get jedi script for {test_file}: {e}")
-        return str(test_file), results, len(results), cache_entries
+        return str(test_file), results, len(results), []
 
     if test_framework == "pytest":
         for function in functions:
@@ -430,19 +429,7 @@ def _process_single_test_file(
                 )
                 results.append((qualified_name_with_modules_from_root, function_called_in_test))
 
-                cache_entries.append(
-                    {
-                        "qualified_name_with_modules_from_root": qualified_name_with_modules_from_root,
-                        "function_name": scope,
-                        "test_class": scope_test_class,
-                        "test_function": scope_test_function,
-                        "test_type": test_type,
-                        "line_number": name.line,
-                        "col_number": name.column,
-                    }
-                )
-
-    return str(test_file), results, len(results), cache_entries
+    return str(test_file), results, len(results), []
 
 
 def process_test_files(
@@ -453,88 +440,43 @@ def process_test_files(
     function_to_test_map = defaultdict(set)
     total_count = 0
 
-    tests_cache = TestsCache()
-
     max_workers = min(len(file_to_test_map) or 1, multiprocessing.cpu_count())
 
     with test_files_progress_bar(total=len(file_to_test_map), description="Processing test files") as (
         progress,
         task_id,
     ):
-        cached_files = {}
-        uncached_files = {}
-
-        for test_file, functions in file_to_test_map.items():
-            file_hash = TestsCache.compute_file_hash(str(test_file))
-            cached_tests = tests_cache.get_tests_for_file(str(test_file), file_hash)
-
-            if cached_tests:
-                cached_files[test_file] = (functions, cached_tests, file_hash)
-            else:
-                uncached_files[test_file] = functions
-
-        for test_file, (_functions, cached_tests, file_hash) in cached_files.items():
-            cur = tests_cache.cur
-            cur.execute(
-                "SELECT qualified_name_with_modules_from_root FROM discovered_tests WHERE file_path = ? AND file_hash = ?",
-                (str(test_file), file_hash),
-            )
-            qualified_names = [row[0] for row in cur.fetchall()]
-            for cached_test, qualified_name in zip(cached_tests, qualified_names):
-                function_to_test_map[qualified_name].add(cached_test)
-            total_count += len(cached_tests)
-            progress.advance(task_id)
-
-        if len(uncached_files) == 1 or max_workers == 1:
-            for test_file, functions in uncached_files.items():
-                _, results, count, cache_entries = _process_single_test_file(
+        if len(file_to_test_map) == 1 or max_workers == 1:
+            for test_file, functions in file_to_test_map.items():
+                _, results, count, _ = _process_single_test_file(
                     test_file, functions, project_root_path, test_framework
                 )
                 total_count += count
 
-                file_hash = TestsCache.compute_file_hash(str(test_file))
-                for cache_entry in cache_entries:
-                    tests_cache.insert_test(file_path=str(test_file), file_hash=file_hash, **cache_entry)
-
                 for qualified_name, function_called in results:
                     function_to_test_map[qualified_name].add(function_called)
                 progress.advance(task_id)
         else:
-            all_cache_entries = []
             with ProcessPoolExecutor(max_workers=max_workers) as executor:
                 future_to_file = {
                     executor.submit(
                         _process_single_test_file, test_file, functions, project_root_path, test_framework
                     ): test_file
-                    for test_file, functions in uncached_files.items()
+                    for test_file, functions in file_to_test_map.items()
                 }
 
                 for future in as_completed(future_to_file):
                     try:
-                        _, results, count, cache_entries = future.result()
+                        _, results, count, _ = future.result()
                         total_count += count
 
-                        test_file = future_to_file[future]
-                        file_hash = TestsCache.compute_file_hash(str(test_file))
-                        
-                        # Collect cache entries for batch insertion
-                        for cache_entry in cache_entries:
-                            cache_entry['file_path'] = str(test_file)
-                            cache_entry['file_hash'] = file_hash
-                            all_cache_entries.append(cache_entry)
-
                         for qualified_name, function_called in results:
                             function_to_test_map[qualified_name].add(function_called)
                         progress.advance(task_id)
                     except Exception as e:
                         test_file = future_to_file[future]
                         logger.error(f"Error processing test file {test_file}: {e}")
                         progress.advance(task_id)
-            
-            # Batch insert all cache entries after all workers complete
-            for cache_entry in all_cache_entries:
-                tests_cache.insert_test(**cache_entry)
 
-    tests_cache.close()
     function_to_tests_dict = {function: list(tests) for function, tests in function_to_test_map.items()}
     return function_to_tests_dict, total_count