Method seed

tests/graph/integration/postgres/lib.rs:206–316

(
        &mut self,
        data_types: D,
        property_types: P,
        entity_types: E,
    )

impl DatabaseTestWrapper {
    pub async fn seed<D, P, E>(
        &mut self,
        data_types: D,
        property_types: P,
        entity_types: E,
    ) -> Result<DatabaseApi<'_>, Report<InsertionError>>
    where
        D: IntoIterator<Item = &'static str, IntoIter: Send> + Send,
        P: IntoIterator<Item = &'static str, IntoIter: Send> + Send,
        E: IntoIterator<Item = &'static str, IntoIter: Send> + Send,
    {
        let mut store = self
            .connection
            .transaction()
            .await
            .expect("could not start test transaction");

        store
            .seed_system_policies()
            .await
            .expect("Should be able to seed system policies");

        let system_account_id = store
            .get_or_create_system_machine("h")
            .await
            .change_context(InsertionError)?;
        let user_id = store
            .create_user_actor(
                system_account_id.into(),
                CreateUserActorParams {
                    user_id: None,
                    shortname: Some("bench-user".to_owned()),
                    registration_complete: true,
                },
            )
            .await
            .change_context(InsertionError)?
            .user_id;

        store
            .create_data_types(
                user_id.into(),
                data_types.into_iter().map(|data_type_str| {
                    let schema: DataType = serde_json::from_str(data_type_str)
                        .expect("could not parse data type representation");
                    CreateDataTypeParams {
                        schema,
                        ownership: OntologyOwnership::Local {
                            web_id: user_id.into(),
                        },
                        conflict_behavior: ConflictBehavior::Skip,
                        provenance: ProvidedOntologyEditionProvenance {
                            actor_type: ActorType::User,
                            origin: OriginProvenance::from_empty_type(OriginType::Api),
                            sources: Vec::new(),
                        },
                        conversions: HashMap::new(),
                    }