mithril_aggregator/database/query/certificate/
insert_certificate.rs

1use mithril_persistence::sqlite::{Query, SourceAlias, SqLiteEntity, WhereCondition};
2
3use crate::database::record::CertificateRecord;
4
5use super::conditions;
6
7/// Query to insert [CertificateRecord] in the sqlite database
8pub struct InsertCertificateRecordQuery {
9    condition: WhereCondition,
10}
11
12impl InsertCertificateRecordQuery {
13    pub fn one(certificate_record: CertificateRecord) -> Self {
14        Self::many(vec![certificate_record])
15    }
16
17    pub fn many(certificates_records: Vec<CertificateRecord>) -> Self {
18        Self {
19            condition: conditions::insert_many(certificates_records),
20        }
21    }
22}
23
24impl Query for InsertCertificateRecordQuery {
25    type Entity = CertificateRecord;
26
27    fn filters(&self) -> WhereCondition {
28        self.condition.clone()
29    }
30
31    fn get_definition(&self, condition: &str) -> String {
32        // it is important to alias the fields with the same name as the table
33        // since the table cannot be aliased in a RETURNING statement in SQLite.
34        let projection = Self::Entity::get_projection()
35            .expand(SourceAlias::new(&[("{:certificate:}", "certificate")]));
36
37        format!("insert into certificate {condition} returning {projection}")
38    }
39}
40
41#[cfg(test)]
42mod tests {
43    use mithril_common::test::crypto_helper::setup_certificate_chain;
44    use mithril_persistence::sqlite::ConnectionExtensions;
45
46    use crate::database::test_helper::main_db_connection;
47
48    use super::*;
49
50    #[test]
51    fn test_insert_certificate_record() {
52        let certificates = setup_certificate_chain(5, 2);
53
54        let connection = main_db_connection().unwrap();
55
56        for certificate in certificates.certificates_chained {
57            let certificate_record: CertificateRecord = certificate.try_into().unwrap();
58            let certificate_record_saved = connection
59                .fetch_first(InsertCertificateRecordQuery::one(
60                    certificate_record.clone(),
61                ))
62                .unwrap();
63            assert_eq!(Some(certificate_record), certificate_record_saved);
64        }
65    }
66
67    #[test]
68    fn test_insert_many_certificates_records() {
69        let certificates = setup_certificate_chain(5, 2);
70        let certificates_records: Vec<CertificateRecord> = certificates.try_into().unwrap();
71
72        let connection = main_db_connection().unwrap();
73
74        let certificates_records_saved: Vec<CertificateRecord> = connection
75            .fetch_collect(InsertCertificateRecordQuery::many(
76                certificates_records.clone(),
77            ))
78            .expect("saving many records should not fail");
79
80        assert_eq!(certificates_records, certificates_records_saved);
81    }
82}