use std::collections::HashMap;
use std::path::PathBuf;
use std::sync::{Arc, Mutex};
use id_effect::{Cap, Env, caps, mock_capability, provide};
use rusqlite::Connection;
use crate::db::{open_store_db, query_path_info};
use crate::error::InfraError;
use crate::model::{PathInfo, QueryOpts};
pub trait PathInfoStore: Send + Sync {
fn query(&self, path: &str, opts: QueryOpts) -> Result<PathInfo, InfraError>;
}
#[derive(Debug, Clone)]
pub struct SqlitePathInfoStore {
pub store_root: PathBuf,
}
impl SqlitePathInfoStore {
pub fn new(store_root: impl Into<PathBuf>) -> Self {
Self {
store_root: store_root.into(),
}
}
pub fn from_default() -> Self {
Self::new(crate::db::DEFAULT_STORE_ROOT)
}
fn conn(&self) -> Result<Connection, InfraError> {
open_store_db(&self.store_root)
}
}
impl PathInfoStore for SqlitePathInfoStore {
fn query(&self, path: &str, opts: QueryOpts) -> Result<PathInfo, InfraError> {
let conn = self.conn()?;
query_path_info(&conn, path, opts)
}
}
#[derive(Default)]
pub struct MockPathInfoStore {
pub paths: Mutex<HashMap<String, PathInfo>>,
}
impl MockPathInfoStore {
pub fn set(&self, info: PathInfo) {
self.paths.lock().unwrap().insert(info.path.clone(), info);
}
}
impl PathInfoStore for MockPathInfoStore {
fn query(&self, path: &str, opts: QueryOpts) -> Result<PathInfo, InfraError> {
let mut info = self
.paths
.lock()
.unwrap()
.get(path)
.cloned()
.ok_or_else(|| InfraError::UnknownPath(path.into()))?;
if !opts.include_referrers {
info.referrers = None;
}
if !opts.include_closure_size {
info.closure_size = None;
}
Ok(info)
}
}
pub type PathInfoStoreKey = Arc<dyn PathInfoStore>;
pub type NixstoreEnv = caps!(PathInfoStoreKey);
#[derive(::id_effect::ProviderSpecDerive)]
#[provides(PathInfoStoreKey)]
pub struct SqlitePathInfoStoreLive;
impl SqlitePathInfoStoreLive {
#[allow(clippy::new_ret_no_self)] fn new() -> PathInfoStoreKey {
Arc::new(SqlitePathInfoStore::from_default())
}
}
mock_capability!(
MockPathInfoStoreLive,
PathInfoStoreKey,
"pathinfo/mock",
|| Arc::new(MockPathInfoStore::default()) as PathInfoStoreKey
);
pub fn live_providers() -> [id_effect::ProviderBox; 1] {
[provide!(SqlitePathInfoStoreLive)]
}
pub fn providers_for_store(store_root: impl Into<PathBuf>) -> Env {
let mut env = Env::new();
let store: PathInfoStoreKey = Arc::new(SqlitePathInfoStore::new(store_root));
env.insert::<Cap<PathInfoStoreKey>>(store);
env
}
#[cfg(test)]
pub fn mock_providers() -> [id_effect::ProviderBox; 1] {
[provide!(MockPathInfoStoreLive)]
}
#[cfg(test)]
mod tests {
use super::*;
use id_effect::{Effect, Exit, FromEnv, Needs, build_env, run_test};
#[test]
fn mock_query() {
let mock = MockPathInfoStore::default();
mock.set(PathInfo {
path: "/nix/store/x".into(),
nar_hash: "sha256-x".into(),
nar_size: 1,
deriver: None,
registration_time: 0,
ultimate: false,
signatures: vec![],
ca: None,
references: vec![],
referrers: Some(vec!["/nix/store/y".into()]),
closure_size: Some(1),
});
let info = mock.query("/nix/store/x", QueryOpts::default()).expect("q");
assert!(info.referrers.is_none());
assert!(info.closure_size.is_none());
}
#[test]
fn build_env_materializes_mock_caps() {
let env = build_env(mock_providers()).expect("env");
assert!(env.has::<Cap<PathInfoStoreKey>>());
}
#[test]
fn run_test_reads_caps() {
let env = NixstoreEnv::from_env(build_env(mock_providers()).expect("env"));
let effect: Effect<bool, (), NixstoreEnv> = Effect::new(|env| {
let _ = Needs::<PathInfoStoreKey>::need(env);
Ok(true)
});
assert_eq!(run_test(effect, env), Exit::Success(true));
}
#[test]
fn providers_for_store_inserts_cap() {
let root = PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("fixtures/minimal");
let env = providers_for_store(&root);
assert!(env.has::<Cap<PathInfoStoreKey>>());
}
}