rapina 0.8.0

A fast, type-safe web framework for Rust inspired by FastAPI
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

#![cfg(feature = "sqlite")]

use rapina::migration::prelude::*;
use rapina::sea_orm::Database;

mod test_migration {
    use super::*;

    #[derive(DeriveMigrationName)]
    pub struct Migration;

    #[async_trait]
    impl MigrationTrait for Migration {
        async fn up(&self, manager: &SchemaManager) -> Result<(), DbErr> {
            manager
                .create_table(
                    Table::create()
                        .table(TestTable::Table)
                        .col(
                            ColumnDef::new(TestTable::Id)
                                .integer()
                                .not_null()
                                .auto_increment()
                                .primary_key(),
                        )
                        .col(ColumnDef::new(TestTable::Name).string().not_null())
                        .to_owned(),
                )
                .await
        }

        async fn down(&self, manager: &SchemaManager) -> Result<(), DbErr> {
            manager
                .drop_table(Table::drop().table(TestTable::Table).to_owned())
                .await
        }
    }

    #[derive(DeriveIden)]
    enum TestTable {
        Table,
        Id,
        Name,
    }
}

rapina::migrations! {
    test_migration,
}

#[tokio::test]
async fn test_run_pending_migrations() {
    let conn = Database::connect("sqlite::memory:").await.unwrap();
    rapina::migration::run_pending::<Migrator>(&conn)
        .await
        .unwrap();
}

#[tokio::test]
async fn test_migration_status() {
    let conn = Database::connect("sqlite::memory:").await.unwrap();
    rapina::migration::status::<Migrator>(&conn).await.unwrap();
}

#[tokio::test]
async fn test_migration_rollback() {
    let conn = Database::connect("sqlite::memory:").await.unwrap();
    rapina::migration::run_pending::<Migrator>(&conn)
        .await
        .unwrap();
    rapina::migration::rollback::<Migrator>(&conn, Some(1))
        .await
        .unwrap();
}