payrail 0.1.2

Provider-neutral Rust payments facade for Stripe, PayPal, and Mobile Money
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115

use crate::{PaymentEventType, PaymentStatus};

pub(crate) fn map_payment_status(
    status: Option<&str>,
    payment_status: Option<&str>,
) -> PaymentStatus {
    match payment_status.or(status) {
        Some("paid" | "succeeded" | "complete") => PaymentStatus::Succeeded,
        Some("unpaid" | "open" | "requires_payment_method") => PaymentStatus::RequiresAction,
        Some("processing") => PaymentStatus::Processing,
        Some("requires_capture") => PaymentStatus::Authorized,
        Some("canceled" | "cancelled") => PaymentStatus::Cancelled,
        Some("expired") => PaymentStatus::Expired,
        Some("refunded") => PaymentStatus::Refunded,
        Some("partially_refunded") => PaymentStatus::PartiallyRefunded,
        Some(_) | None => PaymentStatus::Processing,
    }
}

pub(crate) fn map_refund_status(status: Option<&str>) -> PaymentStatus {
    match status {
        Some("succeeded") => PaymentStatus::Refunded,
        Some("failed" | "canceled") => PaymentStatus::Failed,
        Some("pending") | Some("requires_action") | Some(_) | None => PaymentStatus::Processing,
    }
}

pub(crate) fn map_event_type(event_type: &str) -> (PaymentEventType, PaymentStatus) {
    match event_type {
        "checkout.session.completed" | "payment_intent.succeeded" => {
            (PaymentEventType::PaymentSucceeded, PaymentStatus::Succeeded)
        }
        "payment_intent.payment_failed" => (PaymentEventType::PaymentFailed, PaymentStatus::Failed),
        "payment_intent.canceled" => (PaymentEventType::PaymentCancelled, PaymentStatus::Cancelled),
        "charge.refunded" => (PaymentEventType::PaymentRefunded, PaymentStatus::Refunded),
        "refund.created" | "refund.updated" => {
            (PaymentEventType::RefundCreated, PaymentStatus::Processing)
        }
        _ => (PaymentEventType::PaymentPending, PaymentStatus::Processing),
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn maps_succeeded_status() {
        assert_eq!(
            map_payment_status(None, Some("paid")),
            PaymentStatus::Succeeded
        );
    }

    #[test]
    fn maps_failed_event() {
        assert_eq!(
            map_event_type("payment_intent.payment_failed"),
            (PaymentEventType::PaymentFailed, PaymentStatus::Failed)
        );
    }

    #[test]
    fn maps_payment_status_variants() {
        assert_eq!(
            map_payment_status(Some("processing"), None),
            PaymentStatus::Processing
        );
        assert_eq!(
            map_payment_status(Some("requires_capture"), None),
            PaymentStatus::Authorized
        );
        assert_eq!(
            map_payment_status(Some("canceled"), None),
            PaymentStatus::Cancelled
        );
        assert_eq!(
            map_payment_status(Some("expired"), None),
            PaymentStatus::Expired
        );
        assert_eq!(
            map_payment_status(Some("refunded"), None),
            PaymentStatus::Refunded
        );
        assert_eq!(
            map_payment_status(Some("partially_refunded"), None),
            PaymentStatus::PartiallyRefunded
        );
        assert_eq!(
            map_payment_status(Some("unknown"), None),
            PaymentStatus::Processing
        );
    }

    #[test]
    fn maps_refund_and_event_variants() {
        assert_eq!(
            map_refund_status(Some("succeeded")),
            PaymentStatus::Refunded
        );
        assert_eq!(map_refund_status(Some("failed")), PaymentStatus::Failed);
        assert_eq!(
            map_event_type("payment_intent.canceled"),
            (PaymentEventType::PaymentCancelled, PaymentStatus::Cancelled)
        );
        assert_eq!(
            map_event_type("charge.refunded"),
            (PaymentEventType::PaymentRefunded, PaymentStatus::Refunded)
        );
        assert_eq!(
            map_event_type("refund.created"),
            (PaymentEventType::RefundCreated, PaymentStatus::Processing)
        );
    }
}