rustyroad 1.7.3

Rusty Road is a framework written in Rust that is based on Ruby on Rails. It is designed to provide the familiar conventions and ease of use of Ruby on Rails, while also taking advantage of the performance and efficiency of Rust.
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
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151

//! Ledger integrity: uniqueness, upsert, and parameter binding.

use super::support::{row_count, sqlite_ledger};
use crate::database::migrations::ledger;
use crate::database::migrations::MigrationDirection;
use crate::database::DatabaseConnection;

#[tokio::test]
async fn ensure_table_is_idempotent() {
    let connection = sqlite_ledger().await;
    // `migration all` calls this on every run.
    ledger::ensure_table(&connection)
        .await
        .expect("ensure_table should be safe to call repeatedly");
}

#[tokio::test]
async fn repeated_record_does_not_duplicate_rows() {
    let connection = sqlite_ledger().await;
    let id = "20251114211514-add_columns";

    for _ in 0..3 {
        ledger::record(&connection, id, MigrationDirection::Up)
            .await
            .unwrap();
    }

    // The upsert keeps one authoritative row per (name, direction), instead of the
    // duplicate-per-run growth an insert-only ledger produces.
    assert_eq!(row_count(&connection, id).await, 1);
}

#[tokio::test]
async fn executed_record_keeps_provenance_and_checksum_but_not_verification() {
    let connection = sqlite_ledger().await;
    let id = "20260101000000-add_email";
    let checksum = "9f86d081884c7d659a2feaa0c55ad015";

    ledger::record_with_metadata(
        &connection,
        id,
        MigrationDirection::Up,
        ledger::Provenance::Executed,
        Some(checksum),
    )
    .await
    .unwrap();

    let DatabaseConnection::Sqlite(pool) = &connection else {
        panic!("expected sqlite connection");
    };
    let row: (String, Option<String>, Option<String>) = sqlx::query_as(
        "SELECT provenance, checksum, CAST(verified_at AS TEXT) \
         FROM _rustyroad_migrations WHERE name = ?",
    )
    .bind(id)
    .fetch_one(pool.as_ref())
    .await
    .unwrap();
    assert_eq!(
        row,
        ("executed".to_string(), Some(checksum.to_string()), None)
    );
}

#[tokio::test]
async fn rollback_replaces_rather_than_appends() {
    let connection = sqlite_ledger().await;
    let id = "20251114211514-add_columns";

    ledger::record(&connection, id, MigrationDirection::Up)
        .await
        .unwrap();
    ledger::record(&connection, id, MigrationDirection::Down)
        .await
        .unwrap();

    // One row total: the `up` row is cleared so state stays unambiguous.
    assert_eq!(row_count(&connection, id).await, 1);
}

#[tokio::test]
async fn migration_names_are_bound_not_interpolated() {
    let connection = sqlite_ledger().await;

    // A quote in the name must round-trip rather than break the statement.
    let awkward = "20251114211514-create_o'brien_table";
    ledger::record(&connection, awkward, MigrationDirection::Up)
        .await
        .unwrap();

    assert!(ledger::is_applied(&connection, awkward).await.unwrap());
    assert_eq!(row_count(&connection, awkward).await, 1);
}

#[tokio::test]
async fn repair_keeps_latest_identity_state_and_restores_uniqueness() {
    let connection = sqlite_ledger().await;
    let DatabaseConnection::Sqlite(pool) = &connection else {
        panic!("expected sqlite connection");
    };
    sqlx::query("DROP TABLE _rustyroad_migrations")
        .execute(pool.as_ref())
        .await
        .unwrap();
    sqlx::query(
        "CREATE TABLE _rustyroad_migrations (
            id INTEGER PRIMARY KEY AUTOINCREMENT,
            name TEXT NOT NULL,
            applied_at TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP,
            direction TEXT NOT NULL
        )",
    )
    .execute(pool.as_ref())
    .await
    .unwrap();
    for (direction, applied_at) in [
        ("up", "2026-01-01 00:00:00"),
        ("down", "2026-02-01 00:00:00"),
        ("up", "2026-03-01 00:00:00"),
    ] {
        sqlx::query(
            "INSERT INTO _rustyroad_migrations (name, direction, applied_at) VALUES (?, ?, ?)",
        )
        .bind("20260101000000-add_columns")
        .bind(direction)
        .bind(applied_at)
        .execute(pool.as_ref())
        .await
        .unwrap();
    }

    let report = ledger::repair(&connection).await.unwrap();

    assert_eq!(report.rows_before, 3);
    assert_eq!(report.rows_after, 1);
    assert_eq!(report.rows_removed, 2);
    assert!(
        ledger::is_applied(&connection, "20260101000000-add_columns")
            .await
            .unwrap()
    );
    assert!(
        sqlx::query("INSERT INTO _rustyroad_migrations (name, direction) VALUES (?, ?)")
            .bind("20260101000000-add_columns")
            .bind("up")
            .execute(pool.as_ref())
            .await
            .is_err()
    );
}