cardamon 0.0.2

Cardamon is a tool to help development teams measure the power consumption and carbon emissions of their software.
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

#![allow(unused_imports, dead_code)]

use anyhow::{self, Context};
use cardamon::{
    dao,
    migrations::{Migrator, MigratorTrait},
};
use itertools::*;
use sea_orm::{
    entity::*, error::*, query::*, sea_query, tests_cfg::*, Database, DatabaseBackend,
    DatabaseConnection, DbConn,
};
use std::path::Path;

async fn setup_db() -> anyhow::Result<DatabaseConnection> {
    // Connecting SQLite
    let db = Database::connect("sqlite::memory:").await?;

    // Migrate db
    Migrator::up(&db, None)
        .await
        .context("Error migrating database.")
        .ok();

    Ok(db)
}

async fn setup_fixtures(fixtures: &[&str], db: &DatabaseConnection) -> anyhow::Result<()> {
    for path in fixtures {
        let path = Path::new(path);
        let stmt = std::fs::read_to_string(path)?;
        db.query_one(Statement::from_string(DatabaseBackend::Sqlite, stmt))
            .await
            .context(format!("Error applying fixture {:?}", path))?;
    }

    Ok(())
}

#[tokio::test]
async fn fetch_iterations_of_last_n_runs_for_schema() -> anyhow::Result<()> {
    let db = setup_db().await?;
    setup_fixtures(&["./fixtures/runs.sql", "./fixtures/iterations.sql"], &db).await?;

    // fetch the latest scenario_1 run
    let scenario_iterations = dao::iteration::fetch_runs_last_n("scenario_1", 1, &db).await?;

    let run_ids = scenario_iterations
        .iter()
        .map(|run| run.run_id)
        .collect::<Vec<_>>();
    assert_eq!(run_ids, vec![1]);

    let iterations = scenario_iterations
        .iter()
        .map(|run| run.count)
        .collect::<Vec<_>>();
    assert_eq!(iterations, vec![1]);

    // fetch the last 2 scenario_3 runs
    let scenario_iterations = dao::iteration::fetch_runs_last_n("scenario_3", 2, &db).await?;

    let run_ids = scenario_iterations
        .iter()
        .map(|run| run.run_id)
        .collect::<Vec<_>>();
    assert_eq!(run_ids, vec![2, 2, 2, 3, 3, 3]);

    let iterations = scenario_iterations
        .iter()
        .map(|run| run.count)
        .collect::<Vec<_>>();
    assert_eq!(iterations, vec![1, 2, 3, 1, 2, 3]);

    Ok(())
}

#[tokio::test]
async fn fetch_metrics_within() -> anyhow::Result<()> {
    let db = setup_db().await?;
    setup_fixtures(&["./fixtures/runs.sql", "./fixtures/metrics.sql"], &db).await?;

    let metrics = dao::metrics::fetch_within(1, 1717507600000, 1717507600200, &db).await?;

    assert_eq!(metrics.len(), 4);

    let process_names: Vec<&str> = metrics
        .iter()
        .map(|metric| metric.process_name.as_str())
        .unique()
        .collect();

    assert_eq!(process_names, vec!["yarn", "docker"]);

    Ok(())
}