coyote 0.1.1

Embeddable ACME server with programmable challenges and storage
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

use super::{LoadError, Record, Postgres, SaveError};
use crate::util::make_nonce;
use async_trait::async_trait;
use tokio_postgres::{Row, Transaction};

#[derive(Clone)]
pub struct Nonce {
    nonce: String,
}

impl std::fmt::Debug for Nonce {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.nonce)
    }
}

impl PartialEq for Nonce {
    fn eq(&self, other: &Self) -> bool {
        self.nonce.eq(&other.nonce)
    }
}

impl Nonce {
    pub fn new() -> Self {
        Self {
            nonce: make_nonce(None),
        }
    }
}

#[async_trait]
impl Record<String> for Nonce {
    async fn new_from_row(row: &Row, _tx: &Transaction<'_>) -> Result<Self, LoadError> {
        if row.len() > 0 {
            Ok(Self {
                nonce: row.get("nonce"),
            })
        } else {
            Err(LoadError::NotFound)
        }
    }

    fn id(&self) -> Result<Option<String>, LoadError> {
        return Ok(Some(self.nonce.clone()));
    }

    async fn find(id: String, db: Postgres) -> Result<Self, LoadError> {
        let mut db = db.client().await?;
        let row = db
            .query_one("select nonce from nonces where nonce = $1", &[&id])
            .await?;

        let tx = db.transaction().await?;

        Self::new_from_row(&row, &tx).await
    }

    async fn create(&mut self, db: Postgres) -> Result<String, SaveError> {
        let mut db = db.client().await?;
        let tx = db.transaction().await?;
        tx.execute("insert into nonces (nonce) values ($1)", &[&self.nonce])
            .await?;
        tx.commit().await?;

        Ok(self.nonce.clone())
    }

    async fn delete(&self, db: Postgres) -> Result<(), SaveError> {
        let mut db = db.client().await?;
        let tx = db.transaction().await?;
        let res = tx
            .execute("delete from nonces where nonce = $1", &[&self.nonce])
            .await?;
        tx.commit().await?;

        if res == 0 {
            return Err(SaveError::Generic("nonce was already removed".to_string()));
        }

        Ok(())
    }

    async fn update(&self, _: Postgres) -> Result<(), SaveError> {
        Err(SaveError::Generic("cannot update a nonce".to_string()))
    }
}

mod tests {
    #[tokio::test(flavor = "multi_thread")]
    async fn nonce_crud_test() {
        use spectral::prelude::*;

        use super::Nonce;
        use crate::models::Record;
        use crate::test::PGTest;

        let pg = PGTest::new("nonce_crud_test").await.unwrap();
        let db = pg.db();

        let mut nonce = Nonce::new();
        nonce.create(db.clone()).await.unwrap();

        let found = Nonce::find(nonce.id().unwrap().unwrap(), db.clone())
            .await
            .unwrap();

        assert_that!(nonce).is_equal_to(found.clone());

        let res = found.delete(db.clone()).await;
        assert_that!(res).is_ok();
        let res = found.delete(db.clone()).await;
        assert_that!(res).is_err();

        let res = Nonce::find(found.id().unwrap().unwrap(), db.clone()).await;
        assert_that!(res).is_err();
    }
}