Skip to main content

minco_plugin_ticketing/
model.rs

1use chrono::{DateTime, Utc};
2use minco_interaction::{
3    AttachmentKind, AttachmentMetadata, SupportResourceReference, TransitionRule,
4    transition_allowed,
5};
6use serde::{Deserialize, Serialize};
7use std::{collections::BTreeSet, fmt, str::FromStr};
8use uuid::Uuid;
9
10macro_rules! ticket_id {
11    ($name:ident) => {
12        #[derive(
13            Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize,
14        )]
15        #[serde(transparent)]
16        pub struct $name(pub Uuid);
17
18        impl $name {
19            #[must_use]
20            pub fn new() -> Self {
21                Self(Uuid::now_v7())
22            }
23        }
24
25        impl Default for $name {
26            fn default() -> Self {
27                Self::new()
28            }
29        }
30
31        impl fmt::Display for $name {
32            fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
33                self.0.fmt(formatter)
34            }
35        }
36
37        impl FromStr for $name {
38            type Err = uuid::Error;
39
40            fn from_str(value: &str) -> Result<Self, Self::Err> {
41                value.parse().map(Self)
42            }
43        }
44    };
45}
46
47ticket_id!(TicketId);
48ticket_id!(TicketMessageId);
49ticket_id!(TicketAttachmentId);
50
51#[derive(Debug, Clone, Copy, Default, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)]
52#[serde(rename_all = "snake_case")]
53pub enum TicketPriority {
54    Low,
55    #[default]
56    Normal,
57    High,
58    Urgent,
59}
60
61#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
62#[serde(rename_all = "snake_case")]
63pub enum TicketChannel {
64    Portal,
65    Email,
66    Api,
67    Voice,
68    Internal,
69    Other,
70}
71
72#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)]
73#[serde(rename_all = "snake_case")]
74pub enum TicketStatus {
75    New,
76    Open,
77    PendingRequester,
78    PendingInternal,
79    OnHold,
80    Resolved,
81    Closed,
82}
83
84#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
85#[serde(rename_all = "snake_case")]
86pub enum TicketClockState {
87    Open,
88    Paused,
89    Stopped,
90}
91
92impl TicketStatus {
93    #[must_use]
94    pub const fn clock_state(self) -> TicketClockState {
95        match self {
96            Self::New | Self::Open | Self::PendingInternal => TicketClockState::Open,
97            Self::PendingRequester | Self::OnHold => TicketClockState::Paused,
98            Self::Resolved | Self::Closed => TicketClockState::Stopped,
99        }
100    }
101
102    #[must_use]
103    pub fn can_transition_to(self, target: Self) -> bool {
104        use TicketStatus::{
105            Closed, New, OnHold, Open, PendingInternal, PendingRequester, Resolved,
106        };
107        const RULES: &[TransitionRule<TicketStatus>] = &[
108            TransitionRule::new(New, Open),
109            TransitionRule::new(New, PendingRequester),
110            TransitionRule::new(New, PendingInternal),
111            TransitionRule::new(New, OnHold),
112            TransitionRule::new(New, Resolved),
113            TransitionRule::new(Open, PendingRequester),
114            TransitionRule::new(Open, PendingInternal),
115            TransitionRule::new(Open, OnHold),
116            TransitionRule::new(Open, Resolved),
117            TransitionRule::new(PendingRequester, Open),
118            TransitionRule::new(PendingRequester, PendingInternal),
119            TransitionRule::new(PendingRequester, OnHold),
120            TransitionRule::new(PendingRequester, Resolved),
121            TransitionRule::new(PendingInternal, Open),
122            TransitionRule::new(PendingInternal, PendingRequester),
123            TransitionRule::new(PendingInternal, OnHold),
124            TransitionRule::new(PendingInternal, Resolved),
125            TransitionRule::new(OnHold, Open),
126            TransitionRule::new(OnHold, PendingRequester),
127            TransitionRule::new(OnHold, PendingInternal),
128            TransitionRule::new(OnHold, Resolved),
129            TransitionRule::new(Resolved, Open),
130            TransitionRule::new(Resolved, Closed),
131            TransitionRule::new(Closed, Open),
132        ];
133        transition_allowed(&self, &target, RULES)
134    }
135}
136
137#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
138#[serde(rename_all = "snake_case")]
139pub enum TicketMessageKind {
140    PublicReply,
141    InternalNote,
142    SystemEvent,
143    VoiceTranscript,
144}
145
146#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
147#[serde(rename_all = "snake_case")]
148pub enum TicketMessageDirection {
149    Inbound,
150    Outbound,
151    Internal,
152    System,
153}
154
155#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
156#[serde(deny_unknown_fields)]
157pub struct TicketRequester {
158    pub subject: String,
159    #[serde(default, skip_serializing_if = "Option::is_none")]
160    pub display_name: Option<String>,
161    #[serde(default, skip_serializing_if = "Option::is_none")]
162    pub email: Option<String>,
163}
164
165#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
166#[serde(deny_unknown_fields)]
167pub struct TicketSourceReference {
168    pub provider: String,
169    pub scope: String,
170    pub external_id: String,
171}
172
173#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
174pub struct TicketMessage {
175    pub id: TicketMessageId,
176    pub kind: TicketMessageKind,
177    pub direction: TicketMessageDirection,
178    #[serde(default, skip_serializing_if = "Option::is_none")]
179    pub author_subject: Option<String>,
180    pub body: String,
181    pub created_at: DateTime<Utc>,
182}
183
184#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
185pub struct TicketAttachment {
186    pub id: TicketAttachmentId,
187    pub kind: AttachmentKind,
188    pub object_key: String,
189    pub file_name: String,
190    pub content_type: String,
191    pub size_bytes: u64,
192    pub sha256: String,
193    pub created_at: DateTime<Utc>,
194}
195
196impl From<AttachmentMetadata> for TicketAttachment {
197    fn from(value: AttachmentMetadata) -> Self {
198        Self {
199            id: TicketAttachmentId(value.id),
200            kind: value.kind,
201            object_key: value.object_key.as_str().to_owned(),
202            file_name: value.file_name,
203            content_type: value.content_type,
204            size_bytes: value.size_bytes,
205            sha256: value.sha256,
206            created_at: value.created_at,
207        }
208    }
209}
210
211#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
212pub struct Ticket {
213    pub id: TicketId,
214    pub project_id: String,
215    pub display_reference: String,
216    pub subject: String,
217    pub description: String,
218    pub requester: TicketRequester,
219    pub channel: TicketChannel,
220    pub priority: TicketPriority,
221    pub status: TicketStatus,
222    pub clock_state: TicketClockState,
223    #[serde(default, skip_serializing_if = "Option::is_none")]
224    pub queue_id: Option<String>,
225    #[serde(default, skip_serializing_if = "Option::is_none")]
226    pub assignee_subject: Option<String>,
227    #[serde(default)]
228    pub followers: BTreeSet<String>,
229    #[serde(default, skip_serializing_if = "Option::is_none")]
230    pub category: Option<String>,
231    #[serde(default)]
232    pub tags: BTreeSet<String>,
233    #[serde(default)]
234    pub source_references: Vec<TicketSourceReference>,
235    #[serde(default)]
236    pub resource_references: Vec<SupportResourceReference>,
237    #[serde(default)]
238    pub messages: Vec<TicketMessage>,
239    #[serde(default)]
240    pub attachments: Vec<TicketAttachment>,
241    pub created_at: DateTime<Utc>,
242    pub updated_at: DateTime<Utc>,
243    #[serde(default, skip_serializing_if = "Option::is_none")]
244    pub first_public_response_at: Option<DateTime<Utc>>,
245    #[serde(default, skip_serializing_if = "Option::is_none")]
246    pub waiting_since: Option<DateTime<Utc>>,
247    #[serde(default, skip_serializing_if = "Option::is_none")]
248    pub resolved_at: Option<DateTime<Utc>>,
249    #[serde(default, skip_serializing_if = "Option::is_none")]
250    pub closed_at: Option<DateTime<Utc>>,
251    #[serde(default, skip_serializing_if = "Option::is_none")]
252    pub resolution: Option<String>,
253    #[serde(default, skip_serializing_if = "Option::is_none")]
254    pub close_reason: Option<String>,
255    pub revision: u64,
256}
257
258#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
259pub struct CreateTicketInput {
260    pub project_id: String,
261    pub subject: String,
262    pub description: String,
263    pub requester: TicketRequester,
264    pub channel: TicketChannel,
265    #[serde(default)]
266    pub priority: TicketPriority,
267    #[serde(default)]
268    pub resource_references: Vec<SupportResourceReference>,
269}
270
271impl Ticket {
272    pub fn create(
273        input: CreateTicketInput,
274        display_reference: impl Into<String>,
275        now: DateTime<Utc>,
276    ) -> Result<Self, TicketValidationError> {
277        validate_text("project_id", &input.project_id, 100)?;
278        validate_text("subject", &input.subject, 300)?;
279        validate_text("description", &input.description, 20_000)?;
280        validate_text("requester.subject", &input.requester.subject, 300)?;
281        validate_optional_text(
282            "requester.display_name",
283            input.requester.display_name.as_deref(),
284            300,
285        )?;
286        validate_optional_text("requester.email", input.requester.email.as_deref(), 320)?;
287        let display_reference = display_reference.into();
288        validate_text("display_reference", &display_reference, 100)?;
289        if input.resource_references.len() > 32 {
290            return Err(TicketValidationError::InvalidField {
291                field: "resource_references",
292                detail: "must not contain more than 32 values".into(),
293            });
294        }
295        let id = TicketId::new();
296        let mut ticket = Self {
297            id,
298            project_id: input.project_id,
299            display_reference,
300            subject: input.subject,
301            description: input.description.clone(),
302            requester: input.requester,
303            channel: input.channel,
304            priority: input.priority,
305            status: TicketStatus::New,
306            clock_state: TicketClockState::Open,
307            queue_id: None,
308            assignee_subject: None,
309            followers: BTreeSet::new(),
310            category: None,
311            tags: BTreeSet::new(),
312            source_references: Vec::new(),
313            resource_references: input.resource_references,
314            messages: Vec::new(),
315            attachments: Vec::new(),
316            created_at: now,
317            updated_at: now,
318            first_public_response_at: None,
319            waiting_since: None,
320            resolved_at: None,
321            closed_at: None,
322            resolution: None,
323            close_reason: None,
324            revision: 0,
325        };
326        ticket.messages.push(TicketMessage {
327            id: TicketMessageId::new(),
328            kind: TicketMessageKind::PublicReply,
329            direction: TicketMessageDirection::Inbound,
330            author_subject: Some(ticket.requester.subject.clone()),
331            body: input.description,
332            created_at: now,
333        });
334        Ok(ticket)
335    }
336
337    pub fn reply_as_requester(
338        &mut self,
339        body: impl Into<String>,
340        now: DateTime<Utc>,
341    ) -> Result<(), TicketValidationError> {
342        let body = body.into();
343        validate_text("body", &body, 20_000)?;
344        if matches!(
345            self.status,
346            TicketStatus::PendingRequester | TicketStatus::Resolved | TicketStatus::Closed
347        ) {
348            self.apply_status(TicketStatus::Open, None, None, now)?;
349        }
350        self.messages.push(TicketMessage {
351            id: TicketMessageId::new(),
352            kind: TicketMessageKind::PublicReply,
353            direction: TicketMessageDirection::Inbound,
354            author_subject: Some(self.requester.subject.clone()),
355            body,
356            created_at: now,
357        });
358        self.touch(now);
359        Ok(())
360    }
361
362    pub fn reply_as_agent(
363        &mut self,
364        actor_subject: impl Into<String>,
365        body: impl Into<String>,
366        now: DateTime<Utc>,
367    ) -> Result<(), TicketValidationError> {
368        let actor_subject = actor_subject.into();
369        let body = body.into();
370        validate_text("actor_subject", &actor_subject, 300)?;
371        validate_text("body", &body, 20_000)?;
372        self.first_public_response_at.get_or_insert(now);
373        if self.status == TicketStatus::New {
374            self.apply_status(TicketStatus::Open, None, None, now)?;
375        }
376        self.messages.push(TicketMessage {
377            id: TicketMessageId::new(),
378            kind: TicketMessageKind::PublicReply,
379            direction: TicketMessageDirection::Outbound,
380            author_subject: Some(actor_subject),
381            body,
382            created_at: now,
383        });
384        self.touch(now);
385        Ok(())
386    }
387
388    pub fn add_internal_note(
389        &mut self,
390        actor_subject: impl Into<String>,
391        body: impl Into<String>,
392        now: DateTime<Utc>,
393    ) -> Result<(), TicketValidationError> {
394        let actor_subject = actor_subject.into();
395        let body = body.into();
396        validate_text("actor_subject", &actor_subject, 300)?;
397        validate_text("body", &body, 20_000)?;
398        self.messages.push(TicketMessage {
399            id: TicketMessageId::new(),
400            kind: TicketMessageKind::InternalNote,
401            direction: TicketMessageDirection::Internal,
402            author_subject: Some(actor_subject),
403            body,
404            created_at: now,
405        });
406        self.touch(now);
407        Ok(())
408    }
409
410    pub fn change_status(
411        &mut self,
412        target: TicketStatus,
413        resolution: Option<String>,
414        close_reason: Option<String>,
415        now: DateTime<Utc>,
416    ) -> Result<(), TicketValidationError> {
417        self.apply_status(target, resolution, close_reason, now)?;
418        self.messages.push(TicketMessage {
419            id: TicketMessageId::new(),
420            kind: TicketMessageKind::SystemEvent,
421            direction: TicketMessageDirection::System,
422            author_subject: None,
423            body: format!("status changed to {target:?}").to_ascii_lowercase(),
424            created_at: now,
425        });
426        self.touch(now);
427        Ok(())
428    }
429
430    fn apply_status(
431        &mut self,
432        target: TicketStatus,
433        resolution: Option<String>,
434        close_reason: Option<String>,
435        now: DateTime<Utc>,
436    ) -> Result<(), TicketValidationError> {
437        if !self.status.can_transition_to(target) {
438            return Err(TicketValidationError::InvalidTransition {
439                current: self.status,
440                target,
441            });
442        }
443        if let Some(value) = resolution.as_deref() {
444            validate_text("resolution", value, 20_000)?;
445        }
446        if let Some(value) = close_reason.as_deref() {
447            validate_text("close_reason", value, 500)?;
448        }
449        if target == TicketStatus::Resolved
450            && resolution.as_ref().or(self.resolution.as_ref()).is_none()
451        {
452            return Err(TicketValidationError::ResolutionRequired);
453        }
454        if target == TicketStatus::Closed {
455            if resolution.as_ref().or(self.resolution.as_ref()).is_none() {
456                return Err(TicketValidationError::ResolutionRequired);
457            }
458            if close_reason.is_none() {
459                return Err(TicketValidationError::CloseReasonRequired);
460            }
461        }
462        self.status = target;
463        self.clock_state = target.clock_state();
464        self.waiting_since = matches!(
465            target,
466            TicketStatus::PendingRequester | TicketStatus::OnHold
467        )
468        .then_some(now);
469        if target == TicketStatus::Resolved {
470            self.resolved_at = Some(now);
471            self.resolution = resolution.clone().or_else(|| self.resolution.clone());
472        } else if !matches!(target, TicketStatus::Closed) {
473            self.resolved_at = None;
474            if target == TicketStatus::Open {
475                self.closed_at = None;
476                self.close_reason = None;
477            }
478        }
479        if target == TicketStatus::Closed {
480            self.closed_at = Some(now);
481            self.resolution = resolution.or_else(|| self.resolution.clone());
482            self.close_reason = close_reason;
483        }
484        Ok(())
485    }
486
487    pub fn assign(
488        &mut self,
489        subject: Option<String>,
490        now: DateTime<Utc>,
491    ) -> Result<(), TicketValidationError> {
492        validate_optional_text("assignee_subject", subject.as_deref(), 300)?;
493        self.assignee_subject = subject;
494        self.touch(now);
495        Ok(())
496    }
497
498    pub fn transfer_queue(
499        &mut self,
500        queue_id: String,
501        now: DateTime<Utc>,
502    ) -> Result<(), TicketValidationError> {
503        validate_text("queue_id", &queue_id, 200)?;
504        self.queue_id = Some(queue_id);
505        self.touch(now);
506        Ok(())
507    }
508
509    pub const fn change_priority(&mut self, priority: TicketPriority, now: DateTime<Utc>) {
510        self.priority = priority;
511        self.touch(now);
512    }
513
514    pub fn add_attachment(&mut self, attachment: TicketAttachment, now: DateTime<Utc>) {
515        self.attachments.push(attachment);
516        self.touch(now);
517    }
518
519    const fn touch(&mut self, now: DateTime<Utc>) {
520        self.updated_at = now;
521        self.revision = self.revision.saturating_add(1);
522    }
523
524    #[must_use]
525    pub fn requester_projection(&self) -> RequesterTicket {
526        RequesterTicket {
527            id: self.id,
528            project_id: self.project_id.clone(),
529            display_reference: self.display_reference.clone(),
530            subject: self.subject.clone(),
531            description: self.description.clone(),
532            requester: self.requester.clone(),
533            channel: self.channel.clone(),
534            priority: self.priority,
535            status: self.status,
536            messages: self
537                .messages
538                .iter()
539                .filter(|message| message.kind != TicketMessageKind::InternalNote)
540                .cloned()
541                .collect(),
542            attachments: self
543                .attachments
544                .iter()
545                .map(RequesterTicketAttachment::from)
546                .collect(),
547            created_at: self.created_at,
548            updated_at: self.updated_at,
549            revision: self.revision,
550        }
551    }
552
553    #[must_use]
554    pub fn export_ai_context(&self) -> TicketAiContext {
555        TicketAiContext {
556            schema_version: 1,
557            project_id: self.project_id.clone(),
558            ticket_id: self.id,
559            display_reference: self.display_reference.clone(),
560            subject: self.subject.clone(),
561            description: self.description.clone(),
562            status: self.status,
563            priority: self.priority,
564            resource_references: self.resource_references.clone(),
565            messages: self.messages.clone(),
566        }
567    }
568}
569
570#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
571pub struct RequesterTicketAttachment {
572    pub id: TicketAttachmentId,
573    pub kind: AttachmentKind,
574    pub file_name: String,
575    pub content_type: String,
576    pub size_bytes: u64,
577    pub created_at: DateTime<Utc>,
578}
579
580impl From<&TicketAttachment> for RequesterTicketAttachment {
581    fn from(value: &TicketAttachment) -> Self {
582        Self {
583            id: value.id,
584            kind: value.kind,
585            file_name: value.file_name.clone(),
586            content_type: value.content_type.clone(),
587            size_bytes: value.size_bytes,
588            created_at: value.created_at,
589        }
590    }
591}
592
593#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
594pub struct RequesterTicket {
595    pub id: TicketId,
596    pub project_id: String,
597    pub display_reference: String,
598    pub subject: String,
599    pub description: String,
600    pub requester: TicketRequester,
601    pub channel: TicketChannel,
602    pub priority: TicketPriority,
603    pub status: TicketStatus,
604    pub messages: Vec<TicketMessage>,
605    pub attachments: Vec<RequesterTicketAttachment>,
606    pub created_at: DateTime<Utc>,
607    pub updated_at: DateTime<Utc>,
608    pub revision: u64,
609}
610
611#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
612pub struct TicketAiContext {
613    pub schema_version: u32,
614    pub project_id: String,
615    pub ticket_id: TicketId,
616    pub display_reference: String,
617    pub subject: String,
618    pub description: String,
619    pub status: TicketStatus,
620    pub priority: TicketPriority,
621    pub resource_references: Vec<SupportResourceReference>,
622    pub messages: Vec<TicketMessage>,
623}
624
625#[derive(Debug, Clone, PartialEq, Eq)]
626pub struct TicketFromHandoffInput {
627    pub subject: String,
628    pub description: String,
629    pub channel: TicketChannel,
630    pub priority: TicketPriority,
631}
632
633#[derive(Debug, thiserror::Error, PartialEq, Eq)]
634pub enum TicketValidationError {
635    #[error("invalid {field}: {detail}")]
636    InvalidField { field: &'static str, detail: String },
637    #[error("ticket cannot transition from {current:?} to {target:?}")]
638    InvalidTransition {
639        current: TicketStatus,
640        target: TicketStatus,
641    },
642    #[error("a resolution is required")]
643    ResolutionRequired,
644    #[error("a close reason is required")]
645    CloseReasonRequired,
646}
647
648fn validate_text(
649    field: &'static str,
650    value: &str,
651    maximum: usize,
652) -> Result<(), TicketValidationError> {
653    if value.trim().is_empty()
654        || value.chars().count() > maximum
655        || value.chars().any(char::is_control)
656    {
657        Err(TicketValidationError::InvalidField {
658            field,
659            detail: format!("must contain 1-{maximum} visible characters"),
660        })
661    } else {
662        Ok(())
663    }
664}
665
666fn validate_optional_text(
667    field: &'static str,
668    value: Option<&str>,
669    maximum: usize,
670) -> Result<(), TicketValidationError> {
671    value.map_or(Ok(()), |value| validate_text(field, value, maximum))
672}
673
674#[cfg(test)]
675mod tests {
676    use super::*;
677    use chrono::TimeDelta;
678
679    fn ticket() -> Ticket {
680        Ticket::create(
681            CreateTicketInput {
682                project_id: "project-a".into(),
683                subject: "Need help".into(),
684                description: "It broke".into(),
685                requester: TicketRequester {
686                    subject: "user-1".into(),
687                    display_name: None,
688                    email: None,
689                },
690                channel: TicketChannel::Portal,
691                priority: TicketPriority::Normal,
692                resource_references: Vec::new(),
693            },
694            "SUP-1",
695            Utc::now(),
696        )
697        .unwrap()
698    }
699
700    #[test]
701    fn clock_mapping_keeps_pending_internal_open() {
702        assert_eq!(
703            TicketStatus::PendingInternal.clock_state(),
704            TicketClockState::Open
705        );
706        assert_eq!(
707            TicketStatus::PendingRequester.clock_state(),
708            TicketClockState::Paused
709        );
710        assert_eq!(
711            TicketStatus::Closed.clock_state(),
712            TicketClockState::Stopped
713        );
714    }
715
716    #[test]
717    fn requester_reply_reopens_and_internal_note_stays_private() {
718        let mut ticket = ticket();
719        let now = ticket.created_at + TimeDelta::minutes(1);
720        ticket
721            .change_status(TicketStatus::PendingRequester, None, None, now)
722            .unwrap();
723        ticket.add_internal_note("agent", "private", now).unwrap();
724        assert_eq!(ticket.status, TicketStatus::PendingRequester);
725        ticket.reply_as_requester("more detail", now).unwrap();
726        assert_eq!(ticket.status, TicketStatus::Open);
727        assert!(
728            !serde_json::to_string(&ticket.requester_projection())
729                .unwrap()
730                .contains("private")
731        );
732    }
733
734    #[test]
735    fn first_response_and_resolution_timestamps_are_stable() {
736        let mut ticket = ticket();
737        let first = ticket.created_at + TimeDelta::minutes(1);
738        ticket.reply_as_agent("agent", "hello", first).unwrap();
739        ticket
740            .reply_as_agent("agent", "again", first + TimeDelta::minutes(1))
741            .unwrap();
742        assert_eq!(ticket.first_public_response_at, Some(first));
743        let resolved = first + TimeDelta::minutes(2);
744        ticket
745            .change_status(TicketStatus::Resolved, Some("fixed".into()), None, resolved)
746            .unwrap();
747        assert_eq!(ticket.resolved_at, Some(resolved));
748        assert_eq!(
749            ticket.change_status(TicketStatus::Closed, None, None, resolved),
750            Err(TicketValidationError::CloseReasonRequired)
751        );
752        ticket
753            .change_status(
754                TicketStatus::Closed,
755                None,
756                Some("confirmed".into()),
757                resolved,
758            )
759            .unwrap();
760        ticket.reply_as_requester("regressed", resolved).unwrap();
761        assert_eq!(ticket.status, TicketStatus::Open);
762        assert!(ticket.closed_at.is_none());
763    }
764}