oximod 0.1.11

MongoDB ODM for Rust inspired by Mongoose
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

use mongodb::bson::{ doc, oid::ObjectId };
use oximod::Model;
use testresult::TestResult;
use serde::{ Deserialize, Serialize };

mod common;
use common::init;

// Run test: cargo nextest run saves_with_default_string_and_number
#[tokio::test]
async fn saves_with_default_string_and_number() -> TestResult {
    init().await;

    #[derive(Model, Serialize, Deserialize, Debug)]
    #[db("test")]
    #[collection("defaults_str_num_saves_with_default")]
    pub struct Thing {
        #[serde(skip_serializing_if = "Option::is_none")]
        _id: Option<ObjectId>,

        #[default("Anonymous".to_string())]
        name: String,

        #[default(0)]
        count: i32,
    }

    Thing::clear().await?;

    let thing = Thing::default();
    let id = thing.save().await?;

    let doc = Thing::find_one(doc! { "_id": id.clone() }).await?.unwrap();

    assert_eq!(doc.name, "Anonymous");
    assert_eq!(doc.count, 0);

    Ok(())
}

// Run test: cargo nextest run override_default_values
#[tokio::test]
async fn override_default_values() -> TestResult {
    init().await;

    #[derive(Model, Serialize, Deserialize, Debug)]
    #[db("test")]
    #[collection("defaults_override_explicitly")]
    pub struct Record {
        #[serde(skip_serializing_if = "Option::is_none")]
        _id: Option<ObjectId>,

        #[default("Guest".to_string())]
        user: String,

        #[default(1)]
        retries: i32,
    }

    Record::clear().await?;

    let rec = Record::default().user("Alice".to_string()).retries(5);
    let id = rec.save().await?;

    let got = Record::find_by_id(id).await?.unwrap();
    assert_eq!(got.user, "Alice");
    assert_eq!(got.retries, 5);

    Ok(())
}

// Run test: cargo nextest run enum_default_and_override
#[tokio::test]
async fn enum_default_and_override() -> TestResult {
    init().await;

    #[derive(Clone, Debug, Serialize, Deserialize, PartialEq)]
    pub enum Status {
        Pending,
        Complete,
    }

    #[derive(Model, Serialize, Deserialize, Debug)]
    #[db("test")]
    #[collection("defaults_enum_status_test")]
    pub struct Task {
        #[serde(skip_serializing_if = "Option::is_none")]
        _id: Option<ObjectId>,

        #[default(Status::Pending)]
        status: Status,

        description: String,
    }

    Task::clear().await?;

    let t1 = Task::default().description("T1".into());
    let id1 = t1.save().await?;
    let got1 = Task::find_by_id(id1).await?.unwrap();
    assert_eq!(got1.status, Status::Pending);
    assert_eq!(got1.description, "T1");

    let t2 = Task::default().status(Status::Complete).description("T2".into());
    let id2 = t2.save().await?;
    let got2 = Task::find_by_id(id2).await?.unwrap();
    assert_eq!(got2.status, Status::Complete);
    assert_eq!(got2.description, "T2");

    Ok(())
}