1use crate::{
2 CreateTicketInput, MAX_TICKET_LIST_FETCH_LIMIT, Ticket, TicketFromHandoffInput, TicketId,
3 TicketRequester, TicketStatus, TicketValidationError,
4};
5use async_trait::async_trait;
6use chrono::{DateTime, Utc};
7use minco_interaction::{
8 SupportHandoff, SupportHandoffDigest, SupportHandoffResult, SupportHandoffToken,
9};
10use serde::{Deserialize, Serialize};
11use sha2::{Digest, Sha256};
12use std::{
13 collections::{BTreeMap, BTreeSet},
14 fmt,
15 sync::Arc,
16};
17use subtle::ConstantTimeEq;
18use tokio::sync::Mutex;
19use uuid::Uuid;
20
21#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
22pub struct TicketActivityIntent {
23 pub id: Uuid,
24 pub project_id: String,
25 pub ticket_id: TicketId,
26 pub kind: String,
27 pub correlation_id: Uuid,
28 pub payload: serde_json::Value,
29 pub created_at: DateTime<Utc>,
30}
31
32impl TicketActivityIntent {
33 #[must_use]
34 pub fn new(
35 project_id: impl Into<String>,
36 ticket_id: TicketId,
37 kind: impl Into<String>,
38 correlation_id: Uuid,
39 payload: serde_json::Value,
40 created_at: DateTime<Utc>,
41 ) -> Self {
42 Self {
43 id: Uuid::now_v7(),
44 project_id: project_id.into(),
45 ticket_id,
46 kind: kind.into(),
47 correlation_id,
48 payload,
49 created_at,
50 }
51 }
52}
53
54#[derive(Debug, Clone, Default, PartialEq, Eq)]
55pub struct TicketListFilter {
56 pub project_id: String,
57 pub statuses: BTreeSet<TicketStatus>,
58 pub queue_id: Option<String>,
59 pub assignee_subject: Option<String>,
60 pub requester_subject: Option<String>,
61 pub after_updated_at: Option<DateTime<Utc>>,
62 pub after_id: Option<TicketId>,
63 pub limit: usize,
64}
65
66#[derive(Clone, PartialEq, Eq)]
67pub struct ConsumeHandoffRequest {
68 pub token: SupportHandoffToken,
69 pub project_id: String,
70 pub portal_origin: String,
71 pub input: TicketFromHandoffInput,
72 pub request_fingerprint: String,
73 pub now: DateTime<Utc>,
74}
75
76impl fmt::Debug for ConsumeHandoffRequest {
77 fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
78 formatter
79 .debug_struct("ConsumeHandoffRequest")
80 .field("token", &self.token)
81 .field("project_id", &self.project_id)
82 .field("portal_origin", &self.portal_origin)
83 .field("input", &"[BOUNDED]")
84 .field("request_fingerprint", &"[REDACTED]")
85 .field("now", &self.now)
86 .finish()
87 }
88}
89
90impl ConsumeHandoffRequest {
91 pub fn new(
92 token: SupportHandoffToken,
93 project_id: impl Into<String>,
94 portal_origin: impl Into<String>,
95 input: TicketFromHandoffInput,
96 now: DateTime<Utc>,
97 ) -> Result<Self, TicketStoreError> {
98 let project_id = project_id.into();
99 let portal_origin = portal_origin.into();
100 let serialized = serde_json::to_vec(&serde_json::json!({
101 "project_id": project_id,
102 "portal_origin": portal_origin,
103 "subject": input.subject,
104 "description": input.description,
105 "channel": input.channel,
106 "priority": input.priority,
107 }))
108 .map_err(|error| TicketStoreError::Infrastructure(error.to_string()))?;
109 Ok(Self {
110 token,
111 project_id,
112 portal_origin,
113 input,
114 request_fingerprint: hex::encode(Sha256::digest(serialized)),
115 now,
116 })
117 }
118}
119
120#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
121pub struct ConsumedHandoff {
122 pub ticket: Ticket,
123 pub result: SupportHandoffResult,
124 pub repeated: bool,
125}
126
127#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
128pub struct ExternalMessageIdentity {
129 pub project_id: String,
130 pub provider: String,
131 pub mailbox_scope: String,
132 pub external_id: String,
133 pub content_sha256: String,
134 pub raw_message_object_key: Option<String>,
135 pub internet_message_id: Option<String>,
136 pub in_reply_to: Option<String>,
137 pub references: Vec<String>,
138}
139
140#[derive(Debug, Clone, PartialEq, Eq)]
141pub struct IngestExternalMessageRequest {
142 pub identity: ExternalMessageIdentity,
143 pub ticket_id: TicketId,
144 pub body: String,
145 pub expected_revision: u64,
146 pub correlation_id: Uuid,
147 pub now: DateTime<Utc>,
148}
149
150#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
151pub struct ExternalMessageIngestResult {
152 pub ticket: Ticket,
153 pub repeated: bool,
154}
155
156#[async_trait]
157pub trait TicketingStore: Send + Sync + fmt::Debug {
158 async fn create(
159 &self,
160 ticket: Ticket,
161 intent: TicketActivityIntent,
162 ) -> Result<(), TicketStoreError>;
163
164 async fn get(&self, project_id: &str, id: TicketId)
165 -> Result<Option<Ticket>, TicketStoreError>;
166
167 async fn list(&self, filter: TicketListFilter) -> Result<Vec<Ticket>, TicketStoreError>;
168
169 async fn save(
170 &self,
171 ticket: Ticket,
172 expected_revision: u64,
173 intent: TicketActivityIntent,
174 ) -> Result<(), TicketStoreError>;
175
176 async fn insert_handoff(&self, handoff: SupportHandoff) -> Result<(), TicketStoreError>;
177
178 async fn consume_and_create_ticket(
179 &self,
180 request: ConsumeHandoffRequest,
181 ) -> Result<ConsumedHandoff, TicketStoreError>;
182
183 async fn ingest_external_message(
184 &self,
185 request: IngestExternalMessageRequest,
186 ) -> Result<ExternalMessageIngestResult, TicketStoreError>;
187
188 async fn ready(&self) -> Result<(), TicketStoreError> {
189 Ok(())
190 }
191}
192
193#[derive(Clone)]
194pub struct TicketingStoreService(pub Arc<dyn TicketingStore>);
195
196impl fmt::Debug for TicketingStoreService {
197 fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
198 formatter.debug_tuple("TicketingStoreService").finish()
199 }
200}
201
202impl TicketingStoreService {
203 pub fn new(store: Arc<dyn TicketingStore>) -> Self {
204 Self(store)
205 }
206
207 pub async fn create(
208 &self,
209 ticket: Ticket,
210 intent: TicketActivityIntent,
211 ) -> Result<(), TicketStoreError> {
212 self.0.create(ticket, intent).await
213 }
214
215 pub async fn get(
216 &self,
217 project_id: &str,
218 id: TicketId,
219 ) -> Result<Option<Ticket>, TicketStoreError> {
220 self.0.get(project_id, id).await
221 }
222
223 pub async fn list(&self, filter: TicketListFilter) -> Result<Vec<Ticket>, TicketStoreError> {
224 self.0.list(filter).await
225 }
226
227 pub async fn save(
228 &self,
229 ticket: Ticket,
230 expected_revision: u64,
231 intent: TicketActivityIntent,
232 ) -> Result<(), TicketStoreError> {
233 self.0.save(ticket, expected_revision, intent).await
234 }
235
236 pub async fn insert_handoff(&self, handoff: SupportHandoff) -> Result<(), TicketStoreError> {
237 self.0.insert_handoff(handoff).await
238 }
239
240 pub async fn consume_and_create_ticket(
241 &self,
242 request: ConsumeHandoffRequest,
243 ) -> Result<ConsumedHandoff, TicketStoreError> {
244 self.0.consume_and_create_ticket(request).await
245 }
246
247 pub async fn ingest_external_message(
248 &self,
249 request: IngestExternalMessageRequest,
250 ) -> Result<ExternalMessageIngestResult, TicketStoreError> {
251 self.0.ingest_external_message(request).await
252 }
253
254 pub async fn ready(&self) -> Result<(), TicketStoreError> {
255 self.0.ready().await
256 }
257}
258
259#[derive(Debug, Clone)]
260struct MemoryHandoff {
261 handoff: SupportHandoff,
262 completed_fingerprint: Option<String>,
263}
264
265#[derive(Debug, Clone, Default)]
266struct MemoryState {
267 tickets: BTreeMap<(String, TicketId), Ticket>,
268 display_counters: BTreeMap<String, u64>,
269 handoffs: BTreeMap<SupportHandoffDigest, MemoryHandoff>,
270 external_messages:
271 BTreeMap<(String, String, String, String), (ExternalMessageIdentity, TicketId)>,
272 activity_intents: Vec<TicketActivityIntent>,
273 fail_next_handoff_commit: bool,
274}
275
276#[derive(Debug, Default)]
277pub struct MemoryTicketingStore {
278 state: Mutex<MemoryState>,
279}
280
281impl MemoryTicketingStore {
282 pub async fn activity_intents(&self) -> Vec<TicketActivityIntent> {
283 self.state.lock().await.activity_intents.clone()
284 }
285
286 pub async fn fail_next_handoff_commit(&self) {
287 self.state.lock().await.fail_next_handoff_commit = true;
288 }
289
290 pub async fn ticket_count(&self) -> usize {
291 self.state.lock().await.tickets.len()
292 }
293
294 pub async fn handoff_consumed(&self, digest: &SupportHandoffDigest) -> bool {
295 self.state
296 .lock()
297 .await
298 .handoffs
299 .get(digest)
300 .is_some_and(|entry| entry.handoff.consumed_result.is_some())
301 }
302}
303
304#[async_trait]
305impl TicketingStore for MemoryTicketingStore {
306 async fn create(
307 &self,
308 ticket: Ticket,
309 intent: TicketActivityIntent,
310 ) -> Result<(), TicketStoreError> {
311 let mut state = self.state.lock().await;
312 let key = (ticket.project_id.clone(), ticket.id);
313 if state.tickets.contains_key(&key) {
314 return Err(TicketStoreError::DuplicateTicket(ticket.id));
315 }
316 if state.tickets.values().any(|existing| {
317 existing.project_id == ticket.project_id
318 && existing.display_reference == ticket.display_reference
319 }) {
320 return Err(TicketStoreError::DuplicateDisplayReference);
321 }
322 state.tickets.insert(key, ticket);
323 state.activity_intents.push(intent);
324 drop(state);
325 Ok(())
326 }
327
328 async fn get(
329 &self,
330 project_id: &str,
331 id: TicketId,
332 ) -> Result<Option<Ticket>, TicketStoreError> {
333 Ok(self
334 .state
335 .lock()
336 .await
337 .tickets
338 .get(&(project_id.to_owned(), id))
339 .cloned())
340 }
341
342 async fn list(&self, filter: TicketListFilter) -> Result<Vec<Ticket>, TicketStoreError> {
343 if !(1..=MAX_TICKET_LIST_FETCH_LIMIT).contains(&filter.limit) {
344 return Err(TicketStoreError::InvalidListLimit);
345 }
346 if filter.after_updated_at.is_some() != filter.after_id.is_some() {
347 return Err(TicketStoreError::InvalidListCursor);
348 }
349 let mut values = self
350 .state
351 .lock()
352 .await
353 .tickets
354 .values()
355 .filter(|ticket| ticket.project_id == filter.project_id)
356 .filter(|ticket| filter.statuses.is_empty() || filter.statuses.contains(&ticket.status))
357 .filter(|ticket| {
358 filter
359 .queue_id
360 .as_ref()
361 .is_none_or(|value| ticket.queue_id.as_ref() == Some(value))
362 })
363 .filter(|ticket| {
364 filter
365 .assignee_subject
366 .as_ref()
367 .is_none_or(|value| ticket.assignee_subject.as_ref() == Some(value))
368 })
369 .filter(|ticket| {
370 filter
371 .requester_subject
372 .as_ref()
373 .is_none_or(|value| &ticket.requester.subject == value)
374 })
375 .filter(|ticket| match (filter.after_updated_at, filter.after_id) {
376 (Some(updated), Some(id)) => (ticket.updated_at, ticket.id) > (updated, id),
377 _ => true,
378 })
379 .cloned()
380 .collect::<Vec<_>>();
381 values.sort_by_key(|ticket| (ticket.updated_at, ticket.id));
382 values.truncate(filter.limit);
383 Ok(values)
384 }
385
386 async fn save(
387 &self,
388 ticket: Ticket,
389 expected_revision: u64,
390 intent: TicketActivityIntent,
391 ) -> Result<(), TicketStoreError> {
392 let mut state = self.state.lock().await;
393 let key = (ticket.project_id.clone(), ticket.id);
394 let existing = state
395 .tickets
396 .get(&key)
397 .ok_or(TicketStoreError::NotFound(ticket.id))?;
398 if existing.revision != expected_revision || ticket.revision <= expected_revision {
399 return Err(TicketStoreError::StaleRevision {
400 expected: expected_revision,
401 actual: existing.revision,
402 });
403 }
404 state.tickets.insert(key, ticket);
405 state.activity_intents.push(intent);
406 drop(state);
407 Ok(())
408 }
409
410 async fn insert_handoff(&self, handoff: SupportHandoff) -> Result<(), TicketStoreError> {
411 let mut state = self.state.lock().await;
412 if state.handoffs.contains_key(&handoff.digest) {
413 return Err(TicketStoreError::DuplicateHandoff);
414 }
415 state.handoffs.insert(
416 handoff.digest.clone(),
417 MemoryHandoff {
418 handoff,
419 completed_fingerprint: None,
420 },
421 );
422 drop(state);
423 Ok(())
424 }
425
426 async fn consume_and_create_ticket(
427 &self,
428 request: ConsumeHandoffRequest,
429 ) -> Result<ConsumedHandoff, TicketStoreError> {
430 let mut state = self.state.lock().await;
431 let mut staged = state.clone();
432 let digest = request.token.digest();
433 let matched_digest = staged
434 .handoffs
435 .keys()
436 .find(|candidate| {
437 candidate
438 .as_str()
439 .as_bytes()
440 .ct_eq(digest.as_str().as_bytes())
441 .into()
442 })
443 .cloned()
444 .ok_or(TicketStoreError::UnknownHandoff)?;
445 let entry = staged
446 .handoffs
447 .get_mut(&matched_digest)
448 .expect("matched key exists");
449 if entry.handoff.project_id != request.project_id {
450 return Err(TicketStoreError::WrongHandoffProject);
451 }
452 if entry.handoff.portal_origin != request.portal_origin {
453 return Err(TicketStoreError::WrongHandoffPortal);
454 }
455 if let Some(result) = entry.handoff.consumed_result.clone() {
456 if entry.completed_fingerprint.as_deref() != Some(&request.request_fingerprint) {
457 return Err(TicketStoreError::HandoffAlreadyConsumed);
458 }
459 let ticket = staged
460 .tickets
461 .get(&(request.project_id.clone(), TicketId(result.ticket_id)))
462 .cloned()
463 .ok_or_else(|| {
464 TicketStoreError::Infrastructure("completed handoff ticket is missing".into())
465 })?;
466 return Ok(ConsumedHandoff {
467 ticket,
468 result,
469 repeated: true,
470 });
471 }
472 if entry.handoff.expires_at <= request.now {
473 return Err(TicketStoreError::ExpiredHandoff);
474 }
475 let project_id = entry.handoff.project_id.clone();
476 let requester_subject = entry.handoff.requester_subject.clone();
477 let resources = entry.handoff.context.resource_references.clone();
478 let correlation_id = entry.handoff.correlation_id;
479 let counter = staged
480 .display_counters
481 .get(&project_id)
482 .copied()
483 .unwrap_or(0)
484 .saturating_add(1);
485 let ticket = Ticket::create(
486 CreateTicketInput {
487 project_id: project_id.clone(),
488 subject: request.input.subject,
489 description: request.input.description,
490 requester: TicketRequester {
491 subject: requester_subject,
492 display_name: None,
493 email: None,
494 },
495 channel: request.input.channel,
496 priority: request.input.priority,
497 resource_references: resources,
498 },
499 format!("TKT-{counter:06}"),
500 request.now,
501 )?;
502 let result = SupportHandoffResult {
503 ticket_id: ticket.id.0,
504 requester_session_id: Uuid::now_v7(),
505 };
506 let intent = TicketActivityIntent::new(
507 project_id.clone(),
508 ticket.id,
509 "ticketing.created_from_handoff",
510 correlation_id,
511 serde_json::json!({ "ticket_id": ticket.id, "handoff_id": entry.handoff.id }),
512 request.now,
513 );
514 entry.handoff.consumed_result = Some(result.clone());
515 entry.completed_fingerprint = Some(request.request_fingerprint);
516 staged.display_counters.insert(project_id.clone(), counter);
517 staged
518 .tickets
519 .insert((project_id, ticket.id), ticket.clone());
520 staged.activity_intents.push(intent);
521 if staged.fail_next_handoff_commit {
522 state.fail_next_handoff_commit = false;
523 return Err(TicketStoreError::Infrastructure(
524 "injected handoff transaction failure".into(),
525 ));
526 }
527 *state = staged;
528 drop(state);
529 Ok(ConsumedHandoff {
530 ticket,
531 result,
532 repeated: false,
533 })
534 }
535
536 async fn ingest_external_message(
537 &self,
538 request: IngestExternalMessageRequest,
539 ) -> Result<ExternalMessageIngestResult, TicketStoreError> {
540 let mut state = self.state.lock().await;
541 let external_key = (
542 request.identity.project_id.clone(),
543 request.identity.provider.clone(),
544 request.identity.mailbox_scope.clone(),
545 request.identity.external_id.clone(),
546 );
547 if let Some((existing, ticket_id)) = state.external_messages.get(&external_key) {
548 return if existing.content_sha256 == request.identity.content_sha256 {
549 let ticket = state
550 .tickets
551 .get(&(existing.project_id.clone(), *ticket_id))
552 .cloned()
553 .ok_or_else(|| {
554 TicketStoreError::Infrastructure(
555 "external message authoritative ticket is missing".into(),
556 )
557 })?;
558 Ok(ExternalMessageIngestResult {
559 ticket,
560 repeated: true,
561 })
562 } else {
563 Err(TicketStoreError::ExternalIdentityConflict)
564 };
565 }
566 let key = (request.identity.project_id.clone(), request.ticket_id);
567 let mut ticket = state
568 .tickets
569 .get(&key)
570 .cloned()
571 .ok_or(TicketStoreError::NotFound(request.ticket_id))?;
572 if ticket.revision != request.expected_revision {
573 return Err(TicketStoreError::StaleRevision {
574 expected: request.expected_revision,
575 actual: ticket.revision,
576 });
577 }
578 ticket.reply_as_requester(request.body, request.now)?;
579 let intent = TicketActivityIntent::new(
580 ticket.project_id.clone(),
581 ticket.id,
582 "ticketing.external_message_ingested",
583 request.correlation_id,
584 serde_json::json!({ "ticket_id": ticket.id }),
585 request.now,
586 );
587 state
588 .external_messages
589 .insert(external_key, (request.identity, request.ticket_id));
590 state.tickets.insert(key, ticket.clone());
591 state.activity_intents.push(intent);
592 drop(state);
593 Ok(ExternalMessageIngestResult {
594 ticket,
595 repeated: false,
596 })
597 }
598}
599
600#[derive(Debug, thiserror::Error)]
601pub enum TicketStoreError {
602 #[error(transparent)]
603 Validation(#[from] TicketValidationError),
604 #[error("ticket was not found: {0}")]
605 NotFound(TicketId),
606 #[error("ticket already exists: {0}")]
607 DuplicateTicket(TicketId),
608 #[error("ticket display reference already exists in the project")]
609 DuplicateDisplayReference,
610 #[error("ticket revision is stale: expected {expected}, actual {actual}")]
611 StaleRevision { expected: u64, actual: u64 },
612 #[error("ticket list fetch limit must be between 1 and 201")]
613 InvalidListLimit,
614 #[error("ticket list cursor must contain both timestamp and ticket ID")]
615 InvalidListCursor,
616 #[error("support handoff already exists")]
617 DuplicateHandoff,
618 #[error("support handoff is unknown")]
619 UnknownHandoff,
620 #[error("support handoff expired")]
621 ExpiredHandoff,
622 #[error("support handoff belongs to a different project")]
623 WrongHandoffProject,
624 #[error("support handoff belongs to a different portal")]
625 WrongHandoffPortal,
626 #[error("support handoff was already consumed")]
627 HandoffAlreadyConsumed,
628 #[error("external provider identity was reused with different content")]
629 ExternalIdentityConflict,
630 #[error("ticketing storage failed: {0}")]
631 Infrastructure(String),
632}
633
634#[cfg(test)]
635mod tests {
636 use super::*;
637 use crate::{TicketChannel, TicketPriority};
638 use chrono::TimeDelta;
639 use minco_interaction::{
640 SupportContext, SupportLocationPolicy, SupportSurface, issue_support_handoff,
641 };
642
643 fn issue(now: DateTime<Utc>) -> (SupportHandoff, SupportHandoffToken) {
644 let policy = SupportLocationPolicy {
645 portal_origin: "https://support.example.test".into(),
646 allowed_return_paths: BTreeMap::from([(
647 "https://app.example.test".into(),
648 vec!["/orders".into()],
649 )]),
650 };
651 let (handoff, grant) = issue_support_handoff(
652 "project-a",
653 "user-1",
654 vec!["ticketing.create".into()],
655 SupportSurface::Widget,
656 SupportContext {
657 page_url: "https://app.example.test/orders/1".into(),
658 ..SupportContext::default()
659 },
660 "https://app.example.test/orders/1",
661 Uuid::now_v7(),
662 &policy,
663 now,
664 TimeDelta::minutes(5),
665 )
666 .unwrap();
667 (handoff, grant.token)
668 }
669
670 fn consume(token: SupportHandoffToken, now: DateTime<Utc>) -> ConsumeHandoffRequest {
671 ConsumeHandoffRequest::new(
672 token,
673 "project-a",
674 "https://support.example.test",
675 TicketFromHandoffInput {
676 subject: "Help".into(),
677 description: "Broken".into(),
678 channel: TicketChannel::Portal,
679 priority: TicketPriority::Normal,
680 },
681 now,
682 )
683 .unwrap()
684 }
685
686 fn ingress(
687 ticket_id: TicketId,
688 content_sha256: &str,
689 now: DateTime<Utc>,
690 ) -> IngestExternalMessageRequest {
691 IngestExternalMessageRequest {
692 identity: ExternalMessageIdentity {
693 project_id: "project-a".into(),
694 provider: "example-mail".into(),
695 mailbox_scope: "support@example.test".into(),
696 external_id: "message-1".into(),
697 content_sha256: content_sha256.into(),
698 raw_message_object_key: Some("mail/project-a/message-1".into()),
699 internet_message_id: Some("<message-1@example.test>".into()),
700 in_reply_to: None,
701 references: Vec::new(),
702 },
703 ticket_id,
704 body: "External reply".into(),
705 expected_revision: 0,
706 correlation_id: Uuid::now_v7(),
707 now,
708 }
709 }
710
711 #[tokio::test]
712 async fn handoff_is_atomic_idempotent_project_scoped_and_rolls_back() {
713 let store = Arc::new(MemoryTicketingStore::default());
714 let now = Utc::now();
715 let (handoff, token) = issue(now);
716 let digest = handoff.digest.clone();
717 store.insert_handoff(handoff).await.unwrap();
718 store.fail_next_handoff_commit().await;
719 assert!(matches!(
720 store
721 .consume_and_create_ticket(consume(token.clone(), now))
722 .await,
723 Err(TicketStoreError::Infrastructure(_))
724 ));
725 assert_eq!(store.ticket_count().await, 0);
726 assert!(!store.handoff_consumed(&digest).await);
727
728 let first = store
729 .consume_and_create_ticket(consume(token.clone(), now))
730 .await
731 .unwrap();
732 let repeated = store
733 .consume_and_create_ticket(consume(token, now + TimeDelta::minutes(10)))
734 .await
735 .unwrap();
736 assert!(!first.repeated);
737 assert!(repeated.repeated);
738 assert_eq!(first.result, repeated.result);
739 assert_eq!(store.ticket_count().await, 1);
740 assert_eq!(store.activity_intents().await.len(), 1);
741 }
742
743 #[tokio::test]
744 async fn concurrent_double_consume_creates_one_authoritative_ticket() {
745 let store = Arc::new(MemoryTicketingStore::default());
746 let now = Utc::now();
747 let (handoff, token) = issue(now);
748 store.insert_handoff(handoff).await.unwrap();
749 let left = {
750 let store = store.clone();
751 let token = token.clone();
752 tokio::spawn(async move { store.consume_and_create_ticket(consume(token, now)).await })
753 };
754 let right = {
755 let store = store.clone();
756 tokio::spawn(async move { store.consume_and_create_ticket(consume(token, now)).await })
757 };
758 let (left, right) = tokio::join!(left, right);
759 assert!(left.unwrap().is_ok());
760 assert!(right.unwrap().is_ok());
761 assert_eq!(store.ticket_count().await, 1);
762 }
763
764 #[tokio::test]
765 async fn invalid_handoffs_fail_closed_and_different_replay_is_rejected() {
766 let now = Utc::now();
767
768 let store = MemoryTicketingStore::default();
769 let (handoff, token) = issue(now);
770 store.insert_handoff(handoff).await.unwrap();
771 assert!(matches!(
772 store
773 .consume_and_create_ticket(consume(token, now + TimeDelta::minutes(6)))
774 .await,
775 Err(TicketStoreError::ExpiredHandoff)
776 ));
777
778 let store = MemoryTicketingStore::default();
779 let (handoff, token) = issue(now);
780 store.insert_handoff(handoff).await.unwrap();
781 let mut wrong_project = consume(token, now);
782 wrong_project.project_id = "project-b".into();
783 assert!(matches!(
784 store.consume_and_create_ticket(wrong_project).await,
785 Err(TicketStoreError::WrongHandoffProject)
786 ));
787
788 let store = MemoryTicketingStore::default();
789 let (handoff, token) = issue(now);
790 store.insert_handoff(handoff).await.unwrap();
791 let mut wrong_portal = consume(token, now);
792 wrong_portal.portal_origin = "https://other.example.test".into();
793 assert!(matches!(
794 store.consume_and_create_ticket(wrong_portal).await,
795 Err(TicketStoreError::WrongHandoffPortal)
796 ));
797
798 let store = MemoryTicketingStore::default();
799 assert!(matches!(
800 store
801 .consume_and_create_ticket(consume(SupportHandoffToken::generate(), now))
802 .await,
803 Err(TicketStoreError::UnknownHandoff)
804 ));
805
806 let store = MemoryTicketingStore::default();
807 let (handoff, token) = issue(now);
808 store.insert_handoff(handoff).await.unwrap();
809 store
810 .consume_and_create_ticket(consume(token.clone(), now))
811 .await
812 .unwrap();
813 let mut different = consume(token, now);
814 different.input.description = "A different request".into();
815 different.request_fingerprint = "different-fingerprint".into();
816 assert!(matches!(
817 store.consume_and_create_ticket(different).await,
818 Err(TicketStoreError::HandoffAlreadyConsumed)
819 ));
820 }
821
822 #[tokio::test]
823 async fn external_identity_replay_returns_authoritative_result_and_conflict_fails() {
824 let store = MemoryTicketingStore::default();
825 let now = Utc::now();
826 let ticket = Ticket::create(
827 CreateTicketInput {
828 project_id: "project-a".into(),
829 subject: "Help".into(),
830 description: "Broken".into(),
831 requester: TicketRequester {
832 subject: "user".into(),
833 display_name: None,
834 email: None,
835 },
836 channel: TicketChannel::Api,
837 priority: TicketPriority::Normal,
838 resource_references: Vec::new(),
839 },
840 "TKT-EXTERNAL",
841 now,
842 )
843 .unwrap();
844 let created = TicketActivityIntent::new(
845 "project-a",
846 ticket.id,
847 "created",
848 Uuid::now_v7(),
849 serde_json::json!({}),
850 now,
851 );
852 store.create(ticket.clone(), created).await.unwrap();
853
854 let digest = "a".repeat(64);
855 let first = store
856 .ingest_external_message(ingress(ticket.id, &digest, now))
857 .await
858 .unwrap();
859 let repeated = store
860 .ingest_external_message(ingress(ticket.id, &digest, now))
861 .await
862 .unwrap();
863 assert!(!first.repeated);
864 assert!(repeated.repeated);
865 assert_eq!(first.ticket, repeated.ticket);
866 assert_eq!(first.ticket.revision, 1);
867 assert_eq!(store.activity_intents().await.len(), 2);
868
869 assert!(matches!(
870 store
871 .ingest_external_message(ingress(ticket.id, &"b".repeat(64), now))
872 .await,
873 Err(TicketStoreError::ExternalIdentityConflict)
874 ));
875 assert_eq!(
876 store.get("project-a", ticket.id).await.unwrap(),
877 Some(first.ticket)
878 );
879 }
880
881 #[tokio::test]
882 async fn stale_revision_and_project_isolation_fail_closed() {
883 let store = MemoryTicketingStore::default();
884 let now = Utc::now();
885 let ticket = Ticket::create(
886 CreateTicketInput {
887 project_id: "project-a".into(),
888 subject: "Help".into(),
889 description: "Broken".into(),
890 requester: TicketRequester {
891 subject: "user".into(),
892 display_name: None,
893 email: None,
894 },
895 channel: TicketChannel::Api,
896 priority: TicketPriority::Normal,
897 resource_references: Vec::new(),
898 },
899 "TKT-1",
900 now,
901 )
902 .unwrap();
903 let intent = TicketActivityIntent::new(
904 "project-a",
905 ticket.id,
906 "created",
907 Uuid::now_v7(),
908 serde_json::json!({}),
909 now,
910 );
911 store.create(ticket.clone(), intent).await.unwrap();
912 assert!(store.get("project-b", ticket.id).await.unwrap().is_none());
913 let mut changed = ticket.clone();
914 changed.change_priority(TicketPriority::High, now);
915 let intent = TicketActivityIntent::new(
916 "project-a",
917 changed.id,
918 "changed",
919 Uuid::now_v7(),
920 serde_json::json!({}),
921 now,
922 );
923 assert!(matches!(
924 store.save(changed, 1, intent).await,
925 Err(TicketStoreError::StaleRevision { .. })
926 ));
927 }
928}