mongoose 0.6.2

Convenient MongoDb Wrappers
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

#[cfg(test)]
mod create {
    use crate::tests::mock::{self, log, Log, Post, User};
    use crate::{doc, types::MongooseError, IndexModel, IndexOptions, Model};

    #[tokio::test]
    async fn create_one() -> Result<(), MongooseError> {
        let new_user = mock::user().save().await;
        assert!(new_user.is_ok());
        Ok(())
    }

    #[tokio::test]
    async fn bulk_insert() -> Result<(), MongooseError> {
        let users = (0..5).into_iter().map(|_| mock::user()).collect::<Vec<_>>();
        let inserted = User::bulk_insert(&users).await?;
        assert!(inserted.inserted_ids.len() == 5);
        Ok(())
    }

    #[tokio::test]
    async fn create_one_with_relation() -> Result<(), MongooseError> {
        let new_user = mock::user();
        let inserted = new_user.save().await?;
        assert_eq!(inserted.username, new_user.username);
        assert_eq!(inserted.age, new_user.age);
        let new_post = mock::post(inserted.id.to_string());
        let new_post = new_post.save().await?;
        assert_eq!(new_post.id, new_post.id);
        assert_eq!(new_post.user, inserted.id);
        Ok(())
    }

    #[tokio::test]
    async fn bulk_create_with_relation() -> Result<(), MongooseError> {
        let new_user = mock::user();
        let inserted = new_user.save().await?;
        assert_eq!(inserted.username, new_user.username);
        assert_eq!(inserted.age, new_user.age);
        let posts = (0..5)
            .into_iter()
            .map(|_| mock::post(inserted.id.to_string()))
            .collect::<Vec<_>>();
        let inserted = Post::bulk_insert(&posts).await?;
        assert!(inserted.inserted_ids.len() == 5);
        Ok(())
    }

    #[tokio::test]
    async fn create_indexes() -> Result<(), MongooseError> {
        let indexes = &[
            IndexModel::builder()
                .keys(doc! { "username": 1 })
                .options(IndexOptions::builder().unique(true).build())
                .build(),
            IndexModel::builder()
                .keys(doc! { "slug": 1 })
                .options(IndexOptions::builder().unique(true).build())
                .build(),
            IndexModel::builder()
                .keys(doc! { "slug": "text" })
                .options(IndexOptions::builder().sparse(true).build())
                .build(),
            IndexModel::builder()
                .keys(doc! { "email": 1, "created_at": -1 })
                .options(IndexOptions::builder().unique(true).build())
                .build(),
        ];
        let created_names = User::create_indexes(indexes).await?.index_names;
        let names = User::collection().await.list_index_names().await.unwrap();
        created_names
            .iter()
            .for_each(|name| assert!(names.contains(name)));
        Ok(())
    }

    #[ignore = "run this last, since its so long"]
    #[tokio::test]
    async fn create_ttl_indexes() -> Result<(), MongooseError> {
        let indexes = &[IndexModel::builder()
            .keys(doc! { "created_at": 1 })
            .options(
                IndexOptions::builder()
                    .expire_after(std::time::Duration::from_millis(1_000))
                    .build(),
            )
            .build()];
        Log::create_indexes(indexes).await?;
        let new_log = log().save().await?;
        let log = Log::read_by_uuid(&new_log.id).await?;
        assert!(log.id == new_log.id);
        // must sleep to allow the mongo engine to drop the TTL document
        std::thread::sleep(std::time::Duration::from_secs(60));
        let log = Log::read_by_uuid(&new_log.id).await;
        // should not be found after TTL expires
        assert!(log.is_err());
        Ok(())
    }
}