Skip to content

armgit / macro

Public Imported from GitHub
0

Macro is a unified workspace for teams: email, chat, docs, tasks, agents, calls, and CRM — @-linked together with shared AI memory.

21.8 KB
Raw Blame
//! Generated-query cache inspection integration tests.

use cache_core::engine::{BeginOptimisticWrite, Engine};
use cache_core::link_patch::{
    LinkOperation, LinkPathSegment, ListItemByScalar, OptimisticLinkPatch,
};
use cache_core::predicate::{OptimisticUpsertReconciliation, ProjectionMutation};
use cache_core::query_inspection::{MAX_INSPECTED_VARIANTS, QueryInspection, QueryInspectionError};
use cache_core::queue::{
    ClaimedMutation, MutationClaimRequest, MutationClaimToken, MutationId, MutationUpsertResult,
    NewQueuedMutation, QueuedMutation,
};
use cache_core::store::{InMemoryStorage, Storage};
use cache_core::value::{EntityKey, Record};
use pollster::block_on;
use serde_json::{Value as Json, json};

const GROUP_QUERY: &str = r#"
query GroupViews($input: GroupedSoupInput!) {
  user {
    id
    groupSoup(input: $input) {
      bins { key nextCursor items { __typename id } }
    }
  }
}
"#;

const SHORT_GROUP_QUERY: &str = r#"
query GroupViews($input: GroupedSoupInput!) {
  user { id groupSoup(input: $input) { bins { key items { __typename id } } } }
}
"#;

fn object(value: Json) -> serde_json::Map<String, Json> {
    let Json::Object(value) = value else {
        unreachable!()
    };
    value
}

fn initial(limit: usize) -> serde_json::Map<String, Json> {
    object(json!({"input": {"initial": {
        "groupBy": {"field": "PROPERTY", "propertyDefinitionId": "status-def"},
        "limit": limit
    }}}))
}

fn continuation(cursor: &str) -> serde_json::Map<String, Json> {
    object(json!({"input": {"continuation": {
        "groupBy": {"field": "PROPERTY", "propertyDefinitionId": "status-def"},
        "groupKey": "in-progress",
        "cursor": cursor
    }}}))
}

fn page(item: &str, next_cursor: Option<&str>) -> Json {
    json!({"user": {"id": "user-1", "groupSoup": {"bins": [{
        "key": "in-progress",
        "nextCursor": next_cursor,
        "items": [{"__typename": "GraphqlSoupDocument", "id": item}]
    }]}}})
}

fn inspection(query: &str, path: &[&str]) -> QueryInspection {
    QueryInspection {
        query: query.to_string(),
        operation_name: Some("GroupViews".to_string()),
        path: path.iter().map(|part| (*part).to_string()).collect(),
        variable_filters: Vec::new(),
    }
}

async fn write_group(
    engine: &mut Engine<InMemoryStorage>,
    query: &str,
    variables: &serde_json::Map<String, Json>,
    data: &Json,
) {
    engine
        .write_query(None, query, Some("GroupViews"), variables, data, None)
        .await
        .unwrap();
}

#[derive(Clone, Debug)]
struct OwnerOnlyStorage(InMemoryStorage);

impl Storage for OwnerOnlyStorage {
    type Error = std::convert::Infallible;

    async fn get_batch(&self, keys: &[EntityKey<'_>]) -> Result<Vec<Option<Record>>, Self::Error> {
        assert!(
            keys.iter()
                .all(|key| key.is_root() || key.0 == "GraphqlUser:user-1"),
            "variables-only inspection loaded a non-owner record: {keys:?}"
        );
        self.0.get_batch(keys).await
    }

    async fn put_batch(
        &mut self,
        entries: Vec<(EntityKey<'static>, Record)>,
    ) -> Result<(), Self::Error> {
        self.0.put_batch(entries).await
    }

    async fn put_batch_with_projections(
        &mut self,
        entries: Vec<(EntityKey<'static>, Record)>,
        projections: Vec<ProjectionMutation>,
    ) -> Result<(), Self::Error> {
        self.0
            .put_batch_with_projections(entries, projections)
            .await
    }

    async fn delete_batch(&mut self, keys: &[EntityKey<'static>]) -> Result<(), Self::Error> {
        self.0.delete_batch(keys).await
    }

    async fn upsert_mutation_with_shadow(
        &mut self,
        entry: NewQueuedMutation,
        now_ms: i64,
        reconciliation: OptimisticUpsertReconciliation,
    ) -> Result<MutationUpsertResult, Self::Error> {
        self.0
            .upsert_mutation_with_shadow(entry, now_ms, reconciliation)
            .await
    }

    async fn load_mutation_queue(&self) -> Result<Vec<QueuedMutation>, Self::Error> {
        self.0.load_mutation_queue().await
    }

    async fn claim_next_mutation(
        &mut self,
        request: MutationClaimRequest,
    ) -> Result<Option<ClaimedMutation>, Self::Error> {
        self.0.claim_next_mutation(request).await
    }

    async fn defer_mutation(
        &mut self,
        id: MutationId,
        claim: MutationClaimToken,
        next_attempt_at_ms: i64,
        error: String,
        server_failure: bool,
    ) -> Result<bool, Self::Error> {
        self.0
            .defer_mutation(id, claim, next_attempt_at_ms, error, server_failure)
            .await
    }

    async fn complete_mutation(
        &mut self,
        id: MutationId,
        claim: MutationClaimToken,
        entries: Vec<(EntityKey<'static>, Record)>,
    ) -> Result<bool, Self::Error> {
        self.0.complete_mutation(id, claim, entries).await
    }

    async fn complete_mutation_with_projections(
        &mut self,
        id: MutationId,
        claim: MutationClaimToken,
        entries: Vec<(EntityKey<'static>, Record)>,
        projections: Vec<ProjectionMutation>,
    ) -> Result<bool, Self::Error> {
        self.0
            .complete_mutation_with_projections(id, claim, entries, projections)
            .await
    }

    async fn discard_mutation(
        &mut self,
        id: MutationId,
        claim: MutationClaimToken,
    ) -> Result<bool, Self::Error> {
        self.0.discard_mutation(id, claim).await
    }

    async fn clear(&mut self) -> Result<(), Self::Error> {
        self.0.clear().await
    }

    async fn reset_with_records(
        &mut self,
        entries: Vec<(EntityKey<'static>, Record)>,
        projections: Vec<ProjectionMutation>,
    ) -> Result<(), Self::Error> {
        self.0.reset_with_records(entries, projections).await
    }
}

#[test]
fn variants_only_recovers_pages_without_loading_items() {
    block_on(async {
        let mut writer = Engine::new(InMemoryStorage::new());
        let initial_variables = initial(20);
        let continuation_variables = continuation("cursor-1");
        write_group(
            &mut writer,
            GROUP_QUERY,
            &initial_variables,
            &page("task-1", None),
        )
        .await;
        write_group(
            &mut writer,
            GROUP_QUERY,
            &continuation_variables,
            &page("task-2", Some("cursor-2")),
        )
        .await;

        let storage = OwnerOnlyStorage(writer.storage().clone());
        let mut reopened = Engine::new(storage);
        let variants = reopened
            .inspect_query_variants(&inspection(GROUP_QUERY, &["user", "groupSoup"]))
            .await
            .unwrap();

        assert_eq!(variants.len(), 2);
        assert!(
            variants
                .iter()
                .any(|variant| variant.variables == initial_variables)
        );
        assert!(
            variants
                .iter()
                .any(|variant| variant.variables == continuation_variables)
        );
    });
}

#[test]
fn enumerates_variants_aliases_and_misses_in_canonical_order() {
    block_on(async {
        let mut engine = Engine::new(InMemoryStorage::new());
        write_group(
            &mut engine,
            GROUP_QUERY,
            &initial(20),
            &page("task-1", None),
        )
        .await;
        write_group(
            &mut engine,
            GROUP_QUERY,
            &continuation("cursor-1"),
            &page("task-2", Some("cursor-2")),
        )
        .await;
        // This creates a third `groupSoup` variant, but not enough selected
        // fields for the full inspection query to be a hit.
        write_group(
            &mut engine,
            SHORT_GROUP_QUERY,
            &initial(50),
            &page("task-3", None),
        )
        .await;

        // A different schema field on the same normalized user is ignored.
        let soup_query =
            "query Soup($input: SoupInput!) { user { id soup(input: $input) { nextCursor } } }";
        engine
            .write_query(
                None,
                soup_query,
                Some("Soup"),
                &object(json!({"input": {"initial": {"limit": 20}}})),
                &json!({"user": {"id": "user-1", "soup": {"nextCursor": null}}}),
                None,
            )
            .await
            .unwrap();

        let aliased = GROUP_QUERY
            .replace("user {", "viewer: user {")
            .replace("groupSoup(input:", "grouped: groupSoup(input:");
        let results = engine
            .inspect_query(&inspection(&aliased, &["viewer", "grouped"]))
            .await
            .unwrap();

        assert_eq!(results.len(), 3);
        assert!(results.windows(2).all(|pair| {
            serde_json::to_string(&pair[0].variables).unwrap()
                < serde_json::to_string(&pair[1].variables).unwrap()
        }));
        let miss = results
            .iter()
            .find(|result| result.variables == initial(50))
            .unwrap();
        assert_eq!(miss.value, None);
        let hit = results
            .iter()
            .find(|result| result.variables == initial(20))
            .unwrap();
        assert_eq!(
            hit.value.as_ref().unwrap()["bins"][0]["items"][0]["id"],
            "task-1"
        );
    });
}

#[test]
fn materializes_only_variants_matching_recursive_variable_filters() {
    block_on(async {
        let mut engine = Engine::new(InMemoryStorage::new());
        let status_initial = initial(20);
        let status_continuation = continuation("cursor-1");
        let priority_initial = object(json!({"input": {"initial": {
            "groupBy": {"field": "PROPERTY", "propertyDefinitionId": "priority-def"},
            "limit": 20
        }}}));
        write_group(
            &mut engine,
            GROUP_QUERY,
            &status_initial,
            &page("task-1", None),
        )
        .await;
        write_group(
            &mut engine,
            GROUP_QUERY,
            &status_continuation,
            &page("task-2", None),
        )
        .await;
        write_group(
            &mut engine,
            GROUP_QUERY,
            &priority_initial,
            &page("task-3", None),
        )
        .await;

        let mut filtered = inspection(GROUP_QUERY, &["user", "groupSoup"]);
        filtered.variable_filters = vec![
            object(json!({"input": {"initial": {"groupBy": {
                "field": "PROPERTY",
                "propertyDefinitionId": "status-def"
            }}}})),
            object(json!({"input": {"continuation": {"groupBy": {
                "field": "PROPERTY",
                "propertyDefinitionId": "status-def"
            }}}})),
        ];
        let results = engine.inspect_query(&filtered).await.unwrap();

        assert_eq!(results.len(), 2);
        assert!(
            results
                .iter()
                .any(|result| result.variables == status_initial)
        );
        assert!(
            results
                .iter()
                .any(|result| result.variables == status_continuation)
        );
        assert!(
            results
                .iter()
                .all(|result| result.variables != priority_initial)
        );
    });
}

#[test]
fn recovers_nested_constants_lists_and_repeated_variables() {
    block_on(async {
        let query = r#"
query GroupViews($same: String!, $cursor: String!) {
  user {
    id
    groupSoup(input: {
      markers: [$same, "fixed"]
      continuation: {
        groupBy: { field: $same, propertyDefinitionId: $same }
        groupKey: "in-progress"
        cursor: $cursor
      }
    }) { bins { key nextCursor items { __typename id } } }
  }
}
"#;
        let variables = object(json!({"same": "PROPERTY", "cursor": "cursor-1"}));
        let mut engine = Engine::new(InMemoryStorage::new());
        write_group(&mut engine, query, &variables, &page("task-1", None)).await;

        let results = engine
            .inspect_query(&inspection(query, &["user", "groupSoup"]))
            .await
            .unwrap();
        assert_eq!(results.len(), 1);
        assert_eq!(results[0].variables, variables);

        // The same stored arguments do not match a different constant.
        let mismatch = query.replace("groupKey: \"in-progress\"", "groupKey: \"done\"");
        assert!(
            engine
                .inspect_query(&inspection(&mismatch, &["user", "groupSoup"]))
                .await
                .unwrap()
                .is_empty()
        );
    });
}

#[test]
fn traverses_constant_only_prefix_fields() {
    block_on(async {
        let query = GROUP_QUERY.replace("user {", "user(scope: \"all\") {");
        let mut engine = Engine::new(InMemoryStorage::new());
        write_group(&mut engine, &query, &initial(20), &page("task-1", None)).await;

        let results = engine
            .inspect_query(&inspection(&query, &["user", "groupSoup"]))
            .await
            .unwrap();
        assert_eq!(results.len(), 1);
        assert_eq!(results[0].variables, initial(20));
    });
}

#[test]
fn loads_a_cold_normalized_owner() {
    block_on(async {
        let mut writer = Engine::with_capacity(InMemoryStorage::new(), 1);
        write_group(
            &mut writer,
            GROUP_QUERY,
            &initial(20),
            &page("task-1", None),
        )
        .await;

        let mut reopened = Engine::with_capacity(writer.storage().clone(), 1);
        let results = reopened
            .inspect_query(&inspection(GROUP_QUERY, &["user", "groupSoup"]))
            .await
            .unwrap();
        assert_eq!(results.len(), 1);
        assert!(results[0].value.is_some());
    });
}

#[test]
fn inspection_reads_the_effective_optimistic_view() {
    block_on(async {
        let mut engine = Engine::new(InMemoryStorage::new());
        let variables = initial(20);
        let data = json!({"user": {"id": "user-1", "groupSoup": {"bins": [
            {"key": "in-progress", "nextCursor": null, "items": [{"__typename": "GraphqlSoupDocument", "id": "task-1"}]},
            {"key": "completed", "nextCursor": null, "items": []}
        ]}}});
        write_group(&mut engine, GROUP_QUERY, &variables, &data).await;

        let patch = OptimisticLinkPatch {
            record_root: None,
            query: GROUP_QUERY.to_string(),
            operation_name: Some("GroupViews".to_string()),
            variables_json: serde_json::to_string(&variables).unwrap(),
            path: vec![
                LinkPathSegment::Field {
                    field: "user".into(),
                },
                LinkPathSegment::Field {
                    field: "groupSoup".into(),
                },
                LinkPathSegment::Field {
                    field: "bins".into(),
                },
                LinkPathSegment::ListItem {
                    list_item: ListItemByScalar {
                        where_field: "key".into(),
                        equals: json!("in-progress"),
                    },
                },
                LinkPathSegment::Field {
                    field: "items".into(),
                },
            ],
            operation: LinkOperation::Remove {
                entity_key: EntityKey("GraphqlSoupDocument:task-1".into()),
            },
        };
        let mutation = r#"
mutation SetEntityProperty($input: SetEntityPropertyInput!) {
  setEntityProperty(input: $input) { id }
}
"#;
        let mutation_variables = object(json!({"input": {
            "entityType": "DOCUMENT",
            "entityId": "task-1",
            "propertyDefinitionId": "status-def"
        }}));
        engine
            .begin_optimistic_write(
                None,
                BeginOptimisticWrite {
                    client_metadata: None,
                    uuid: "00000000-0000-4000-8000-000000000002",
                    query: mutation,
                    operation_name: Some("SetEntityProperty"),
                    variables: &mutation_variables,
                    data: &json!({"setEntityProperty": {"id": "property-1"}}),
                    link_patches: &[patch],
                    revalidations: &[],
                    created_at_ms: 0,
                    identity_bindings: &[],
                },
            )
            .await
            .unwrap();

        let results = engine
            .inspect_query(&inspection(GROUP_QUERY, &["user", "groupSoup"]))
            .await
            .unwrap();
        assert!(
            results[0].value.as_ref().unwrap()["bins"][0]["items"]
                .as_array()
                .unwrap()
                .is_empty()
        );
    });
}

#[test]
fn rejects_invalid_entrypoints_paths_variables_and_limits() {
    block_on(async {
        let mut engine = Engine::new(InMemoryStorage::new());
        write_group(
            &mut engine,
            GROUP_QUERY,
            &initial(20),
            &page("task-1", None),
        )
        .await;

        let mutation = QueryInspection {
            query: "mutation GroupViews { renameFile(input: {}) { id } }".into(),
            operation_name: Some("GroupViews".into()),
            path: vec!["renameFile".into()],
            variable_filters: Vec::new(),
        };
        assert!(matches!(
            engine.inspect_query(&mutation).await.unwrap_err(),
            cache_core::engine::EngineError::QueryInspection(QueryInspectionError::NotQuery)
        ));
        assert!(matches!(
            engine
                .inspect_query(&inspection(GROUP_QUERY, &[]))
                .await
                .unwrap_err(),
            cache_core::engine::EngineError::QueryInspection(QueryInspectionError::InvalidDepth(0))
        ));
        assert!(matches!(
            engine
                .inspect_query(&inspection(GROUP_QUERY, &["user", "id"]))
                .await
                .unwrap_err(),
            cache_core::engine::EngineError::QueryInspection(
                QueryInspectionError::NonCompositeFinalField
            )
        ));
        let too_deep = vec!["user"; 17];
        assert!(matches!(
            engine
                .inspect_query(&inspection(GROUP_QUERY, &too_deep))
                .await
                .unwrap_err(),
            cache_core::engine::EngineError::QueryInspection(QueryInspectionError::InvalidDepth(
                17
            ))
        ));
        let list_path_query = r#"
query GroupViews {
  user {
    groupSoup(input: { initial: {
      groupBy: { field: PROPERTY, propertyDefinitionId: "status-def" }
      limit: 20
    } }) { bins { items { __typename id } } }
  }
}
"#;
        write_group(
            &mut engine,
            list_path_query,
            &serde_json::Map::new(),
            &page("task-1", None),
        )
        .await;
        assert!(matches!(
            engine
                .inspect_query(&inspection(
                    list_path_query,
                    &["user", "groupSoup", "bins", "items"]
                ))
                .await
                .unwrap_err(),
            cache_core::engine::EngineError::QueryInspection(QueryInspectionError::WrongShape)
        ));
        assert!(matches!(
            engine
                .inspect_query(&inspection(GROUP_QUERY, &["user", "missing"]))
                .await
                .unwrap_err(),
            cache_core::engine::EngineError::QueryInspection(
                QueryInspectionError::UnselectedField { .. }
            )
        ));

        let prefix_variable = r#"
query GroupViews($id: String!, $input: GroupedSoupInput!) {
  user(id: $id) { groupSoup(input: $input) { bins { key } } }
}
"#;
        assert!(matches!(
            engine
                .inspect_query(&inspection(prefix_variable, &["user", "groupSoup"]))
                .await
                .unwrap_err(),
            cache_core::engine::EngineError::QueryInspection(QueryInspectionError::VariablePrefix(
                _
            ))
        ));

        let unresolved = r#"
query GroupViews($input: GroupedSoupInput!, $other: Int!) {
  user { groupSoup(input: $input) { bins(limit: $other) { key } } }
}
"#;
        assert!(matches!(
            engine
                .inspect_query(&inspection(unresolved, &["user", "groupSoup"]))
                .await
                .unwrap_err(),
            cache_core::engine::EngineError::QueryInspection(
                QueryInspectionError::UnrecoverableVariable(_)
            )
        ));

        let ambiguous = r#"
query GroupViews($input: GroupedSoupInput!) {
  user {
    groupSoup(input: $input) { bins { key } }
    groupSoup(input: $input) { bins { key } }
  }
}
"#;
        assert!(matches!(
            engine
                .inspect_query(&inspection(ambiguous, &["user", "groupSoup"]))
                .await
                .unwrap_err(),
            cache_core::engine::EngineError::QueryInspection(
                QueryInspectionError::AmbiguousField { .. }
            )
        ));

        // Legacy storage can exceed today's retention budget. Bypass normal
        // writes to keep exercising the inspection boundary's defensive cap.
        let mut storage = engine.into_storage();
        let key = EntityKey("GraphqlUser:user-1".into());
        let mut record = storage
            .get_batch(std::slice::from_ref(&key))
            .await
            .unwrap()
            .remove(0)
            .unwrap();
        for limit in 0..=MAX_INSPECTED_VARIANTS {
            record.fields.insert(
                format!("groupSoup({{\"input\":{{\"initial\":{{\"limit\":{limit}}}}}}})"),
                cache_core::value::CacheValue::Null,
            );
        }
        storage.put_batch(vec![(key, record)]).await.unwrap();
        let mut engine = Engine::new(storage);
        assert!(matches!(
            engine
                .inspect_query(&inspection(GROUP_QUERY, &["user", "groupSoup"]))
                .await
                .unwrap_err(),
            cache_core::engine::EngineError::QueryInspection(
                QueryInspectionError::TooManyVariants { .. }
            )
        ));
    });
}