owlen/crates/app/cli/tests/permissions.rs

use assert_cmd::Command;
use std::fs;
use tempfile::tempdir;

#[test]
fn plan_mode_allows_read_operations() {
    // Create a temp file to read
    let dir = tempdir().unwrap();
    let file = dir.path().join("test.txt");
    fs::write(&file, "hello world").unwrap();

    // Read operation should work in plan mode (default)
    let mut cmd = Command::new(assert_cmd::cargo::cargo_bin!("owlen"));
    cmd.arg("read").arg(file.to_str().unwrap());
    cmd.assert().success().stdout("hello world\n");
}

#[test]
fn plan_mode_allows_glob_operations() {
    let dir = tempdir().unwrap();
    fs::write(dir.path().join("a.txt"), "test").unwrap();
    fs::write(dir.path().join("b.txt"), "test").unwrap();

    let pattern = format!("{}/*.txt", dir.path().display());

    // Glob operation should work in plan mode (default)
    let mut cmd = Command::new(assert_cmd::cargo::cargo_bin!("owlen"));
    cmd.arg("glob").arg(&pattern);
    cmd.assert().success();
}

#[test]
fn plan_mode_allows_grep_operations() {
    let dir = tempdir().unwrap();
    fs::write(dir.path().join("test.txt"), "hello world\nfoo bar").unwrap();

    // Grep operation should work in plan mode (default)
    let mut cmd = Command::new(assert_cmd::cargo::cargo_bin!("owlen"));
    cmd.arg("grep").arg(dir.path().to_str().unwrap()).arg("hello");
    cmd.assert().success();
}

#[test]
fn mode_override_via_cli_flag() {
    let dir = tempdir().unwrap();
    let file = dir.path().join("test.txt");
    fs::write(&file, "content").unwrap();

    // Test with --mode code (should also allow read)
    let mut cmd = Command::new(assert_cmd::cargo::cargo_bin!("owlen"));
    cmd.arg("--mode")
        .arg("code")
        .arg("read")
        .arg(file.to_str().unwrap());
    cmd.assert().success().stdout("content\n");
}

#[test]
fn plan_mode_blocks_write_operations() {
    let dir = tempdir().unwrap();
    let file = dir.path().join("new.txt");

    // Write operation should be blocked in plan mode (default)
    let mut cmd = Command::new(assert_cmd::cargo::cargo_bin!("owlen"));
    cmd.arg("write").arg(file.to_str().unwrap()).arg("content");
    cmd.assert().failure();
}

#[test]
fn plan_mode_blocks_edit_operations() {
    let dir = tempdir().unwrap();
    let file = dir.path().join("test.txt");
    fs::write(&file, "old content").unwrap();

    // Edit operation should be blocked in plan mode (default)
    let mut cmd = Command::new(assert_cmd::cargo::cargo_bin!("owlen"));
    cmd.arg("edit")
        .arg(file.to_str().unwrap())
        .arg("old")
        .arg("new");
    cmd.assert().failure();
}

#[test]
fn accept_edits_mode_allows_write() {
    let dir = tempdir().unwrap();
    let file = dir.path().join("new.txt");

    // Write operation should work in acceptEdits mode
    let mut cmd = Command::new(assert_cmd::cargo::cargo_bin!("owlen"));
    cmd.arg("--mode")
        .arg("acceptEdits")
        .arg("write")
        .arg(file.to_str().unwrap())
        .arg("new content");
    cmd.assert().success();

    // Verify file was written
    assert_eq!(fs::read_to_string(&file).unwrap(), "new content");
}

#[test]
fn accept_edits_mode_allows_edit() {
    let dir = tempdir().unwrap();
    let file = dir.path().join("test.txt");
    fs::write(&file, "line 1\nline 2\nline 3").unwrap();

    // Edit operation should work in acceptEdits mode
    let mut cmd = Command::new(assert_cmd::cargo::cargo_bin!("owlen"));
    cmd.arg("--mode")
        .arg("acceptEdits")
        .arg("edit")
        .arg(file.to_str().unwrap())
        .arg("line 2")
        .arg("modified line");
    cmd.assert().success();

    // Verify file was edited
    assert_eq!(
        fs::read_to_string(&file).unwrap(),
        "line 1\nmodified line\nline 3"
    );
}

#[test]
fn code_mode_allows_all_operations() {
    let dir = tempdir().unwrap();
    let file = dir.path().join("test.txt");

    // Write in code mode
    let mut cmd = Command::new(assert_cmd::cargo::cargo_bin!("owlen"));
    cmd.arg("--mode")
        .arg("code")
        .arg("write")
        .arg(file.to_str().unwrap())
        .arg("initial content");
    cmd.assert().success();

    // Edit in code mode
    let mut cmd = Command::new(assert_cmd::cargo::cargo_bin!("owlen"));
    cmd.arg("--mode")
        .arg("code")
        .arg("edit")
        .arg(file.to_str().unwrap())
        .arg("initial")
        .arg("modified");
    cmd.assert().success();

    assert_eq!(fs::read_to_string(&file).unwrap(), "modified content");
}