#[cfg(test)]
mod tests {
use chrono::Duration;
use dotenv::dotenv;
use tokio::time::sleep;
use xendit::{
client::XenditClient,
payment_method::{
payment_method::PaymentMethodClient, EWallet, EWalletChannel, EWalletChannelProperties,
GetPaymentMethodsParams, PaymentMethodBody, PaymentMethodUpdateBody, PaymentStatus,
PaymentType, Reusability, VirtualAccountChannel,
VirtualAccountChannelProperties, VirtualAccountParameter,
VirtualAccountParameterUpdate,
},
};
fn initialize_client() -> XenditClient {
dotenv().ok();
XenditClient::new(std::env::var("XENDIT_API_KEY").unwrap())
}
#[tokio::test]
async fn create_payment_method_ewallet() {
let client = initialize_client();
let body = PaymentMethodBody::new(PaymentType::Ewallet, Reusability::OneTimeUse)
.set_description(String::from("Payment for order #123"))
.set_ewallet(
EWallet::new(EWalletChannel::Ovo)
.set_channel_properties(
EWalletChannelProperties::new()
.set_mobile_number(String::from("62817555493"))
.build(),
)
.build(),
)
.build();
assert!(match PaymentMethodClient::new(&client)
.create_payment_method(body, None)
.await
{
Ok(payment_method) => !payment_method.get_id().is_empty(),
Err(e) => {
println!("{}", e);
false
}
})
}
#[tokio::test]
async fn create_payment_method_va() {
let client = initialize_client();
let body = PaymentMethodBody::new(PaymentType::VirtualAccount, Reusability::MultipleUse)
.set_description(String::from("Payment for order #123"))
.set_virtual_account(
VirtualAccountParameter::new(VirtualAccountChannel::Bri)
.set_amount(120000.0)
.set_channel_properties(
VirtualAccountChannelProperties::new()
.set_customer_name(String::from("Airani Iofi"))
.set_expires_at(chrono::Utc::now() + Duration::days(2))
.build(),
)
.build(),
)
.build();
assert!(match PaymentMethodClient::new(&client)
.create_payment_method(body, None)
.await
{
Ok(payment_method) => !payment_method.get_id().is_empty(),
Err(e) => {
println!("{}", e);
false
}
})
}
#[tokio::test]
async fn get_payment_method_by_id() {
let client = initialize_client();
let body = PaymentMethodBody::new(PaymentType::Ewallet, Reusability::OneTimeUse)
.set_description(String::from("Payment for order #123"))
.set_ewallet(
EWallet::new(EWalletChannel::Ovo)
.set_channel_properties(
EWalletChannelProperties::new()
.set_mobile_number(String::from("62817555493"))
.build(),
)
.build(),
)
.build();
let payment_method = PaymentMethodClient::new(&client)
.create_payment_method(body, None)
.await
.unwrap();
assert!(match PaymentMethodClient::new(&client)
.get_payment_method_by_id(&payment_method.get_id(), None)
.await
{
Ok(payment_method) => !payment_method.get_id().is_empty(),
Err(e) => {
println!("{}", e);
false
}
})
}
#[tokio::test]
async fn update_payment_method() {
let client = initialize_client();
let body = PaymentMethodBody::new(PaymentType::VirtualAccount, Reusability::MultipleUse)
.set_description(String::from("Payment for order #1507"))
.set_virtual_account(
VirtualAccountParameter::new(VirtualAccountChannel::Bri)
.set_amount(120000.0)
.set_channel_properties(
VirtualAccountChannelProperties::new()
.set_customer_name(String::from("Airani Iofi"))
.set_expires_at(chrono::Utc::now() + Duration::days(2))
.build(),
)
.build(),
)
.build();
let payment_method = PaymentMethodClient::new(&client)
.create_payment_method(body, None)
.await
.unwrap();
sleep(std::time::Duration::from_millis(500)).await;
let updated_body = PaymentMethodUpdateBody::new()
.set_description(String::from("Updated Payment for order #1507"))
.set_virtual_account(
VirtualAccountParameterUpdate::new()
.set_amount(150000.0)
.build(),
)
.build();
assert!(match PaymentMethodClient::new(&client)
.patch_payment_method(&payment_method.get_id(), updated_body, None)
.await
{
Ok(payment_method) => !payment_method.get_id().is_empty(),
Err(e) => {
println!("{}", e);
false
}
})
}
#[tokio::test]
async fn get_all_payment_methods() {
let client = initialize_client();
assert!(match PaymentMethodClient::new(&client)
.get_all_payment_methods(None, None)
.await
{
Ok(payment_methods) => !payment_methods.data.is_empty(),
Err(e) => {
println!("{}", e);
false
}
})
}
#[tokio::test]
async fn get_all_payment_methods_with_params() {
let client = initialize_client();
let params = GetPaymentMethodsParams::new()
.set_status(vec![PaymentStatus::Pending, PaymentStatus::Active])
.set_limit(5)
.build();
assert!(match PaymentMethodClient::new(&client)
.get_all_payment_methods(Some(params), None)
.await
{
Ok(payment_methods) => !payment_methods.data.is_empty(),
Err(e) => {
println!("{}", e);
false
}
})
}
#[tokio::test]
async fn set_payment_method_expire() {
let client = initialize_client();
let body = PaymentMethodBody::new(PaymentType::VirtualAccount, Reusability::MultipleUse)
.set_description(String::from("Payment for order #1507"))
.set_virtual_account(
VirtualAccountParameter::new(VirtualAccountChannel::Bri)
.set_amount(120000.0)
.set_channel_properties(
VirtualAccountChannelProperties::new()
.set_customer_name(String::from("Airani Iofi"))
.set_expires_at(chrono::Utc::now() + Duration::days(2))
.build(),
)
.build(),
)
.build();
let payment_method = PaymentMethodClient::new(&client)
.create_payment_method(body, None)
.await
.unwrap();
assert!(match PaymentMethodClient::new(&client)
.expire_payment_method(&payment_method.get_id(), None, None)
.await
{
Ok(payment_method) => !payment_method.get_id().is_empty(),
Err(e) => {
println!("{}", e);
false
}
})
}
#[tokio::test]
async fn get_payments_by_payment_method_id() {
let client = initialize_client();
let payment_method_client = PaymentMethodClient::new(&client);
let body = PaymentMethodBody::new(PaymentType::VirtualAccount, Reusability::OneTimeUse)
.set_description(String::from("Payment for order #123"))
.set_virtual_account(
VirtualAccountParameter::new(VirtualAccountChannel::Bri)
.set_amount(120000.0)
.set_channel_properties(
VirtualAccountChannelProperties::new()
.set_customer_name(String::from("Airani Iofi"))
.set_expires_at(chrono::Utc::now() + Duration::days(2))
.build(),
)
.build(),
)
.build();
let payment_method = payment_method_client
.create_payment_method(body, None)
.await
.unwrap();
sleep(std::time::Duration::from_millis(500)).await;
let status = payment_method_client
.simulate_payment(&payment_method.get_id(), 120000.0)
.await
.unwrap();
println!("status {}; message {}", status.get_status(), status.get_message());
sleep(std::time::Duration::from_secs(1)).await;
assert!(match payment_method_client
.get_payments_by_payment_method_id(
"pm-e64c59c3-8f25-4e70-abc1-cc2d1973780d".to_string(),
None,
None
)
.await
{
Ok(payment) => !payment.data.is_empty(),
Err(e) => {
println!("{}", e);
false
}
})
}
}