WizardMerge/backend/tests/test_context_analyzer.cpp

/**
 * @file test_context_analyzer.cpp
 * @brief Unit tests for context analysis module
 */

#include "wizardmerge/analysis/context_analyzer.h"
#include <gtest/gtest.h>

using namespace wizardmerge::analysis;

/**
 * Test basic context analysis
 */
TEST(ContextAnalyzerTest, BasicContextAnalysis) {
  std::vector<std::string> lines = {"#include <iostream>",
                                    "",
                                    "class MyClass {",
                                    "public:",
                                    "    void myMethod() {",
                                    "        int x = 42;",
                                    "        int y = 100;",
                                    "        return;",
                                    "    }",
                                    "};"};

  auto context = analyze_context(lines, 5, 7);

  EXPECT_EQ(context.start_line, 5);
  EXPECT_EQ(context.end_line, 7);
  EXPECT_FALSE(context.surrounding_lines.empty());
}

/**
 * Test function name extraction
 */
TEST(ContextAnalyzerTest, ExtractFunctionName) {
  std::vector<std::string> lines = {"void testFunction() {", "    int x = 10;",
                                    "    return;", "}"};

  std::string func_name = extract_function_name(lines, 1);
  EXPECT_EQ(func_name, "testFunction");
}

/**
 * Test Python function name extraction
 */
TEST(ContextAnalyzerTest, ExtractPythonFunctionName) {
  std::vector<std::string> lines = {"def my_python_function():", "    x = 10",
                                    "    return x"};

  std::string func_name = extract_function_name(lines, 1);
  EXPECT_EQ(func_name, "my_python_function");
}

/**
 * Test class name extraction
 */
TEST(ContextAnalyzerTest, ExtractClassName) {
  std::vector<std::string> lines = {"class TestClass {", "    int member;",
                                    "};"};

  std::string class_name = extract_class_name(lines, 1);
  EXPECT_EQ(class_name, "TestClass");
}

/**
 * Test import extraction
 */
TEST(ContextAnalyzerTest, ExtractImports) {
  std::vector<std::string> lines = {
      "#include <iostream>", "#include <vector>", "",
      "int main() {",        "    return 0;",     "}"};

  auto imports = extract_imports(lines);
  EXPECT_EQ(imports.size(), 2);
  EXPECT_EQ(imports[0], "#include <iostream>");
  EXPECT_EQ(imports[1], "#include <vector>");
}

/**
 * Test context with no function
 */
TEST(ContextAnalyzerTest, NoFunctionContext) {
  std::vector<std::string> lines = {"int x = 10;", "int y = 20;"};

  std::string func_name = extract_function_name(lines, 0);
  EXPECT_EQ(func_name, "");
}

/**
 * Test context window boundaries
 */
TEST(ContextAnalyzerTest, ContextWindowBoundaries) {
  std::vector<std::string> lines = {"line1", "line2", "line3", "line4",
                                    "line5"};

  // Test with small context window at beginning of file
  auto context = analyze_context(lines, 0, 0, 2);
  EXPECT_GE(context.surrounding_lines.size(), 1);

  // Test with context window at end of file
  context = analyze_context(lines, 4, 4, 2);
  EXPECT_GE(context.surrounding_lines.size(), 1);
}

/**
 * Test TypeScript function detection
 */
TEST(ContextAnalyzerTest, TypeScriptFunctionDetection) {
  std::vector<std::string> lines = {"export async function fetchData() {",
                                    "    const data = await api.get();",
                                    "    return data;", "}"};

  std::string func_name = extract_function_name(lines, 1);
  EXPECT_EQ(func_name, "fetchData");
}

/**
 * Test TypeScript arrow function detection
 */
TEST(ContextAnalyzerTest, TypeScriptArrowFunctionDetection) {
  std::vector<std::string> lines = {
      "const handleClick = (event: MouseEvent) => {", "    console.log(event);",
      "};"};

  std::string func_name = extract_function_name(lines, 0);
  EXPECT_EQ(func_name, "handleClick");
}

/**
 * Test TypeScript interface detection
 */
TEST(ContextAnalyzerTest, TypeScriptInterfaceDetection) {
  std::vector<std::string> lines = {
      "export interface User {", "    id: number;", "    name: string;", "}"};

  std::string class_name = extract_class_name(lines, 1);
  EXPECT_EQ(class_name, "User");
}

/**
 * Test TypeScript type alias detection
 */
TEST(ContextAnalyzerTest, TypeScriptTypeAliasDetection) {
  std::vector<std::string> lines = {
      "export type Status = 'pending' | 'approved' | 'rejected';",
      "const status: Status = 'pending';"};

  std::string type_name = extract_class_name(lines, 0);
  EXPECT_EQ(type_name, "Status");
}

/**
 * Test TypeScript enum detection
 */
TEST(ContextAnalyzerTest, TypeScriptEnumDetection) {
  std::vector<std::string> lines = {"enum Color {", "    Red,", "    Green,",
                                    "    Blue", "}"};

  std::string enum_name = extract_class_name(lines, 1);
  EXPECT_EQ(enum_name, "Color");
}

/**
 * Test TypeScript import extraction
 */
TEST(ContextAnalyzerTest, TypeScriptImportExtraction) {
  std::vector<std::string> lines = {"import { Component } from 'react';",
                                    "import type { User } from './types';",
                                    "import * as utils from './utils';",
                                    "",
                                    "function MyComponent() {",
                                    "    return null;",
                                    "}"};

  auto imports = extract_imports(lines);
  EXPECT_GE(imports.size(), 3);
}