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
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212

use uuid::Uuid;

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

use crate::common::Person;

#[test]
fn can_create_collection() {
    fixture::Collection::new(Memory::new());
}

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

    let actual_entity = collection.find(id).expect("entity should exists");

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

#[test]
fn cant_find_absent_entity() {
    let collection = fixture::Collection::new(Memory::new());
    let id = Uuid::parse_str("78190929-3d84-4735-9e40-80e3cd5530e9").unwrap();

    let entity = collection.find(id);

    assert!(entity.expect_err("entity should not exist").is_not_found(), "entity should not exist");
}

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

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

    assert!(entities.contains(&entity1), "entity 1 should exist");
    assert!(entities.contains(&entity2), "entity 2 should exist");
}

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

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

    //As long as all entities are yielded, this is considered a success.
    assert!(entities.contains(&entity1), "entity 1 should exist");
    assert!(entities.contains(&entity2), "entity 2 should exist");
}

#[test]
fn can_insert_entity() {
    let mut collection = fixture::Collection::new(Memory::new());
    let mut entity = Person::new();

    collection.insert(&mut entity).expect("could not insert in collection");

    fixture::assert_entity_equals(&collection, &entity);
}

#[test]
fn should_assign_new_id_when_inserted() {
    let mut collection = fixture::Collection::new(Memory::new());
    let mut entity = Person::new();
    collection.insert(&mut entity).expect("could not insert in collection");
    let old_id = entity.id.expect("entity should have an id");

    collection.insert(&mut entity).expect("could not insert in collection");
    let new_id = entity.id.expect("entity should have a new id");

    assert_ne!(old_id, new_id, "entity should have a new id");
}

#[test]
fn can_update_entity() {
    let mut collection = fixture::Collection::new(Memory::new());
    let mut entity = Person::with_age(42);
    collection.insert(&mut entity).expect("could not insert in collection");

    entity.age = 18;
    collection.update(&mut entity).expect("could not update collection");

    fixture::assert_entity_equals(&collection, &entity);
}

#[test]
fn cant_update_absent_entity() {
    let mut collection = fixture::Collection::new(Memory::new());
    let mut entity = Person::with_age(42);

    let result = collection.update(&mut entity);

    assert!(result.is_err(), "entity should not have been updated");
}

#[test]
fn can_upsert_existing_entity() {
    let mut collection = fixture::Collection::new(Memory::new());
    let mut entity = Person::with_age(42);
    collection.insert(&mut entity).expect("could not insert in collection");

    entity.age = 18;
    collection.upsert(&mut entity).expect("could not upsert in collection");

    fixture::assert_entity_equals(&collection, &entity);
}

#[test]
fn cant_upsert_absent_entity() {
    let mut collection = fixture::Collection::new(Memory::new());
    let id = Uuid::parse_str("78190929-3d84-4735-9e40-80e3cd5530e9").unwrap();
    let mut entity = Person::with_id(id);
    collection.insert(&mut entity).expect("could not insert in collection");

    entity.age = 18;
    collection.upsert(&mut entity).expect("could not upsert in collection");

    fixture::assert_entity_equals(&collection, &entity);
}

#[test]
fn should_keep_id_when_upserted() {
    let mut collection = fixture::Collection::new(Memory::new());
    let mut entity = Person::new();
    collection.insert(&mut entity).expect("could not insert in collection");

    entity.age = 18;
    //Clone entity to leave the current one untouched.
    collection.upsert(&mut entity.clone()).expect("could not upsert in collection");

    fixture::assert_entity_equals(&collection, &entity);
}

#[test]
fn can_delete_entity() {
    let mut collection = fixture::Collection::new(Memory::new());
    let mut entity = Person::new();
    collection.insert(&mut entity).expect("could not insert in collection");
    let id = entity.id.expect("entity should have an id");

    let deleted = collection.delete(id).expect("could not delete from collection");

    assert!(deleted, "something should have been deleted");
    fixture::assert_entity_not_exists(&collection, id);
}

#[test]
fn can_delete_absent_entity() {
    let mut collection = fixture::Collection::new(Memory::new());
    let id = Uuid::parse_str("78190929-3d84-4735-9e40-80e3cd5530e9").unwrap();

    let deleted = collection.delete(id).expect("could not delete from collection");

    assert!(!deleted, "entity should not have been deleted");
    fixture::assert_entity_not_exists(&collection, id);
}

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

    collection.clear().expect("collection should have been clearable");

    fixture::assert_entity_not_exists(&collection, id1);
    fixture::assert_entity_not_exists(&collection, id2);
}

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

    collection.clear().expect("collection should have been clearable");
}

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 assert_entity_equals(collection: &Collection, expected_entity: &Person) {
        let actual_entity = collection.find(expected_entity.id.expect("unable to get id from entity")).expect("entity should exist");
        assert_eq!(*expected_entity, actual_entity, "entities should be the same.");
    }

    pub fn assert_entity_not_exists(collection: &Collection, id: Uuid) {
        assert!(collection.find(id).expect_err("entity should not exist").is_not_found(), "entity should not exist");
    }
}