Method new

tests/graph/benches/util.rs:70–244

(
        bench_db_name: &str,
        fail_on_exists: bool,
        delete_on_drop: bool,
        account_id: ActorEntityUuid,
    )

impl StoreWrapper {
    #[expect(clippy::too_many_lines)]
    pub async fn new(
        bench_db_name: &str,
        fail_on_exists: bool,
        delete_on_drop: bool,
        account_id: ActorEntityUuid,
    ) -> Self {
        load_env(Environment::Test);

        let super_user = std::env::var("POSTGRES_USER").unwrap_or_else(|_| "postgres".to_owned());
        let super_password =
            std::env::var("POSTGRES_PASSWORD").unwrap_or_else(|_| "postgres".to_owned());

        let user = std::env::var("HASH_GRAPH_PG_USER").unwrap_or_else(|_| "graph".to_owned());
        let password =
            std::env::var("HASH_GRAPH_PG_PASSWORD").unwrap_or_else(|_| "graph".to_owned());
        let host = std::env::var("HASH_GRAPH_PG_HOST").unwrap_or_else(|_| "localhost".to_owned());
        let port = std::env::var("HASH_GRAPH_PG_PORT").map_or(5432, |port| {
            port.parse::<u16>()
                .unwrap_or_else(|_| panic!("{port} is not a valid port"))
        });
        let database =
            std::env::var("HASH_GRAPH_PG_DATABASE").unwrap_or_else(|_| "graph".to_owned());

        let source_db_connection_info = DatabaseConnectionInfo::new(
            DatabaseType::Postgres,
            super_user.clone(), // super user as we need to create and delete tables
            super_password.clone(),
            host.clone(),
            port,
            database,
        );

        let bench_db_connection_info = DatabaseConnectionInfo::new(
            DatabaseType::Postgres,
            user,
            password,
            host.clone(),
            port,
            bench_db_name.to_owned(),
        );

        let source_db_pool = PostgresStorePool::new(
            &source_db_connection_info,
            &DatabasePoolConfig::default(),
            NoTls,
            PostgresStoreSettings::default(),
        )
        .await
        .expect("could not connect to database");

        // Create a new connection to the source database, copy the database, drop the connection
        {
            let conn = source_db_pool
                .acquire_owned(None)
                .await
                .expect("could not acquire a database connection");
            let client = conn.as_client();