dodo 0.3.1

Basic persistence library designed to be a quick and easy way to create a persistent 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

use dodo::{Memory, prelude::*};

use crate::common::Person;

#[test]
fn can_skip_entities() {
    let mut collection = fixture::Collection::new(Memory::new());
    fixture::create_entity_in(&mut collection);
    fixture::create_entity_in(&mut collection);

    let entities = collection
        .find_all().expect("could not read collection")
        .skip(1)
        .collect().expect("could not read collection");

    assert_eq!(entities.len(), 1, "only one entity should have been yielded");
}

#[test]
fn can_filter_entities() {
    let mut collection = fixture::Collection::new(Memory::new());
    let mut entity1 = Person::with_age(42);
    let mut entity2 = Person::with_age(18);
    fixture::add_entity_in(&mut collection, &mut entity1);
    fixture::add_entity_in(&mut collection, &mut entity2);

    let entities = collection
        .find_all().expect("could not read collection")
        .filter(|person| person.age > 20)
        .collect().expect("could not read collection");

    assert!(entities.contains(&entity1), "entity 1 should be yielded");
    assert!(!entities.contains(&entity2), "entity 2 should have been filtered");
}

#[test]
fn can_map_entities() {
    let mut collection = fixture::Collection::new(Memory::new());
    let mut entity1 = Person::with_age(42);
    let mut entity2 = Person::with_age(18);
    fixture::add_entity_in(&mut collection, &mut entity1);
    fixture::add_entity_in(&mut collection, &mut entity2);

    let entities = collection
        .find_all().expect("could not read collection")
        .map(|person| person.age)
        .collect().expect("could not read collection");

    assert!(entities.contains(&42), "entity 1 age should be yielded");
    assert!(entities.contains(&18), "entity 2 age should be yielded");
}

#[test]
fn can_get_first_entity() {
    let mut collection = fixture::Collection::new(Memory::new());
    let (_, expected_entity) = fixture::create_entity_in(&mut collection);

    let actual_entity = collection
        .find_all().expect("could not read collection")
        .first().expect("could not read collection").expect("entity should exist");

    assert_eq!(expected_entity, actual_entity, "entities should be the same.");
}

#[test]
fn can_get_nth_entity() {
    let mut collection = fixture::Collection::new(Memory::new());
    fixture::create_entity_in(&mut collection);
    fixture::create_entity_in(&mut collection);

    let mut cursor = collection.find_all().expect("could not read collection");

    assert!(matches!(cursor.nth(1), Ok(Some(_person))), "should yield second entity");
    assert!(matches!(cursor.next(), Ok(None)), "cursor should be empty.");
}

#[test]
fn can_take_n_entities() {
    let mut collection = fixture::Collection::new(Memory::new());
    fixture::create_entity_in(&mut collection);
    fixture::create_entity_in(&mut collection);

    let entities = collection
        .find_all().expect("could not read collection")
        .take(1).expect("could not read collection");

    assert_eq!(entities.len(), 1, "should yield only one entity");
}

mod fixture {
    use uuid::Uuid;

    use dodo::{Memory, prelude::*};

    use crate::common::Person;

    pub type Collection = dodo::Collection<Person, Memory, JsonSerializer>;

    pub fn create_entity_in(collection: &mut Collection) -> (Uuid, Person) {
        let mut entity = Person::new();
        collection.insert(&mut entity).expect("could not insert in collection");
        let id = entity.id.expect("unable to get id from entity");
        (id, entity)
    }

    pub fn add_entity_in(collection: &mut Collection, mut entity: &mut Person) {
        collection.insert(&mut entity).expect("could not insert in collection");
    }
}