fix the tests

dump/src/lib.rs

@@ -30,3 +30,237 @@ pub enum Version {
     V5,
     V6,
 }
+
+#[cfg(test)]
+pub(crate) mod test {
+    use std::{
+        fs::File,
+        io::{Read, Seek, SeekFrom},
+        str::FromStr,
+    };
+
+    use big_s::S;
+    use index::{Checked, Settings};
+    use index_scheduler::{milli::update::Setting, task::Details, Kind, Status, TaskView};
+    use maplit::btreeset;
+    use meilisearch_auth::{Action, Key};
+    use meilisearch_types::{index_uid::IndexUid, star_or::StarOr};
+    use serde_json::{json, Map, Value};
+    use time::{macros::datetime, Duration};
+    use uuid::Uuid;
+
+    use crate::{reader, DumpWriter, Version};
+
+    pub fn create_test_instance_uid() -> Uuid {
+        Uuid::parse_str("9e15e977-f2ae-4761-943f-1eaf75fd736d").unwrap()
+    }
+
+    pub fn create_test_documents() -> Vec<Map<String, Value>> {
+        vec![
+            json!({ "id": 1, "race": "golden retriever", "name": "paul", "age": 4 })
+                .as_object()
+                .unwrap()
+                .clone(),
+            json!({ "id": 2, "race": "bernese mountain", "name": "tamo", "age": 6 })
+                .as_object()
+                .unwrap()
+                .clone(),
+            json!({ "id": 3, "race": "great pyrenees", "name": "patou", "age": 5 })
+                .as_object()
+                .unwrap()
+                .clone(),
+        ]
+    }
+
+    pub fn create_test_settings() -> Settings<Checked> {
+        let settings = Settings {
+            displayed_attributes: Setting::Set(vec![S("race"), S("name")]),
+            searchable_attributes: Setting::Set(vec![S("name"), S("race")]),
+            filterable_attributes: Setting::Set(btreeset! { S("race"), S("age") }),
+            sortable_attributes: Setting::Set(btreeset! { S("age") }),
+            ranking_rules: Setting::NotSet,
+            stop_words: Setting::NotSet,
+            synonyms: Setting::NotSet,
+            distinct_attribute: Setting::NotSet,
+            typo_tolerance: Setting::NotSet,
+            faceting: Setting::NotSet,
+            pagination: Setting::NotSet,
+            _kind: std::marker::PhantomData,
+        };
+        settings.check()
+    }
+
+    pub fn create_test_tasks() -> Vec<(TaskView, Option<&'static [u8]>)> {
+        vec![
+            (
+                TaskView {
+                    uid: 0,
+                    index_uid: Some(S("doggos")),
+                    status: Status::Succeeded,
+                    kind: Kind::DocumentAddition,
+                    details: Some(Details::DocumentAddition {
+                        received_documents: 10_000,
+                        indexed_documents: 3,
+                    }),
+                    error: None,
+                    duration: Some(Duration::DAY),
+                    enqueued_at: datetime!(2022-11-11 0:00 UTC),
+                    started_at: Some(datetime!(2022-11-20 0:00 UTC)),
+                    finished_at: Some(datetime!(2022-11-21 0:00 UTC)),
+                },
+                None,
+            ),
+            (
+                TaskView {
+                    uid: 1,
+                    index_uid: Some(S("doggos")),
+                    status: Status::Enqueued,
+                    kind: Kind::DocumentAddition,
+                    details: None,
+                    error: None,
+                    duration: Some(Duration::DAY),
+                    enqueued_at: datetime!(2022-11-11 0:00 UTC),
+                    started_at: Some(datetime!(2022-11-20 0:00 UTC)),
+                    finished_at: Some(datetime!(2022-11-21 0:00 UTC)),
+                },
+                Some(br#"{ "id": 4, "race": "leonberg" }"#),
+            ),
+            (
+                TaskView {
+                    uid: 5,
+                    index_uid: Some(S("doggos")),
+                    status: Status::Enqueued,
+                    kind: Kind::IndexDeletion,
+                    details: None,
+                    error: None,
+                    duration: None,
+                    enqueued_at: datetime!(2022-11-15 0:00 UTC),
+                    started_at: None,
+                    finished_at: None,
+                },
+                None,
+            ),
+        ]
+    }
+
+    pub fn create_test_api_keys() -> Vec<Key> {
+        vec![
+            Key {
+                description: Some(S("The main key to manage all the doggos")),
+                name: Some(S("doggos_key")),
+                uid: Uuid::from_str("9f8a34da-b6b2-42f0-939b-dbd4c3448655").unwrap(),
+                actions: vec![Action::DocumentsAll],
+                indexes: vec![StarOr::Other(IndexUid::from_str("doggos").unwrap())],
+                expires_at: Some(datetime!(4130-03-14 12:21 UTC)),
+                created_at: datetime!(1960-11-15 0:00 UTC),
+                updated_at: datetime!(2022-11-10 0:00 UTC),
+            },
+            Key {
+                description: Some(S("The master key for everything and even the doggos")),
+                name: Some(S("master_key")),
+                uid: Uuid::from_str("4622f717-1c00-47bb-a494-39d76a49b591").unwrap(),
+                actions: vec![Action::All],
+                indexes: vec![StarOr::Star],
+                expires_at: None,
+                created_at: datetime!(0000-01-01 00:01 UTC),
+                updated_at: datetime!(1964-05-04 17:25 UTC),
+            },
+            Key {
+                description: Some(S("The useless key to for nothing nor the doggos")),
+                name: Some(S("useless_key")),
+                uid: Uuid::from_str("fb80b58b-0a34-412f-8ba7-1ce868f8ac5c").unwrap(),
+                actions: vec![],
+                indexes: vec![],
+                expires_at: None,
+                created_at: datetime!(400-02-29 0:00 UTC),
+                updated_at: datetime!(1024-02-29 0:00 UTC),
+            },
+        ]
+    }
+
+    pub fn create_test_dump() -> File {
+        let instance_uid = create_test_instance_uid();
+        let dump = DumpWriter::new(instance_uid.clone()).unwrap();
+
+        // ========== Adding an index
+        let documents = create_test_documents();
+        let settings = create_test_settings();
+
+        let mut index = dump.create_index("doggos").unwrap();
+        for document in &documents {
+            index.push_document(document).unwrap();
+        }
+        index.settings(&settings).unwrap();
+
+        // ========== pushing the task queue
+        let tasks = create_test_tasks();
+
+        let mut task_queue = dump.create_tasks_queue().unwrap();
+        for (task, update_file) in &tasks {
+            task_queue.push_task(task, update_file.map(|c| c)).unwrap();
+        }
+
+        // ========== pushing the api keys
+        let api_keys = create_test_api_keys();
+
+        let mut keys = dump.create_keys().unwrap();
+        for key in &api_keys {
+            keys.push_key(key).unwrap();
+        }
+
+        // create the dump
+        let mut file = tempfile::tempfile().unwrap();
+        dump.persist_to(&mut file).unwrap();
+        file.seek(SeekFrom::Start(0)).unwrap();
+
+        file
+    }
+
+    #[test]
+    fn test_creating_dump() {
+        let mut file = create_test_dump();
+        let mut dump = reader::open(&mut file).unwrap();
+
+        // ==== checking the top level infos
+        assert_eq!(dump.version(), Version::V6);
+        assert!(dump.date().is_some());
+        assert_eq!(
+            dump.instance_uid().unwrap().unwrap(),
+            create_test_instance_uid()
+        );
+
+        // ==== checking the index
+        let mut indexes = dump.indexes().unwrap();
+        let mut index = indexes.next().unwrap().unwrap();
+        assert!(indexes.next().is_none()); // there was only one index in the dump
+
+        assert_eq!(index.name(), "doggos");
+
+        for (document, expected) in index.documents().unwrap().zip(create_test_documents()) {
+            assert_eq!(document.unwrap(), expected);
+        }
+        assert_eq!(index.settings().unwrap(), create_test_settings());
+
+        // ==== checking the task queue
+        for (task, expected) in dump.tasks().zip(create_test_tasks()) {
+            let (task, content_file) = task.unwrap();
+            assert_eq!(task, expected.0);
+
+            if let Some(expected_update) = expected.1 {
+                assert!(
+                    content_file.is_some(),
+                    "A content file was expected for the task {}.",
+                    expected.0.uid
+                );
+                let mut update = Vec::new();
+                content_file.unwrap().read_to_end(&mut update).unwrap();
+                assert_eq!(update, expected_update);
+            }
+        }
+
+        // ==== checking the keys
+        for (key, expected) in dump.keys().zip(create_test_api_keys()) {
+            assert_eq!(key.unwrap(), expected);
+        }
+    }
+}