#[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> {

        document.header.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 = Basic::document_contents(document)?;

        document.header.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 = Basic::document_contents(document)?;

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

            document

                .header

                .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 = Basic::document_contents(document)?;

        contents

            .tags

            .iter()

            .map(|tag| document.header.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> {

        document.header.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(Clone, 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 = Unique::document_contents(document)?;

        document.header.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(Serialize, Deserialize, Clone, 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<()> {

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

                let harness = $harness::new($crate::test_util::HarnessTest::ServerConnectionTests)?;

                let db = harness.server();

                $crate::test_util::blocking_basic_server_connection_tests(

                    db,

                    &format!("server-connection-tests-{}", $harness::server_name()),

                )?;

                harness.shutdown()

            }

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

                let harness = $harness::new($crate::test_util::HarnessTest::StoreRetrieveUpdate)?;

                let db = harness.connect()?;

                $crate::test_util::blocking_store_retrieve_update_delete_tests(&db)?;

                harness.shutdown()

            }

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

                let harness = $harness::new($crate::test_util::HarnessTest::NotFound)?;

                let db = harness.connect()?;

                $crate::test_util::blocking_not_found_tests(&db)?;

                harness.shutdown()

            }

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

                let harness = $harness::new($crate::test_util::HarnessTest::Conflict)?;

                let db = harness.connect()?;

                $crate::test_util::blocking_conflict_tests(&db)?;

                harness.shutdown()

            }

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

                let harness = $harness::new($crate::test_util::HarnessTest::BadUpdate)?;

                let db = harness.connect()?;

                $crate::test_util::blocking_bad_update_tests(&db)?;

                harness.shutdown()

            }

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

                let harness = $harness::new($crate::test_util::HarnessTest::NoUpdate)?;

                let db = harness.connect()?;

                $crate::test_util::blocking_no_update_tests(&db)?;

                harness.shutdown()

            }

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

                let harness = $harness::new($crate::test_util::HarnessTest::GetMultiple)?;

                let db = harness.connect()?;

                $crate::test_util::blocking_get_multiple_tests(&db)?;

                harness.shutdown()

            }

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

                let harness = $harness::new($crate::test_util::HarnessTest::List)?;

                let db = harness.connect()?;

                $crate::test_util::blocking_list_tests(&db)?;

                harness.shutdown()

            }

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

                let harness = $harness::new($crate::test_util::HarnessTest::ListTransactions)?;

                let db = harness.connect()?;

                $crate::test_util::blocking_list_transactions_tests(&db)?;

                harness.shutdown()

            }

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

                let harness = $harness::new($crate::test_util::HarnessTest::ViewQuery)?;

                let db = harness.connect()?;

                $crate::test_util::blocking_view_query_tests(&db)?;

                harness.shutdown()

            }

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

                let harness =

                    $harness::new($crate::test_util::HarnessTest::UnassociatedCollection)?;

                let db = harness.connect()?;

                $crate::test_util::blocking_unassociated_collection_tests(&db)?;

                harness.shutdown()

            }

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

                let harness =

                    $harness::new($crate::test_util::HarnessTest::ViewUnimplementedReduce)?;

                let db = harness.connect()?;

                $crate::test_util::blocking_unimplemented_reduce(&db)?;

                harness.shutdown()

            }

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

                let harness = $harness::new($crate::test_util::HarnessTest::ViewUpdate)?;

                let db = harness.connect()?;

                $crate::test_util::blocking_view_update_tests(&db)?;

                harness.shutdown()

            }

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

                let harness = $harness::new($crate::test_util::HarnessTest::ViewMultiEmit)?;

                let db = harness.connect()?;

                $crate::test_util::blocking_view_multi_emit_tests(&db)?;

                harness.shutdown()

            }

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

                let harness = $harness::new($crate::test_util::HarnessTest::ViewAccessPolicies)?;

                let db = harness.connect()?;

                $crate::test_util::blocking_view_access_policy_tests(&db)?;

                harness.shutdown()

            }

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

                let harness = $harness::new($crate::test_util::HarnessTest::UniqueViews)?;

                let db = harness.connect()?;

                $crate::test_util::blocking_unique_view_tests(&db)?;

                harness.shutdown()

            }

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

                let harness = $harness::new($crate::test_util::HarnessTest::NamedCollection)?;

                let db = harness.connect()?;

                $crate::test_util::blocking_named_collection_tests(&db)?;

                harness.shutdown()

            }

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

                let harness = $harness::new($crate::test_util::HarnessTest::UserManagement)?;

                let _db = harness.connect()?;

                let server = harness.server();

                let admin =

                    server.database::<$crate::admin::Admin>($crate::admin::ADMIN_DATABASE_NAME)?;

                $crate::test_util::blocking_user_management_tests(

                    &admin,

                    server,

                    $harness::server_name(),

                )?;

                harness.shutdown()

            }

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

                let harness = $harness::new($crate::test_util::HarnessTest::Compact)?;

                let db = harness.connect()?;

                $crate::test_util::blocking_compaction_tests(&db)?;

                harness.shutdown()

            }

pub async fn store_retrieve_update_delete_tests<C: AsyncConnection>(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 = Basic::document_contents(&doc)?;

    assert_eq!(original_value, value);

    let old_revision = doc.header.revision;

    // Update the value

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

    Basic::set_document_contents(&mut doc, value.clone())?;

    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!(Basic::document_contents(&doc)?, 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 changes = transaction

            .changes

            .documents()

            .expect("incorrect transaction type");

        assert_eq!(changes.documents.len(), 1);

        assert_eq!(changes.collections.len(), 1);

        assert_eq!(changes.collections[0], Basic::collection_name());

        assert_eq!(changes.documents[0].collection, 0);

        assert_eq!(header.id, changes.documents[0].id.deserialize()?);

        assert!(!changes.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 changes = transaction

        .changes

        .documents()

        .expect("incorrect transaction type");

    assert_eq!(changes.documents.len(), 1);

    assert_eq!(changes.collections[0], Basic::collection_name());

    assert_eq!(header.id, changes.documents[0].id.deserialize()?);

    assert!(changes.documents[0].deleted);

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

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

    doc.update_async(db).await?;

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

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

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

    let document_42 = db

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

        .await?;

    assert_eq!(document_42.id, 42);

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

    assert_eq!(document_43.header.id, 43);

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

        .insert_into_async(doc.header.id, db)

        .await

        .unwrap_err();

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

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

        .overwrite_into_async(doc.header.id, db)

        .await

        .unwrap();

    assert!(overwritten.header.revision.id > doc.header.revision.id);

    Ok(())

}

pub fn blocking_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)?;

    let mut doc = collection

        .get(header.id)?

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

    let mut value = Basic::document_contents(&doc)?;

    assert_eq!(original_value, value);

    let old_revision = doc.header.revision;

    // Update the value

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

    Basic::set_document_contents(&mut doc, value.clone())?;

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

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

    let doc = collection

        .get(header.id)?

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

    assert_eq!(Basic::document_contents(&doc)?, value);

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

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

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

    for transaction in &transactions {

        let changes = transaction

            .changes

            .documents()

            .expect("incorrect transaction type");

        assert_eq!(changes.documents.len(), 1);

        assert_eq!(changes.collections.len(), 1);

        assert_eq!(changes.collections[0], Basic::collection_name());

        assert_eq!(changes.documents[0].collection, 0);

        assert_eq!(header.id, changes.documents[0].id.deserialize()?);

        assert!(!changes.documents[0].deleted);

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

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

    let transactions =

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

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

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

    let changes = transaction

        .changes

        .documents()

        .expect("incorrect transaction type");

    assert_eq!(changes.documents.len(), 1);

    assert_eq!(changes.collections[0], Basic::collection_name());

    assert_eq!(header.id, changes.documents[0].id.deserialize()?);

    assert!(changes.documents[0].deleted);

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

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

    doc.update(db)?;

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

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

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

    let document_42 = db.insert::<Basic, _, _>(Some(doc.header.id), doc.contents.into_vec())?;

    assert_eq!(document_42.id, 42);

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

    assert_eq!(document_43.header.id, 43);

    let conflict_err = Basic::new("43").insert_into(doc.header.id, db).unwrap_err();

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

    let overwritten = Basic::new("43").overwrite_into(doc.header.id, db).unwrap();

    assert!(overwritten.header.revision.id > doc.header.revision.id);

    Ok(())

}

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

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

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

    Ok(())

}

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

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

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

    Ok(())

}

pub async fn conflict_tests<C: AsyncConnection>(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 = Basic::document_contents(&doc)?;

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

    Basic::set_document_contents(&mut doc, value.clone())?;

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

    doc.header = Header::try_from(header).unwrap();

    match db

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

        .await

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

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

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

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

    db.collection::<Basic>().overwrite(&mut doc).await.unwrap();

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

    doc.modify_async(db, |doc| {

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

    })

    .await?;

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

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

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

    Ok(())

}

pub fn blocking_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)?;

    let mut doc = collection

        .get(header.id)?

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

    let mut value = Basic::document_contents(&doc)?;

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

    Basic::set_document_contents(&mut doc, value)?;

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

    doc.header = Header::try_from(header).unwrap();

    match db

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

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

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

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

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

    db.collection::<Basic>().overwrite(&mut doc).unwrap();

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

    doc.modify(db, |doc| {

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

    })?;

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

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

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

    Ok(())

}

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

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

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

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

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

            assert_eq!(id.as_ref(), &DocumentId::from_u64(1));

            Ok(())

}

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

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

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

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

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

            assert_eq!(id.as_ref(), &DocumentId::from_u64(1));

            Ok(())

}

pub async fn no_update_tests<C: AsyncConnection>(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!(CollectionHeader::try_from(doc.header)?, header);

    Ok(())

}

pub fn blocking_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)?;

    let mut doc = collection

        .get(header.id)?

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

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

    assert_eq!(CollectionHeader::try_from(doc.header)?, header);

    Ok(())

}

pub async fn get_multiple_tests<C: AsyncConnection>(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_async([doc1.id, doc2.id], db).await?;

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

    let out_of_order = Basic::get_multiple_async([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 fn blocking_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)?;

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

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

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

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

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

    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: AsyncConnection>(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_async(db).await?;

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

    assert_eq!(Basic::all_async(db).count().await?, 2);

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

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

    assert_eq!(Basic::list_async(doc1.id..=doc2.id, db).count().await?, 2);

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

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

    let both_headers = Basic::list_async(doc1.id..=doc2.id, db).headers().await?;

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

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

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

    let limited = Basic::list_async(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 fn blocking_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)?;

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

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

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

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

    assert_eq!(Basic::all(db).count()?, 2);

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

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

    assert_eq!(Basic::list(doc1.id..=doc2.id, db).count()?, 2);

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

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

    let both_headers = Basic::list(doc1.id..=doc2.id, db).headers()?;

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

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

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

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

        .limit(1)

        .descending()

        .query()?;

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

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

    Ok(())

}

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

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