swarm-engine-core 0.1.6

//! GraphMap 統合テスト
//!
//! 探索シナリオ全体をテストする。
//! Map の基本 API テストは map.rs 内の unit tests を参照。

use swarm_engine_core::exploration::map::{
    ExplorationMap, GraphMap, HierarchicalMap, MapNodeState,
};

// ============================================================================
// テスト用の型定義
// ============================================================================

/// テスト用ノード型
#[derive(Debug, Clone, PartialEq)]
enum NodeType {
    /// 検索クエリ（ルート）
    Search { query: String },
    /// ファイル（Read で内容確認 → Close）
    File { path: String },
    /// ディレクトリ（List で子を展開 → Close）
    Dir { path: String },
}

impl NodeType {
    fn key(&self) -> String {
        match self {
            NodeType::Search { query } => format!("search:{}", query),
            NodeType::File { path } => format!("file:{}", path),
            NodeType::Dir { path } => format!("dir:{}", path),
        }
    }
}

/// エッジ（アクション）の型
#[derive(Debug, Clone, PartialEq)]
enum EdgeType {
    Grep,
    List,
}

// ============================================================================
// 基本探索フローテスト
// ============================================================================

/// 基本的な探索フロー
///
/// シナリオ:
/// 1. Search("auth") をルートに
/// 2. Grep → File("src/auth.rs"), Dir("src/auth/")
/// 3. File → Read → Close
/// 4. Dir → List → File("src/auth/mod.rs"), File("src/auth/login.rs")
/// 5. 重複チェック: 同じパスは追加しない
/// 6. 全て Close
#[test]
fn test_exploration_basic_flow() {
    let mut map: GraphMap<NodeType, EdgeType, MapNodeState> = GraphMap::new();
    let key_fn = |n: &NodeType| n.key();

    // Step 1: Search ルートを作成
    let root = map
        .create_root_if_absent(
            NodeType::Search {
                query: "auth".to_string(),
            },
            MapNodeState::Open,
            key_fn,
        )
        .into_inner();

    assert_eq!(map.frontiers().len(), 1);

    // Step 2: Grep 結果を追加
    let file1 = map
        .add_child_if_absent(
            root,
            EdgeType::Grep,
            NodeType::File {
                path: "src/auth.rs".to_string(),
            },
            MapNodeState::Open,
            key_fn,
        )
        .unwrap()
        .into_inner();

    let dir1 = map
        .add_child_if_absent(
            root,
            EdgeType::Grep,
            NodeType::Dir {
                path: "src/auth/".to_string(),
            },
            MapNodeState::Open,
            key_fn,
        )
        .unwrap()
        .into_inner();

    // root は子が生成されたので Close
    map.set_state(root, MapNodeState::Closed);
    assert_eq!(map.frontiers().len(), 2); // file1, dir1

    // Step 3: File を Read して Close
    map.set_state(file1, MapNodeState::Closed);
    assert_eq!(map.frontiers().len(), 1); // dir1 only

    // Step 4: Dir を List して子ファイルを発見
    let file2 = map
        .add_child_if_absent(
            dir1,
            EdgeType::List,
            NodeType::File {
                path: "src/auth/mod.rs".to_string(),
            },
            MapNodeState::Open,
            key_fn,
        )
        .unwrap()
        .into_inner();

    let file3 = map
        .add_child_if_absent(
            dir1,
            EdgeType::List,
            NodeType::File {
                path: "src/auth/login.rs".to_string(),
            },
            MapNodeState::Open,
            key_fn,
        )
        .unwrap()
        .into_inner();

    // dir1 は展開完了したので Close
    map.set_state(dir1, MapNodeState::Closed);
    assert_eq!(map.frontiers().len(), 2); // file2, file3

    // Step 5: 重複チェック
    let dup_result = map.add_child_if_absent(
        root,
        EdgeType::Grep,
        NodeType::File {
            path: "src/auth.rs".to_string(),
        },
        MapNodeState::Open,
        key_fn,
    );
    assert!(dup_result.unwrap().is_already_exists());
    assert_eq!(map.node_count(), 5); // root, file1, dir1, file2, file3

    // Step 6: 残りを Close
    map.set_state(file2, MapNodeState::Closed);
    map.set_state(file3, MapNodeState::Closed);

    // 全て Close されたか確認
    assert!(map.frontiers().is_empty());
    assert_eq!(map.closed_nodes().len(), 5);
}

/// 深い階層の探索
///
/// シナリオ: root → dir1 → dir2 → dir3 → file
#[test]
fn test_exploration_deep_hierarchy() {
    let mut map: GraphMap<NodeType, EdgeType, MapNodeState> = GraphMap::new();
    let key_fn = |n: &NodeType| n.key();

    let root = map
        .create_root_if_absent(
            NodeType::Search {
                query: "deep".to_string(),
            },
            MapNodeState::Open,
            key_fn,
        )
        .into_inner();

    // 階層的にディレクトリを展開
    let dir1 = map
        .add_child_if_absent(
            root,
            EdgeType::Grep,
            NodeType::Dir {
                path: "a/".to_string(),
            },
            MapNodeState::Open,
            key_fn,
        )
        .unwrap()
        .into_inner();
    map.set_state(root, MapNodeState::Closed);

    let dir2 = map
        .add_child_if_absent(
            dir1,
            EdgeType::List,
            NodeType::Dir {
                path: "a/b/".to_string(),
            },
            MapNodeState::Open,
            key_fn,
        )
        .unwrap()
        .into_inner();
    map.set_state(dir1, MapNodeState::Closed);

    let dir3 = map
        .add_child_if_absent(
            dir2,
            EdgeType::List,
            NodeType::Dir {
                path: "a/b/c/".to_string(),
            },
            MapNodeState::Open,
            key_fn,
        )
        .unwrap()
        .into_inner();
    map.set_state(dir2, MapNodeState::Closed);

    let file = map
        .add_child_if_absent(
            dir3,
            EdgeType::List,
            NodeType::File {
                path: "a/b/c/target.rs".to_string(),
            },
            MapNodeState::Open,
            key_fn,
        )
        .unwrap()
        .into_inner();
    map.set_state(dir3, MapNodeState::Closed);

    // depth 確認
    assert_eq!(map.depth(root), 0);
    assert_eq!(map.depth(dir1), 1);
    assert_eq!(map.depth(dir2), 2);
    assert_eq!(map.depth(dir3), 3);
    assert_eq!(map.depth(file), 4);

    // 親子関係確認
    assert_eq!(map.parent(file), Some(dir3));
    assert_eq!(map.parent(dir3), Some(dir2));
    assert_eq!(map.parent(dir2), Some(dir1));
    assert_eq!(map.parent(dir1), Some(root));
    assert_eq!(map.parent(root), None);

    // frontiers は file のみ
    assert_eq!(map.frontiers(), vec![file]);

    // file を Close
    map.set_state(file, MapNodeState::Closed);
    assert!(map.frontiers().is_empty());
}

/// 並列 Worker による重複防止
///
/// シナリオ: Worker A と Worker B が同時に同じファイルを発見
#[test]
fn test_exploration_parallel_workers() {
    let mut map: GraphMap<NodeType, EdgeType, MapNodeState> = GraphMap::new();
    let key_fn = |n: &NodeType| n.key();

    let root = map
        .create_root_if_absent(
            NodeType::Search {
                query: "parallel".to_string(),
            },
            MapNodeState::Open,
            key_fn,
        )
        .into_inner();

    // Worker A: auth.rs を発見
    let result_a = map.add_child_if_absent(
        root,
        EdgeType::Grep,
        NodeType::File {
            path: "auth.rs".to_string(),
        },
        MapNodeState::Open,
        key_fn,
    );
    let file_a = result_a.unwrap();
    assert!(file_a.is_added());

    // Worker B: 同じ auth.rs を発見（並行実行をシミュレート）
    let result_b = map.add_child_if_absent(
        root,
        EdgeType::Grep,
        NodeType::File {
            path: "auth.rs".to_string(),
        },
        MapNodeState::Open,
        key_fn,
    );
    let file_b = result_b.unwrap();
    assert!(file_b.is_already_exists());

    // 同じ ID を返すことを確認
    assert_eq!(file_a.into_inner(), file_b.into_inner());

    // ノード数は 2 (root + auth.rs)
    assert_eq!(map.node_count(), 2);
}

/// サイクル防止
///
/// シナリオ: シンボリックリンク等でサイクルが発生するケース
/// dir_a/ → dir_b/ → dir_a/ (cycle!)
#[test]
fn test_exploration_cycle_prevention() {
    let mut map: GraphMap<NodeType, EdgeType, MapNodeState> = GraphMap::new();
    let key_fn = |n: &NodeType| n.key();

    let root = map
        .create_root_if_absent(
            NodeType::Search {
                query: "cycle".to_string(),
            },
            MapNodeState::Open,
            key_fn,
        )
        .into_inner();

    let dir_a = map
        .add_child_if_absent(
            root,
            EdgeType::Grep,
            NodeType::Dir {
                path: "dir_a/".to_string(),
            },
            MapNodeState::Open,
            key_fn,
        )
        .unwrap()
        .into_inner();
    map.set_state(root, MapNodeState::Closed);

    let dir_b = map
        .add_child_if_absent(
            dir_a,
            EdgeType::List,
            NodeType::Dir {
                path: "dir_b/".to_string(),
            },
            MapNodeState::Open,
            key_fn,
        )
        .unwrap()
        .into_inner();
    map.set_state(dir_a, MapNodeState::Closed);

    // dir_b から dir_a へのサイクル → 重複チェックで追加されない
    let cycle_result = map.add_child_if_absent(
        dir_b,
        EdgeType::List,
        NodeType::Dir {
            path: "dir_a/".to_string(),
        },
        MapNodeState::Open,
        key_fn,
    );
    assert!(cycle_result.unwrap().is_already_exists());

    // dir_b を Close
    map.set_state(dir_b, MapNodeState::Closed);

    // ノード数は 3 (root, dir_a, dir_b) - サイクルは追加されない
    assert_eq!(map.node_count(), 3);
    assert!(map.frontiers().is_empty());
}

// ============================================================================
// カスケードテスト
// ============================================================================

/// 下方向カスケード
///
/// 構造:
///       root
///      /    \
///   dir1    dir2
///   /  \
/// file1 file2
#[test]
fn test_cascade_down() {
    let mut map: GraphMap<NodeType, EdgeType, MapNodeState> = GraphMap::new();
    let key_fn = |n: &NodeType| n.key();

    let root = map
        .create_root_if_absent(
            NodeType::Search {
                query: "test".to_string(),
            },
            MapNodeState::Open,
            key_fn,
        )
        .into_inner();

    let dir1 = map
        .add_child_if_absent(
            root,
            EdgeType::Grep,
            NodeType::Dir {
                path: "dir1/".to_string(),
            },
            MapNodeState::Open,
            key_fn,
        )
        .unwrap()
        .into_inner();

    let dir2 = map
        .add_child_if_absent(
            root,
            EdgeType::Grep,
            NodeType::Dir {
                path: "dir2/".to_string(),
            },
            MapNodeState::Open,
            key_fn,
        )
        .unwrap()
        .into_inner();

    let file1 = map
        .add_child_if_absent(
            dir1,
            EdgeType::List,
            NodeType::File {
                path: "dir1/a.rs".to_string(),
            },
            MapNodeState::Open,
            key_fn,
        )
        .unwrap()
        .into_inner();

    let file2 = map
        .add_child_if_absent(
            dir1,
            EdgeType::List,
            NodeType::File {
                path: "dir1/b.rs".to_string(),
            },
            MapNodeState::Open,
            key_fn,
        )
        .unwrap()
        .into_inner();

    assert_eq!(map.frontiers().len(), 5);

    // dir1 から下方向カスケード → dir1, file1, file2 が Close
    let closed = map.cascade_down(dir1);

    assert_eq!(closed.len(), 3); // file1, file2, dir1
    assert!(map.get(dir1).unwrap().state.is_closed());
    assert!(map.get(file1).unwrap().state.is_closed());
    assert!(map.get(file2).unwrap().state.is_closed());

    // root と dir2 は Open のまま
    assert!(map.get(root).unwrap().state.is_open());
    assert!(map.get(dir2).unwrap().state.is_open());
    assert_eq!(map.frontiers().len(), 2); // root, dir2
}

/// 上方向カスケード
///
/// 構造:
///       root
///      /    \
///   dir1    dir2
///   /  \
/// file1 file2
#[test]
fn test_cascade_up() {
    let mut map: GraphMap<NodeType, EdgeType, MapNodeState> = GraphMap::new();
    let key_fn = |n: &NodeType| n.key();

    let root = map
        .create_root_if_absent(
            NodeType::Search {
                query: "test".to_string(),
            },
            MapNodeState::Open,
            key_fn,
        )
        .into_inner();

    let dir1 = map
        .add_child_if_absent(
            root,
            EdgeType::Grep,
            NodeType::Dir {
                path: "dir1/".to_string(),
            },
            MapNodeState::Open,
            key_fn,
        )
        .unwrap()
        .into_inner();

    let dir2 = map
        .add_child_if_absent(
            root,
            EdgeType::Grep,
            NodeType::Dir {
                path: "dir2/".to_string(),
            },
            MapNodeState::Open,
            key_fn,
        )
        .unwrap()
        .into_inner();

    let file1 = map
        .add_child_if_absent(
            dir1,
            EdgeType::List,
            NodeType::File {
                path: "dir1/a.rs".to_string(),
            },
            MapNodeState::Open,
            key_fn,
        )
        .unwrap()
        .into_inner();

    let file2 = map
        .add_child_if_absent(
            dir1,
            EdgeType::List,
            NodeType::File {
                path: "dir1/b.rs".to_string(),
            },
            MapNodeState::Open,
            key_fn,
        )
        .unwrap()
        .into_inner();

    // Step 1: file1 を Close + up cascade
    let closed1 = map.close_with_cascade_up(file1);
    // file1 のみ Close（file2 がまだ Open なので dir1 は Close されない）
    assert_eq!(closed1, vec![file1]);
    assert!(map.get(dir1).unwrap().state.is_open());

    // Step 2: file2 を Close + up cascade
    let closed2 = map.close_with_cascade_up(file2);
    // file2 と dir1 が Close（dir1 の子が全て Closed になった）
    assert_eq!(closed2.len(), 2);
    assert!(closed2.contains(&file2));
    assert!(closed2.contains(&dir1));
    assert!(map.get(dir1).unwrap().state.is_closed());
    assert!(map.get(root).unwrap().state.is_open()); // dir2 がまだ Open

    // Step 3: dir2 を Close + up cascade
    let closed3 = map.close_with_cascade_up(dir2);
    // dir2 と root が Close（root の子が全て Closed になった）
    assert_eq!(closed3.len(), 2);
    assert!(closed3.contains(&dir2));
    assert!(closed3.contains(&root));
    assert!(map.get(root).unwrap().state.is_closed());

    // 全て Close
    assert!(map.frontiers().is_empty());
}

/// 探索フローで上方向カスケードを使用
///
/// シナリオ:
/// 1. Search → Grep → dir1, dir2
/// 2. dir1 → List → file1, file2
/// 3. dir2 → List → file3
/// 4. 各ファイルを Close + up_cascade
/// 5. 自動的に全て Close される
#[test]
fn test_exploration_with_up_cascade() {
    let mut map: GraphMap<NodeType, EdgeType, MapNodeState> = GraphMap::new();
    let key_fn = |n: &NodeType| n.key();

    // 構築
    let root = map
        .create_root_if_absent(
            NodeType::Search {
                query: "auth".to_string(),
            },
            MapNodeState::Open,
            key_fn,
        )
        .into_inner();

    let dir1 = map
        .add_child_if_absent(
            root,
            EdgeType::Grep,
            NodeType::Dir {
                path: "auth/".to_string(),
            },
            MapNodeState::Open,
            key_fn,
        )
        .unwrap()
        .into_inner();

    let dir2 = map
        .add_child_if_absent(
            root,
            EdgeType::Grep,
            NodeType::Dir {
                path: "user/".to_string(),
            },
            MapNodeState::Open,
            key_fn,
        )
        .unwrap()
        .into_inner();

    let file1 = map
        .add_child_if_absent(
            dir1,
            EdgeType::List,
            NodeType::File {
                path: "auth/mod.rs".to_string(),
            },
            MapNodeState::Open,
            key_fn,
        )
        .unwrap()
        .into_inner();

    let file2 = map
        .add_child_if_absent(
            dir1,
            EdgeType::List,
            NodeType::File {
                path: "auth/login.rs".to_string(),
            },
            MapNodeState::Open,
            key_fn,
        )
        .unwrap()
        .into_inner();

    let file3 = map
        .add_child_if_absent(
            dir2,
            EdgeType::List,
            NodeType::File {
                path: "user/mod.rs".to_string(),
            },
            MapNodeState::Open,
            key_fn,
        )
        .unwrap()
        .into_inner();

    assert_eq!(map.node_count(), 6);
    assert_eq!(map.frontiers().len(), 6);

    // ファイルを順に Close + up_cascade
    let c1 = map.close_with_cascade_up(file1);
    assert_eq!(c1, vec![file1]); // file2 がまだ Open

    let c2 = map.close_with_cascade_up(file2);
    assert!(c2.contains(&file2));
    assert!(c2.contains(&dir1)); // dir1 の子が全て Closed

    let c3 = map.close_with_cascade_up(file3);
    assert!(c3.contains(&file3));
    assert!(c3.contains(&dir2));
    assert!(c3.contains(&root)); // 全て Close

    // 最終確認
    assert!(map.frontiers().is_empty());
    assert_eq!(map.closed_nodes().len(), 6);
}