import argparse import json import shelve import sys from pathlib import Path from typing import Optional, Union from dotenv import load_dotenv from autoresttest.config import get_config from autoresttest.config.config import Config from autoresttest.graph import RequestGenerator from autoresttest.graph.generate_graph import OperationGraph from autoresttest.llm import LanguageModel from autoresttest.marl import QLearning from autoresttest.models import to_dict_helper from autoresttest.specification import SpecificationParser from autoresttest.tui import ConfigWizard, InitializationProgressDisplay, LiveDisplay, TUIDisplay from autoresttest.tui.config_wizard import apply_config_overrides from autoresttest.tui.themes import DEFAULT_THEME from autoresttest.utils import ( EmbeddingModel, construct_db_dir, get_api_url, get_graph_cache_path, get_q_table_cache_path, is_json_seriable, ) load_dotenv() AUTORESTTEST_DIR = Path(__file__).resolve().parent PROJECT_ROOT = AUTORESTTEST_DIR.parent.parent DATA_ROOT = PROJECT_ROOT / "data" def ensure_output_dir(spec_name: str) -> Path: output_dir = DATA_ROOT / spec_name output_dir.mkdir(parents=True, exist_ok=True) return output_dir def parse_args(): parser = argparse.ArgumentParser( description="AutoRestTest - Automated REST API Testing with Multi-Agent RL", formatter_class=argparse.RawDescriptionHelpFormatter, epilog=""" Examples: autoresttest # Run with TUI and configuration wizard autoresttest --quick # Quick setup (essential settings only) autoresttest --skip-wizard # Skip wizard, use configurations.toml directly For more information, visit: https://github.com/tylerstennett/AutoRestTest """, ) parser.add_argument( "--skip-wizard", action="store_true", help="Skip configuration wizard and use configurations.toml directly", ) parser.add_argument( "--quick", action="store_true", help="Run quick setup wizard (essential settings only)", ) parser.add_argument( "-s", "--spec", type=str, default=None, help="Override specification path (relative to project root)", ) parser.add_argument( "-t", "--time", type=int, default=None, help="Override test duration in seconds", ) parser.add_argument( "--width", type=int, default=100, help="TUI display width (default: 100)", ) return parser.parse_args() def output_q_table(q_learning: QLearning, spec_name: str): parameter_table = q_learning.parameter_agent.q_table body_obj_table = q_learning.body_object_agent.q_table value_table = q_learning.value_agent.q_table operation_table = q_learning.operation_agent.q_table data_source_table = q_learning.data_source_agent.q_table dependency_table = q_learning.dependency_agent.q_table header_table = ( q_learning.header_agent.q_table if q_learning.header_agent.q_table else "Disabled" ) simplified_param_table = {} for operation, operation_values in parameter_table.items(): simplified_param_table[operation] = {"params": {}, "body": {}} for parameter, parameter_values in operation_values["params"].items(): simplified_param_table[operation]["params"][str(parameter)] = ( parameter_values ) for body, body_values in operation_values["body"].items(): simplified_param_table[operation]["body"][str(body)] = body_values simplified_body_table = {} for operation, operation_values in body_obj_table.items(): simplified_body_table[operation] = {} for mime_type, mime_values in operation_values.items(): if mime_type not in simplified_body_table[operation]: simplified_body_table[operation][mime_type] = {} for body, body_values in mime_values.items(): simplified_body_table[operation][mime_type][str(body)] = body_values compiled_q_table = { "OPERATION AGENT": operation_table, "HEADER AGENT": header_table, "PARAMETER AGENT": simplified_param_table, "VALUE AGENT": value_table, "BODY OBJECT AGENT": simplified_body_table, "DATA SOURCE AGENT": data_source_table, "DEPENDENCY AGENT": dependency_table, } compiled_q_table = to_dict_helper(compiled_q_table) output_dir = ensure_output_dir(spec_name) q_tables_path = output_dir / "q_tables.json" with q_tables_path.open("w") as f: json.dump(compiled_q_table, f, indent=2) def output_successes(q_learning: QLearning, spec_name: str): output_dir = ensure_output_dir(spec_name) with (output_dir / "successful_parameters.json").open("w") as f: json.dump(to_dict_helper(q_learning.successful_parameters), f, indent=2) with (output_dir / "successful_bodies.json").open("w") as f: json.dump(q_learning.successful_bodies, f, indent=2) with (output_dir / "successful_responses.json").open("w") as f: json.dump(q_learning.successful_responses, f, indent=2) with (output_dir / "successful_primitives.json").open("w") as f: json.dump(q_learning.successful_primitives, f, indent=2) def output_errors(q_learning: QLearning, spec_name: str): output_dir = ensure_output_dir(spec_name) seriable_errors = {} for operation_idx, unique_errors in q_learning.unique_errors.items(): seriable_errors[operation_idx] = [ error for error in unique_errors if is_json_seriable(error) ] with (output_dir / "server_errors.json").open("w") as f: json.dump(seriable_errors, f, indent=2) def output_operation_status_codes(q_learning: QLearning, spec_name: str): output_dir = ensure_output_dir(spec_name) with (output_dir / "operation_status_codes.json").open("w") as f: json.dump(q_learning.operation_response_counter, f, indent=2) def output_report( q_learning: QLearning, spec_name: str, spec_parser: SpecificationParser ): output_dir = ensure_output_dir(spec_name) title = spec_parser.get_api_title() if spec_parser.get_api_title() else spec_name title = f"'{title}' ({spec_name})" unique_processed_200s = set() for operation_idx, status_codes in q_learning.operation_response_counter.items(): for status_code in status_codes: if status_code // 100 == 2: unique_processed_200s.add(operation_idx) unique_errors = 0 for operation_idx in q_learning.unique_errors: unique_errors += len(q_learning.unique_errors[operation_idx]) total_requests = sum(q_learning.responses.values()) report_content = { "Title": "AutoRestTest Report for " + title, "Duration": f"{q_learning.time_duration} seconds", "Total Requests Sent": total_requests, "Status Code Distribution": dict(q_learning.responses), "Number of Total Operations": len(q_learning.operation_agent.q_table), "Number of Successfully Processed Operations": len(unique_processed_200s), "Percentage of Successfully Processed Operations": str( round( len(unique_processed_200s) / max(len(q_learning.operation_agent.q_table), 1) * 100, 2, ) ) + "%", "Number of Unique Server Errors": unique_errors, "Operations with Server Errors": q_learning.errors, } with (output_dir / "report.json").open("w") as f: json.dump(report_content, f, indent=2) def parse_specification_location(spec_loc: str): spec_path = Path(spec_loc).expanduser() return spec_path.parent, spec_path.stem, spec_path.suffix class AutoRestTest: """Main AutoRestTest execution class with TUI integration.""" def __init__( self, spec_dir: Union[Path, str], config: Config, tui: TUIDisplay, ): self.spec_dir = Path(spec_dir).expanduser() self.is_naive = False construct_db_dir() self.config = config self.tui = tui self.use_cached_graph = self.config.cache.use_cached_graph self.use_cached_table = self.config.cache.use_cached_table def init_graph( self, spec_name: str, spec_path: Union[Path, str], embedding_model: EmbeddingModel, ) -> OperationGraph: self.tui.print_step(f"Parsing OpenAPI specification: {spec_path}...", "progress") spec_parser = SpecificationParser(spec_path=str(spec_path), spec_name=spec_name) self.tui.print_step("Specification parsed successfully!", "success") if self.config.api.override_url: api_url = self.config.custom_api_url self.tui.print_step(f"Using custom API URL: {api_url}", "info") else: api_url = get_api_url(spec_parser) self.tui.print_step(f"Using API URL from specification: {api_url}", "info") operation_graph = OperationGraph( spec_path=str(spec_path), spec_name=spec_name, spec_parser=spec_parser, embedding_model=embedding_model, ) request_generator = RequestGenerator( operation_graph=operation_graph, api_url=api_url, is_naive=self.is_naive ) operation_graph.assign_request_generator(request_generator) return operation_graph def generate_graph( self, spec_name: str, ext: str, embedding_model: EmbeddingModel ) -> OperationGraph: spec_path = self.spec_dir / f"{spec_name}{ext}" db_graph = get_graph_cache_path(spec_name) self.tui.print_phase_start( "Semantic Operation Dependency Graph", "Building operation relationships and dependencies", ) # Always initialize the graph first operation_graph = self.init_graph(spec_name, spec_path, embedding_model) with shelve.open(str(db_graph)) as db: loaded_from_shelf = False if spec_name in db and self.use_cached_graph: self.tui.print_step(f"Loading cached graph for {spec_name}...", "progress") try: graph_properties = db[spec_name] operation_graph.operation_edges = graph_properties["edges"] operation_graph.operation_nodes = graph_properties["nodes"] self.tui.print_step("Loaded graph from cache", "success") loaded_from_shelf = True except Exception as e: self.tui.print_step(f"Cache load failed: {e}", "warning") if not loaded_from_shelf: self.tui.print_step(f"Building new graph for {spec_name}...", "progress") operation_graph.create_graph() graph_properties = { "edges": operation_graph.operation_edges, "nodes": operation_graph.operation_nodes, } try: db[spec_name] = graph_properties self.tui.print_step("Graph cached for future runs", "success") except Exception as e: self.tui.print_step(f"Cache save failed: {e}", "warning") self.tui.print_phase_complete( "Graph Construction", f"{len(operation_graph.operation_nodes)} operations discovered", ) return operation_graph def perform_q_learning(self, operation_graph: OperationGraph, spec_name: str): self.tui.print_phase_start( "Q-Table Initialization", "Initializing reinforcement learning agents", ) q_learning = QLearning( operation_graph, alpha=self.config.q_learning.learning_rate, gamma=self.config.q_learning.discount_factor, epsilon=self.config.q_learning.max_exploration, time_duration=self.config.request_generation.time_duration, mutation_rate=self.config.request_generation.mutation_rate, tui=self.tui, ) db_q_table = get_q_table_cache_path(spec_name) # Initialize Q-tables for all agents with progress tracking agents = [ ("Operation", q_learning.operation_agent), ("Parameter", q_learning.parameter_agent), ("Body Object", q_learning.body_object_agent), ("Dependency", q_learning.dependency_agent), ("Data Source", q_learning.data_source_agent), ] for agent_name, agent in agents: agent.initialize_q_table() self.tui.print_step(f"Initialized {agent_name} Agent Q-table", "success") output_q_table(q_learning, spec_name) with shelve.open(str(db_q_table)) as db: loaded_value_from_shelf = False loaded_header_from_shelf = False if spec_name in db and self.use_cached_table: self.tui.print_step(f"Loading cached Q-tables for {spec_name}...", "progress") compiled_q_table = db[spec_name] try: q_learning.value_agent.q_table = compiled_q_table["value"] self.tui.print_step("Loaded Value Agent Q-table from cache", "success") loaded_value_from_shelf = True except Exception: self.tui.print_step("Cache load failed for Value Agent", "warning") loaded_value_from_shelf = False if self.config.enable_header_agent: try: q_learning.header_agent.q_table = compiled_q_table["header"] self.tui.print_step("Loaded Header Agent Q-table from cache", "success") loaded_header_from_shelf = ( True if q_learning.header_agent.q_table else False ) except Exception: self.tui.print_step("Cache load failed for Header Agent", "warning") loaded_header_from_shelf = False if not loaded_value_from_shelf: total_ops = len(operation_graph.operation_nodes) with InitializationProgressDisplay( title="Value Agent Q-Table Generation", total_operations=total_ops, width=self.tui.width, ) as progress: def value_progress_callback(op_id: str, completed: int): progress.update(op_id, completed) q_learning.value_agent.initialize_q_table( progress_callback=value_progress_callback ) token_counter = LanguageModel.get_tokens() self.tui.print_step( f"Value Agent Q-table generated - Tokens: {token_counter.input_tokens:,} in / {token_counter.output_tokens:,} out", "success", ) if self.config.enable_header_agent and not loaded_header_from_shelf: total_ops = len(operation_graph.operation_nodes) with InitializationProgressDisplay( title="Header Agent Q-Table Generation", total_operations=total_ops, width=self.tui.width, ) as progress: def header_progress_callback(op_id: str, completed: int): progress.update(op_id, completed) q_learning.header_agent.initialize_q_table( progress_callback=header_progress_callback ) token_counter = LanguageModel.get_tokens() self.tui.print_step( f"Header Agent Q-table generated - Tokens: {token_counter.input_tokens:,} in / {token_counter.output_tokens:,} out", "success", ) elif not self.config.enable_header_agent: q_learning.header_agent.q_table = {} try: db[spec_name] = { "value": q_learning.value_agent.q_table, "header": q_learning.header_agent.q_table, } self.tui.print_step("Q-tables cached for future runs", "success") except Exception: self.tui.print_step("Failed to cache Q-tables", "warning") output_q_table(q_learning, spec_name) self.tui.print_phase_complete("Q-Table Initialization") self.tui.print_phase_start( "Request Generation (MARL)", f"Testing API for {self.config.request_generation.time_duration} seconds using Multi-Agent Reinforcement Learning", ) q_learning.run() self.tui.print_phase_complete("Request Generation") return q_learning def print_performance(self, q_learning: QLearning, spec_parser: SpecificationParser): token_counter = LanguageModel.get_tokens() # Calculate statistics for final report unique_processed_200s = set() for operation_idx, status_codes in q_learning.operation_response_counter.items(): for status_code in status_codes: if status_code // 100 == 2: unique_processed_200s.add(operation_idx) unique_errors = sum(len(errs) for errs in q_learning.unique_errors.values()) total_requests = sum(q_learning.responses.values()) title = spec_parser.get_api_title() if spec_parser.get_api_title() else "API" self.tui.print_final_report( title=title, duration=q_learning.time_duration, total_requests=total_requests, status_distribution=dict(q_learning.responses), total_operations=len(q_learning.operation_agent.q_table), successful_operations=len(unique_processed_200s), unique_errors=unique_errors, ) self.tui.print_token_usage( input_tokens=token_counter.input_tokens, output_tokens=token_counter.output_tokens, ) def run_all(self): for spec_file in self.spec_dir.iterdir(): if not spec_file.is_file(): continue spec_name = spec_file.stem self.tui.print_section_header(f"Testing: {spec_name}") self.run_single(spec_name, spec_file.suffix) def run_single(self, spec_name: str, ext: str): self.tui.print_section_header(f"Testing: {spec_name}") embedding_model = EmbeddingModel() operation_graph = self.generate_graph(spec_name, ext, embedding_model) q_learning = self.perform_q_learning(operation_graph, spec_name) self.print_performance(q_learning, operation_graph.spec_parser) output_q_table(q_learning, spec_name) output_successes(q_learning, spec_name) output_errors(q_learning, spec_name) output_operation_status_codes(q_learning, spec_name) output_report(q_learning, spec_name, operation_graph.spec_parser) self.tui.print_success("AutoRestTest completed successfully!") self.tui.print_step(f"Results saved to: data/{spec_name}/", "info") def main(): args = parse_args() # Initialize TUI (always enabled) tui = TUIDisplay(width=args.width) tui.clear() tui.print_banner() # Get configuration if args.skip_wizard: config = get_config() else: wizard = ConfigWizard(width=args.width) overrides = wizard.run(quick_mode=args.quick) if overrides is None: # User cancelled sys.exit(0) elif overrides: config = apply_config_overrides(overrides) else: config = get_config() # Apply CLI overrides if args.spec or args.time: from autoresttest.config.config import _load_raw_config raw_config = _load_raw_config() if args.spec: raw_config["spec"]["location"] = args.spec if args.time: raw_config["request_generation"]["time_duration"] = args.time config = Config.model_validate(raw_config) # Display configuration summary config_summary = { "Specification": config.specification_location, "LLM Engine": config.openai_llm_engine, "API Base": config.llm_api_base, "Duration": f"{config.request_generation.time_duration}s", "Cache Graph": config.cache.use_cached_graph, "Cache Q-Tables": config.cache.use_cached_table, } tui.print_config_summary(config_summary) if not tui.confirm("Start testing with this configuration?"): tui.print_warning("Execution cancelled by user") sys.exit(0) # Parse specification location and run specification_directory, specification_name, ext = parse_specification_location( str(PROJECT_ROOT / config.specification_location) ) auto_rest_test = AutoRestTest( spec_dir=specification_directory, config=config, tui=tui, ) auto_rest_test.run_single(specification_name, ext) if __name__ == "__main__": main()