xendit 0.0.2

Xendit Rust SDK
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

#[cfg(test)]

mod tests {
    use dotenv::dotenv;
    use xendit::{
        client::XenditClient,
        common::Currency,
        payment_method::{
            EWallet, EWalletChannel, EWalletChannelProperties, PaymentMethodBody, PaymentType,
            Reusability, VirtualAccountChannel, VirtualAccountChannelProperties,
            VirtualAccountParameter,
        },
        payment_request::{PaymentRequestClient, PaymentRequestParameters},
    };

    fn initialize_client() -> XenditClient {
        dotenv().ok();
        XenditClient::new(std::env::var("XENDIT_API_KEY").unwrap())
    }

    #[tokio::test]
    async fn test_create_payment_request() {
        let client = initialize_client();
        let body = PaymentRequestParameters::new(Currency::IDR)
            .set_amount(150000.0)
            .set_payment_method(
                PaymentMethodBody::new(PaymentType::Ewallet, Reusability::OneTimeUse)
                    .set_ewallet(
                        EWallet::new(EWalletChannel::Shopeepay)
                            .set_channel_properties(
                                EWalletChannelProperties::new()
                                    .set_success_return_url(String::from(
                                        "https://your-redirect-website.com/success",
                                    ))
                                    .build(),
                            )
                            .build(),
                    )
                    .build(),
            )
            .build();

        assert!(match PaymentRequestClient::new(&client)
            .create_payment_request(body, None, None)
            .await
        {
            Ok(payment_request) => !payment_request.get_id().is_empty(),
            Err(e) => {
                println!("{}", e);
                false
            }
        })
    }

    #[tokio::test]
    async fn test_get_payment_request() {
        let client = initialize_client();

        // Create Payment Request First
        let body = PaymentRequestParameters::new(Currency::IDR)
            .set_amount(150000.0)
            .set_payment_method(
                PaymentMethodBody::new(PaymentType::VirtualAccount, Reusability::OneTimeUse)
                    .set_virtual_account(
                        VirtualAccountParameter::new(VirtualAccountChannel::Bri)
                            .set_channel_properties(
                                VirtualAccountChannelProperties::new()
                                    .set_customer_name(String::from("Airani Iofi"))
                                    .build(),
                            )
                            .build(),
                    )
                    .build(),
            )
            .set_customer_id(String::from("cust-b9a2f48e-bc3d-40b1-84b3-c8cb1c82349b"))
            .build();
        let payment_request = PaymentRequestClient::new(&client)
            .create_payment_request(body, None, None)
            .await
            .unwrap();

        assert!(match PaymentRequestClient::new(&client)
            .get_payment_request_by_id(payment_request.get_id().to_string(), None)
            .await
        {
            Ok(payment_request) => !payment_request.get_id().is_empty(),
            Err(e) => {
                println!("{}", e);
                false
            }
        })
    }

    #[tokio::test]
    async fn test_get_payment_request_list() {
        let client = initialize_client();

        assert!(
            match PaymentRequestClient::new(&client).get_all_payment_requests(None).await {
                Ok(payment_request_list) => !payment_request_list.get_data().is_empty(),
                Err(e) => {
                    println!("{}", e);
                    false
                }
            }
        )
    }
}