centaurus 0.17.4

A utility library for various use cases.
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

use sea_orm::{ActiveValue::Set, IntoActiveModel, prelude::*};

use crate::{db::entities::setup, error::Result};

const SETUP_ID: i32 = 1;

pub struct SetupTable<'db> {
  db: &'db DatabaseConnection,
}

impl<'db> SetupTable<'db> {
  pub fn new(db: &'db DatabaseConnection) -> Self {
    Self { db }
  }

  pub async fn is_setup(&self) -> Result<bool> {
    let res = setup::Entity::find_by_id(SETUP_ID).one(self.db).await?;
    Ok(res.is_some_and(|s| s.completed))
  }

  async fn get_setup(&self) -> Result<setup::Model> {
    let res = setup::Entity::find_by_id(SETUP_ID).one(self.db).await?;

    if let Some(model) = res {
      Ok(model)
    } else {
      Ok(
        setup::ActiveModel {
          id: Set(SETUP_ID),
          admin_group_created: Set(None),
          completed: Set(false),
        }
        .insert(self.db)
        .await?,
      )
    }
  }

  pub async fn mark_completed(&self) -> Result<()> {
    let mut model = self.get_setup().await?.into_active_model();
    model.completed = Set(true);

    model.update(self.db).await?;

    Ok(())
  }

  pub async fn set_admin_group_created(&self, group_id: Uuid) -> Result<()> {
    let mut model = self.get_setup().await?.into_active_model();
    model.admin_group_created = Set(Some(group_id));

    model.update(self.db).await?;

    Ok(())
  }

  pub async fn get_admin_group_id(&self) -> Result<Option<Uuid>> {
    let model = self.get_setup().await?;
    Ok(model.admin_group_created)
  }
}

#[cfg(test)]
mod tests {
  use super::*;
  use crate::db::config::DBConfig;
  use crate::db::init::{Connection, connect_db};
  use crate::db::migrations::Migrator;
  use sea_orm_migration::MigratorTrait;

  async fn setup() -> Connection {
    let db_config = DBConfig::default();
    let conn = connect_db(&db_config, "sqlite::memory:").await;
    Migrator::up(&*conn, None).await.unwrap();
    conn
  }

  #[tokio::test]
  async fn test_fresh_setup_state() {
    let conn = setup().await;
    let table = SetupTable::new(&conn);

    // A fresh database is not set up and has no admin group.
    assert!(!table.is_setup().await.unwrap());
    assert_eq!(table.get_admin_group_id().await.unwrap(), None);
  }

  #[tokio::test]
  async fn test_mark_completed() {
    let conn = setup().await;
    let table = SetupTable::new(&conn);

    table.mark_completed().await.unwrap();
    assert!(table.is_setup().await.unwrap());

    // Marking completed again is idempotent.
    table.mark_completed().await.unwrap();
    assert!(table.is_setup().await.unwrap());
  }

  #[tokio::test]
  async fn test_admin_group_persistence() {
    let conn = setup().await;
    let table = SetupTable::new(&conn);
    let group = Uuid::now_v7();

    table.set_admin_group_created(group).await.unwrap();
    assert_eq!(table.get_admin_group_id().await.unwrap(), Some(group));

    // The admin group can be reassigned, and is independent of completion.
    let group2 = Uuid::now_v7();
    table.set_admin_group_created(group2).await.unwrap();
    assert_eq!(table.get_admin_group_id().await.unwrap(), Some(group2));
    assert!(!table.is_setup().await.unwrap());
  }
}