kwaak 0.3.3

Run a team of autonomous agents on your code, right from your terminal
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112

use assert_cmd::prelude::*;
use predicates::prelude::*;
use std::process::Command;
use tempfile::TempDir;
struct Context {
    dir: TempDir,
}

fn setup() -> Context {
    let dir = tempfile::Builder::new()
        .prefix("kwaak-test")
        .tempdir()
        .unwrap();

    Context { dir }
}

impl Context {
    fn cmd(&mut self) -> Command {
        let mut cmd = Command::cargo_bin("kwaak").unwrap();
        cmd.current_dir(&self.dir);
        cmd.env_clear();
        cmd.env("TAVILY_API_KEY", "noop");
        cmd.env("KWAAK_GITHUB_TOKEN", "noop");
        cmd.env("KWAAK_OPENAI_API_KEY", "noop");
        cmd.env("RUST_LOG", "debug");
        cmd.env("RUST_BACKTRACE", "1");
        cmd
    }

    fn with_git(self) -> Self {
        Command::new("git")
            .arg("init")
            .current_dir(&self.dir)
            .assert()
            .success();

        Command::new("git")
            .args([
                "remote",
                "add",
                "origin",
                "https://github.com/bosun-ai/kwaak",
            ])
            .current_dir(&self.dir)
            .assert()
            .success();

        self
    }

    fn with_config(self) -> Self {
        // Copies over kwaak.toml to the tempdir
        Command::new("cp")
            .args(["kwaak.toml", self.dir.path().to_str().unwrap()])
            .assert()
            .success();

        self
    }
}

#[test_log::test(tokio::test)]
async fn test_creates_a_new_init_file() {
    let mut context = setup().with_git();

    context
        .cmd()
        .arg("init")
        .assert()
        .stdout(predicate::str::contains("Initialized kwaak project"))
        .success();

    // assert the file exists
    std::fs::metadata(context.dir.path().join("kwaak.toml")).unwrap();
}

#[test_log::test(tokio::test)]
async fn test_fails_if_not_git() {
    let mut context = setup();
    context
        .cmd()
        .arg("init")
        .assert()
        .failure()
        .stderr(predicate::str::contains("Not a git repository"));
}

#[test_log::test(tokio::test)]
async fn test_fails_config_present() {
    let mut cmd = Command::cargo_bin("kwaak").unwrap();
    cmd.arg("init");

    cmd.assert()
        .failure()
        .stderr(predicate::str::contains("already exists"));
}

#[test_log::test(tokio::test)]
async fn test_print_config() {
    let mut context = setup().with_git().with_config();

    context.cmd().arg("print-config").assert().success();
}

#[test_log::test(tokio::test)]
async fn test_self_fixing_after_clear_cache() {
    let mut context = setup().with_git().with_config();

    context.cmd().arg("clear-cache").assert().success();
    context.cmd().arg("print-config").assert().success();
}