0.0.2-alpha.5

crates/knowledge-app-lib/unit_tests/repository_sync.rs

@@ -0,0 +1,121 @@
+// file: crates/knowledge-app-lib/unit_tests/repository_sync.rs
+// version: 1
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+struct FakeRepositoryError;
+
+struct FakeRepository {
+    observed_revision: knowledge_git_api::GitRevision,
+    reject_snapshot: bool,
+}
+
+impl FakeRepository {
+    fn new(observed_revision: &str, reject_snapshot: bool) -> FakeRepository {
+        return FakeRepository { observed_revision: knowledge_git_api::GitRevision::new(observed_revision), reject_snapshot };
+    }
+}
+
+impl knowledge_git_api::GitRepository for FakeRepository {
+    type Error = FakeRepositoryError;
+
+    fn refresh(&mut self, _source_id: &knowledge_domain_lib::SourceId) -> Result<(), Self::Error> {
+        return Ok(());
+    }
+
+    fn resolve_revision(
+        &self,
+        _source_id: &knowledge_domain_lib::SourceId,
+        _reference: &knowledge_git_api::GitReference,
+    ) -> Result<knowledge_git_api::GitRevision, Self::Error> {
+        return Ok(self.observed_revision.clone());
+    }
+
+    fn prepare_snapshot(
+        &self,
+        _source_id: &knowledge_domain_lib::SourceId,
+        revision: &knowledge_git_api::GitRevision,
+    ) -> Result<knowledge_git_api::GitSnapshot, Self::Error> {
+        if self.reject_snapshot {
+            return Err(FakeRepositoryError);
+        }
+        return Ok(knowledge_git_api::GitSnapshot::new(revision.clone(), std::path::PathBuf::from("/controlled/snapshot")));
+    }
+}
+
+fn source_id() -> Option<knowledge_domain_lib::SourceId> {
+    let result = knowledge_domain_lib::SourceId::new("snippets");
+    match result {
+        Ok(value) => return Some(value),
+        Err(_) => return None,
+    }
+}
+
+fn signal(cause: knowledge_sync_api::RepositorySyncCause) -> Option<knowledge_sync_api::RepositorySyncSignal> {
+    let id = match source_id() {
+        Some(value) => value,
+        None => return None,
+    };
+    return Some(knowledge_sync_api::RepositorySyncSignal::new(id, cause));
+}
+
+#[test]
+fn changed_revision_prepares_snapshot_and_returns_observed_revision() {
+    let mut repository = FakeRepository::new("bbbb", false);
+    let request = match signal(knowledge_sync_api::RepositorySyncCause::Explicit) {
+        Some(value) => value,
+        None => return,
+    };
+    let reference = knowledge_git_api::GitReference::new("refs/heads/main");
+    let previous = knowledge_git_api::GitRevision::new("aaaa");
+    let result = crate::synchronize_repository(&mut repository, &request, &reference, Some(&previous));
+    assert!(result.is_ok());
+    let outcome = match result {
+        Ok(value) => value,
+        Err(_) => return,
+    };
+    assert!(outcome.is_changed());
+    assert_eq!(outcome.revision().as_str(), "bbbb");
+    assert!(outcome.snapshot().is_some());
+    return;
+}
+
+#[test]
+fn unchanged_revision_does_not_prepare_snapshot() {
+    let mut repository = FakeRepository::new("bbbb", true);
+    let request = match signal(knowledge_sync_api::RepositorySyncCause::Explicit) {
+        Some(value) => value,
+        None => return,
+    };
+    let reference = knowledge_git_api::GitReference::new("refs/heads/main");
+    let previous = knowledge_git_api::GitRevision::new("bbbb");
+    let result = crate::synchronize_repository(&mut repository, &request, &reference, Some(&previous));
+    assert!(result.is_ok());
+    let outcome = match result {
+        Ok(value) => value,
+        Err(_) => return,
+    };
+    assert!(!outcome.is_changed());
+    assert_eq!(outcome.revision().as_str(), "bbbb");
+    assert!(outcome.snapshot().is_none());
+    return;
+}
+
+#[test]
+fn periodic_signal_uses_the_same_reconciliation_path() {
+    let mut repository = FakeRepository::new("cccc", false);
+    let request = match signal(knowledge_sync_api::RepositorySyncCause::Periodic) {
+        Some(value) => value,
+        None => return,
+    };
+    let reference = knowledge_git_api::GitReference::new("refs/heads/main");
+    let result = crate::synchronize_repository(&mut repository, &request, &reference, None);
+    assert!(result.is_ok());
+    let outcome = match result {
+        Ok(value) => value,
+        Err(_) => return,
+    };
+    assert!(outcome.is_changed());
+    assert_eq!(outcome.revision().as_str(), "cccc");
+    assert!(outcome.snapshot().is_some());
+    return;
+}