oximod 0.2.0

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
112
113
114
115
116

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

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 collection = Thing::get_collection()?;
    let doc = collection.find_one(doc! { "_id": id }).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").retries(5);
    let id = rec.save().await?;

    let collection = Record::get_collection()?;
    let got = collection.find_one(doc! { "_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 collection = Task::get_collection()?;

    let t1 = Task::default().description("T1");
    let id1 = t1.save().await?;
    let got1 = collection.find_one(doc! { "_id": id1 }).await?.unwrap();
    assert_eq!(got1.status, Status::Pending);
    assert_eq!(got1.description, "T1");

    let t2 = Task::default().status(Status::Complete).description("T2");
    let id2 = t2.save().await?;
    let got2 = collection.find_one(doc! { "_id": id2 }).await?.unwrap();
    assert_eq!(got2.status, Status::Complete);
    assert_eq!(got2.description, "T2");

    Ok(())
}