test_generation_api.h

Go to the documentation of this file.

#ifndef YAZE_CLI_AUTOMATION_TEST_GENERATION_API_H
#define YAZE_CLI_AUTOMATION_TEST_GENERATION_API_H
 
#include <chrono>
#include <functional>
#include <memory>
#include <string>
#include <vector>
 
#include "absl/status/status.h"
#include "absl/status/statusor.h"
#include "app/editor/editor.h"
#include "nlohmann/json.hpp"
 
namespace yaze {
namespace cli {
namespace automation {
 
class TestGenerationAPI {
 public:
  // ============================================================================
  // Test Frameworks
  // ============================================================================
 
  enum class TestFramework {
    GTEST,      // Google Test
    CATCH2,     // Catch2
    DOCTEST,    // doctest
    IMGUI_TEST  // ImGui Test Engine
  };
 
  // ============================================================================
  // Recording Infrastructure
  // ============================================================================
 
  struct RecordedInteraction {
    std::chrono::steady_clock::time_point timestamp;
    std::string action_type;  // click, drag, keyboard, menu, etc.
    nlohmann::json parameters;
    nlohmann::json pre_state;   // State before action
    nlohmann::json post_state;  // State after action
  };
 
  struct RecordingSession {
    std::string name;
    std::chrono::steady_clock::time_point started_at;
    std::chrono::steady_clock::time_point ended_at;
    std::vector<RecordedInteraction> interactions;
    nlohmann::json initial_state;
    nlohmann::json final_state;
    std::map<std::string, std::string> metadata;
  };
 
  absl::Status StartRecording(const std::string& test_name,
                              bool capture_state = true);
 
  absl::StatusOr<RecordingSession> StopRecording();
 
  void PauseRecording();
 
  void ResumeRecording();
 
  void AnnotateRecording(const std::string& annotation);
 
  // ============================================================================
  // Test Code Generation
  // ============================================================================
 
  struct GenerationOptions {
    TestFramework framework = TestFramework::GTEST;
    bool include_setup_teardown = true;
    bool generate_assertions = true;
    bool include_comments = true;
    bool use_fixtures = true;
    bool generate_mocks = false;
    std::string namespace_name = "yaze::test";
    std::string output_directory;
  };
 
  absl::StatusOr<std::string> GenerateTestFromRecording(
      const RecordingSession& session,
      const GenerationOptions& options = {});
 
  struct TestSpecification {
    std::string class_under_test;
    std::vector<std::string> methods_to_test;
    bool include_edge_cases = true;
    bool include_error_cases = true;
    bool include_performance_tests = false;
    std::map<std::string, nlohmann::json> custom_cases;
  };
 
  absl::StatusOr<std::string> GenerateTestSuite(
      const TestSpecification& spec,
      const GenerationOptions& options = {});
 
  absl::StatusOr<std::string> GenerateRegressionTest(
      const std::string& bug_description,
      const std::vector<std::string>& repro_steps,
      const std::string& expected_behavior,
      const GenerationOptions& options = {});
 
  // ============================================================================
  // Test Fixtures and Mocks
  // ============================================================================
 
  absl::StatusOr<std::string> GenerateFixture(
      app::editor::Editor* editor,
      const std::string& fixture_name);
 
  absl::StatusOr<std::string> GenerateMock(
      const std::string& interface_name,
      const std::string& mock_name);
 
  // ============================================================================
  // Test Execution
  // ============================================================================
 
  struct TestResult {
    bool passed;
    std::string test_name;
    double execution_time_ms;
    std::string output;
    std::vector<std::string> failures;
    std::vector<std::string> warnings;
    nlohmann::json coverage_data;
  };
 
  absl::StatusOr<TestResult> ExecuteGeneratedTest(
      const std::string& test_code,
      bool compile_only = false);
 
  absl::StatusOr<std::vector<TestResult>> RunTestFile(
      const std::string& test_file,
      const std::string& filter = "");
 
  // ============================================================================
  // Coverage Analysis
  // ============================================================================
 
  struct CoverageReport {
    double line_coverage_percent;
    double branch_coverage_percent;
    double function_coverage_percent;
    std::map<std::string, double> file_coverage;
    std::vector<std::string> uncovered_lines;
    std::vector<std::string> uncovered_branches;
  };
 
  absl::StatusOr<CoverageReport> GenerateCoverageReport(
      const std::vector<TestResult>& test_results);
 
  // ============================================================================
  // Test Validation
  // ============================================================================
 
  std::vector<std::string> ValidateTestCode(const std::string& test_code);
 
  std::map<std::string, std::vector<std::string>> CheckRequirementsCoverage(
      const std::string& test_code,
      const std::vector<std::string>& requirements);
 
  // ============================================================================
  // AI-Assisted Test Generation
  // ============================================================================
 
  absl::StatusOr<nlohmann::json> SuggestTestCases(
      const std::string& code_under_test,
      const std::string& model_name = "gemini");
 
  absl::StatusOr<std::string> ImproveTest(
      const std::string& test_code,
      const std::vector<std::string>& improvement_goals);
 
  // ============================================================================
  // Test Organization
  // ============================================================================
 
  nlohmann::json OrganizeTestSuites(
      const std::vector<std::string>& test_files);
 
  absl::StatusOr<std::string> GenerateTestDocumentation(
      const std::string& test_file,
      const std::string& format = "markdown");
 
  // ============================================================================
  // Callbacks and Events
  // ============================================================================
 
  using RecordingCallback = std::function<void(const RecordedInteraction&)>;
  using GenerationCallback = std::function<void(const std::string& progress)>;
 
  void SetRecordingCallback(RecordingCallback callback);
 
  void SetGenerationCallback(GenerationCallback callback);
 
 private:
  std::unique_ptr<RecordingSession> current_recording_;
  bool is_recording_ = false;
  bool is_paused_ = false;
  RecordingCallback recording_callback_;
  GenerationCallback generation_callback_;
 
  // Helper methods
  std::string GenerateTestHeader(const GenerationOptions& options) const;
  std::string GenerateTestBody(const RecordingSession& session,
                               const GenerationOptions& options) const;
  std::string GenerateAssertion(const RecordedInteraction& interaction,
                                TestFramework framework) const;
  absl::Status CompileTest(const std::string& test_code) const;
};
 
}  // namespace automation
}  // namespace cli
}  // namespace yaze
 
#endif  // YAZE_CLI_AUTOMATION_TEST_GENERATION_API_H