new testarena

asf-cloud-server/testarena_1/scenario_scan.py

@@ -0,0 +1,127 @@
+import os
+import sys
+from collections import defaultdict
+
+def find_test_scenarios(root_dir):
+    """
+    Recursively searches the given root directory for files ending with
+    '.test_scenario.xml' and returns a dictionary mapping scenario names to their
+    paths relative to the root directory.
+
+    Args:
+        root_dir (str): The absolute path to the starting directory (e.g., 'COMPONENTS').
+
+    Returns:
+        dict[str, str]: A dictionary mapping scenario names (without suffix) to 
+                        their relative file paths.
+    """
+    if not os.path.isdir(root_dir):
+        print(f"Error: Directory not found or not accessible: {root_dir}")
+        return {} # Return empty dictionary
+
+    print(f"Scanning directory: '{root_dir}'...")
+
+    scenario_suffix = ".test_scenario.xml"
+    
+    # Dictionary comprehension: {scenario_name: relative_path}
+    scenarios_map = {
+        # Key: Scenario name (filename without suffix)
+        filename.replace(scenario_suffix, ""): 
+        # Value: Relative path
+        os.path.relpath(os.path.join(dirpath, filename), root_dir)
+        
+        for dirpath, _, filenames in os.walk(root_dir)
+        for filename in filenames if filename.endswith(scenario_suffix)
+    }
+    
+    return scenarios_map
+
+def organize_by_layer_component(scenarios_map):
+    """
+    Organizes scenario paths into a nested dictionary structure based on the file path:
+    {Layer_Folder: {Component_Folder: [scenario_name, ...]}}
+    
+    It assumes the Layer is the first folder and the Component is the folder
+    preceding the 'test' directory (i.e., the third-to-last segment).
+
+    Args:
+        scenarios_map (dict[str, str]): Dictionary mapping scenario names to their 
+                                        relative file paths.
+
+    Returns:
+        defaultdict: Nested dictionary (Layer -> Component -> List of Scenario Names).
+    """
+    organized_data = defaultdict(lambda: defaultdict(list))
+    
+    # Iterate over the scenario name and path
+    for scenario_name, path in scenarios_map.items():
+        # Split path into segments using the OS separator
+        segments = path.split(os.sep)
+        
+        # Layer is the first segment (e.g., 'application_layer', 'drivers')
+        layer = segments[0]
+        
+        # Component is the third-to-last segment (e.g., 'actuator_manager', 'ammonia')
+        # We assume the file is inside a 'test' folder inside a component folder.
+        if len(segments) >= 3:
+            component = segments[-3]
+        else:
+            # Fallback for scenarios found too close to the root
+            component = "Root_Component" 
+
+        # Populate the nested dictionary
+        organized_data[layer][component].append(scenario_name)
+        
+    return organized_data
+
+def scenario_scan(components_root_dir):
+    """
+    Main function to scan for test scenarios, print the organized structure, and
+    return the resulting dictionaries.
+    
+    Returns:
+        tuple[defaultdict, dict]: The organized layer/component structure and the 
+                                  raw dictionary of scenario names to paths.
+    """
+    # 1. Find all relative paths (now a dictionary: {name: path})
+    found_scenarios_map = find_test_scenarios(components_root_dir)
+
+    if not found_scenarios_map:
+        print(f"\nNo files ending with '.test_scenario.xml' were found in {components_root_dir}.")
+        # Return empty structures if nothing is found
+        return defaultdict(lambda: defaultdict(list)), {}
+    
+    num_scenarios = len(found_scenarios_map)
+    
+    # 2. Print the simple list of found paths
+    print(f"\n--- Found {num_scenarios} Test Scenarios ---")
+    for scenario_name, path in found_scenarios_map.items():
+        print(f"Scenario: '{scenario_name}' | Relative Path: {os.path.join("components",path)}")
+
+    # 3. Organize into the layer/component structure
+    organized_scenarios = organize_by_layer_component(found_scenarios_map)
+
+    # 4. Print the organized structure
+    print("\n--- Organized Layer/Component Structure ---")
+    for layer, components in organized_scenarios.items():
+        print(f"\n[LAYER] {layer.upper()}:")
+        for component, scenarios in components.items():
+            scenario_list = ", ".join(scenarios)
+            print(f"  [Component] {component}: {scenario_list}")
+
+    return organized_scenarios, found_scenarios_map
+
+if __name__ == "__main__":
+    # Check if the user provided the path as a command-line argument
+    if len(sys.argv) < 2:
+        print("Usage: python scan_scenarios.py <path_to_components_folder>")
+        print("\nExample:")
+        print("  python scan_scenarios.py \"D:\\ASF_01\\GITEA\\ASF-SH\\COMPONENTS\"")
+        sys.exit(1)
+
+    # The first argument is the directory path
+    components_root_dir = sys.argv[1]
+    
+    # The return value from scenario_scan now includes the dictionary you requested
+    organized_data, scenario_map = scenario_scan(components_root_dir)
+    print(scenario_map)