#[derive(Serialize, Deserialize, Debug, PartialEq, Default, Clone, Collection)]

    pub fn new(value: impl Into<String>) -> Self {

        Self {

            value: value.into(),

            tags: Vec::default(),

            category: None,

            parent_id: None,

        }

    }

    pub fn with_category(mut self, category: impl Into<String>) -> Self {

        self.category = Some(category.into());

        self

    }

    pub fn with_tag(mut self, tag: impl Into<String>) -> Self {

        self.tags.push(tag.into());

        self

    }

    pub const fn with_parent_id(mut self, parent_id: u64) -> Self {

        self.parent_id = Some(parent_id);

        self

    }

#[derive(Debug, Clone, View)]

    fn map(&self, document: &BorrowedDocument<'_>) -> ViewMapResult<Self::View> {

        Ok(document.emit_key_and_value((), 1))

    }

    fn reduce(

        &self,

        mappings: &[ViewMappedValue<Self::View>],

        _rereduce: bool,

    ) -> ReduceResult<Self::View> {

        Ok(mappings.iter().map(|map| map.value).sum())

    }

#[derive(Debug, Clone, View)]

    fn version(&self) -> u64 {

        1

    }

    fn map(&self, document: &BorrowedDocument<'_>) -> ViewMapResult<Self::View> {

        let contents = document.contents::<Basic>()?;

        Ok(document.emit_key_and_value(contents.parent_id, 1))

    }

    fn reduce(

        &self,

        mappings: &[ViewMappedValue<Self::View>],

        _rereduce: bool,

    ) -> ReduceResult<Self::View> {

        Ok(mappings.iter().map(|map| map.value).sum())

    }

#[derive(Debug, Clone, View)]

    fn map(&self, document: &BorrowedDocument<'_>) -> ViewMapResult<Self::View> {

        let contents = document.contents::<Basic>()?;

        if let Some(category) = &contents.category {

            Ok(document.emit_key_and_value(category.to_lowercase(), 1))

            Ok(Mappings::none())

    }

    fn reduce(

        &self,

        mappings: &[ViewMappedValue<Self::View>],

        _rereduce: bool,

    ) -> ReduceResult<Self::View> {

        Ok(mappings.iter().map(|map| map.value).sum())

    }

#[derive(Debug, Clone, View)]

    fn map(&self, document: &BorrowedDocument<'_>) -> ViewMapResult<Self::View> {

        let contents = document.contents::<Basic>()?;

        Ok(contents

            .tags

            .iter()

            .map(|tag| document.emit_key_and_value(tag.clone(), 1))

            .collect())

    }

    fn reduce(

        &self,

        mappings: &[ViewMappedValue<Self::View>],

        _rereduce: bool,

    ) -> ReduceResult<Self::View> {

        Ok(mappings.iter().map(|map| map.value).sum())

    }

#[derive(Debug, Clone, View)]

    fn map(&self, document: &BorrowedDocument<'_>) -> ViewMapResult<Self::View> {

        Ok(document.emit())

    }

#[derive(Serialize, Deserialize, Debug, PartialEq, Default, Clone, Collection)]

    pub fn new(value: impl Into<String>) -> Self {

        Self {

            value: value.into(),

            category: None,

            parent_id: None,

        }

    }

#[derive(Debug, Clone, View)]

#[derive(Debug, Clone, View)]

#[derive(Debug, Clone, View)]

#[derive(Debug, Schema)]

#[derive(Serialize, Deserialize, Debug, PartialEq, Default, Collection)]

    pub fn new(value: impl Display) -> Self {

        Self {

            value: value.to_string(),

        }

    }

#[derive(Debug, Clone, View)]

    fn unique(&self) -> bool {

        true

    }

    fn map(&self, document: &BorrowedDocument<'_>) -> ViewMapResult<Self::View> {

        let entry = document.contents::<Unique>()?;

        Ok(document.emit_key(entry.value))

    }

    pub fn new<S: AsRef<Path>>(name: S) -> Self {

        let path = std::env::temp_dir().join(name);

        if path.exists() {

        }

        Self(path)

    }

        if let Err(err) = std::fs::remove_dir_all(&self.0) {

        }

    }

    fn as_ref(&self) -> &Path {

        &self.0

    }

    fn deref(&self) -> &Self::Target {

        &self.0

    }

    fn collection_name() -> CollectionName {

        Basic::collection_name()

    }

    fn define_views(_schema: &mut Schematic) -> Result<(), Error> {

        Ok(())

    }

    fn format() -> Self::Format {

        Pot::default()

    }

    fn collection_name() -> CollectionName {

        Basic::collection_name()

    }

    fn define_views(schema: &mut Schematic) -> Result<(), Error> {

        schema.define_view(BasicByBrokenParentId)

    }

#[derive(Debug, Collection)]

#[derive(Copy, Clone, Debug)]

    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {

        Debug::fmt(&self, f)

    }

        async fn server_connection_tests() -> anyhow::Result<()> {

        async fn store_retrieve_update_delete() -> anyhow::Result<()> {

        async fn not_found() -> anyhow::Result<()> {

        async fn conflict() -> anyhow::Result<()> {

        async fn bad_update() -> anyhow::Result<()> {

        async fn no_update() -> anyhow::Result<()> {

        async fn get_multiple() -> anyhow::Result<()> {

        async fn list() -> anyhow::Result<()> {

        async fn list_transactions() -> anyhow::Result<()> {

        async fn view_query() -> anyhow::Result<()> {

        async fn unassociated_collection() -> anyhow::Result<()> {

        async fn unimplemented_reduce() -> anyhow::Result<()> {

        async fn view_update() -> anyhow::Result<()> {

        async fn view_multi_emit() -> anyhow::Result<()> {

        async fn view_access_policies() -> anyhow::Result<()> {

        async fn unique_views() -> anyhow::Result<()> {

        async fn named_collection() -> anyhow::Result<()> {

        async fn user_management() -> anyhow::Result<()> {

        async fn compaction() -> anyhow::Result<()> {

pub async fn store_retrieve_update_delete_tests<C: Connection>(db: &C) -> anyhow::Result<()> {

    let original_value = Basic::new("initial_value");

    let collection = db.collection::<Basic>();

    let header = collection.push(&original_value).await?;

    let mut doc = collection

        .get(header.id)

        .await?

        .expect("couldn't retrieve stored item");

    let mut value = doc.contents::<Basic>()?;

    assert_eq!(original_value, value);

    let old_revision = doc.header.revision.clone();

    // Update the value

    value.value = String::from("updated_value");

    doc.set_contents(&value)?;

    db.update::<Basic, _>(&mut doc).await?;

    assert_ne!(doc.header.revision, old_revision);

    let doc = collection

        .get(header.id)

        .await?

        .expect("couldn't retrieve stored item");

    assert_eq!(doc.contents::<Basic>()?, value);

    let transactions = db.list_executed_transactions(None, None).await?;

    assert_eq!(transactions.len(), 2);

    assert!(transactions[0].id < transactions[1].id);

    for transaction in &transactions {

        let changed_documents = transaction

            .changes

            .documents()

            .expect("incorrect transaction type");

        assert_eq!(changed_documents.len(), 1);

        assert_eq!(changed_documents[0].collection, Basic::collection_name());

        assert_eq!(changed_documents[0].id, header.id);

        assert!(!changed_documents[0].deleted);

    db.collection::<Basic>().delete(&doc).await?;

    assert!(collection.get(header.id).await?.is_none());

    let transactions = db

        .list_executed_transactions(Some(transactions.last().as_ref().unwrap().id + 1), None)

        .await?;

    assert_eq!(transactions.len(), 1);

    let transaction = transactions.first().unwrap();

    let changed_documents = transaction

        .changes

        .documents()

        .expect("incorrect transaction type");

    assert_eq!(changed_documents.len(), 1);

    assert_eq!(changed_documents[0].collection, Basic::collection_name());

    assert_eq!(changed_documents[0].id, header.id);

    assert!(changed_documents[0].deleted);

    let mut doc = original_value.clone().push_into(db).await?;

    doc.contents.category = Some(String::from("updated"));

    doc.update(db).await?;

    let reloaded = Basic::get(doc.header.id, db).await?.unwrap();

    assert_eq!(doc.contents, reloaded.contents);

    let doc = BorrowedDocument::with_contents(42, &Basic::new("42"))?;

    let document_42 = db

        .insert::<Basic, _>(Some(doc.id), doc.contents.into_vec())

        .await?;

    assert_eq!(document_42.id, 42);

    let document_43 = Basic::new("43").insert_into(43, db).await?;

    assert_eq!(document_43.id, 43);

    let conflict_err = Basic::new("43")

        .insert_into(doc.header.id, db)

        .await

        .unwrap_err();

    assert!(matches!(conflict_err.error, Error::DocumentConflict(..)));

    Ok(())

}

pub async fn not_found_tests<C: Connection>(db: &C) -> anyhow::Result<()> {

    assert!(db.collection::<Basic>().get(1).await?.is_none());

    assert!(db.last_transaction_id().await?.is_none());

    Ok(())

}

pub async fn conflict_tests<C: Connection>(db: &C) -> anyhow::Result<()> {

    let original_value = Basic::new("initial_value");

    let collection = db.collection::<Basic>();

    let header = collection.push(&original_value).await?;

    let mut doc = collection

        .get(header.id)

        .await?

        .expect("couldn't retrieve stored item");

    let mut value = doc.contents::<Basic>()?;

    value.value = String::from("updated_value");

    doc.set_contents(&value)?;

    db.update::<Basic, _>(&mut doc).await?;

    doc.header = header;

    match db

        .update::<Basic, _>(&mut doc)

        .await

        .expect_err("conflict should have generated an error")

        Error::DocumentConflict(collection, id) => {

            assert_eq!(collection, Basic::collection_name());

            assert_eq!(id, doc.header.id);

    let mut doc = CollectionDocument::<Basic>::try_from(&doc)?;

    doc.modify(db, |doc| {

        doc.contents.value = String::from("modify worked");

    })

    .await?;

    assert_eq!(doc.contents.value, "modify worked");

    let doc = Basic::get(doc.id, db).await?.unwrap();

    assert_eq!(doc.contents.value, "modify worked");

    Ok(())

}

pub async fn bad_update_tests<C: Connection>(db: &C) -> anyhow::Result<()> {

    let mut doc = BorrowedDocument::with_contents(1, &Basic::default())?;

    match db.update::<Basic, _>(&mut doc).await {

        Err(Error::DocumentNotFound(collection, id)) => {

            assert_eq!(collection, Basic::collection_name());

            assert_eq!(id, 1);

            Ok(())

}

pub async fn no_update_tests<C: Connection>(db: &C) -> anyhow::Result<()> {

    let original_value = Basic::new("initial_value");

    let collection = db.collection::<Basic>();

    let header = collection.push(&original_value).await?;

    let mut doc = collection

        .get(header.id)

        .await?

        .expect("couldn't retrieve stored item");

    db.update::<Basic, _>(&mut doc).await?;

    assert_eq!(doc.header, header);

    Ok(())

}

pub async fn get_multiple_tests<C: Connection>(db: &C) -> anyhow::Result<()> {

    let collection = db.collection::<Basic>();

    let doc1_value = Basic::new("initial_value");

    let doc1 = collection.push(&doc1_value).await?;

    let doc2_value = Basic::new("second_value");

    let doc2 = collection.push(&doc2_value).await?;

    let both_docs = Basic::get_multiple(&[doc1.id, doc2.id], db).await?;

    assert_eq!(both_docs.len(), 2);

    let out_of_order = Basic::get_multiple(&[doc2.id, doc1.id], db).await?;

    assert_eq!(out_of_order.len(), 2);

    let doc1 = both_docs

        .iter()

        .find(|doc| doc.header.id == doc1.id)

        .expect("Couldn't find doc1");

    assert_eq!(doc1.contents.value, doc1_value.value);

    let doc2 = both_docs

        .iter()

        .find(|doc| doc.header.id == doc2.id)

        .expect("Couldn't find doc2");

    assert_eq!(doc2.contents.value, doc2_value.value);

    Ok(())

}

pub async fn list_tests<C: Connection>(db: &C) -> anyhow::Result<()> {

    let collection = db.collection::<Basic>();

    let doc1_value = Basic::new("initial_value");

    let doc1 = collection.push(&doc1_value).await?;

    let doc2_value = Basic::new("second_value");

    let doc2 = collection.push(&doc2_value).await?;

    let all_docs = Basic::all(db).await?;

    assert_eq!(all_docs.len(), 2);

    let both_docs = Basic::list(doc1.id..=doc2.id, db).await?;

    assert_eq!(both_docs.len(), 2);

    assert_eq!(both_docs[0].contents.value, doc1_value.value);

    assert_eq!(both_docs[1].contents.value, doc2_value.value);

    let one_doc = Basic::list(doc1.id..doc2.id, db).await?;

    assert_eq!(one_doc.len(), 1);

    let limited = Basic::list(doc1.id..=doc2.id, db)

        .limit(1)

        .descending()

        .await?;

    assert_eq!(limited.len(), 1);

    assert_eq!(limited[0].contents.value, doc2_value.value);

    Ok(())

}

pub async fn list_transactions_tests<C: Connection>(db: &C) -> anyhow::Result<()> {

    let collection = db.collection::<Basic>();

    // create LIST_TRANSACTIONS_MAX_RESULTS + 1 items, giving us just enough

    // transactions to test the edge cases of `list_transactions`

    futures::future::join_all(

        (0..=(LIST_TRANSACTIONS_MAX_RESULTS))

            .map(|_| async { collection.push(&Basic::default()).await.unwrap() }),

    )

    .await;

    let transactions = db.list_executed_transactions(None, None).await?;

    assert_eq!(transactions.len(), LIST_TRANSACTIONS_DEFAULT_RESULT_COUNT);

    let transactions = db

        .list_executed_transactions(None, Some(LIST_TRANSACTIONS_MAX_RESULTS + 1))

        .await?;

    assert_eq!(transactions.len(), LIST_TRANSACTIONS_MAX_RESULTS);

    let transactions = db.list_executed_transactions(None, Some(0)).await?;

    assert!(transactions.is_empty());

    let mut transactions = Vec::new();

    let mut starting_id = None;

        let chunk = db

            .list_executed_transactions(starting_id, Some(100))

            .await?;

        if chunk.is_empty() {

            break;

        }

        let max_id = chunk.last().map(|tx| tx.id).unwrap();

        starting_id = Some(max_id + 1);

        transactions.extend(chunk);

    assert_eq!(transactions.len(), LIST_TRANSACTIONS_MAX_RESULTS + 1);

    Ok(())

}

pub async fn view_query_tests<C: Connection>(db: &C) -> anyhow::Result<()> {

    let collection = db.collection::<Basic>();

    let a = collection.push(&Basic::new("A")).await?;

    let b = collection.push(&Basic::new("B")).await?;

    let a_child = collection

        .push(

            &Basic::new("A.1")

                .with_parent_id(a.id)

                .with_category("Alpha"),

        )

        .await?;

    collection

        .push(&Basic::new("B.1").with_parent_id(b.id).with_category("Beta"))

        .await?;

    collection

        .push(&Basic::new("B.2").with_parent_id(b.id).with_category("beta"))

        .await?;

    let a_children = db

        .view::<BasicByParentId>()

        .with_key(Some(a.id))

        .query()

        .await?;

    assert_eq!(a_children.len(), 1);

    let a_children = db

        .view::<BasicByParentId>()

        .with_key(Some(a.id))

        .query_with_collection_docs()

        .await?;

    assert_eq!(a_children.len(), 1);

    assert_eq!(a_children.get(0).unwrap().document.header, a_child);

    let b_children = db

        .view::<BasicByParentId>()

        .with_key(Some(b.id))

        .query()

        .await?;

    assert_eq!(b_children.len(), 2);

    let a_and_b_children = db

        .view::<BasicByParentId>()

        .with_keys([Some(a.id), Some(b.id)])

        .query()

        .await?;

    assert_eq!(a_and_b_children.len(), 3);

    let a_and_b_children = db

        .view::<BasicByParentId>()

        .with_keys([Some(b.id), Some(a.id)])

        .query()

        .await?;

    assert_eq!(a_and_b_children.len(), 3);

    let has_parent = db

        .view::<BasicByParentId>()

        .with_key_range(Some(0)..=Some(u64::MAX))

        .query()

        .await?;

    assert_eq!(has_parent.len(), 3);

    assert!(has_parent

        .windows(2)

        .all(|window| window[0].key <= window[1].key));

    let last_with_parent = db

        .view::<BasicByParentId>()

        .with_key_range(Some(0)..=Some(u64::MAX))

        .descending()

        .limit(1)

        .query()

        .await?;

    assert_eq!(last_with_parent.iter().map(|m| m.key).unique().count(), 1);

    assert_eq!(last_with_parent[0].key, has_parent[2].key);

    let items_with_categories = db.view::<BasicByCategory>().query().await?;

    assert_eq!(items_with_categories.len(), 3);

    let deleted_count = db

        .view::<BasicByParentId>()

        .with_key(Some(b.id))

        .delete_docs()

        .await?;

    assert_eq!(b_children.len() as u64, deleted_count);

        db.view::<BasicByParentId>()

            .with_key(Some(b.id))

            .query()

            .await?

            .len(),

    Ok(())

}

pub async fn unassociated_collection_tests<C: Connection>(db: &C) -> anyhow::Result<()> {

    let result = db

        .insert::<UnassociatedCollection, _>(None, Vec::new())

        .await;

    match result {

        Err(Error::CollectionNotFound) => {}

    Ok(())

}

pub async fn unimplemented_reduce<C: Connection>(db: &C) -> anyhow::Result<()> {

    assert!(matches!(

        db.view::<UniqueValue>().reduce().await,

    Ok(())

}

pub async fn view_update_tests<C: Connection>(db: &C) -> anyhow::Result<()> {

    let collection = db.collection::<Basic>();

    let a = collection.push(&Basic::new("A")).await?;

    let a_children = db

        .view::<BasicByParentId>()

        .with_key(Some(a.id))

        .query()

        .await?;

    assert_eq!(a_children.len(), 0);

        db.view::<BasicByParentId>()

            .with_key(Some(a.id))

            .reduce()

            .await?,

    let a_child = collection

        .push(

            &Basic::new("A.1")

                .with_parent_id(a.id)

                .with_category("Alpha"),

        )

        .await?;

    let a_children = db

        .view::<BasicByParentId>()

        .with_key(Some(a.id))

        .query()

        .await?;

    assert_eq!(a_children.len(), 1);

        db.view::<BasicByParentId>()

            .with_key(Some(a.id))

            .reduce()

            .await?,

        db.view::<BasicByParentId>().reduce_grouped().await?,

        vec![MappedValue::new(None, 1,), MappedValue::new(Some(a.id), 1,),]

    let mut doc = db.collection::<Basic>().get(a_child.id).await?.unwrap();

    let mut basic = doc.contents::<Basic>()?;

    basic.parent_id = None;

    doc.set_contents(&basic)?;

    db.update::<Basic, _>(&mut doc).await?;

    let a_children = db

        .view::<BasicByParentId>()

        .with_key(Some(a.id))

        .query()

        .await?;

    assert_eq!(a_children.len(), 0);

        db.view::<BasicByParentId>()

            .with_key(Some(a.id))

            .reduce()

            .await?,

    assert_eq!(db.view::<BasicByParentId>().reduce().await?, 2);

    db.collection::<Basic>().delete(&doc).await?;

    let all_entries = db.view::<BasicByParentId>().query().await?;

    assert_eq!(all_entries.len(), 1);

        db.view::<BasicByParentId>().reduce_grouped().await?,

        vec![MappedValue::new(None, 1,),]

    Ok(())

}

pub async fn view_multi_emit_tests<C: Connection>(db: &C) -> anyhow::Result<()> {

    let mut a = Basic::new("A")

        .with_tag("red")

        .with_tag("green")

        .push_into(db)

        .await?;

    let mut b = Basic::new("B")

        .with_tag("blue")

        .with_tag("green")

        .push_into(db)

        .await?;

    assert_eq!(db.view::<BasicByTag>().query().await?.len(), 4);

        db.view::<BasicByTag>()

            .with_key(String::from("green"))

            .query()

            .await?

            .len(),

        db.view::<BasicByTag>()

            .with_key(String::from("red"))

            .query()

            .await?

            .len(),

        db.view::<BasicByTag>()

            .with_key(String::from("blue"))

            .query()

            .await?

            .len(),

    a.contents.tags = vec![String::from("red"), String::from("blue")];

    a.update(db).await?;

        db.view::<BasicByTag>()

            .with_key(String::from("green"))

            .query()

            .await?

            .len(),

        db.view::<BasicByTag>()

            .with_key(String::from("red"))

            .query()

            .await?

            .len(),

        db.view::<BasicByTag>()

            .with_key(String::from("blue"))

            .query()

            .await?

            .len(),

    b.contents.tags.clear();

    b.update(db).await?;

        db.view::<BasicByTag>()

            .with_key(String::from("green"))

            .query()

            .await?

            .len(),

        db.view::<BasicByTag>()

            .with_key(String::from("red"))

            .query()

            .await?

            .len(),

        db.view::<BasicByTag>()

            .with_key(String::from("blue"))

            .query()

            .await?

            .len(),

    Ok(())

}

pub async fn view_access_policy_tests<C: Connection>(db: &C) -> anyhow::Result<()> {

    let collection = db.collection::<Basic>();

    let a = collection.push(&Basic::new("A")).await?;

    collection

        .push(

            &Basic::new("A.1")

                .with_parent_id(a.id)

                .with_category("Alpha"),

        )

        .await?;

    let a_children = db

        .view::<BasicByParentId>()

        .with_key(Some(a.id))

        .with_access_policy(AccessPolicy::NoUpdate)

        .query()

        .await?;

    assert_eq!(a_children.len(), 0);

    tokio::time::sleep(Duration::from_millis(20)).await;

    let a_children = db

        .view::<BasicByParentId>()

        .with_key(Some(a.id))

        .with_access_policy(AccessPolicy::UpdateAfter)

        .query()

        .await?;

    assert_eq!(a_children.len(), 0);

    for _ in 0..10_u8 {

        tokio::time::sleep(Duration::from_millis(20)).await;

        let a_children = db

            .view::<BasicByParentId>()

            .with_key(Some(a.id))

            .with_access_policy(AccessPolicy::NoUpdate)

            .query()

            .await?;

        if a_children.len() == 1 {

            return Ok(());

}

pub async fn unique_view_tests<C: Connection>(db: &C) -> anyhow::Result<()> {

    let first_doc = db.collection::<Unique>().push(&Unique::new("1")).await?;

        view,

        existing_document,

        conflicting_document,

    }) = db.collection::<Unique>().push(&Unique::new("1")).await

        assert_eq!(view, UniqueValue.view_name());

        assert_eq!(existing_document.id, first_doc.id);

        assert_ne!(conflicting_document, existing_document);

    let second_doc = db.collection::<Unique>().push(&Unique::new("2")).await?;

    let mut second_doc = db.collection::<Unique>().get(second_doc.id).await?.unwrap();

    let mut contents = second_doc.contents::<Unique>()?;

    contents.value = String::from("1");

    second_doc.set_contents(&contents)?;

        view,

        existing_document,

        conflicting_document,

    }) = db.update::<Unique, _>(&mut second_doc).await

        assert_eq!(view, UniqueValue.view_name());

        assert_eq!(existing_document.id, first_doc.id);

        assert_eq!(conflicting_document.id, second_doc.header.id);

    Ok(())

}

pub async fn named_collection_tests<C: Connection>(db: &C) -> anyhow::Result<()> {

    Unique::new("0").push_into(db).await?;

    let original_entry = Unique::entry("1", db)

        .update_with(|_existing: &mut Unique| unreachable!())

        .or_insert_with(|| Unique::new("1"))

        .await?

        .expect("Document not inserted");

    let updated = Unique::entry("1", db)

        .update_with(|existing: &mut Unique| {

            existing.value = String::from("2");

        })

        .or_insert_with(|| unreachable!())

        .await?

        .unwrap();

    assert_eq!(original_entry.id, updated.id);

    assert_ne!(original_entry.contents.value, updated.contents.value);

    let retrieved = Unique::entry("2", db).await?.unwrap();

    assert_eq!(retrieved.contents.value, updated.contents.value);

    let conflict = Unique::entry("2", db)

        .update_with(|existing: &mut Unique| {