Macro is a unified workspace for teams: email, chat, docs, tasks, agents, calls, and CRM — @-linked together with shared AI memory.
TypeScript agentaiai-agentsall-in-onecrmcrm-systememaillinearmcpmessagingnotesnotionofficerustslackslack-alternativestartupstartup-toolstypescriptworkspace
use entity_access::domain::models::MemberTeamRole;
use foreign_entity::domain::models::{
CreateForeignEntity, ForeignEntity, ForeignEntityError, PatchForeignEntity, SourceId,
};
use foreign_entity::domain::ports::{ForeignEntityListQuery, ForeignEntityService};
use macro_event_broker::{EventBrokerError, MacroEvent, MacroEventBroker};
use macro_user_id::cowlike::CowLike;
use model::document::{DocumentMetadata, FileType};
use std::sync::{Arc, Mutex};
use crate::domain::models::{
EmailImportRepoOutcome, GithubPullRequest, ImportEmailAttachmentRepoArgs, OwnerTeam,
TeamTaskNumber,
};
use crate::domain::ports::{DocumentContentEventService, MockDocumentRepo};
use super::*;
mod sync_content;
fn make_test_metadata() -> DocumentMetadata {
DocumentMetadata {
document_id: "doc-1".to_string(),
document_version_id: 1,
owner: Owner::from_principal_str("macro|[email protected]").unwrap(),
document_name: "test_doc".to_string(),
file_type: Some("txt".to_string()),
sha: Some("sha-1".to_string()),
project_id: Some("project-1".to_string()),
project_name: Some("Test Project".to_string()),
branched_from_id: None,
branched_from_version_id: None,
document_family_id: None,
document_bom: None,
modification_data: None,
created_at: None,
updated_at: None,
deleted_at: None,
sub_type: None,
}
}
fn make_mock_repo() -> MockDocumentRepo {
MockDocumentRepo::new()
}
fn test_cloudfront_config() -> CloudFrontConfig {
CloudFrontConfig {
distribution_url: "https://cdn.example.test".to_string(),
signer_public_key_id: "test-key-id".to_string(),
signer_private_key: "test-private-key".to_string(),
presigned_url_expiry_seconds: 60,
browser_cache_expiry_seconds: 60,
}
}
fn task_document_context(document_id: &str) -> DocumentBasic {
DocumentBasic {
document_id: document_id.to_string(),
document_name: "Test task".to_string(),
owner: Owner::from_principal_str("macro|[email protected]").unwrap(),
file_type: Some("md".to_string()),
sub_type: Some(DocumentSubType::Task),
branched_from_id: None,
branched_from_version_id: None,
document_family_id: None,
project_id: None,
deleted_at: None,
}
}
fn authenticated_receipt(document_id: &str) -> EntityAccessReceipt<ViewAccessLevel> {
let user_id = macro_user_id::user_id::MacroUserIdStr::parse_from_str("macro|[email protected]")
.unwrap()
.into_owned();
EntityAccessReceipt::dangerously_assert_authenticated_user(
user_id,
document_id,
EntityType::Document,
)
}
fn internal_receipt(document_id: &str) -> EntityAccessReceipt<ViewAccessLevel> {
EntityAccessReceipt::dangerously_assert_internal_user(document_id, EntityType::Document)
}
fn member_team_receipt(team_id: &str, user_id: &str) -> EntityAccessReceipt<MemberTeamRole> {
let user_id = macro_user_id::user_id::MacroUserIdStr::parse_from_str(user_id)
.unwrap()
.into_owned();
EntityAccessReceipt::dangerously_assert_authenticated_user(user_id, team_id, EntityType::Team)
}
fn bot_id() -> entity_access::domain::models::BotId {
entity_access::domain::models::BotId::new_from_uuid(uuid::uuid!(
"00000000-0000-0000-0000-000000000123"
))
}
fn bot_receipt_scope() -> entity_access::domain::models::BotReceiptScope {
entity_access::domain::models::BotReceiptScope::Team {
team_id: uuid::uuid!("00000000-0000-0000-0000-000000000456"),
}
}
fn bot_receipt(document_id: &str) -> EntityAccessReceipt<ViewAccessLevel> {
EntityAccessReceipt::dangerously_assert_bot(
bot_id().into_storage_id(),
bot_receipt_scope(),
document_id,
EntityType::Document,
)
}
struct TestUploadUrlPort;
impl PresignedUploadUrlPort for TestUploadUrlPort {
async fn delete_object(&self, _key: &str) -> anyhow::Result<()> {
Ok(())
}
async fn put_document_storage_presigned_url(
&self,
_key: &str,
_sha: &str,
_content_type: ContentType,
) -> anyhow::Result<String> {
Ok(String::new())
}
async fn put_docx_upload_presigned_url(
&self,
_key: &str,
_sha: &str,
_content_type: ContentType,
) -> anyhow::Result<String> {
Ok(String::new())
}
async fn copy_object(&self, _source_key: &str, _destination_key: &str) -> anyhow::Result<()> {
Ok(())
}
async fn get_snapshot(&self, _document_id: &str) -> anyhow::Result<Option<Vec<u8>>> {
Ok(None)
}
async fn upload_snapshot(&self, _document_id: &str, _bytes: Vec<u8>) -> anyhow::Result<()> {
Ok(())
}
}
struct TestTaskPropertiesPort;
impl TaskPropertiesPort for TestTaskPropertiesPort {
async fn attach_task_properties(&self, _entity_ids: Vec<String>) -> anyhow::Result<()> {
Ok(())
}
async fn update_task_status(
&self,
_access: &EntityAccessReceipt<EditAccessLevel>,
_credited_user: Option<¯o_user_id::user_id::MacroUserIdStr<'static>>,
_source: Option<&models_properties::service::property_change_source::PropertyChangeSource>,
_status: &str,
) -> anyhow::Result<()> {
Ok(())
}
async fn set_entity_property(
&self,
_principal: &CreationPrincipal,
_entity_id: &str,
_property_definition_id: uuid::Uuid,
_value: Option<models_properties::api::requests::SetPropertyValue>,
) -> anyhow::Result<()> {
Ok(())
}
async fn copy_task_properties(
&self,
_from_task_id: &str,
_to_task_id: &str,
) -> anyhow::Result<()> {
Ok(())
}
}
#[derive(Default)]
struct TestConnectionService {
invalidations: Mutex<usize>,
}
impl ConnectionService for TestConnectionService {
async fn send_invalidation_event<'a, T: std::fmt::Debug + serde::Serialize + Send>(
&self,
_invalidation_event: InvalidationEvent<'a, T>,
) -> Result<(), connection::domain::models::ConnectionError> {
*self.invalidations.lock().unwrap() += 1;
Ok(())
}
async fn send_channel_message<'a>(
&self,
_users: &[macro_user_id::user_id::MacroUserIdStr<'a>],
_message_type: &str,
_message: serde_json::Value,
) -> Result<(), connection::domain::models::ConnectionError> {
Ok(())
}
}
#[derive(Clone, Default)]
struct TestEntityAccessManagementService {
added_to_projects: Arc<Mutex<Vec<uuid::Uuid>>>,
removed_from_projects: Arc<Mutex<Vec<uuid::Uuid>>>,
}
impl EntityAccessManagementService for TestEntityAccessManagementService {
async fn add_entity_to_project(
&self,
_entity_id: &uuid::Uuid,
_entity_type: EntityType,
project_id: &uuid::Uuid,
) -> Result<(), entity_access_management::domain::models::EntityAccessManagementError> {
self.added_to_projects.lock().unwrap().push(*project_id);
Ok(())
}
async fn remove_entity_from_project(
&self,
_entity_id: &uuid::Uuid,
_entity_type: EntityType,
old_project_id: &uuid::Uuid,
) -> Result<(), entity_access_management::domain::models::EntityAccessManagementError> {
self.removed_from_projects
.lock()
.unwrap()
.push(*old_project_id);
Ok(())
}
async fn move_project(
&self,
_project_id: &uuid::Uuid,
_old_project_id: Option<&uuid::Uuid>,
_new_project_id: Option<&uuid::Uuid>,
) -> Result<(), entity_access_management::domain::models::EntityAccessManagementError> {
Ok(())
}
}
#[derive(Clone, Debug, Eq, PartialEq)]
struct ForeignEntityLookupRequest {
foreign_entity_id: String,
foreign_entity_source: Option<String>,
}
#[derive(Clone, Default)]
struct TestForeignEntityService {
foreign_entities: Arc<Vec<ForeignEntity>>,
lookup_requests: Arc<Mutex<Vec<ForeignEntityLookupRequest>>>,
}
impl TestForeignEntityService {
fn new(foreign_entities: Vec<ForeignEntity>) -> Self {
Self {
foreign_entities: Arc::new(foreign_entities),
lookup_requests: Arc::new(Mutex::new(Vec::new())),
}
}
fn lookup_requests(&self) -> Arc<Mutex<Vec<ForeignEntityLookupRequest>>> {
Arc::clone(&self.lookup_requests)
}
}
impl ForeignEntityService for TestForeignEntityService {
async fn get_foreign_entity(
&self,
_receipt: EntityAccessReceipt<ViewAccessLevel>,
) -> Result<ForeignEntity, ForeignEntityError> {
unreachable!("test service only supports foreign entity lookups by external ID")
}
async fn get_foreign_entity_by_id(
&self,
_id: uuid::Uuid,
) -> Result<ForeignEntity, ForeignEntityError> {
unreachable!("test service only supports foreign entity lookups by external ID")
}
async fn get_foreign_entities_by_foreign_entity_id(
&self,
foreign_entity_id: &str,
foreign_entity_source: Option<&str>,
) -> Result<Vec<ForeignEntity>, ForeignEntityError> {
self.lookup_requests
.lock()
.unwrap()
.push(ForeignEntityLookupRequest {
foreign_entity_id: foreign_entity_id.to_string(),
foreign_entity_source: foreign_entity_source.map(str::to_string),
});
Ok(self
.foreign_entities
.iter()
.filter(|foreign_entity| {
foreign_entity.foreign_entity_id == foreign_entity_id
&& foreign_entity_source
.is_none_or(|source| foreign_entity.foreign_entity_source == source)
})
.cloned()
.collect())
}
async fn get_foreign_entities_for_user(
&self,
_requesting_user: Option<String>,
_source_ids: Vec<SourceId>,
_limit: u32,
_query: ForeignEntityListQuery,
) -> Result<Vec<ForeignEntity>, ForeignEntityError> {
unreachable!("test service only supports foreign entity lookups by external ID")
}
async fn create_foreign_entity(
&self,
_create: CreateForeignEntity,
) -> Result<ForeignEntity, ForeignEntityError> {
unreachable!("test service only supports foreign entity lookups by external ID")
}
async fn delete_foreign_entity(&self, _id: uuid::Uuid) -> Result<(), ForeignEntityError> {
unreachable!("test service only supports foreign entity lookups by external ID")
}
async fn patch_foreign_entity(
&self,
_id: uuid::Uuid,
_patch: PatchForeignEntity,
) -> Result<ForeignEntity, ForeignEntityError> {
unreachable!("test service only supports foreign entity lookups by external ID")
}
}
/// A document lifecycle event recorded by [`TestEventBroker`].
#[derive(Clone, Debug)]
struct PublishedEvent {
topic: &'static str,
key: String,
payload: serde_json::Value,
}
#[derive(Clone, Default)]
struct TestEventBroker {
published: Arc<Mutex<Vec<PublishedEvent>>>,
fail_send: bool,
}
impl TestEventBroker {
fn failing() -> Self {
Self {
fail_send: true,
..Self::default()
}
}
fn published(&self) -> Arc<Mutex<Vec<PublishedEvent>>> {
Arc::clone(&self.published)
}
}
impl MacroEventBroker for TestEventBroker {
fn send_event<E: MacroEvent + ?Sized>(
&self,
event: &E,
) -> Result<tokio::task::JoinHandle<Result<(), EventBrokerError>>, EventBrokerError> {
if self.fail_send {
return Err(EventBrokerError::Publish("test broker failure".to_string()));
}
self.published.lock().unwrap().push(PublishedEvent {
topic: event.topic(),
key: event.key().to_string(),
payload: serde_json::to_value(event.event())?,
});
Ok(tokio::spawn(async { Ok(()) }))
}
}
type TestDocumentService = DocumentServiceImpl<
MockDocumentRepo,
TestUploadUrlPort,
TestTaskPropertiesPort,
TestConnectionService,
TestEntityAccessManagementService,
TestForeignEntityService,
TestEventBroker,
sync_service_client::SyncServiceClient,
>;
fn make_test_service(repo: MockDocumentRepo) -> TestDocumentService {
make_test_service_with_foreign_entities(repo, Vec::new())
}
fn make_test_service_with_foreign_entities(
repo: MockDocumentRepo,
foreign_entities: Vec<ForeignEntity>,
) -> TestDocumentService {
make_test_service_with_foreign_entity_service(
repo,
TestForeignEntityService::new(foreign_entities),
)
}
fn make_test_service_with_foreign_entity_service(
repo: MockDocumentRepo,
foreign_entity_service: TestForeignEntityService,
) -> TestDocumentService {
DocumentServiceImpl::new(
repo,
test_cloudfront_config(),
sync_service_client::SyncServiceClient::new(
"test-sync-key".to_string(),
"http://sync-service.test".to_string(),
),
TestUploadUrlPort,
TestTaskPropertiesPort,
TestConnectionService::default(),
TestEntityAccessManagementService::default(),
foreign_entity_service,
TestEventBroker::default(),
)
}
/// Build a test service along with a handle to its recording entity access service.
fn make_test_service_with_entity_access(
repo: MockDocumentRepo,
) -> (TestDocumentService, TestEntityAccessManagementService) {
let entity_access = TestEntityAccessManagementService::default();
let service = DocumentServiceImpl::new(
repo,
test_cloudfront_config(),
sync_service_client::SyncServiceClient::new(
"test-sync-key".to_string(),
"http://sync-service.test".to_string(),
),
TestUploadUrlPort,
TestTaskPropertiesPort,
TestConnectionService::default(),
entity_access.clone(),
TestForeignEntityService::default(),
TestEventBroker::default(),
);
(service, entity_access)
}
/// Build a test service along with a handle to its recording event broker.
fn make_test_service_with_event_broker(
repo: MockDocumentRepo,
) -> (TestDocumentService, TestEventBroker) {
make_test_service_with_configured_event_broker(repo, TestEventBroker::default())
}
fn make_test_service_with_configured_event_broker(
repo: MockDocumentRepo,
event_broker: TestEventBroker,
) -> (TestDocumentService, TestEventBroker) {
let service = DocumentServiceImpl::new(
repo,
test_cloudfront_config(),
sync_service_client::SyncServiceClient::new(
"test-sync-key".to_string(),
"http://sync-service.test".to_string(),
),
TestUploadUrlPort,
TestTaskPropertiesPort,
TestConnectionService::default(),
TestEntityAccessManagementService::default(),
TestForeignEntityService::default(),
event_broker.clone(),
);
(service, event_broker)
}
fn make_foreign_entity(
id: uuid::Uuid,
foreign_entity_id: &str,
foreign_entity_source: &str,
stored_for_id: &str,
stored_for_auth_entity: &str,
) -> ForeignEntity {
let timestamp = chrono::Utc::now();
ForeignEntity {
id,
foreign_entity_id: foreign_entity_id.to_string(),
foreign_entity_source: foreign_entity_source.to_string(),
metadata: serde_json::json!({}),
stored_for_id: stored_for_id.to_string(),
stored_for_auth_entity: stored_for_auth_entity.to_string(),
created_at: timestamp,
updated_at: timestamp,
}
}
fn make_foreign_entity_with_metadata(
id: uuid::Uuid,
foreign_entity_id: &str,
foreign_entity_source: &str,
stored_for_id: &str,
stored_for_auth_entity: &str,
metadata: serde_json::Value,
) -> ForeignEntity {
let mut foreign_entity = make_foreign_entity(
id,
foreign_entity_id,
foreign_entity_source,
stored_for_id,
stored_for_auth_entity,
);
foreign_entity.metadata = metadata;
foreign_entity
}
fn expect_authenticated_team_lookup(repo: &mut MockDocumentRepo, team_ids: Vec<uuid::Uuid>) {
repo.expect_get_team_ids_for_user()
.withf(|user_id| user_id == "macro|[email protected]")
.return_once(move |_| Box::pin(std::future::ready(Ok(team_ids))));
}
fn assert_pull_request_ref(
pull_request: &GithubPullRequest,
github_key: &str,
owner: &str,
repo: &str,
number: u64,
) {
let expected_url = format!("https://github.com/{owner}/{repo}/pull/{number}");
let expected_display_name = format!("{owner}/{repo}#{number}");
assert_eq!(pull_request.github_key.as_str(), github_key);
assert_eq!(pull_request.owner.as_str(), owner);
assert_eq!(pull_request.repo.as_str(), repo);
assert_eq!(pull_request.number, number);
assert_eq!(pull_request.url.as_str(), expected_url.as_str());
assert_eq!(
pull_request.display_name.as_str(),
expected_display_name.as_str()
);
}
fn assert_no_enriched_pull_request_metadata(pull_request: &GithubPullRequest) {
assert!(pull_request.name.is_none());
assert!(pull_request.status.is_none());
assert!(pull_request.additions.is_none());
assert!(pull_request.deletions.is_none());
assert!(pull_request.comments.is_none());
assert!(pull_request.checks.is_none());
let pull_request_json = serde_json::to_value(pull_request).unwrap();
assert!(pull_request_json.get("name").is_none());
assert!(pull_request_json.get("status").is_none());
assert!(pull_request_json.get("additions").is_none());
assert!(pull_request_json.get("deletions").is_none());
assert!(pull_request_json.get("comments").is_none());
assert!(pull_request_json.get("checks").is_none());
}
fn assert_raw_pull_request(
pull_request: &GithubPullRequest,
github_key: &str,
owner: &str,
repo: &str,
number: u64,
) {
assert_pull_request_ref(pull_request, github_key, owner, repo, number);
assert!(pull_request.foreign_entity_id.is_none());
assert_no_enriched_pull_request_metadata(pull_request);
let pull_request_json = serde_json::to_value(pull_request).unwrap();
assert!(pull_request_json.get("foreignEntityId").is_none());
}
fn assert_shallow_pull_request_with_foreign_entity_id(
pull_request: &GithubPullRequest,
github_key: &str,
owner: &str,
repo: &str,
number: u64,
foreign_entity_id: uuid::Uuid,
) {
assert_pull_request_ref(pull_request, github_key, owner, repo, number);
assert_eq!(pull_request.foreign_entity_id, Some(foreign_entity_id));
assert_no_enriched_pull_request_metadata(pull_request);
let pull_request_json = serde_json::to_value(pull_request).unwrap();
let expected_foreign_entity_id = serde_json::json!(foreign_entity_id.to_string());
assert_eq!(
pull_request_json.get("foreignEntityId"),
Some(&expected_foreign_entity_id)
);
}
#[tokio::test]
async fn get_document_by_team_slug_resolves_valid_slug() {
let team_id = uuid::uuid!("00000000-0000-0000-0000-000000000701");
let mut repo = make_mock_repo();
repo.expect_get_document_id_by_team_task_number()
.withf(move |actual_team_id, task_num| actual_team_id == &team_id && *task_num == 42)
.return_once(|_, _| Box::pin(std::future::ready(Ok(Some("doc-1".to_string())))));
repo.expect_get_basic_document()
.withf(|document_id| document_id == "doc-1")
.return_once(|_| Box::pin(std::future::ready(Ok(task_document_context("doc-1")))));
let document_id = make_test_service(repo)
.get_document_by_team_slug(
member_team_receipt(&team_id.to_string(), "macro|[email protected]"),
"engineering-platform-42",
)
.await
.unwrap();
assert_eq!(document_id, "doc-1");
}
#[tokio::test]
async fn get_document_by_team_slug_rejects_malformed_slugs() {
for slug in [
"",
"engineering",
"-1",
"engineering-",
"engineering--task-1",
"engineering-task",
"engineering-1.5",
"engineering-+1",
] {
let mut repo = make_mock_repo();
repo.expect_get_document_id_by_team_task_number().times(0);
repo.expect_get_basic_document().times(0);
let result = make_test_service(repo)
.get_document_by_team_slug(
member_team_receipt(
"00000000-0000-0000-0000-000000000701",
"macro|[email protected]",
),
slug,
)
.await;
assert!(
matches!(result, Err(DocumentError::BadRequest(_))),
"expected {slug:?} to be rejected, got {result:?}"
);
}
}
#[tokio::test]
async fn get_document_by_team_slug_rejects_non_positive_and_overflowing_numbers() {
for slug in ["engineering-0", "engineering--1", "engineering-2147483648"] {
let mut repo = make_mock_repo();
repo.expect_get_document_id_by_team_task_number().times(0);
repo.expect_get_basic_document().times(0);
let result = make_test_service(repo)
.get_document_by_team_slug(
member_team_receipt(
"00000000-0000-0000-0000-000000000701",
"macro|[email protected]",
),
slug,
)
.await;
assert!(
matches!(result, Err(DocumentError::BadRequest(_))),
"expected {slug:?} to be rejected, got {result:?}"
);
}
}
#[tokio::test]
async fn get_document_by_team_slug_rejects_wrong_receipt_entity_type() {
let mut repo = make_mock_repo();
repo.expect_get_document_id_by_team_task_number().times(0);
repo.expect_get_basic_document().times(0);
let receipt = EntityAccessReceipt::<MemberTeamRole>::dangerously_assert_authenticated_user(
macro_user_id::user_id::MacroUserIdStr::parse_from_str("macro|[email protected]")
.unwrap()
.into_owned(),
"00000000-0000-0000-0000-000000000701",
EntityType::Document,
);
let result = make_test_service(repo)
.get_document_by_team_slug(receipt, "engineering-1")
.await;
assert!(matches!(result, Err(DocumentError::BadRequest(_))));
}
#[tokio::test]
async fn get_document_by_team_slug_rejects_malformed_team_uuid() {
let mut repo = make_mock_repo();
repo.expect_get_document_id_by_team_task_number().times(0);
repo.expect_get_basic_document().times(0);
let result = make_test_service(repo)
.get_document_by_team_slug(
member_team_receipt("not-a-team-uuid", "macro|[email protected]"),
"engineering-1",
)
.await;
assert!(matches!(result, Err(DocumentError::BadRequest(_))));
}
#[tokio::test]
async fn get_document_by_team_slug_maps_missing_lookup_to_not_found() {
let team_id = uuid::uuid!("00000000-0000-0000-0000-000000000701");
let mut repo = make_mock_repo();
repo.expect_get_document_id_by_team_task_number()
.withf(move |actual_team_id, task_num| actual_team_id == &team_id && *task_num == 404)
.return_once(|_, _| Box::pin(std::future::ready(Ok(None))));
repo.expect_get_basic_document().times(0);
let result = make_test_service(repo)
.get_document_by_team_slug(
member_team_receipt(&team_id.to_string(), "macro|[email protected]"),
"engineering-404",
)
.await;
assert!(matches!(
result,
Err(DocumentError::NotFound(slug)) if slug == "engineering-404"
));
}
#[tokio::test]
async fn get_document_by_team_slug_maps_lookup_error_to_internal() {
let team_id = uuid::uuid!("00000000-0000-0000-0000-000000000701");
let mut repo = make_mock_repo();
repo.expect_get_document_id_by_team_task_number()
.return_once(|_, _| Box::pin(std::future::ready(Err(anyhow!("database unavailable")))));
repo.expect_get_basic_document().times(0);
let result = make_test_service(repo)
.get_document_by_team_slug(
member_team_receipt(&team_id.to_string(), "macro|[email protected]"),
"engineering-1",
)
.await;
assert!(matches!(result, Err(DocumentError::Internal(_))));
}
#[tokio::test]
async fn get_document_by_team_slug_maps_document_load_error_to_internal() {
let team_id = uuid::uuid!("00000000-0000-0000-0000-000000000701");
let mut repo = make_mock_repo();
repo.expect_get_document_id_by_team_task_number()
.return_once(|_, _| Box::pin(std::future::ready(Ok(Some("doc-1".to_string())))));
repo.expect_get_basic_document()
.return_once(|_| Box::pin(std::future::ready(Err(anyhow!("database unavailable")))));
let result = make_test_service(repo)
.get_document_by_team_slug(
member_team_receipt(&team_id.to_string(), "macro|[email protected]"),
"engineering-1",
)
.await;
assert!(matches!(result, Err(DocumentError::Internal(_))));
}
#[tokio::test]
async fn get_document_by_team_slug_allows_owner_of_deleted_document() {
let team_id = uuid::uuid!("00000000-0000-0000-0000-000000000701");
let mut document = task_document_context("doc-1");
document.deleted_at = Some(chrono::Utc::now());
let mut repo = make_mock_repo();
repo.expect_get_document_id_by_team_task_number()
.return_once(|_, _| Box::pin(std::future::ready(Ok(Some("doc-1".to_string())))));
repo.expect_get_basic_document()
.return_once(move |_| Box::pin(std::future::ready(Ok(document))));
let result = make_test_service(repo)
.get_document_by_team_slug(
member_team_receipt(&team_id.to_string(), "macro|[email protected]"),
"engineering-1",
)
.await;
assert_eq!(result.unwrap(), "doc-1");
}
#[tokio::test]
async fn get_document_by_team_slug_rejects_non_owner_of_deleted_document() {
let team_id = uuid::uuid!("00000000-0000-0000-0000-000000000701");
let mut document = task_document_context("doc-1");
document.deleted_at = Some(chrono::Utc::now());
let mut repo = make_mock_repo();
repo.expect_get_document_id_by_team_task_number()
.return_once(|_, _| Box::pin(std::future::ready(Ok(Some("doc-1".to_string())))));
repo.expect_get_basic_document()
.return_once(move |_| Box::pin(std::future::ready(Ok(document))));
let result = make_test_service(repo)
.get_document_by_team_slug(
member_team_receipt(&team_id.to_string(), "macro|[email protected]"),
"engineering-1",
)
.await;
assert!(matches!(result, Err(DocumentError::Unauthorized)));
}
#[tokio::test]
async fn bot_document_has_no_saved_user_view_location() {
let mut repo = make_mock_repo();
let metadata = make_test_metadata();
repo.expect_get_document_metadata()
.return_once(move |_| Box::pin(std::future::ready(Ok(metadata))));
repo.expect_get_user_view_location().times(0);
repo.expect_get_persisted_document_content()
.return_once(|_| {
Box::pin(std::future::ready(Ok(Some(DocumentContent::ready(
DocumentContentLocation::ObjectStorage,
)))))
});
repo.expect_get_team_task_metadata()
.return_once(|_| Box::pin(std::future::ready(Ok(None))));
let response = make_test_service(repo)
.get_document(bot_receipt("doc-1"))
.await
.unwrap();
assert_eq!(response.view_location, None);
}
#[tokio::test]
async fn bot_lifecycle_event_has_no_actor_user_id() {
let mut repo = make_mock_repo();
repo.expect_get_document_metadata()
.returning(|_| Box::pin(std::future::ready(Ok(make_test_metadata()))));
repo.expect_soft_delete_document()
.withf(|id| id == "doc-1")
.return_once(|_| Box::pin(std::future::ready(Ok(()))));
let (service, event_broker) = make_test_service_with_event_broker(repo);
let receipt = EntityAccessReceipt::<OwnerAccessLevel>::dangerously_assert_bot(
bot_id().into_storage_id(),
bot_receipt_scope(),
"doc-1",
EntityType::Document,
);
service.delete_document(receipt, None).await.unwrap();
let published = event_broker.published();
let published = published.lock().unwrap();
assert_eq!(published.len(), 1);
assert_eq!(
published[0].payload["metadata"]["actor_user_id"],
serde_json::Value::Null
);
}
#[tokio::test]
async fn bot_task_branch_uses_macro_fallback() {
let document_id = "00000000-0000-0000-0000-000000000124";
let service = make_test_service(make_mock_repo());
let response = service
.get_task_branch_name(bot_receipt(document_id), "Fix bot auth".to_string())
.await
.unwrap();
assert_eq!(
response.branch_name,
build_task_branch_name(
"macro",
None,
None,
&short_id_for_entity_id(document_id).unwrap(),
"Fix bot auth",
)
);
}
#[tokio::test]
async fn test_get_document_happy_path() {
let mut repo = make_mock_repo();
let metadata = make_test_metadata();
let metadata_clone = metadata.clone();
repo.expect_get_document_metadata()
.withf(|id| id == "doc-1")
.returning(move |_| Box::pin(std::future::ready(Ok(metadata_clone.clone()))));
repo.expect_get_user_view_location()
.withf(|uid, did| uid == "user-1" && did == "doc-1")
.returning(|_, _| Box::pin(std::future::ready(Ok(Some("page-3".to_string())))));
// We can't easily construct the full service because it needs SyncServiceClient + PgPool.
// Instead, test the repo interaction directly via the trait.
let result = repo.get_document_metadata("doc-1").await.unwrap();
assert_eq!(result.document_id, "doc-1");
assert_eq!(result.document_name, "test_doc");
let view_loc = repo
.get_user_view_location("user-1", "doc-1")
.await
.unwrap();
assert_eq!(view_loc, Some("page-3".to_string()));
}
#[tokio::test]
async fn test_get_document_not_found() {
let mut repo = make_mock_repo();
repo.expect_get_document_metadata()
.withf(|id| id == "nonexistent")
.returning(|_| {
Box::pin(std::future::ready(Err(anyhow!(
"no rows returned by a query that expected to return at least one row"
))))
});
let result = repo.get_document_metadata("nonexistent").await;
assert!(result.is_err());
assert!(result.unwrap_err().to_string().contains("no rows returned"));
}
#[tokio::test]
async fn test_soft_delete_document() {
let mut repo = make_mock_repo();
repo.expect_soft_delete_document()
.withf(|id| id == "doc-1")
.returning(|_| Box::pin(std::future::ready(Ok(()))));
let result = repo.soft_delete_document("doc-1").await;
assert!(result.is_ok());
}
#[tokio::test]
async fn bot_pull_request_does_not_hydrate_foreign_entity() {
let document_id = "00000000-0000-0000-0000-000000000125";
let expected_short_id = short_id_for_entity_id(document_id).unwrap();
let foreign_entity_id = uuid::uuid!("00000000-0000-0000-0000-000000000126");
let mut repo = make_mock_repo();
repo.expect_get_task_github_pull_request_keys()
.withf(move |task_short_id| task_short_id == expected_short_id)
.return_once(|_| {
Box::pin(std::future::ready(Ok(vec![
"macro/repo/pull/17".to_string(),
])))
});
let service = make_test_service_with_foreign_entities(
repo,
vec![make_foreign_entity(
foreign_entity_id,
"macro/repo/pull/17",
GITHUB_PULL_REQUEST_FOREIGN_ENTITY_SOURCE,
bot_id().into_storage_id().as_ref(),
"bot",
)],
);
let response = service
.get_task_github_pull_requests(
bot_receipt(document_id),
&task_document_context(document_id),
)
.await
.unwrap();
assert_eq!(response.pull_requests.len(), 1);
assert_raw_pull_request(
&response.pull_requests[0],
"macro/repo/pull/17",
"macro",
"repo",
17,
);
}
#[tokio::test]
async fn test_get_task_github_pull_requests_returns_raw_refs_for_authenticated_user() {
let document_id = "00000000-0000-0000-0000-000000000001";
let expected_short_id = short_id_for_entity_id(document_id).unwrap();
let mut repo = make_mock_repo();
repo.expect_get_task_github_pull_request_keys()
.withf(move |task_short_id| task_short_id == expected_short_id)
.return_once(|_| {
Box::pin(std::future::ready(Ok(vec![
"macro/repo/pull/7".to_string(),
])))
});
expect_authenticated_team_lookup(&mut repo, Vec::new());
let service = make_test_service(repo);
let response = service
.get_task_github_pull_requests(
authenticated_receipt(document_id),
&task_document_context(document_id),
)
.await
.unwrap();
assert_eq!(response.pull_requests.len(), 1);
assert_raw_pull_request(
&response.pull_requests[0],
"macro/repo/pull/7",
"macro",
"repo",
7,
);
}
#[tokio::test]
async fn test_get_task_github_pull_requests_adds_user_foreign_entity_id() {
let document_id = "00000000-0000-0000-0000-000000000002";
let expected_short_id = short_id_for_entity_id(document_id).unwrap();
let foreign_entity_id = uuid::uuid!("00000000-0000-0000-0000-000000000101");
let mut repo = make_mock_repo();
repo.expect_get_task_github_pull_request_keys()
.withf(move |task_short_id| task_short_id == expected_short_id)
.return_once(|_| {
Box::pin(std::future::ready(Ok(vec![
"macro/repo/pull/8".to_string(),
])))
});
expect_authenticated_team_lookup(&mut repo, Vec::new());
let service = make_test_service_with_foreign_entities(
repo,
vec![make_foreign_entity(
foreign_entity_id,
"macro/repo/pull/8",
GITHUB_PULL_REQUEST_FOREIGN_ENTITY_SOURCE,
"macro|[email protected]",
"user",
)],
);
let response = service
.get_task_github_pull_requests(
authenticated_receipt(document_id),
&task_document_context(document_id),
)
.await
.unwrap();
assert_eq!(response.pull_requests.len(), 1);
assert_pull_request_ref(
&response.pull_requests[0],
"macro/repo/pull/8",
"macro",
"repo",
8,
);
assert_eq!(
response.pull_requests[0].foreign_entity_id,
Some(foreign_entity_id)
);
}
#[tokio::test]
async fn test_get_task_github_pull_requests_hydrates_visible_foreign_entity_metadata() {
let document_id = "00000000-0000-0000-0000-000000000008";
let expected_short_id = short_id_for_entity_id(document_id).unwrap();
let foreign_entity_id = uuid::uuid!("00000000-0000-0000-0000-000000000501");
let mut repo = make_mock_repo();
repo.expect_get_task_github_pull_request_keys()
.withf(move |task_short_id| task_short_id == expected_short_id)
.return_once(|_| {
Box::pin(std::future::ready(Ok(vec![
"macro/repo/pull/14".to_string(),
])))
});
expect_authenticated_team_lookup(&mut repo, Vec::new());
let metadata = serde_json::json!({
"githubKey": "macro/repo/pull/14",
"owner": "macro",
"repo": "repo",
"number": 14,
"url": "https://github.com/macro/repo/pull/14",
"displayName": "macro/repo#14",
"name": "Hydrate GitHub pull request metadata",
"status": "open",
"additions": 120,
"deletions": 34,
"comments": [
{
"id": 9001,
"body": "Looks ready to merge.",
"authorLogin": "alice",
"authorAssociation": "MEMBER",
"url": "https://github.com/macro/repo/pull/14#issuecomment-9001",
"createdAt": "2026-06-09T12:00:00Z",
"updatedAt": "2026-06-09T12:05:00Z",
"source": "issue_comment"
}
],
"checks": [
{
"id": 7001,
"name": "ci/test",
"status": "completed",
"conclusion": "success",
"url": "https://github.com/macro/repo/actions/runs/7001",
"startedAt": "2026-06-09T11:00:00Z",
"completedAt": "2026-06-09T11:03:00Z"
}
]
});
let service = make_test_service_with_foreign_entities(
repo,
vec![make_foreign_entity_with_metadata(
foreign_entity_id,
"macro/repo/pull/14",
GITHUB_PULL_REQUEST_FOREIGN_ENTITY_SOURCE,
"macro|[email protected]",
"user",
metadata.clone(),
)],
);
let response = service
.get_task_github_pull_requests(
authenticated_receipt(document_id),
&task_document_context(document_id),
)
.await
.unwrap();
assert_eq!(response.pull_requests.len(), 1);
let mut expected_pull_request = metadata;
expected_pull_request.as_object_mut().unwrap().insert(
"foreignEntityId".to_string(),
serde_json::json!(foreign_entity_id.to_string()),
);
assert_eq!(
serde_json::to_value(&response.pull_requests[0]).unwrap(),
expected_pull_request
);
}
#[tokio::test]
async fn test_get_task_github_pull_requests_falls_back_when_foreign_entity_metadata_is_malformed() {
let document_id = "00000000-0000-0000-0000-000000000009";
let expected_short_id = short_id_for_entity_id(document_id).unwrap();
let malformed_foreign_entity_id = uuid::uuid!("00000000-0000-0000-0000-000000000601");
let mismatched_foreign_entity_id = uuid::uuid!("00000000-0000-0000-0000-000000000602");
let mut repo = make_mock_repo();
repo.expect_get_task_github_pull_request_keys()
.withf(move |task_short_id| task_short_id == expected_short_id)
.return_once(|_| {
Box::pin(std::future::ready(Ok(vec![
"macro/repo/pull/15".to_string(),
"macro/repo/pull/16".to_string(),
])))
});
expect_authenticated_team_lookup(&mut repo, Vec::new());
let service = make_test_service_with_foreign_entities(
repo,
vec![
make_foreign_entity_with_metadata(
malformed_foreign_entity_id,
"macro/repo/pull/15",
GITHUB_PULL_REQUEST_FOREIGN_ENTITY_SOURCE,
"macro|[email protected]",
"user",
serde_json::json!({
"githubKey": "macro/repo/pull/15",
"owner": "macro"
}),
),
make_foreign_entity_with_metadata(
mismatched_foreign_entity_id,
"macro/repo/pull/16",
GITHUB_PULL_REQUEST_FOREIGN_ENTITY_SOURCE,
"macro|[email protected]",
"user",
serde_json::json!({
"githubKey": "macro/repo/pull/999",
"owner": "macro",
"repo": "repo",
"number": 999,
"url": "https://github.com/macro/repo/pull/999",
"displayName": "macro/repo#999",
"name": "Wrong pull request metadata",
"status": "merged",
"additions": 999,
"deletions": 999,
"comments": [],
"checks": []
}),
),
],
);
let response = service
.get_task_github_pull_requests(
authenticated_receipt(document_id),
&task_document_context(document_id),
)
.await
.unwrap();
assert_eq!(response.pull_requests.len(), 2);
assert_shallow_pull_request_with_foreign_entity_id(
&response.pull_requests[0],
"macro/repo/pull/15",
"macro",
"repo",
15,
malformed_foreign_entity_id,
);
assert_shallow_pull_request_with_foreign_entity_id(
&response.pull_requests[1],
"macro/repo/pull/16",
"macro",
"repo",
16,
mismatched_foreign_entity_id,
);
}
#[tokio::test]
async fn test_get_task_github_pull_requests_adds_team_foreign_entity_id() {
let document_id = "00000000-0000-0000-0000-000000000003";
let expected_short_id = short_id_for_entity_id(document_id).unwrap();
let team_id = uuid::uuid!("00000000-0000-0000-0000-000000000201");
let foreign_entity_id = uuid::uuid!("00000000-0000-0000-0000-000000000202");
let mut repo = make_mock_repo();
repo.expect_get_task_github_pull_request_keys()
.withf(move |task_short_id| task_short_id == expected_short_id)
.return_once(|_| {
Box::pin(std::future::ready(Ok(vec![
"macro/repo/pull/9".to_string(),
])))
});
expect_authenticated_team_lookup(&mut repo, vec![team_id]);
let service = make_test_service_with_foreign_entities(
repo,
vec![make_foreign_entity(
foreign_entity_id,
"macro/repo/pull/9",
GITHUB_PULL_REQUEST_FOREIGN_ENTITY_SOURCE,
&team_id.to_string(),
"team",
)],
);
let response = service
.get_task_github_pull_requests(
authenticated_receipt(document_id),
&task_document_context(document_id),
)
.await
.unwrap();
assert_eq!(response.pull_requests.len(), 1);
assert_pull_request_ref(
&response.pull_requests[0],
"macro/repo/pull/9",
"macro",
"repo",
9,
);
assert_eq!(
response.pull_requests[0].foreign_entity_id,
Some(foreign_entity_id)
);
}
#[tokio::test]
async fn test_get_task_github_pull_requests_ignores_unrelated_foreign_entity_source() {
let document_id = "00000000-0000-0000-0000-000000000004";
let expected_short_id = short_id_for_entity_id(document_id).unwrap();
let unrelated_foreign_entity_id = uuid::uuid!("00000000-0000-0000-0000-000000000301");
let mut repo = make_mock_repo();
repo.expect_get_task_github_pull_request_keys()
.withf(move |task_short_id| task_short_id == expected_short_id)
.return_once(|_| {
Box::pin(std::future::ready(Ok(vec![
"macro/repo/pull/10".to_string(),
])))
});
expect_authenticated_team_lookup(&mut repo, Vec::new());
let foreign_entity_service = TestForeignEntityService::new(vec![make_foreign_entity(
unrelated_foreign_entity_id,
"macro/repo/pull/10",
"linear_issue",
"macro|[email protected]",
"user",
)]);
let lookup_requests = foreign_entity_service.lookup_requests();
let service = make_test_service_with_foreign_entity_service(repo, foreign_entity_service);
let response = service
.get_task_github_pull_requests(
authenticated_receipt(document_id),
&task_document_context(document_id),
)
.await
.unwrap();
assert_eq!(response.pull_requests.len(), 1);
assert_raw_pull_request(
&response.pull_requests[0],
"macro/repo/pull/10",
"macro",
"repo",
10,
);
assert_eq!(
*lookup_requests.lock().unwrap(),
vec![ForeignEntityLookupRequest {
foreign_entity_id: "macro/repo/pull/10".to_string(),
foreign_entity_source: Some(GITHUB_PULL_REQUEST_FOREIGN_ENTITY_SOURCE.to_string()),
}]
);
}
#[tokio::test]
async fn test_get_task_github_pull_requests_ignores_unrelated_stored_source() {
let document_id = "00000000-0000-0000-0000-000000000005";
let expected_short_id = short_id_for_entity_id(document_id).unwrap();
let unrelated_foreign_entity_id = uuid::uuid!("00000000-0000-0000-0000-000000000401");
let mut repo = make_mock_repo();
repo.expect_get_task_github_pull_request_keys()
.withf(move |task_short_id| task_short_id == expected_short_id)
.return_once(|_| {
Box::pin(std::future::ready(Ok(vec![
"macro/repo/pull/11".to_string(),
])))
});
expect_authenticated_team_lookup(&mut repo, Vec::new());
let service = make_test_service_with_foreign_entities(
repo,
vec![make_foreign_entity_with_metadata(
unrelated_foreign_entity_id,
"macro/repo/pull/11",
GITHUB_PULL_REQUEST_FOREIGN_ENTITY_SOURCE,
"macro|[email protected]",
"user",
serde_json::json!({
"githubKey": "macro/repo/pull/11",
"owner": "macro",
"repo": "repo",
"number": 11,
"url": "https://github.com/macro/repo/pull/11",
"displayName": "macro/repo#11",
"name": "Invisible pull request metadata",
"status": "open",
"additions": 55,
"deletions": 13,
"comments": [
{
"id": 3001,
"body": "This comment should not be visible.",
"authorLogin": "mallory",
"authorAssociation": "CONTRIBUTOR",
"url": "https://github.com/macro/repo/pull/11#issuecomment-3001",
"createdAt": "2026-06-09T10:00:00Z",
"updatedAt": "2026-06-09T10:01:00Z",
"source": "issue_comment"
}
],
"checks": [
{
"id": 3002,
"name": "ci/private",
"status": "completed",
"conclusion": "failure",
"url": "https://github.com/macro/repo/actions/runs/3002",
"startedAt": "2026-06-09T09:00:00Z",
"completedAt": "2026-06-09T09:04:00Z"
}
]
}),
)],
);
let response = service
.get_task_github_pull_requests(
authenticated_receipt(document_id),
&task_document_context(document_id),
)
.await
.unwrap();
assert_eq!(response.pull_requests.len(), 1);
assert_raw_pull_request(
&response.pull_requests[0],
"macro/repo/pull/11",
"macro",
"repo",
11,
);
}
#[tokio::test]
async fn test_get_task_github_pull_requests_returns_raw_refs_for_internal_access() {
let document_id = "00000000-0000-0000-0000-000000000006";
let expected_short_id = short_id_for_entity_id(document_id).unwrap();
let mut repo = make_mock_repo();
repo.expect_get_task_github_pull_request_keys()
.withf(move |task_short_id| task_short_id == expected_short_id)
.return_once(|_| {
Box::pin(std::future::ready(Ok(vec![
"macro/repo/pull/12".to_string(),
])))
});
let service = make_test_service(repo);
let response = service
.get_task_github_pull_requests(
internal_receipt(document_id),
&task_document_context(document_id),
)
.await
.unwrap();
assert_eq!(response.pull_requests.len(), 1);
assert_raw_pull_request(
&response.pull_requests[0],
"macro/repo/pull/12",
"macro",
"repo",
12,
);
}
#[tokio::test]
async fn test_get_task_github_pull_requests_skips_malformed_keys_before_lookup() {
let document_id = "00000000-0000-0000-0000-000000000007";
let expected_short_id = short_id_for_entity_id(document_id).unwrap();
let mut repo = make_mock_repo();
repo.expect_get_task_github_pull_request_keys()
.withf(move |task_short_id| task_short_id == expected_short_id)
.return_once(|_| {
Box::pin(std::future::ready(Ok(vec![
"not-a-pr-key".to_string(),
"macro/repo/pull/13".to_string(),
])))
});
let foreign_entity_service = TestForeignEntityService::default();
let lookup_requests = foreign_entity_service.lookup_requests();
let service = make_test_service_with_foreign_entity_service(repo, foreign_entity_service);
let response = service
.get_task_github_pull_requests(
internal_receipt(document_id),
&task_document_context(document_id),
)
.await
.unwrap();
assert_eq!(response.pull_requests.len(), 1);
assert_raw_pull_request(
&response.pull_requests[0],
"macro/repo/pull/13",
"macro",
"repo",
13,
);
assert_eq!(
*lookup_requests.lock().unwrap(),
vec![ForeignEntityLookupRequest {
foreign_entity_id: "macro/repo/pull/13".to_string(),
foreign_entity_source: Some(GITHUB_PULL_REQUEST_FOREIGN_ENTITY_SOURCE.to_string()),
}]
);
}
fn owner_receipt(document_id: &str) -> EntityAccessReceipt<OwnerAccessLevel> {
let user_id = macro_user_id::user_id::MacroUserIdStr::parse_from_str("macro|[email protected]")
.unwrap()
.into_owned();
EntityAccessReceipt::dangerously_assert_authenticated_user(
user_id,
document_id,
EntityType::Document,
)
}
fn team_share_facts() -> models_permissions::share_permission::team_share::TeamShareFacts {
let owner = task_document_context("doc-1").owner;
models_permissions::share_permission::team_share::TeamShareFacts {
entity: EntityType::Document.with_entity_str("doc-1"),
owner,
owner_team_id: Some(uuid::Uuid::from_u128(1)),
current: None,
revision: 0,
}
}
#[tokio::test]
async fn team_toggle_rejects_non_owner_without_writes_or_events() {
let mut repo = make_mock_repo();
repo.expect_get_team_share_facts()
.returning(|_| Box::pin(async { Ok(team_share_facts()) }));
let (service, broker) = make_test_service_with_event_broker(repo);
let result = service.set_team_share(edit_receipt("doc-1"), true).await;
assert!(matches!(result, Err(DocumentError::Unauthorized)));
assert!(broker.published().lock().unwrap().is_empty());
}
fn team_edit_args(
level: Option<models_permissions::share_permission::access_level::AccessLevel>,
) -> EditDocumentServiceArgs {
EditDocumentServiceArgs {
document_name: Some("renamed".to_string()),
project_id: None,
file_type: None,
share_permission: Some(UpdateSharePermissionRequestV2 {
team_share_access_level: Some(level),
link_share: None,
link_share_access_level: None,
channel_share_permissions: None,
}),
}
}
fn team_policy_receipts() -> Vec<EntityAccessReceipt<EditAccessLevel>> {
use entity_access::domain::models::{AccessLevel, Entity, EntityPermission};
let entity = Entity {
entity_id: "doc-1".to_string(),
entity_type: EntityType::Document,
};
let non_owner = edit_receipt("doc-1").acting_user_id().unwrap().clone();
let mut receipts = Vec::new();
for access_level in [AccessLevel::Edit, AccessLevel::Owner] {
receipts.push(
EntityAccessReceipt::try_new_authenticated_user(
non_owner.clone(),
entity.clone(),
EntityPermission::AccessLevel { access_level },
)
.unwrap(),
);
}
receipts.push(
EntityAccessReceipt::try_new_bot(
bot_id().into_storage_id(),
bot_receipt_scope(),
entity.clone(),
EntityPermission::AccessLevel {
access_level: AccessLevel::Owner,
},
)
.unwrap(),
);
for auth in [
EntityAccessAuth::Internal,
EntityAccessAuth::Unauthenticated,
] {
receipts.push(
EntityAccessReceipt::try_new(
auth,
entity.clone(),
EntityPermission::AccessLevel {
access_level: AccessLevel::Owner,
},
)
.unwrap(),
);
}
receipts
}
#[tokio::test]
async fn team_policy_rejects_editors_inherited_owners_and_identityless_receipts() {
use models_permissions::share_permission::access_level::AccessLevel;
for level in [
Some(AccessLevel::View),
Some(AccessLevel::Comment),
Some(AccessLevel::Edit),
None,
] {
for receipt in team_policy_receipts() {
let mut repo = make_mock_repo();
repo.expect_get_team_share_facts()
.returning(|_| Box::pin(async { Ok(team_share_facts()) }));
let (service, broker) = make_test_service_with_event_broker(repo);
// Even a context claiming the actor owns it cannot replace persisted facts.
let mut context = task_document_context("doc-1");
context.owner = Owner::User(edit_receipt("doc-1").acting_user_id().unwrap().clone());
assert!(matches!(
service
.edit_document(receipt, context, team_edit_args(level))
.await,
Err(DocumentError::Unauthorized)
));
assert!(broker.published().lock().unwrap().is_empty());
}
}
for enabled in [true, false] {
for receipt in team_policy_receipts() {
let mut repo = make_mock_repo();
repo.expect_get_team_share_facts()
.returning(|_| Box::pin(async { Ok(team_share_facts()) }));
assert!(matches!(
make_test_service(repo)
.set_team_share(receipt, enabled)
.await,
Err(DocumentError::Unauthorized)
));
}
}
}
fn owner_bot_edit_receipt() -> EntityAccessReceipt<EditAccessLevel> {
use entity_access::domain::models::{AccessLevel, Entity, EntityPermission};
EntityAccessReceipt::try_new_bot(
bot_id().into_storage_id(),
BotReceiptScope::User {
acting_user: team_share_facts().owner.as_user().unwrap().clone(),
},
Entity {
entity_id: "doc-1".to_string(),
entity_type: EntityType::Document,
},
EntityPermission::AccessLevel {
access_level: AccessLevel::Edit,
},
)
.unwrap()
}
#[tokio::test]
async fn owner_scoped_bot_can_edit_and_toggle_explicit_team_sharing() {
use models_permissions::share_permission::access_level::AccessLevel;
for level in [
Some(AccessLevel::View),
Some(AccessLevel::Comment),
Some(AccessLevel::Edit),
None,
] {
let mut repo = make_mock_repo();
repo.expect_get_team_share_facts()
.returning(|_| Box::pin(async { Ok(team_share_facts()) }));
repo.expect_edit_document()
.times(1)
.withf(move |args| {
let command = args.team_share.as_ref().unwrap();
command.expected() == &team_share_facts()
&& command.target().map(|grant| AccessLevel::from(grant.level)) == level
})
.returning(|_| Box::pin(async { Ok(()) }));
make_test_service(repo)
.edit_document(
owner_bot_edit_receipt(),
task_document_context("doc-1"),
team_edit_args(level),
)
.await
.unwrap();
}
for enabled in [true, false] {
let mut repo = make_mock_repo();
repo.expect_get_team_share_facts()
.returning(|_| Box::pin(async { Ok(team_share_facts()) }));
repo.expect_set_team_share()
.times(1)
.withf(move |command| command.target().is_some() == enabled)
.returning(move |_| {
Box::pin(async move {
Ok(super::super::models::DocumentTeamShare {
team_id: team_share_facts().owner_team_id,
shared_with_team: enabled,
})
})
});
make_test_service(repo)
.set_team_share(owner_bot_edit_receipt(), enabled)
.await
.unwrap();
}
}
#[tokio::test]
async fn team_edit_conflict_does_not_publish_success() {
let mut repo = make_mock_repo();
repo.expect_get_team_share_facts()
.returning(|_| Box::pin(async { Ok(team_share_facts()) }));
repo.expect_edit_document()
.returning(|_| Box::pin(async { Err(DocumentError::Conflict("stale facts".to_string())) }));
let (service, broker) = make_test_service_with_event_broker(repo);
assert!(matches!(
service
.edit_document(
owner_bot_edit_receipt(),
task_document_context("doc-1"),
team_edit_args(None)
)
.await,
Err(DocumentError::Conflict(_))
));
assert!(broker.published().lock().unwrap().is_empty());
assert_eq!(*service.connection_service.invalidations.lock().unwrap(), 0);
}
#[tokio::test]
async fn team_toggle_conflict_does_not_invalidate() {
let mut repo = make_mock_repo();
repo.expect_get_team_share_facts()
.returning(|_| Box::pin(async { Ok(team_share_facts()) }));
repo.expect_set_team_share()
.returning(|_| Box::pin(async { Err(DocumentError::Conflict("stale facts".to_string())) }));
let service = make_test_service(repo);
assert!(matches!(
service.set_team_share(owner_bot_edit_receipt(), true).await,
Err(DocumentError::Conflict(_))
));
assert_eq!(*service.connection_service.invalidations.lock().unwrap(), 0);
}
#[tokio::test]
async fn team_edit_rejects_owner_level_and_enable_without_team_before_writes() {
use models_permissions::share_permission::access_level::AccessLevel;
for (level, has_team) in [(AccessLevel::Owner, true), (AccessLevel::View, false)] {
let mut repo = make_mock_repo();
repo.expect_get_team_share_facts().returning(move |_| {
Box::pin(async move {
let mut facts = team_share_facts();
if !has_team {
facts.owner_team_id = None;
}
Ok(facts)
})
});
let service = make_test_service(repo);
assert!(matches!(
service
.edit_document(
owner_bot_edit_receipt(),
task_document_context("doc-1"),
team_edit_args(Some(level))
)
.await,
Err(DocumentError::BadRequest(_))
));
assert_eq!(*service.connection_service.invalidations.lock().unwrap(), 0);
}
}
fn edit_receipt(document_id: &str) -> EntityAccessReceipt<EditAccessLevel> {
let user_id = macro_user_id::user_id::MacroUserIdStr::parse_from_str("macro|[email protected]")
.unwrap()
.into_owned();
EntityAccessReceipt::dangerously_assert_authenticated_user(
user_id,
document_id,
EntityType::Document,
)
}
#[tokio::test]
async fn content_uploaded_publishes_document_event_with_owner_and_version() {
let mut repo = make_mock_repo();
repo.expect_get_basic_document()
.withf(|document_id| document_id == "doc-1")
.return_once(|_| Box::pin(std::future::ready(Ok(task_document_context("doc-1")))));
let (service, event_broker) = make_test_service_with_event_broker(repo);
service
.publish_content_uploaded("doc-1", FileType::Pdf, Some("convert".to_string()))
.await
.unwrap();
let published = event_broker.published();
let published = published.lock().unwrap();
assert_eq!(published.len(), 1);
let event = &published[0];
assert_eq!(event.topic, "macro.documents");
assert_eq!(event.key, "doc-1");
assert_eq!(event.payload["event_type"], "document.content_uploaded");
assert_eq!(event.payload["metadata"]["document_id"], "doc-1");
assert_eq!(event.payload["metadata"]["owner"], "macro|[email protected]");
assert_eq!(event.payload["metadata"]["file_type"], "pdf");
assert_eq!(event.payload["metadata"]["document_version_id"], "convert");
}
#[tokio::test]
async fn content_uploaded_preserves_an_absent_version() {
let mut repo = make_mock_repo();
repo.expect_get_basic_document()
.return_once(|_| Box::pin(std::future::ready(Ok(task_document_context("doc-1")))));
let (service, event_broker) = make_test_service_with_event_broker(repo);
service
.publish_content_uploaded("doc-1", FileType::Pdf, None)
.await
.unwrap();
let published = event_broker.published();
let published = published.lock().unwrap();
assert_eq!(
published[0].payload["metadata"]["document_version_id"],
serde_json::Value::Null
);
}
#[tokio::test]
async fn content_uploaded_maps_a_missing_document_to_not_found() {
let mut repo = make_mock_repo();
repo.expect_get_basic_document().return_once(|_| {
Box::pin(std::future::ready(Err(anyhow!(
"no rows returned by a query that expected to return at least one row"
))))
});
let (service, event_broker) = make_test_service_with_event_broker(repo);
let result = service
.publish_content_uploaded("missing-doc", FileType::Pdf, None)
.await;
assert!(matches!(
result,
Err(DocumentError::NotFound(document_id)) if document_id == "missing-doc"
));
assert!(event_broker.published().lock().unwrap().is_empty());
}
#[tokio::test]
async fn content_uploaded_maps_an_immediate_broker_failure_to_internal() {
let mut repo = make_mock_repo();
repo.expect_get_basic_document()
.return_once(|_| Box::pin(std::future::ready(Ok(task_document_context("doc-1")))));
let event_broker = TestEventBroker::failing();
let (service, event_broker) =
make_test_service_with_configured_event_broker(repo, event_broker);
let result = service
.publish_content_uploaded("doc-1", FileType::Pdf, None)
.await;
assert!(matches!(result, Err(DocumentError::Internal(_))));
assert!(event_broker.published().lock().unwrap().is_empty());
}
#[tokio::test]
async fn test_delete_document_publishes_document_deleted_event() {
let mut repo = make_mock_repo();
repo.expect_get_document_metadata().returning(|_| {
let mut metadata = make_test_metadata();
metadata.sub_type = Some(DocumentSubType::Task);
Box::pin(std::future::ready(Ok(metadata)))
});
repo.expect_soft_delete_document()
.withf(|id| id == "doc-1")
.returning(|_| Box::pin(std::future::ready(Ok(()))));
repo.expect_update_project_modified()
.withf(|id| id == "project-1")
.returning(|_| Box::pin(std::future::ready(Ok(()))));
let (service, event_broker) = make_test_service_with_event_broker(repo);
service
.delete_document(owner_receipt("doc-1"), Some("project-1".to_string()))
.await
.unwrap();
let published = event_broker.published();
let published = published.lock().unwrap();
assert_eq!(published.len(), 1);
let event = &published[0];
assert_eq!(event.topic, "macro.documents");
assert_eq!(event.key, "doc-1");
assert_eq!(event.payload["event_type"], "document.deleted");
assert_eq!(event.payload["schema_version"], 1);
assert_eq!(event.payload["metadata"]["document_id"], "doc-1");
assert_eq!(event.payload["metadata"]["sub_type"], "task");
assert_eq!(
event.payload["metadata"]["actor_user_id"],
"macro|[email protected]"
);
assert_eq!(event.payload["metadata"]["project_id"], "project-1");
assert!(
uuid::Uuid::parse_str(event.payload["event_id"].as_str().unwrap()).is_ok(),
"event_id should be a valid uuid: {:?}",
event.payload["event_id"]
);
}
#[tokio::test]
async fn test_delete_document_publishes_no_event_when_repo_fails() {
let mut repo = make_mock_repo();
repo.expect_get_document_metadata()
.returning(|_| Box::pin(std::future::ready(Ok(make_test_metadata()))));
repo.expect_soft_delete_document()
.withf(|id| id == "doc-1")
.returning(|_| Box::pin(std::future::ready(Err(anyhow!("db is down")))));
let (service, event_broker) = make_test_service_with_event_broker(repo);
let result = service.delete_document(owner_receipt("doc-1"), None).await;
assert!(result.is_err());
assert!(event_broker.published().lock().unwrap().is_empty());
}
#[tokio::test]
async fn delete_document_rejects_initiative_description() {
let mut repo = make_mock_repo();
let mut metadata = make_test_metadata();
metadata.sub_type = Some(DocumentSubType::InitiativeDescription);
repo.expect_get_document_metadata()
.return_once(move |_| Box::pin(std::future::ready(Ok(metadata))));
repo.expect_soft_delete_document().times(0);
let (service, event_broker) = make_test_service_with_event_broker(repo);
let result = service.delete_document(owner_receipt("doc-1"), None).await;
assert!(matches!(result, Err(DocumentError::BadRequest(_))));
assert!(event_broker.published().lock().unwrap().is_empty());
}
#[tokio::test]
async fn edit_document_sets_revocation_intent_from_link_share_target() {
for (link_share, expected_revocation) in [
(Some(Some(LinkShare::Team)), true),
(Some(None), true),
(Some(Some(LinkShare::Public)), false),
(None, false),
] {
let mut repo = make_mock_repo();
repo.expect_edit_document()
.withf(move |args| {
args.revoke_non_owner_user_access == expected_revocation
&& args
.share_permission
.as_ref()
.is_some_and(|permission| permission.link_share == link_share)
})
.return_once(|_| Box::pin(std::future::ready(Ok(()))));
make_test_service(repo)
.edit_document(
edit_receipt("doc-1"),
task_document_context("doc-1"),
EditDocumentServiceArgs {
document_name: None,
project_id: None,
share_permission: Some(UpdateSharePermissionRequestV2 {
link_share,
link_share_access_level: None,
team_share_access_level: None,
channel_share_permissions: None,
}),
file_type: None,
},
)
.await
.unwrap();
}
}
#[tokio::test]
async fn test_edit_document_publishes_document_updated_event() {
let mut repo = make_mock_repo();
repo.expect_edit_document()
.withf(|args| args.document_id == "doc-1" && !args.revoke_non_owner_user_access)
.returning(|_| Box::pin(std::future::ready(Ok(()))));
let (service, event_broker) = make_test_service_with_event_broker(repo);
service
.edit_document(
edit_receipt("doc-1"),
task_document_context("doc-1"),
EditDocumentServiceArgs {
document_name: Some("New name.md".to_string()),
project_id: None,
share_permission: None,
file_type: None,
},
)
.await
.unwrap();
let published = event_broker.published();
let published = published.lock().unwrap();
assert_eq!(published.len(), 1);
let event = &published[0];
assert_eq!(event.topic, "macro.documents");
assert_eq!(event.key, "doc-1");
assert_eq!(event.payload["event_type"], "document.updated");
assert_eq!(event.payload["metadata"]["document_name"], "New name");
assert_eq!(event.payload["metadata"]["owner"], "macro|[email protected]");
assert_eq!(
event.payload["metadata"]["actor_user_id"],
"macro|[email protected]"
);
assert_eq!(event.payload["metadata"]["share_permission_updated"], false);
assert_eq!(
event.payload["metadata"]["previous_project_id"],
serde_json::Value::Null
);
assert_eq!(
event.payload["metadata"]["project_id"],
serde_json::Value::Null
);
}
#[tokio::test]
async fn test_edit_document_rename_only_keeps_project_access() {
let document_id = uuid::Uuid::new_v4().to_string();
let old_project_id = uuid::Uuid::new_v4();
let mut repo = make_mock_repo();
repo.expect_edit_document()
.returning(|_| Box::pin(std::future::ready(Ok(()))));
let (service, entity_access) = make_test_service_with_entity_access(repo);
let mut context = task_document_context(&document_id);
context.project_id = Some(old_project_id.to_string());
service
.edit_document(
edit_receipt(&document_id),
context,
EditDocumentServiceArgs {
document_name: Some("New name".to_string()),
project_id: None,
share_permission: None,
file_type: None,
},
)
.await
.unwrap();
assert!(
entity_access
.removed_from_projects
.lock()
.unwrap()
.is_empty()
);
assert!(entity_access.added_to_projects.lock().unwrap().is_empty());
}
#[tokio::test]
async fn test_edit_document_project_change_moves_project_access() {
let document_id = uuid::Uuid::new_v4().to_string();
let old_project_id = uuid::Uuid::new_v4();
let new_project_id = uuid::Uuid::new_v4();
let mut repo = make_mock_repo();
repo.expect_edit_document()
.returning(|_| Box::pin(std::future::ready(Ok(()))));
repo.expect_update_project_modified()
.times(2)
.returning(|_| Box::pin(std::future::ready(Ok(()))));
let (service, entity_access) = make_test_service_with_entity_access(repo);
let mut context = task_document_context(&document_id);
context.project_id = Some(old_project_id.to_string());
service
.edit_document(
edit_receipt(&document_id),
context,
EditDocumentServiceArgs {
document_name: None,
project_id: Some(new_project_id.to_string()),
share_permission: None,
file_type: None,
},
)
.await
.unwrap();
assert_eq!(
*entity_access.removed_from_projects.lock().unwrap(),
vec![old_project_id]
);
assert_eq!(
*entity_access.added_to_projects.lock().unwrap(),
vec![new_project_id]
);
}
#[tokio::test]
async fn copy_document_best_effort_bumps_inherited_project_and_publishes_event() {
let mut repo = make_mock_repo();
let original_metadata = make_test_metadata();
let original_for_lookup = original_metadata.clone();
repo.expect_get_document_metadata()
.withf(|id| id == "doc-1")
.returning(move |_| Box::pin(std::future::ready(Ok(original_for_lookup.clone()))));
repo.expect_get_project_owner()
.withf(|id| id == "project-1")
.returning(|_| {
Box::pin(std::future::ready(Ok(
macro_user_id::user_id::MacroUserIdStr::parse_from_str("macro|[email protected]")
.unwrap()
.into_owned(),
)))
});
let mut copied_metadata = make_test_metadata();
copied_metadata.document_id = "doc-2".to_string();
copied_metadata.document_name = "copied doc".to_string();
repo.expect_get_owner_team()
.returning(|_| Box::pin(std::future::ready(Ok(None))));
repo.expect_copy_document()
.returning(move |_, _| Box::pin(std::future::ready(Ok(copied_metadata.clone()))));
repo.expect_get_document_version_id()
.returning(|_| Box::pin(std::future::ready(Ok((1, true)))));
repo.expect_get_latest_document_version_id()
.returning(|_| Box::pin(std::future::ready(Ok((1, true)))));
repo.expect_set_document_content()
.returning(|_, _| Box::pin(std::future::ready(Ok(()))));
repo.expect_update_project_modified()
.withf(|project_id| project_id == "project-1")
.times(1)
.returning(|_| Box::pin(std::future::ready(Err(anyhow!("db is down")))));
repo.expect_get_team_task_metadata()
.returning(|_| Box::pin(std::future::ready(Ok(None))));
let (service, event_broker) = make_test_service_with_event_broker(repo);
let mut document_context = task_document_context("doc-1");
document_context.file_type = Some("txt".to_string());
document_context.sub_type = None;
service
.copy_document(
authenticated_receipt("doc-1"),
document_context,
&CreationPrincipal::User(test_user()),
"copied doc".to_string(),
None,
None,
)
.await
.unwrap();
let published = event_broker.published();
let published = published.lock().unwrap();
assert_eq!(published.len(), 1);
let event = &published[0];
assert_eq!(event.topic, "macro.documents");
assert_eq!(event.key, "doc-2");
assert_eq!(event.payload["event_type"], "document.copied");
assert_eq!(event.payload["metadata"]["document_id"], "doc-2");
assert_eq!(event.payload["metadata"]["source_document_id"], "doc-1");
assert_eq!(event.payload["metadata"]["document_name"], "copied doc");
assert_eq!(event.payload["metadata"]["owner"], "macro|[email protected]");
}
#[derive(Clone, Default)]
struct RecordingUploadUrlPort {
copies: Arc<Mutex<Vec<(String, String)>>>,
deletions: Arc<Mutex<Vec<String>>>,
uploads: Arc<Mutex<Vec<(String, String)>>>,
fail_delete: bool,
}
impl PresignedUploadUrlPort for RecordingUploadUrlPort {
async fn delete_object(&self, key: &str) -> anyhow::Result<()> {
self.deletions.lock().unwrap().push(key.to_string());
if self.fail_delete {
anyhow::bail!("storage cleanup unavailable");
}
Ok(())
}
async fn put_document_storage_presigned_url(
&self,
key: &str,
sha: &str,
_content_type: ContentType,
) -> anyhow::Result<String> {
self.uploads
.lock()
.unwrap()
.push((key.to_string(), sha.to_string()));
Ok(String::new())
}
async fn put_docx_upload_presigned_url(
&self,
_key: &str,
_sha: &str,
_content_type: ContentType,
) -> anyhow::Result<String> {
Ok(String::new())
}
async fn copy_object(&self, source_key: &str, destination_key: &str) -> anyhow::Result<()> {
self.copies
.lock()
.unwrap()
.push((source_key.to_string(), destination_key.to_string()));
Ok(())
}
async fn get_snapshot(&self, _document_id: &str) -> anyhow::Result<Option<Vec<u8>>> {
Ok(None)
}
async fn upload_snapshot(&self, _document_id: &str, _bytes: Vec<u8>) -> anyhow::Result<()> {
Ok(())
}
}
#[tokio::test]
async fn bot_owned_copy_reads_the_source_owner_key_and_writes_the_bot_key() {
let principal = CreationPrincipal::TeamBot {
bot: bot_id::NonSystemBotId::new(bot_id()).unwrap(),
team: uuid::uuid!("00000000-0000-0000-0000-000000000456"),
};
for (file_type, source_key, destination_key) in [
(
"txt",
"macro|[email protected]/doc-1/1",
"bot|00000000-0000-0000-0000-000000000123/doc-2/3",
),
(
"docx",
"macro|[email protected]/doc-1/converted.pdf",
"bot|00000000-0000-0000-0000-000000000123/doc-2/converted.pdf",
),
] {
let mut original = make_test_metadata();
original.project_id = None;
original.project_name = None;
original.file_type = Some(file_type.to_string());
original.document_bom = Some(serde_json::json!([]));
let mut repo = make_mock_repo();
repo.expect_get_document_metadata()
.returning(move |_| Box::pin(std::future::ready(Ok(original.clone()))));
repo.expect_get_owner_team()
.returning(|_| Box::pin(std::future::ready(Ok(None))));
repo.expect_copy_document().returning(|args, _| {
let mut copied = make_test_metadata();
copied.document_id = "doc-2".to_string();
copied.document_version_id = 3;
copied.owner = args.owner;
copied.project_id = None;
Box::pin(std::future::ready(Ok(copied)))
});
repo.expect_get_document_version_id()
.returning(|_| Box::pin(std::future::ready(Ok((1, true)))));
repo.expect_get_latest_document_version_id()
.returning(|_| Box::pin(std::future::ready(Ok((1, true)))));
repo.expect_set_document_content()
.returning(|_, _| Box::pin(std::future::ready(Ok(()))));
repo.expect_get_team_task_metadata()
.returning(|_| Box::pin(std::future::ready(Ok(None))));
let uploads = RecordingUploadUrlPort::default();
let service = DocumentServiceImpl::new(
repo,
test_cloudfront_config(),
sync_service_client::SyncServiceClient::new(
"test-sync-key".to_string(),
"http://sync-service.test".to_string(),
),
uploads.clone(),
TestTaskPropertiesPort,
TestConnectionService::default(),
TestEntityAccessManagementService::default(),
TestForeignEntityService::default(),
TestEventBroker::default(),
);
let mut context = task_document_context("doc-1");
context.file_type = Some(file_type.to_string());
context.sub_type = None;
service
.copy_document(
bot_receipt("doc-1"),
context,
&principal,
"copied doc".to_string(),
None,
None,
)
.await
.unwrap();
assert_eq!(
*uploads.copies.lock().unwrap(),
[(source_key.to_string(), destination_key.to_string())]
);
}
}
struct RejectUnexpectedFinalization;
impl crate::domain::ports::markdown::MarkdownInitializationPort for RejectUnexpectedFinalization {
async fn initialize_existing_markdown(
&self,
_: &str,
_: &str,
) -> Result<Vec<u8>, DocumentError> {
panic!("failed repository creation must not initialize markdown");
}
async fn initialize_existing_notion(
&self,
_: &str,
_: &crate::domain::notion_markdown::NotionMarkdown,
) -> Result<crate::domain::ports::markdown::MarkdownSnapshot, DocumentError> {
panic!("failed repository creation must not initialize markdown");
}
}
impl crate::domain::ports::create::DocumentBytesUploadPort for RejectUnexpectedFinalization {
async fn upload_document_bytes(
&self,
_: crate::domain::ports::create::DocumentBytesUpload,
) -> Result<(), DocumentError> {
panic!("failed repository creation must not upload content");
}
}
impl crate::domain::ports::mentions::DocumentMentionTrackingPort for RejectUnexpectedFinalization {
async fn track_document_mentions(
&self,
_: &str,
_: Option<¯o_user_id::user_id::MacroUserIdStr<'static>>,
_: &str,
) -> anyhow::Result<()> {
panic!("failed repository creation must not track mentions");
}
}
#[tokio::test]
async fn creator_forwards_explicit_consent_and_stops_after_repository_failure() {
use crate::domain::create::{
DocumentCreator, MarkdownSubtype, NewDocumentMetadata, NewMarkdownTextDocument,
};
for (subtype, expected_share) in [
(MarkdownSubtype::Note, false),
(MarkdownSubtype::Snippet, false),
(
MarkdownSubtype::from_task_flag(true, Some(uuid::Uuid::from_u128(7))),
true,
),
(
MarkdownSubtype::Task {
property_values: None,
share_with_team: false,
team_id: None,
},
false,
),
] {
let mut repo = make_mock_repo();
repo.expect_get_owner_team()
.returning(|_| Box::pin(std::future::ready(Ok(None))));
repo.expect_create_document()
.withf(move |args, permission| {
args.document.share_with_team == expected_share
&& permission.team_share_access_level.is_none()
})
.times(1)
.returning(|_, _| {
Box::pin(std::future::ready(Err(DocumentError::Internal(
anyhow::anyhow!("creation rolled back"),
))))
});
let (service, event_broker) = make_test_service_with_event_broker(repo);
let creator = DocumentCreator::new(
service,
RejectUnexpectedFinalization,
RejectUnexpectedFinalization,
RejectUnexpectedFinalization,
);
let result = creator
.create_markdown_text(
&CreationPrincipal::User(test_user()),
NewMarkdownTextDocument {
metadata: NewDocumentMetadata::new("test"),
markdown: String::new(),
subtype,
},
)
.await;
assert!(result.is_err());
assert!(event_broker.published().lock().unwrap().is_empty());
}
}
fn test_user() -> MacroUserIdStr<'static> {
MacroUserIdStr::parse_from_str("macro|[email protected]")
.unwrap()
.into_owned()
}
fn new_document(file_type: FileType) -> NewDocument {
NewDocument {
id: None,
sha: "sha".to_string(),
document_name: "doc".to_string(),
file_type: Some(file_type),
project_id: None,
team_id: None,
share_with_team: false,
created_at: None,
updated_at: None,
sub_type: None,
skip_history: false,
initial_link_share: InitialLinkShare::EntityDefault,
}
}
#[tokio::test]
async fn team_bot_task_rejects_a_different_numbering_team() {
let mut repo = make_mock_repo();
repo.expect_get_owner_team().times(0);
repo.expect_create_document().times(0);
let (service, broker) = make_test_service_with_event_broker(repo);
let team = uuid::Uuid::from_u128(7);
let principal = CreationPrincipal::TeamBot {
bot: bot_id::NonSystemBotId::new(bot_id::BotId::TEST_A).unwrap(),
team,
};
let mut document = new_document(FileType::Md);
document.sub_type = Some(DocumentSubType::Task);
document.team_id = Some(uuid::Uuid::from_u128(8));
let error = crate::domain::ports::DocumentService::create_document(
&service, &principal, document, None,
)
.await
.unwrap_err();
assert_eq!(
error.to_string(),
"bad request: task team does not match the creating bot's team"
);
assert!(broker.published().lock().unwrap().is_empty());
}
async fn create_document_with_team_default(
team_default: Option<models_permissions::share_permission::TeamLinkShareDefault>,
file_type: FileType,
expected_link_share: Option<models_permissions::share_permission::LinkShare>,
expected_access_level: Option<models_permissions::share_permission::access_level::AccessLevel>,
) {
let mut repo = make_mock_repo();
repo.expect_get_owner_team()
.withf(|owner| *owner == Owner::User(test_user()))
.returning(move |_| {
Box::pin(std::future::ready(Ok(team_default.map(
|default_link_share| OwnerTeam {
team_id: uuid::Uuid::from_u128(1),
default_link_share,
},
))))
});
let created_metadata = make_test_metadata();
repo.expect_create_document()
.withf(move |_, share_permission| {
share_permission.link_share == expected_link_share
&& share_permission.link_share_access_level == expected_access_level
})
.times(1)
.returning(move |_, _| Box::pin(std::future::ready(Ok(created_metadata.clone()))));
repo.expect_set_document_content()
.returning(|_, _| Box::pin(std::future::ready(Ok(()))));
repo.expect_get_team_task_metadata()
.returning(|_| Box::pin(std::future::ready(Ok(None))));
let (service, _event_broker) = make_test_service_with_event_broker(repo);
crate::domain::ports::DocumentService::create_document(
&service,
&CreationPrincipal::User(test_user()),
new_document(file_type),
None,
)
.await
.unwrap();
}
#[tokio::test]
async fn create_document_repo_receives_team_derived_share_permission() {
use models_permissions::share_permission::access_level::AccessLevel;
use models_permissions::share_permission::{LinkShare, TeamLinkShareDefault};
// Team scope applies; a non-md doc has no entity level so it falls back to View.
create_document_with_team_default(
Some(TeamLinkShareDefault(Some(LinkShare::Team))),
FileType::Txt,
Some(LinkShare::Team),
Some(AccessLevel::View),
)
.await;
// Md keeps its Edit level under a team scope.
create_document_with_team_default(
Some(TeamLinkShareDefault(Some(LinkShare::Team))),
FileType::Md,
Some(LinkShare::Team),
Some(AccessLevel::Edit),
)
.await;
}
#[tokio::test]
async fn create_document_repo_receives_entity_default_without_team() {
use models_permissions::share_permission::LinkShare;
use models_permissions::share_permission::access_level::AccessLevel;
create_document_with_team_default(
None,
FileType::Md,
Some(LinkShare::Public),
Some(AccessLevel::Edit),
)
.await;
create_document_with_team_default(None, FileType::Txt, None, None).await;
}
#[tokio::test]
async fn create_document_repo_receives_disabled_share_when_team_turned_link_share_off() {
use models_permissions::share_permission::TeamLinkShareDefault;
create_document_with_team_default(Some(TeamLinkShareDefault(None)), FileType::Md, None, None)
.await;
}
#[tokio::test]
async fn exact_initial_link_share_bypasses_md_public_edit_default() {
use models_permissions::share_permission::access_level::AccessLevel;
use models_permissions::share_permission::{LinkShare, LinkShareState};
for state in [
LinkShareState::Off,
LinkShareState::On {
scope: LinkShare::Team,
level: AccessLevel::View,
},
] {
let mut repo = make_mock_repo();
let created_metadata = make_test_metadata();
repo.expect_get_owner_team().times(0);
repo.expect_create_document()
.withf(move |args, share_permission| {
args.document.initial_link_share == InitialLinkShare::Exact(state)
&& share_permission.link_share_state() == state
&& share_permission.team_share_access_level.is_none()
})
.times(1)
.returning(move |_, _| Box::pin(std::future::ready(Ok(created_metadata.clone()))));
repo.expect_set_document_content()
.returning(|_, _| Box::pin(std::future::ready(Ok(()))));
repo.expect_get_team_task_metadata()
.returning(|_| Box::pin(std::future::ready(Ok(None))));
let (service, _event_broker) = make_test_service_with_event_broker(repo);
let mut document = new_document(FileType::Md);
document.initial_link_share = InitialLinkShare::Exact(state);
crate::domain::ports::DocumentService::create_document(
&service,
&CreationPrincipal::User(test_user()),
document,
None,
)
.await
.unwrap();
}
}
#[tokio::test]
async fn initiative_description_rejects_entity_default_link_share() {
let repo = make_mock_repo();
let (service, event_broker) = make_test_service_with_event_broker(repo);
let mut document = new_document(FileType::Md);
document.sub_type = Some(document_sub_type::DocumentSubType::InitiativeDescription);
let err = crate::domain::ports::DocumentService::create_document(
&service,
&CreationPrincipal::User(test_user()),
document,
None,
)
.await
.unwrap_err();
assert_eq!(
err.to_string(),
"bad request: initiative descriptions must set an exact initial link share"
);
assert!(event_broker.published().lock().unwrap().is_empty());
}
#[tokio::test]
async fn initiative_description_accepts_exact_link_share() {
use models_permissions::share_permission::LinkShareState;
let mut repo = make_mock_repo();
let created_metadata = make_test_metadata();
repo.expect_get_owner_team().times(0);
repo.expect_create_document()
.withf(|args, share_permission| {
args.document.sub_type
== Some(document_sub_type::DocumentSubType::InitiativeDescription)
&& args.document.initial_link_share == InitialLinkShare::Exact(LinkShareState::Off)
&& share_permission.link_share_state() == LinkShareState::Off
})
.times(1)
.returning(move |_, _| Box::pin(std::future::ready(Ok(created_metadata.clone()))));
repo.expect_set_document_content()
.returning(|_, _| Box::pin(std::future::ready(Ok(()))));
repo.expect_get_team_task_metadata()
.returning(|_| Box::pin(std::future::ready(Ok(None))));
let (service, _event_broker) = make_test_service_with_event_broker(repo);
let mut document = new_document(FileType::Md);
document.sub_type = Some(document_sub_type::DocumentSubType::InitiativeDescription);
document.initial_link_share = InitialLinkShare::Exact(LinkShareState::Off);
crate::domain::ports::DocumentService::create_document(
&service,
&CreationPrincipal::User(test_user()),
document,
None,
)
.await
.unwrap();
}
#[tokio::test]
async fn create_document_publishes_the_principal_as_owner_and_actor() {
let team_bot = CreationPrincipal::TeamBot {
bot: bot_id::NonSystemBotId::new(bot_id::BotId::TEST_A).unwrap(),
team: uuid::Uuid::from_u128(7),
};
for (principal, owner, actor, on_behalf_of) in [
(
CreationPrincipal::User(test_user()),
"macro|[email protected]",
"macro|[email protected]",
None,
),
(
CreationPrincipal::BotForUser {
bot: bot_id::MACRO_AI_BOT_ID,
user: test_user(),
},
"macro|[email protected]",
"bot|00000000-0000-0000-0000-00000000a1a1",
Some("macro|[email protected]"),
),
(
team_bot,
"bot|00000000-0000-0000-0000-00000000b07a",
"bot|00000000-0000-0000-0000-00000000b07a",
None,
),
] {
let mut repo = make_mock_repo();
repo.expect_get_owner_team()
.returning(|_| Box::pin(std::future::ready(Ok(None))));
repo.expect_create_document().returning(|args, _| {
let mut metadata = make_test_metadata();
metadata.owner = args.owner;
Box::pin(std::future::ready(Ok(metadata)))
});
repo.expect_set_document_content()
.returning(|_, _| Box::pin(std::future::ready(Ok(()))));
repo.expect_get_team_task_metadata()
.returning(|_| Box::pin(std::future::ready(Ok(None))));
let (service, event_broker) = make_test_service_with_event_broker(repo);
crate::domain::ports::DocumentService::create_document(
&service,
&principal,
new_document(FileType::Txt),
None,
)
.await
.unwrap();
let published = event_broker.published();
let published = published.lock().unwrap();
let metadata = &published[0].payload["metadata"];
assert_eq!(metadata["owner"], owner);
assert_eq!(metadata["actor"], actor);
assert_eq!(
metadata.get("on_behalf_of").and_then(|user| user.as_str()),
on_behalf_of
);
}
}
#[tokio::test]
async fn email_import_is_attributed_to_the_system_bot() {
let mut repo = make_mock_repo();
repo.expect_get_owner_team()
.returning(|_| Box::pin(std::future::ready(Ok(None))));
let created_metadata = make_test_metadata();
repo.expect_import_email_attachment_document()
.returning(move |_, _| {
Box::pin(std::future::ready(Ok(EmailImportRepoOutcome::Created(
created_metadata.clone(),
))))
});
repo.expect_set_document_content()
.returning(|_, _| Box::pin(std::future::ready(Ok(()))));
repo.expect_get_team_task_metadata()
.returning(|_| Box::pin(std::future::ready(Ok(None))));
let (service, event_broker) = make_test_service_with_event_broker(repo);
let args = ImportEmailAttachmentRepoArgs {
email_attachment_id: uuid::Uuid::from_u128(7),
owner: test_user(),
document: new_document(FileType::Txt),
};
crate::domain::ports::DocumentService::import_email_attachment(&service, args)
.await
.unwrap();
let published = event_broker.published();
let published = published.lock().unwrap();
assert_eq!(published[0].payload["event_type"], "document.created");
assert_eq!(
published[0].payload["metadata"]["owner"],
"macro|[email protected]"
);
assert_eq!(
published[0].payload["metadata"]["actor"],
bot_id::MACRO_SYSTEM_BOT_ID.into_storage_id().as_ref()
);
assert!(
published[0].payload["metadata"]
.get("on_behalf_of")
.is_none()
);
}
type PropertyWrite = (CreationPrincipal, uuid::Uuid, Option<SetPropertyValue>);
#[derive(Default, Clone)]
struct RecordingTaskPropertiesPort {
writes: Arc<Mutex<Vec<PropertyWrite>>>,
}
impl TaskPropertiesPort for RecordingTaskPropertiesPort {
async fn attach_task_properties(&self, _entity_ids: Vec<String>) -> anyhow::Result<()> {
Ok(())
}
async fn update_task_status(
&self,
_access: &EntityAccessReceipt<EditAccessLevel>,
_credited_user: Option<¯o_user_id::user_id::MacroUserIdStr<'static>>,
_source: Option<&models_properties::service::property_change_source::PropertyChangeSource>,
_status: &str,
) -> anyhow::Result<()> {
Ok(())
}
async fn set_entity_property(
&self,
principal: &CreationPrincipal,
_entity_id: &str,
property_definition_id: uuid::Uuid,
value: Option<SetPropertyValue>,
) -> anyhow::Result<()> {
self.writes
.lock()
.unwrap()
.push((principal.clone(), property_definition_id, value));
Ok(())
}
async fn copy_task_properties(
&self,
_from_task_id: &str,
_to_task_id: &str,
) -> anyhow::Result<()> {
Ok(())
}
}
#[tokio::test]
async fn default_task_properties_assign_the_acting_user_and_never_a_team_bot() {
let assignees = uuid::Uuid::parse_str(ASSIGNEES_PROPERTY_ID).unwrap();
let status = uuid::Uuid::parse_str(STATUS_PROPERTY_ID).unwrap();
let not_started = SetPropertyValue::SelectOption {
option_id: NOT_STARTED_STATUS_OPTION_ID,
};
let assigned_to_user = SetPropertyValue::MultiEntityReference {
references: vec![EntityReference {
entity_id: "macro|[email protected]".to_string(),
entity_type: models_properties::EntityType::User,
specific_message_id: None,
}],
};
let bot_for_user = CreationPrincipal::BotForUser {
bot: bot_id::MACRO_SYSTEM_BOT_ID,
user: test_user(),
};
let team_bot = CreationPrincipal::TeamBot {
bot: bot_id::NonSystemBotId::new(bot_id::BotId::TEST_A).unwrap(),
team: uuid::Uuid::from_u128(7),
};
for (principal, expected) in [
(
bot_for_user,
vec![
(assignees, Some(assigned_to_user)),
(status, Some(not_started.clone())),
],
),
(team_bot, vec![(status, Some(not_started))]),
] {
let task_properties = RecordingTaskPropertiesPort::default();
let service = DocumentServiceImpl::new(
make_mock_repo(),
test_cloudfront_config(),
sync_service_client::SyncServiceClient::new(
"test-sync-key".to_string(),
"http://sync-service.test".to_string(),
),
TestUploadUrlPort,
task_properties.clone(),
TestConnectionService::default(),
TestEntityAccessManagementService::default(),
TestForeignEntityService::default(),
TestEventBroker::default(),
);
crate::domain::ports::DocumentService::handle_task_properties(
&service,
&principal,
"task-1",
&CreateTaskRequest {
task_name: "Intro to tasks".to_string(),
markdown: None,
project_id: None,
team_id: None,
property_values: None,
share_with_team: false,
},
)
.await
.unwrap();
let writes = task_properties.writes.lock().unwrap().clone();
assert!(
writes
.iter()
.all(|(written_as, _, _)| *written_as == principal)
);
assert_eq!(
writes
.into_iter()
.map(|(_, property, value)| (property, value))
.collect::<Vec<_>>(),
expected
);
}
}
#[tokio::test]
async fn create_document_reuse_skips_content_url_and_created_event() {
let mut repo = make_mock_repo();
repo.expect_get_owner_team()
.returning(|_| Box::pin(std::future::ready(Ok(None))));
let created_metadata = make_test_metadata();
repo.expect_import_email_attachment_document()
.returning(move |_, _| {
Box::pin(std::future::ready(Ok(EmailImportRepoOutcome::Reused(
created_metadata.clone(),
))))
});
repo.expect_set_document_content().times(0);
repo.expect_get_persisted_document_content()
.return_once(|_| {
Box::pin(std::future::ready(Ok(Some(DocumentContent::ready(
DocumentContentLocation::ObjectStorage,
)))))
});
repo.expect_get_team_task_metadata()
.returning(|_| Box::pin(std::future::ready(Ok(None))));
let (service, event_broker) = make_test_service_with_event_broker(repo);
let args = ImportEmailAttachmentRepoArgs {
email_attachment_id: uuid::Uuid::from_u128(9),
owner: test_user(),
document: new_document(FileType::Txt),
};
let response = crate::domain::ports::DocumentService::import_email_attachment(&service, args)
.await
.unwrap();
assert!(response.document_response.presigned_url.is_none());
assert_eq!(
response
.document_response
.document_metadata
.metadata
.document_id,
"doc-1"
);
assert_eq!(
response.document_response.document_metadata.content,
DocumentContent::ready(DocumentContentLocation::ObjectStorage),
);
assert!(event_broker.published().lock().unwrap().is_empty());
}
/// Imports an attachment that reuses `metadata`, whose content is `content`,
/// and returns the response with the uploads it signed.
async fn reimport_email_document(
metadata: DocumentMetadata,
content: DocumentContent,
file_type: FileType,
) -> (CreateDocumentResponseData, Vec<(String, String)>) {
let mut repo = make_mock_repo();
repo.expect_get_owner_team()
.returning(|_| Box::pin(std::future::ready(Ok(None))));
repo.expect_import_email_attachment_document()
.returning(move |_, _| {
Box::pin(std::future::ready(Ok(EmailImportRepoOutcome::Reused(
metadata.clone(),
))))
});
repo.expect_set_document_content().times(0);
repo.expect_get_persisted_document_content()
.return_once(|_| Box::pin(std::future::ready(Ok(Some(content)))));
repo.expect_get_team_task_metadata()
.returning(|_| Box::pin(std::future::ready(Ok(None))));
let uploads = RecordingUploadUrlPort::default();
let service = DocumentServiceImpl::new(
repo,
test_cloudfront_config(),
sync_service_client::SyncServiceClient::new(
"test-sync-key".to_string(),
"http://sync-service.test".to_string(),
),
uploads.clone(),
TestTaskPropertiesPort,
TestConnectionService::default(),
TestEntityAccessManagementService::default(),
TestForeignEntityService::default(),
TestEventBroker::default(),
);
let args = ImportEmailAttachmentRepoArgs {
email_attachment_id: uuid::Uuid::from_u128(9),
owner: test_user(),
document: new_document(file_type),
};
let response = crate::domain::ports::DocumentService::import_email_attachment(&service, args)
.await
.unwrap();
let signed = uploads.uploads.lock().unwrap().clone();
(response, signed)
}
fn pending_email_document(file_type: &str, sha: &str) -> (DocumentMetadata, DocumentContent) {
let mut metadata = make_test_metadata();
metadata.file_type = Some(file_type.to_string());
metadata.sha = Some(sha.to_string());
(
metadata,
DocumentContent::pending_at(DocumentContentLocation::ObjectStorage),
)
}
#[tokio::test]
async fn reusing_a_pending_email_document_signs_its_upload_again() {
let (metadata, content) = pending_email_document("pdf", "sha");
let key = build_cloud_storage_bucket_document_key(&metadata.owner, "doc-1", 1);
// The attachment's own declared type must not change the signed content type.
let (response, signed) = reimport_email_document(metadata, content, FileType::Txt).await;
assert!(response.document_response.presigned_url.is_some());
assert_eq!(response.content_type, "application/pdf");
assert_eq!(response.file_type.as_deref(), Some("pdf"));
assert_eq!(signed, [(key, "sha".to_string())]);
}
#[tokio::test]
async fn different_bytes_cannot_replace_a_pending_email_document() {
let (metadata, content) = pending_email_document("pdf", "other-sha");
let (response, signed) = reimport_email_document(metadata, content, FileType::Pdf).await;
assert!(response.document_response.presigned_url.is_none());
assert!(signed.is_empty());
}
#[tokio::test]
async fn reusing_a_converting_docx_does_not_sign_an_upload() {
let (metadata, _) = pending_email_document("docx", "sha");
let (response, signed) = reimport_email_document(
metadata,
DocumentContent::pending_at(DocumentContentLocation::ConvertedPdf),
FileType::Docx,
)
.await;
assert!(response.document_response.presigned_url.is_none());
assert!(signed.is_empty());
}
#[tokio::test]
async fn edited_interaction_bumps_document_before_publishing() {
let mut repo = make_mock_repo();
repo.expect_update_document_modified()
.withf(|document_id| document_id == "doc-1")
.times(1)
.returning(|_| Box::pin(std::future::ready(Ok(()))));
let (service, event_broker) = make_test_service_with_event_broker(repo);
service
.record_interaction("doc-1", InteractionReason::Edited)
.await
.unwrap();
let published = event_broker.published();
let published = published.lock().unwrap();
assert_eq!(published.len(), 1);
assert_eq!(published[0].topic, "macro.documents");
assert_eq!(published[0].key, "doc-1");
assert_eq!(published[0].payload["event_type"], "document.interaction");
assert_eq!(published[0].payload["metadata"]["document_id"], "doc-1");
assert_eq!(published[0].payload["metadata"]["reason"], "edited");
}
#[tokio::test]
async fn edited_interaction_does_not_publish_when_document_bump_fails() {
let mut repo = make_mock_repo();
repo.expect_update_document_modified()
.withf(|document_id| document_id == "doc-1")
.times(1)
.returning(|_| Box::pin(std::future::ready(Err(anyhow!("db is down")))));
let (service, event_broker) = make_test_service_with_event_broker(repo);
let result = service
.record_interaction("doc-1", InteractionReason::Edited)
.await;
assert_eq!(result.unwrap_err().to_string(), "db is down");
assert!(event_broker.published().lock().unwrap().is_empty());
}
#[tokio::test]
async fn join_and_leave_interactions_publish_without_bumping_document() {
for (reason, expected_reason) in [
(InteractionReason::FirstJoin, "first_join"),
(InteractionReason::LastLeave, "last_leave"),
] {
let mut repo = make_mock_repo();
repo.expect_update_document_modified().times(0);
let (service, event_broker) = make_test_service_with_event_broker(repo);
service.record_interaction("doc-1", reason).await.unwrap();
let published = event_broker.published();
let published = published.lock().unwrap();
assert_eq!(published.len(), 1);
assert_eq!(published[0].payload["event_type"], "document.interaction");
assert_eq!(published[0].payload["metadata"]["reason"], expected_reason);
}
}
fn spreadsheet_test_service(
repo: MockDocumentRepo,
sync: crate::domain::ports::sync::MockDocumentSyncPort,
) -> DocumentServiceImpl<
MockDocumentRepo,
TestUploadUrlPort,
TestTaskPropertiesPort,
TestConnectionService,
TestEntityAccessManagementService,
TestForeignEntityService,
TestEventBroker,
crate::domain::ports::sync::MockDocumentSyncPort,
> {
DocumentServiceImpl::new(
repo,
test_cloudfront_config(),
sync,
TestUploadUrlPort,
TestTaskPropertiesPort,
TestConnectionService::default(),
TestEntityAccessManagementService::default(),
TestForeignEntityService::default(),
TestEventBroker::default(),
)
}
#[tokio::test]
async fn canvas_copy_preserves_live_content_and_legacy_canvases_still_copy() {
for (shared, native) in [(false, false), (true, false), (true, true)] {
let mut repo = make_mock_repo();
repo.expect_get_persisted_document_content()
.returning(move |_| {
Box::pin(std::future::ready(Ok(Some(DocumentContent::ready(
if native {
DocumentContentLocation::SyncService
} else {
DocumentContentLocation::ObjectStorage
},
)))))
});
let mut original = make_test_metadata();
original.project_id = None;
original.file_type = Some("canvas".to_string());
repo.expect_get_document_metadata()
.returning(move |_| Box::pin(std::future::ready(Ok(original.clone()))));
let mut copied = make_test_metadata();
copied.document_id = "doc-2".to_string();
copied.project_id = None;
copied.file_type = Some("canvas".to_string());
repo.expect_copy_document()
.returning(move |_, _| Box::pin(std::future::ready(Ok(copied.clone()))));
repo.expect_get_owner_team()
.returning(|_| Box::pin(std::future::ready(Ok(None))));
repo.expect_get_latest_document_version_id()
.times(usize::from(!native))
.returning(|_| Box::pin(std::future::ready(Ok((1, true)))));
repo.expect_set_document_content()
.returning(|_, _| Box::pin(std::future::ready(Ok(()))));
repo.expect_get_team_task_metadata()
.returning(|_| Box::pin(std::future::ready(Ok(None))));
let mut sync = crate::domain::ports::sync::MockDocumentSyncPort::new();
sync.expect_exists()
.withf(|id| id == "doc-1")
.times(usize::from(!native))
.returning(move |_| Box::pin(std::future::ready(Ok(shared))));
sync.expect_copy_document()
.withf(|from, to, _| from == "doc-1" && to == "doc-2")
.times(usize::from(shared))
.returning(|_, _, _| Box::pin(std::future::ready(Ok(()))));
let service = spreadsheet_test_service(repo, sync);
let mut context = task_document_context("doc-1");
context.file_type = Some("canvas".to_string());
context.sub_type = None;
service
.copy_document(
authenticated_receipt("doc-1"),
context,
&CreationPrincipal::User(test_user()),
"copied canvas".to_string(),
None,
None,
)
.await
.unwrap();
}
}
#[tokio::test]
async fn canvas_copy_failure_compensates_only_its_destinations_and_still_removes_rows() {
for phase in ["lookup", "copy", "ready", "legacy-ready", "metadata"] {
let mut repo = make_mock_repo();
repo.expect_get_persisted_document_content().returning(|_| {
Box::pin(std::future::ready(Ok(Some(DocumentContent::ready(
DocumentContentLocation::ObjectStorage,
)))))
});
let mut original = make_test_metadata();
original.project_id = None;
original.file_type = Some("canvas".to_string());
repo.expect_get_document_metadata()
.returning(move |_| Box::pin(std::future::ready(Ok(original.clone()))));
let mut copied = make_test_metadata();
copied.document_id = "doc-2".to_string();
copied.project_id = None;
copied.file_type = Some("canvas".to_string());
repo.expect_copy_document()
.returning(move |_, _| Box::pin(std::future::ready(Ok(copied.clone()))));
repo.expect_get_owner_team()
.returning(|_| Box::pin(std::future::ready(Ok(None))));
repo.expect_get_latest_document_version_id()
.returning(|_| Box::pin(std::future::ready(Ok((1, true)))));
repo.expect_delete_document_by_id()
.withf(|id| id == "doc-2")
.times(1)
.returning(|_| Box::pin(std::future::ready(Ok(()))));
if phase.ends_with("ready") || phase == "metadata" {
repo.expect_set_document_content()
.times(1)
.returning(move |_, _| {
Box::pin(std::future::ready(if phase == "metadata" {
Ok(())
} else {
Err(anyhow!("content update unavailable"))
}))
});
}
if phase == "metadata" {
repo.expect_get_team_task_metadata()
.times(1)
.returning(|_| Box::pin(std::future::ready(Err(anyhow!("metadata unavailable")))));
}
let mut sync = crate::domain::ports::sync::MockDocumentSyncPort::new();
sync.expect_exists()
.withf(|id| id == "doc-1")
.times(1)
.returning(move |_| {
Box::pin(std::future::ready(if phase == "lookup" {
Err(anyhow!("lookup unavailable"))
} else {
Ok(phase != "legacy-ready")
}))
});
let room_attempted = phase == "copy" || phase == "ready" || phase == "metadata";
sync.expect_copy_document()
.withf(|from, to, _| from == "doc-1" && to == "doc-2")
.times(usize::from(room_attempted))
.returning(move |_, _, _| {
Box::pin(std::future::ready(if phase == "copy" {
Err(anyhow!("room copy unavailable"))
} else {
Ok(())
}))
});
sync.expect_delete_document()
.withf(|id| id == "doc-2")
.times(usize::from(room_attempted))
.returning(move |_| {
Box::pin(std::future::ready(if phase == "copy" {
Err(anyhow!("room cleanup unavailable"))
} else {
Ok(())
}))
});
// Cleanup failures must not prevent the remaining compensation steps.
let uploads = RecordingUploadUrlPort {
fail_delete: phase == "copy",
..Default::default()
};
let deleted = uploads.deletions.clone();
let service = DocumentServiceImpl::new(
repo,
test_cloudfront_config(),
sync,
uploads,
TestTaskPropertiesPort,
TestConnectionService::default(),
TestEntityAccessManagementService::default(),
TestForeignEntityService::default(),
TestEventBroker::default(),
);
let mut context = task_document_context("doc-1");
context.file_type = Some("canvas".to_string());
context.sub_type = None;
assert!(
service
.copy_document(
authenticated_receipt("doc-1"),
context,
&CreationPrincipal::User(test_user()),
"copied canvas".to_string(),
None,
None,
)
.await
.is_err()
);
assert_eq!(
*deleted.lock().unwrap(),
vec!["macro|[email protected]/doc-2/1"]
);
}
}
fn spreadsheet_document() -> NewDocument {
let mut document = new_document(FileType::Spreadsheet);
document.sha = "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855".to_string();
document
}
#[tokio::test]
async fn spreadsheet_creation_is_ready_only_after_sync_initialization() {
let mut repo = make_mock_repo();
let mut sync = crate::domain::ports::sync::MockDocumentSyncPort::new();
let mut sequence = mockall::Sequence::new();
repo.expect_get_owner_team()
.returning(|_| Box::pin(std::future::ready(Ok(None))));
repo.expect_create_document().returning(|_, _| {
let mut metadata = make_test_metadata();
metadata.file_type = Some("spreadsheet".to_string());
Box::pin(std::future::ready(Ok(metadata)))
});
repo.expect_set_document_content()
.withf(|_, content| {
*content == DocumentContent::pending_at(DocumentContentLocation::SyncService)
})
.times(1)
.in_sequence(&mut sequence)
.returning(|_, _| Box::pin(std::future::ready(Ok(()))));
sync.expect_initialize_spreadsheet()
.withf(|id| id == "doc-1")
.times(1)
.in_sequence(&mut sequence)
.returning(|_| Box::pin(std::future::ready(Ok(()))));
repo.expect_set_document_content()
.withf(|_, content| {
*content == DocumentContent::ready(DocumentContentLocation::SyncService)
})
.times(1)
.in_sequence(&mut sequence)
.returning(|_, _| Box::pin(std::future::ready(Ok(()))));
repo.expect_get_team_task_metadata()
.returning(|_| Box::pin(std::future::ready(Ok(None))));
let service = spreadsheet_test_service(repo, sync);
let result = DocumentService::create_document(
&service,
&CreationPrincipal::User(test_user()),
spreadsheet_document(),
None,
)
.await
.unwrap();
assert!(result.document_response.presigned_url.is_none());
assert_eq!(
result.document_response.document_metadata.content,
DocumentContent::ready(DocumentContentLocation::SyncService)
);
}
#[tokio::test]
async fn failed_spreadsheet_initialization_cleans_up_document_metadata() {
let mut repo = make_mock_repo();
let mut sync = crate::domain::ports::sync::MockDocumentSyncPort::new();
repo.expect_get_owner_team()
.returning(|_| Box::pin(std::future::ready(Ok(None))));
repo.expect_create_document()
.returning(|_, _| Box::pin(std::future::ready(Ok(make_test_metadata()))));
repo.expect_set_document_content()
.withf(|_, content| content.state == DocumentContentState::Pending)
.times(1)
.returning(|_, _| Box::pin(std::future::ready(Ok(()))));
sync.expect_initialize_spreadsheet()
.times(1)
.returning(|_| Box::pin(std::future::ready(Err(anyhow!("sync unavailable")))));
repo.expect_delete_document_by_id()
.withf(|id| id == "doc-1")
.times(1)
.returning(|_| Box::pin(std::future::ready(Ok(()))));
let service = spreadsheet_test_service(repo, sync);
assert!(
DocumentService::create_document(
&service,
&CreationPrincipal::User(test_user()),
spreadsheet_document(),
None,
)
.await
.is_err()
);
}
#[tokio::test]
async fn native_spreadsheet_location_uses_sync_without_an_object_url() {
let mut repo = make_mock_repo();
repo.expect_get_persisted_document_content().returning(|_| {
Box::pin(std::future::ready(Ok(Some(DocumentContent::ready(
DocumentContentLocation::SyncService,
)))))
});
let sync = crate::domain::ports::sync::MockDocumentSyncPort::new();
let service = spreadsheet_test_service(repo, sync);
let mut context = task_document_context("doc-1");
context.file_type = Some("spreadsheet".to_string());
context.sub_type = None;
let result = service
.get_document_location(
&context,
authenticated_receipt("doc-1"),
LocationQueryParams {
document_version_id: None,
get_converted_docx_url: None,
},
)
.await
.unwrap();
assert!(matches!(
result,
LocationResponseV3::SyncServiceContent { .. }
));
}
#[test]
fn spreadsheet_uploads_are_rejected_instead_of_discarding_their_bytes() {
assert!(
validate_spreadsheet_creation(Some(FileType::Spreadsheet), "uploaded-workbook-sha")
.is_err()
);
assert!(
validate_spreadsheet_creation(Some(FileType::Spreadsheet), &spreadsheet_document().sha)
.is_ok()
);
assert!(validate_spreadsheet_creation(Some(FileType::Csv), "uploaded-csv-sha").is_ok());
}
#[test]
fn presigned_url_path_percent_encodes_the_owner_segment_of_the_object_key() {
let service = make_test_service(make_mock_repo());
let owner = Owner::from_principal_str("macro|[email protected]").unwrap();
let key = build_cloud_storage_bucket_document_key(&owner, "doc-1", 7);
// The object key stays the raw principal; only the URL path is encoded.
assert_eq!(key, "macro|[email protected]/doc-1/7");
assert_eq!(
service.cloudfront_url_for_key(&key),
"https://cdn.example.test/macro%7Cowner%40user.com/doc-1/7"
);
}
#[test]
fn presigned_url_path_for_a_converted_docx_matches_the_legacy_encoding() {
let service = make_test_service(make_mock_repo());
let owner = Owner::from_principal_str("macro|[email protected]").unwrap();
let key = build_docx_to_pdf_converted_document_key(&owner, "doc-1");
assert_eq!(
service.cloudfront_url_for_key(&key),
"https://cdn.example.test/macro%7Cowner%40user.com/doc-1/converted.pdf"
);
}
#[test]
fn presigned_url_path_for_bot_and_team_owners_uses_their_principals() {
let service = make_test_service(make_mock_repo());
let bot = Owner::from_principal_str("bot|00000000-0000-0000-0000-00000000a1a1").unwrap();
let team = Owner::from_principal_str("00000000-0000-0000-0000-000000000456").unwrap();
assert_eq!(
service.cloudfront_url_for_key(&build_cloud_storage_bucket_document_key(&bot, "doc-1", 7)),
"https://cdn.example.test/bot%7C00000000-0000-0000-0000-00000000a1a1/doc-1/7"
);
assert_eq!(
service.cloudfront_url_for_key(&build_cloud_storage_bucket_document_key(&team, "doc-1", 7)),
"https://cdn.example.test/00000000-0000-0000-0000-000000000456/doc-1/7"
);
}
/// A random (v4) id: the kind a collab surface could also hold.
fn random_id(seed: u128) -> uuid::Uuid {
uuid::Builder::from_random_bytes(seed.to_be_bytes()).into_uuid()
}
fn sync_with_session(
id: uuid::Uuid,
exists: bool,
) -> crate::domain::ports::sync::MockDocumentSyncPort {
let mut sync = crate::domain::ports::sync::MockDocumentSyncPort::new();
sync.expect_exists()
.withf(move |document_id| document_id == id.to_string())
.times(1)
.returning(move |_| Box::pin(std::future::ready(Ok(exists))));
sync
}
#[tokio::test]
async fn a_caller_chosen_id_that_already_has_a_session_is_refused() {
let id = random_id(42);
let mut repo = make_mock_repo();
repo.expect_get_owner_team().times(0);
repo.expect_create_document().times(0);
let service = spreadsheet_test_service(repo, sync_with_session(id, true));
let mut document = new_document(FileType::Md);
document.id = Some(id);
let err = DocumentService::create_document(
&service,
&CreationPrincipal::User(test_user()),
document,
None,
)
.await
.unwrap_err();
assert!(matches!(err, DocumentError::Conflict(_)));
}
#[tokio::test]
async fn a_caller_chosen_id_without_a_session_is_created() {
let id = random_id(43);
let mut repo = make_mock_repo();
repo.expect_get_owner_team()
.returning(|_| Box::pin(std::future::ready(Ok(None))));
repo.expect_create_document()
.withf(move |args, _| args.document.id == Some(id))
.times(1)
.returning(|_, _| {
let mut metadata = make_test_metadata();
metadata.file_type = Some("spreadsheet".to_string());
Box::pin(std::future::ready(Ok(metadata)))
});
repo.expect_set_document_content()
.returning(|_, _| Box::pin(std::future::ready(Ok(()))));
repo.expect_get_team_task_metadata()
.returning(|_| Box::pin(std::future::ready(Ok(None))));
let mut sync = sync_with_session(id, false);
sync.expect_initialize_spreadsheet()
.times(1)
.returning(|_| Box::pin(std::future::ready(Ok(()))));
let service = spreadsheet_test_service(repo, sync);
let mut document = spreadsheet_document();
document.id = Some(id);
DocumentService::create_document(
&service,
&CreationPrincipal::User(test_user()),
document,
None,
)
.await
.unwrap();
}
#[tokio::test]
async fn a_deterministic_id_with_a_leftover_session_is_created() {
// Starter documents use v5 ids, which no collab surface can have, so a
// retry after a partial create that left a session still creates them.
let id = uuid::Uuid::new_v5(&uuid::Uuid::NAMESPACE_OID, b"starter-document");
let mut repo = make_mock_repo();
repo.expect_get_owner_team()
.returning(|_| Box::pin(std::future::ready(Ok(None))));
repo.expect_create_document()
.withf(move |args, _| args.document.id == Some(id))
.times(1)
.returning(|_, _| {
let mut metadata = make_test_metadata();
metadata.file_type = Some("spreadsheet".to_string());
Box::pin(std::future::ready(Ok(metadata)))
});
repo.expect_set_document_content()
.returning(|_, _| Box::pin(std::future::ready(Ok(()))));
repo.expect_get_team_task_metadata()
.returning(|_| Box::pin(std::future::ready(Ok(None))));
let mut sync = crate::domain::ports::sync::MockDocumentSyncPort::new();
sync.expect_exists().times(0);
sync.expect_initialize_spreadsheet()
.times(1)
.returning(|_| Box::pin(std::future::ready(Ok(()))));
let service = spreadsheet_test_service(repo, sync);
let mut document = spreadsheet_document();
document.id = Some(id);
DocumentService::create_document(
&service,
&CreationPrincipal::User(test_user()),
document,
None,
)
.await
.unwrap();
}
#[tokio::test]
async fn an_email_import_cannot_choose_its_document_id() {
let mut repo = make_mock_repo();
repo.expect_get_owner_team().times(0);
repo.expect_import_email_attachment_document().times(0);
let mut sync = crate::domain::ports::sync::MockDocumentSyncPort::new();
sync.expect_exists().times(0);
let service = spreadsheet_test_service(repo, sync);
let mut document = new_document(FileType::Pdf);
document.id = Some(random_id(44));
let err = DocumentService::import_email_attachment(
&service,
ImportEmailAttachmentRepoArgs {
email_attachment_id: uuid::Uuid::from_u128(45),
owner: test_user(),
document,
},
)
.await
.unwrap_err();
assert!(matches!(err, DocumentError::BadRequest(_)));
}
#[tokio::test]
async fn user_display_names_join_the_parts_a_user_set() {
for (first, last, expected) in [
(Some(" Jacob "), Some("Beckerman"), Some("Jacob Beckerman")),
(Some("Jacob"), None, Some("Jacob")),
(Some(" "), None, None),
(None, None, None),
] {
let mut repo = make_mock_repo();
repo.expect_get_user_name()
.withf(|user_id| user_id == "macro|[email protected]")
.return_once(move |_| {
Box::pin(std::future::ready(Ok((
first.map(str::to_owned),
last.map(str::to_owned),
))))
});
let name = make_test_service(repo)
.internal_get_user_display_name("macro|[email protected]")
.await
.unwrap();
assert_eq!(name.as_deref(), expected);
}
}
#[tokio::test]
async fn github_pull_request_tasks_are_returned_only_for_visible_pull_requests() {
let visible_task = "00000000-0000-0000-0000-000000000201";
let other_task = "00000000-0000-0000-0000-000000000202";
let hidden_task = "00000000-0000-0000-0000-000000000203";
let short = |id: &str| short_id_for_entity_id(id).unwrap();
let links = vec![
("macro/repo/pull/1".to_string(), short(visible_task)),
("macro/repo/pull/1".to_string(), short(other_task)),
("macro/repo/pull/2".to_string(), short(hidden_task)),
(
"macro/repo/pull/1".to_string(),
"not base58 0OIl".to_string(),
),
];
let mut repo = make_mock_repo();
repo.expect_get_github_pull_request_task_links()
.withf(|keys| {
keys == [
"macro/repo/pull/1".to_string(),
"macro/repo/pull/2".to_string(),
"macro/repo/pull/3".to_string(),
]
})
.return_once(move |_| Box::pin(std::future::ready(Ok(links))));
expect_authenticated_team_lookup(&mut repo, Vec::new());
let service = make_test_service_with_foreign_entities(
repo,
vec![
make_foreign_entity(
uuid::uuid!("00000000-0000-0000-0000-000000000211"),
"macro/repo/pull/1",
GITHUB_PULL_REQUEST_FOREIGN_ENTITY_SOURCE,
"macro|[email protected]",
"user",
),
make_foreign_entity(
uuid::uuid!("00000000-0000-0000-0000-000000000212"),
"macro/repo/pull/2",
GITHUB_PULL_REQUEST_FOREIGN_ENTITY_SOURCE,
"macro|[email protected]",
"user",
),
],
);
let response = service
.get_github_pull_request_tasks(
"macro|[email protected]",
vec![
"macro/repo/pull/3".to_string(),
"macro/repo/pull/1".to_string(),
"macro/repo/pull/2".to_string(),
],
)
.await
.unwrap();
assert_eq!(
response
.pull_requests
.iter()
.map(|pull_request| (
pull_request.github_key.as_str(),
pull_request.task_ids.clone()
))
.collect::<Vec<_>>(),
vec![
("macro/repo/pull/3", vec![]),
(
"macro/repo/pull/1",
vec![visible_task.to_string(), other_task.to_string()]
),
("macro/repo/pull/2", vec![]),
]
);
}
#[tokio::test]
async fn github_pull_request_tasks_reject_oversized_lookups() {
let service = make_test_service(make_mock_repo());
let keys = (1..=101)
.map(|number| format!("macro/repo/pull/{number}"))
.collect();
let result = service
.get_github_pull_request_tasks("macro|[email protected]", keys)
.await;
assert!(matches!(result, Err(DocumentError::BadRequest(_))));
}
#[tokio::test]
async fn task_identity_names_a_team_task_by_its_team_number() {
let document_id = "00000000-0000-0000-0000-000000000301";
let mut repo = make_mock_repo();
repo.expect_get_team_task_number()
.withf(move |id| id == document_id)
.return_once(|_| {
Box::pin(std::future::ready(Ok(Some(TeamTaskNumber {
team_slug: "ENG".to_string(),
task_num: 42,
}))))
});
let service = make_test_service(repo);
let identity = service
.get_task_identity(
authenticated_receipt(document_id),
&task_document_context(document_id),
)
.await
.unwrap();
assert_eq!(
identity,
TaskIdentity {
document_id: document_id.to_string(),
title: "Test task".to_string(),
short_id: short_id_for_entity_id(document_id).unwrap(),
team_task: Some(TeamTaskNumber {
team_slug: "ENG".to_string(),
task_num: 42,
}),
}
);
}
#[tokio::test]
async fn task_identity_rejects_a_document_that_is_not_a_task() {
let document_id = "00000000-0000-0000-0000-000000000302";
let service = make_test_service(make_mock_repo());
let mut document = task_document_context(document_id);
document.sub_type = None;
let result = service
.get_task_identity(authenticated_receipt(document_id), &document)
.await;
assert!(matches!(result, Err(DocumentError::BadRequest(_))));
}
#[tokio::test]
async fn task_identity_treats_a_deleted_task_as_missing() {
let document_id = "00000000-0000-0000-0000-000000000303";
let service = make_test_service(make_mock_repo());
let mut document = task_document_context(document_id);
document.deleted_at = Some(chrono::Utc::now());
let result = service
.get_task_identity(authenticated_receipt(document_id), &document)
.await;
assert!(matches!(result, Err(DocumentError::NotFound(_))));
}
#[tokio::test]
async fn native_canvas_location_uses_sync_without_an_object_url() {
let mut repo = make_mock_repo();
repo.expect_get_persisted_document_content().returning(|_| {
Box::pin(std::future::ready(Ok(Some(DocumentContent::ready(
DocumentContentLocation::SyncService,
)))))
});
let sync = crate::domain::ports::sync::MockDocumentSyncPort::new();
let service = spreadsheet_test_service(repo, sync);
let mut context = task_document_context("doc-1");
context.file_type = Some("canvas".to_string());
context.sub_type = None;
let result = service
.get_document_location(
&context,
authenticated_receipt("doc-1"),
LocationQueryParams {
document_version_id: None,
get_converted_docx_url: None,
},
)
.await
.unwrap();
assert!(matches!(
result,
LocationResponseV3::SyncServiceContent { .. }
));
}
#[tokio::test]
async fn a_document_with_its_own_dates_dates_its_folder_by_them() {
let created_at = chrono::DateTime::parse_from_rfc3339("2021-03-01T00:00:00Z")
.unwrap()
.to_utc();
let updated_at = chrono::DateTime::parse_from_rfc3339("2024-02-01T00:00:00Z")
.unwrap()
.to_utc();
let mut repo = make_mock_repo();
repo.expect_get_owner_team()
.returning(|_| Box::pin(std::future::ready(Ok(None))));
repo.expect_create_document().returning(|_, _| {
let mut metadata = make_test_metadata();
metadata.document_id = "00000000-0000-0000-0000-000000000001".to_string();
Box::pin(std::future::ready(Ok(metadata)))
});
repo.expect_set_document_content()
.returning(|_, _| Box::pin(std::future::ready(Ok(()))));
repo.expect_get_team_task_metadata()
.returning(|_| Box::pin(std::future::ready(Ok(None))));
repo.expect_update_project_modified().times(0);
repo.expect_extend_project_dates()
.withf(move |project_id, created, updated| {
project_id == "00000000-0000-0000-0000-000000000009"
&& *created == created_at
&& *updated == updated_at
})
.times(1)
.returning(|_, _, _| Box::pin(std::future::ready(Ok(()))));
let (service, _event_broker) = make_test_service_with_event_broker(repo);
let mut document = new_document(FileType::Txt);
document.project_id = Some(uuid::Uuid::from_u128(9));
document.created_at = Some(created_at);
document.updated_at = Some(updated_at);
crate::domain::ports::DocumentService::create_document(
&service,
&CreationPrincipal::User(test_user()),
document,
None,
)
.await
.unwrap();
}
#[tokio::test]
async fn a_document_without_dates_marks_its_folder_updated_now() {
let mut repo = make_mock_repo();
repo.expect_get_owner_team()
.returning(|_| Box::pin(std::future::ready(Ok(None))));
repo.expect_create_document().returning(|_, _| {
let mut metadata = make_test_metadata();
metadata.document_id = "00000000-0000-0000-0000-000000000001".to_string();
Box::pin(std::future::ready(Ok(metadata)))
});
repo.expect_set_document_content()
.returning(|_, _| Box::pin(std::future::ready(Ok(()))));
repo.expect_get_team_task_metadata()
.returning(|_| Box::pin(std::future::ready(Ok(None))));
repo.expect_extend_project_dates().times(0);
repo.expect_update_project_modified()
.withf(|project_id| project_id == "00000000-0000-0000-0000-000000000009")
.times(1)
.returning(|_| Box::pin(std::future::ready(Ok(()))));
let (service, _event_broker) = make_test_service_with_event_broker(repo);
let mut document = new_document(FileType::Txt);
document.project_id = Some(uuid::Uuid::from_u128(9));
crate::domain::ports::DocumentService::create_document(
&service,
&CreationPrincipal::User(test_user()),
document,
None,
)
.await
.unwrap();
}