text
stringlengths 70
351k
| source
stringclasses 4
values |
|---|---|
<|meta_start|><|file|> hyperswitch/crates/hyperswitch_connectors/src/connectors/zsl.rs<|crate|> hyperswitch_connectors<|connector|> zsl anchor=get_url kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=1<|meta_end|>
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/zsl.rs" role="context" start="152" end="158">
fn get_url(
&self,
_req: &PaymentsAuthorizeRouterData,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
Ok(format!("{}ecp", self.base_url(connectors)))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/zsl.rs" role="context" start="151" end="151">
fn get_headers(
&self,
req: &PaymentsAuthorizeRouterData,
connectors: &Connectors,
) -> CustomResult<Vec<(String, masking::Maskable<String>)>, errors::ConnectorError> {
self.build_headers(req, connectors)
}
fn get_content_type(&self) -> &'static str {
self.common_get_content_type()
}
fn get_url(
&self,
_req: &PaymentsAuthorizeRouterData,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
Ok(format!("{}ecp", self.base_url(connectors)))
}
fn get_request_body(
&self,
req: &PaymentsAuthorizeRouterData,
_connectors: &Connectors,
) -> CustomResult<RequestContent, errors::ConnectorError> {
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/zsl.rs" role="context" start="175" end="195">
fn build_request(
&self,
req: &PaymentsAuthorizeRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Ok(Some(
RequestBuilder::new()
.method(Method::Post)
.url(&types::PaymentsAuthorizeType::get_url(
self, req, connectors,
)?)
.attach_default_headers()
.headers(types::PaymentsAuthorizeType::get_headers(
self, req, connectors,
)?)
.set_body(types::PaymentsAuthorizeType::get_request_body(
self, req, connectors,
)?)
.build(),
))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/zsl.rs" role="context" start="160" end="173">
fn get_request_body(
&self,
req: &PaymentsAuthorizeRouterData,
_connectors: &Connectors,
) -> CustomResult<RequestContent, errors::ConnectorError> {
let connector_router_data = zsl::ZslRouterData::try_from((
&self.get_currency_unit(),
req.request.currency,
req.request.amount,
req,
))?;
let connector_req = zsl::ZslPaymentsRequest::try_from(&connector_router_data)?;
Ok(RequestContent::FormUrlEncoded(Box::new(connector_req)))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/zsl.rs" role="context" start="148" end="150">
fn get_content_type(&self) -> &'static str {
self.common_get_content_type()
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/zsl.rs" role="context" start="140" end="146">
fn get_headers(
&self,
req: &PaymentsAuthorizeRouterData,
connectors: &Connectors,
) -> CustomResult<Vec<(String, masking::Maskable<String>)>, errors::ConnectorError> {
self.build_headers(req, connectors)
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/hyperswitch_connectors/src/connectors/zsl.rs<|crate|> hyperswitch_connectors<|connector|> zsl anchor=get_webhook_event_type kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/zsl.rs" role="context" start="383" end="391">
fn get_webhook_event_type(
&self,
request: &IncomingWebhookRequestDetails<'_>,
) -> CustomResult<IncomingWebhookEvent, errors::ConnectorError> {
let notif = get_webhook_object_from_body(request.body)
.change_context(errors::ConnectorError::WebhookEventTypeNotFound)?;
Ok(get_status(notif.status))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/zsl.rs" role="context" start="382" end="382">
use common_utils::{
errors::CustomResult,
ext_traits::{BytesExt, ValueExt},
request::{Method, Request, RequestBuilder, RequestContent},
};
use hyperswitch_interfaces::{
api::{
self, ConnectorCommon, ConnectorCommonExt, ConnectorIntegration, ConnectorSpecifications,
ConnectorValidation,
},
configs::Connectors,
errors,
events::connector_api_logs::ConnectorEvent,
types::{self, Response},
webhooks::{IncomingWebhook, IncomingWebhookFlowError, IncomingWebhookRequestDetails},
};
use transformers::{self as zsl, get_status};
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/zsl.rs" role="context" start="402" end="432">
async fn verify_webhook_source(
&self,
request: &IncomingWebhookRequestDetails<'_>,
_merchant_id: &common_utils::id_type::MerchantId,
_connector_webhook_details: Option<common_utils::pii::SecretSerdeValue>,
connector_account_details: common_utils::crypto::Encryptable<Secret<serde_json::Value>>,
_connector_label: &str,
) -> CustomResult<bool, errors::ConnectorError> {
let connector_account_details = connector_account_details
.parse_value::<ConnectorAuthType>("ConnectorAuthType")
.change_context_lazy(|| errors::ConnectorError::WebhookSourceVerificationFailed)?;
let auth_type = zsl::ZslAuthType::try_from(&connector_account_details)?;
let key = auth_type.api_key.expose();
let mer_id = auth_type.merchant_id.expose();
let webhook_response = get_webhook_object_from_body(request.body)?;
let signature = zsl::calculate_signature(
webhook_response.enctype,
zsl::ZslSignatureType::WebhookSignature {
status: webhook_response.status,
txn_id: webhook_response.txn_id,
txn_date: webhook_response.txn_date,
paid_ccy: webhook_response.paid_ccy.to_string(),
paid_amt: webhook_response.paid_amt,
mer_ref: webhook_response.mer_ref,
mer_id,
key,
},
)?;
Ok(signature.eq(&webhook_response.signature))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/zsl.rs" role="context" start="393" end="400">
fn get_webhook_resource_object(
&self,
request: &IncomingWebhookRequestDetails<'_>,
) -> CustomResult<Box<dyn masking::ErasedMaskSerialize>, errors::ConnectorError> {
let response = get_webhook_object_from_body(request.body)
.change_context(errors::ConnectorError::WebhookEventTypeNotFound)?;
Ok(Box::new(response))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/zsl.rs" role="context" start="372" end="381">
fn get_webhook_object_reference_id(
&self,
request: &IncomingWebhookRequestDetails<'_>,
) -> CustomResult<ObjectReferenceId, errors::ConnectorError> {
let notif = get_webhook_object_from_body(request.body)
.change_context(errors::ConnectorError::WebhookReferenceIdNotFound)?;
Ok(ObjectReferenceId::PaymentId(
api_models::payments::PaymentIdType::PaymentAttemptId(notif.mer_ref),
))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/zsl.rs" role="context" start="357" end="367">
fn build_request(
&self,
_req: &RefundSyncRouterData,
_connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Err(errors::ConnectorError::NotSupported {
message: "Rsync flow ".to_owned(),
connector: "Zsl",
}
.into())
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/zsl.rs" role="context" start="443" end="450">
fn get_webhook_object_from_body(
body: &[u8],
) -> CustomResult<zsl::ZslWebhookResponse, errors::ConnectorError> {
let response: zsl::ZslWebhookResponse =
serde_urlencoded::from_bytes::<zsl::ZslWebhookResponse>(body)
.change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
Ok(response)
}
<file_sep path="hyperswitch/crates/api_models/src/webhooks.rs" role="context" start="12" end="68">
pub enum IncomingWebhookEvent {
/// Authorization + Capture success
PaymentIntentFailure,
/// Authorization + Capture failure
PaymentIntentSuccess,
PaymentIntentProcessing,
PaymentIntentPartiallyFunded,
PaymentIntentCancelled,
PaymentIntentCancelFailure,
PaymentIntentAuthorizationSuccess,
PaymentIntentAuthorizationFailure,
PaymentIntentCaptureSuccess,
PaymentIntentCaptureFailure,
PaymentActionRequired,
EventNotSupported,
SourceChargeable,
SourceTransactionCreated,
RefundFailure,
RefundSuccess,
DisputeOpened,
DisputeExpired,
DisputeAccepted,
DisputeCancelled,
DisputeChallenged,
// dispute has been successfully challenged by the merchant
DisputeWon,
// dispute has been unsuccessfully challenged
DisputeLost,
MandateActive,
MandateRevoked,
EndpointVerification,
ExternalAuthenticationARes,
FrmApproved,
FrmRejected,
#[cfg(feature = "payouts")]
PayoutSuccess,
#[cfg(feature = "payouts")]
PayoutFailure,
#[cfg(feature = "payouts")]
PayoutProcessing,
#[cfg(feature = "payouts")]
PayoutCancelled,
#[cfg(feature = "payouts")]
PayoutCreated,
#[cfg(feature = "payouts")]
PayoutExpired,
#[cfg(feature = "payouts")]
PayoutReversed,
#[cfg(all(feature = "revenue_recovery", feature = "v2"))]
RecoveryPaymentFailure,
#[cfg(all(feature = "revenue_recovery", feature = "v2"))]
RecoveryPaymentSuccess,
#[cfg(all(feature = "revenue_recovery", feature = "v2"))]
RecoveryPaymentPending,
#[cfg(all(feature = "revenue_recovery", feature = "v2"))]
RecoveryInvoiceCancel,
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/hyperswitch_connectors/src/connectors/zsl.rs<|crate|> hyperswitch_connectors<|connector|> zsl anchor=get_webhook_resource_object kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=1<|meta_end|>
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/zsl.rs" role="context" start="393" end="400">
fn get_webhook_resource_object(
&self,
request: &IncomingWebhookRequestDetails<'_>,
) -> CustomResult<Box<dyn masking::ErasedMaskSerialize>, errors::ConnectorError> {
let response = get_webhook_object_from_body(request.body)
.change_context(errors::ConnectorError::WebhookEventTypeNotFound)?;
Ok(Box::new(response))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/zsl.rs" role="context" start="392" end="392">
use common_utils::{
errors::CustomResult,
ext_traits::{BytesExt, ValueExt},
request::{Method, Request, RequestBuilder, RequestContent},
};
use hyperswitch_interfaces::{
api::{
self, ConnectorCommon, ConnectorCommonExt, ConnectorIntegration, ConnectorSpecifications,
ConnectorValidation,
},
configs::Connectors,
errors,
events::connector_api_logs::ConnectorEvent,
types::{self, Response},
webhooks::{IncomingWebhook, IncomingWebhookFlowError, IncomingWebhookRequestDetails},
};
use masking::{ExposeInterface, Secret};
use transformers::{self as zsl, get_status};
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/zsl.rs" role="context" start="434" end="440">
fn get_webhook_api_response(
&self,
_request: &IncomingWebhookRequestDetails<'_>,
_error_kind: Option<IncomingWebhookFlowError>,
) -> CustomResult<ApplicationResponse<serde_json::Value>, errors::ConnectorError> {
Ok(ApplicationResponse::TextPlain("CALLBACK-OK".to_string()))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/zsl.rs" role="context" start="402" end="432">
async fn verify_webhook_source(
&self,
request: &IncomingWebhookRequestDetails<'_>,
_merchant_id: &common_utils::id_type::MerchantId,
_connector_webhook_details: Option<common_utils::pii::SecretSerdeValue>,
connector_account_details: common_utils::crypto::Encryptable<Secret<serde_json::Value>>,
_connector_label: &str,
) -> CustomResult<bool, errors::ConnectorError> {
let connector_account_details = connector_account_details
.parse_value::<ConnectorAuthType>("ConnectorAuthType")
.change_context_lazy(|| errors::ConnectorError::WebhookSourceVerificationFailed)?;
let auth_type = zsl::ZslAuthType::try_from(&connector_account_details)?;
let key = auth_type.api_key.expose();
let mer_id = auth_type.merchant_id.expose();
let webhook_response = get_webhook_object_from_body(request.body)?;
let signature = zsl::calculate_signature(
webhook_response.enctype,
zsl::ZslSignatureType::WebhookSignature {
status: webhook_response.status,
txn_id: webhook_response.txn_id,
txn_date: webhook_response.txn_date,
paid_ccy: webhook_response.paid_ccy.to_string(),
paid_amt: webhook_response.paid_amt,
mer_ref: webhook_response.mer_ref,
mer_id,
key,
},
)?;
Ok(signature.eq(&webhook_response.signature))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/zsl.rs" role="context" start="383" end="391">
fn get_webhook_event_type(
&self,
request: &IncomingWebhookRequestDetails<'_>,
) -> CustomResult<IncomingWebhookEvent, errors::ConnectorError> {
let notif = get_webhook_object_from_body(request.body)
.change_context(errors::ConnectorError::WebhookEventTypeNotFound)?;
Ok(get_status(notif.status))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/zsl.rs" role="context" start="372" end="381">
fn get_webhook_object_reference_id(
&self,
request: &IncomingWebhookRequestDetails<'_>,
) -> CustomResult<ObjectReferenceId, errors::ConnectorError> {
let notif = get_webhook_object_from_body(request.body)
.change_context(errors::ConnectorError::WebhookReferenceIdNotFound)?;
Ok(ObjectReferenceId::PaymentId(
api_models::payments::PaymentIdType::PaymentAttemptId(notif.mer_ref),
))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/zsl.rs" role="context" start="443" end="450">
fn get_webhook_object_from_body(
body: &[u8],
) -> CustomResult<zsl::ZslWebhookResponse, errors::ConnectorError> {
let response: zsl::ZslWebhookResponse =
serde_urlencoded::from_bytes::<zsl::ZslWebhookResponse>(body)
.change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
Ok(response)
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/hyperswitch_connectors/src/connectors/zsl.rs<|crate|> hyperswitch_connectors<|connector|> zsl anchor=get_webhook_object_reference_id kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=1<|meta_end|>
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/zsl.rs" role="context" start="372" end="381">
fn get_webhook_object_reference_id(
&self,
request: &IncomingWebhookRequestDetails<'_>,
) -> CustomResult<ObjectReferenceId, errors::ConnectorError> {
let notif = get_webhook_object_from_body(request.body)
.change_context(errors::ConnectorError::WebhookReferenceIdNotFound)?;
Ok(ObjectReferenceId::PaymentId(
api_models::payments::PaymentIdType::PaymentAttemptId(notif.mer_ref),
))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/zsl.rs" role="context" start="371" end="371">
_connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Err(errors::ConnectorError::NotSupported {
message: "Rsync flow ".to_owned(),
connector: "Zsl",
}
.into())
}
}
#[async_trait::async_trait]
impl IncomingWebhook for Zsl {
fn get_webhook_object_reference_id(
&self,
request: &IncomingWebhookRequestDetails<'_>,
) -> CustomResult<ObjectReferenceId, errors::ConnectorError> {
let notif = get_webhook_object_from_body(request.body)
.change_context(errors::ConnectorError::WebhookReferenceIdNotFound)?;
Ok(ObjectReferenceId::PaymentId(
api_models::payments::PaymentIdType::PaymentAttemptId(notif.mer_ref),
))
}
fn get_webhook_event_type(
&self,
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/zsl.rs" role="context" start="393" end="400">
fn get_webhook_resource_object(
&self,
request: &IncomingWebhookRequestDetails<'_>,
) -> CustomResult<Box<dyn masking::ErasedMaskSerialize>, errors::ConnectorError> {
let response = get_webhook_object_from_body(request.body)
.change_context(errors::ConnectorError::WebhookEventTypeNotFound)?;
Ok(Box::new(response))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/zsl.rs" role="context" start="383" end="391">
fn get_webhook_event_type(
&self,
request: &IncomingWebhookRequestDetails<'_>,
) -> CustomResult<IncomingWebhookEvent, errors::ConnectorError> {
let notif = get_webhook_object_from_body(request.body)
.change_context(errors::ConnectorError::WebhookEventTypeNotFound)?;
Ok(get_status(notif.status))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/zsl.rs" role="context" start="357" end="367">
fn build_request(
&self,
_req: &RefundSyncRouterData,
_connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Err(errors::ConnectorError::NotSupported {
message: "Rsync flow ".to_owned(),
connector: "Zsl",
}
.into())
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/zsl.rs" role="context" start="343" end="353">
fn build_request(
&self,
_req: &RefundsRouterData<Execute>,
_connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Err(errors::ConnectorError::NotSupported {
message: "Refund flow".to_owned(),
connector: "Zsl",
}
.into())
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/zsl.rs" role="context" start="443" end="450">
fn get_webhook_object_from_body(
body: &[u8],
) -> CustomResult<zsl::ZslWebhookResponse, errors::ConnectorError> {
let response: zsl::ZslWebhookResponse =
serde_urlencoded::from_bytes::<zsl::ZslWebhookResponse>(body)
.change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
Ok(response)
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/hyperswitch_connectors/src/connectors/zsl.rs<|crate|> hyperswitch_connectors<|connector|> zsl anchor=get_request_body kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/zsl.rs" role="context" start="160" end="173">
fn get_request_body(
&self,
req: &PaymentsAuthorizeRouterData,
_connectors: &Connectors,
) -> CustomResult<RequestContent, errors::ConnectorError> {
let connector_router_data = zsl::ZslRouterData::try_from((
&self.get_currency_unit(),
req.request.currency,
req.request.amount,
req,
))?;
let connector_req = zsl::ZslPaymentsRequest::try_from(&connector_router_data)?;
Ok(RequestContent::FormUrlEncoded(Box::new(connector_req)))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/zsl.rs" role="context" start="159" end="159">
fn get_content_type(&self) -> &'static str {
self.common_get_content_type()
}
fn get_url(
&self,
_req: &PaymentsAuthorizeRouterData,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
Ok(format!("{}ecp", self.base_url(connectors)))
}
fn get_request_body(
&self,
req: &PaymentsAuthorizeRouterData,
_connectors: &Connectors,
) -> CustomResult<RequestContent, errors::ConnectorError> {
let connector_router_data = zsl::ZslRouterData::try_from((
&self.get_currency_unit(),
req.request.currency,
req.request.amount,
req,
))?;
let connector_req = zsl::ZslPaymentsRequest::try_from(&connector_router_data)?;
Ok(RequestContent::FormUrlEncoded(Box::new(connector_req)))
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/zsl.rs" role="context" start="197" end="214">
fn handle_response(
&self,
data: &PaymentsAuthorizeRouterData,
event_builder: Option<&mut ConnectorEvent>,
res: Response,
) -> CustomResult<PaymentsAuthorizeRouterData, errors::ConnectorError> {
let response = serde_urlencoded::from_bytes::<zsl::ZslPaymentsResponse>(&res.response)
.change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
event_builder.map(|i: &mut ConnectorEvent| i.set_response_body(&response));
router_env::logger::info!(connector_response=?response);
RouterData::try_from(ResponseRouterData {
response,
data: data.clone(),
http_code: res.status_code,
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/zsl.rs" role="context" start="175" end="195">
fn build_request(
&self,
req: &PaymentsAuthorizeRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Ok(Some(
RequestBuilder::new()
.method(Method::Post)
.url(&types::PaymentsAuthorizeType::get_url(
self, req, connectors,
)?)
.attach_default_headers()
.headers(types::PaymentsAuthorizeType::get_headers(
self, req, connectors,
)?)
.set_body(types::PaymentsAuthorizeType::get_request_body(
self, req, connectors,
)?)
.build(),
))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/zsl.rs" role="context" start="152" end="158">
fn get_url(
&self,
_req: &PaymentsAuthorizeRouterData,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
Ok(format!("{}ecp", self.base_url(connectors)))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/zsl.rs" role="context" start="148" end="150">
fn get_content_type(&self) -> &'static str {
self.common_get_content_type()
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/zsl/transformers.rs" role="context" start="34" end="37">
pub struct ZslRouterData<T> {
pub amount: String,
pub router_data: T,
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/hyperswitch_connectors/src/connectors/zsl.rs<|crate|> hyperswitch_connectors<|connector|> zsl anchor=verify_webhook_source kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/zsl.rs" role="context" start="402" end="432">
async fn verify_webhook_source(
&self,
request: &IncomingWebhookRequestDetails<'_>,
_merchant_id: &common_utils::id_type::MerchantId,
_connector_webhook_details: Option<common_utils::pii::SecretSerdeValue>,
connector_account_details: common_utils::crypto::Encryptable<Secret<serde_json::Value>>,
_connector_label: &str,
) -> CustomResult<bool, errors::ConnectorError> {
let connector_account_details = connector_account_details
.parse_value::<ConnectorAuthType>("ConnectorAuthType")
.change_context_lazy(|| errors::ConnectorError::WebhookSourceVerificationFailed)?;
let auth_type = zsl::ZslAuthType::try_from(&connector_account_details)?;
let key = auth_type.api_key.expose();
let mer_id = auth_type.merchant_id.expose();
let webhook_response = get_webhook_object_from_body(request.body)?;
let signature = zsl::calculate_signature(
webhook_response.enctype,
zsl::ZslSignatureType::WebhookSignature {
status: webhook_response.status,
txn_id: webhook_response.txn_id,
txn_date: webhook_response.txn_date,
paid_ccy: webhook_response.paid_ccy.to_string(),
paid_amt: webhook_response.paid_amt,
mer_ref: webhook_response.mer_ref,
mer_id,
key,
},
)?;
Ok(signature.eq(&webhook_response.signature))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/zsl.rs" role="context" start="401" end="401">
Ok(get_status(notif.status))
}
fn get_webhook_resource_object(
&self,
request: &IncomingWebhookRequestDetails<'_>,
) -> CustomResult<Box<dyn masking::ErasedMaskSerialize>, errors::ConnectorError> {
let response = get_webhook_object_from_body(request.body)
.change_context(errors::ConnectorError::WebhookEventTypeNotFound)?;
Ok(Box::new(response))
}
async fn verify_webhook_source(
&self,
request: &IncomingWebhookRequestDetails<'_>,
_merchant_id: &common_utils::id_type::MerchantId,
_connector_webhook_details: Option<common_utils::pii::SecretSerdeValue>,
connector_account_details: common_utils::crypto::Encryptable<Secret<serde_json::Value>>,
_connector_label: &str,
) -> CustomResult<bool, errors::ConnectorError> {
let connector_account_details = connector_account_details
.parse_value::<ConnectorAuthType>("ConnectorAuthType")
.change_context_lazy(|| errors::ConnectorError::WebhookSourceVerificationFailed)?;
let auth_type = zsl::ZslAuthType::try_from(&connector_account_details)?;
let key = auth_type.api_key.expose();
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/zsl.rs" role="context" start="443" end="450">
fn get_webhook_object_from_body(
body: &[u8],
) -> CustomResult<zsl::ZslWebhookResponse, errors::ConnectorError> {
let response: zsl::ZslWebhookResponse =
serde_urlencoded::from_bytes::<zsl::ZslWebhookResponse>(body)
.change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
Ok(response)
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/zsl.rs" role="context" start="434" end="440">
fn get_webhook_api_response(
&self,
_request: &IncomingWebhookRequestDetails<'_>,
_error_kind: Option<IncomingWebhookFlowError>,
) -> CustomResult<ApplicationResponse<serde_json::Value>, errors::ConnectorError> {
Ok(ApplicationResponse::TextPlain("CALLBACK-OK".to_string()))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/zsl.rs" role="context" start="393" end="400">
fn get_webhook_resource_object(
&self,
request: &IncomingWebhookRequestDetails<'_>,
) -> CustomResult<Box<dyn masking::ErasedMaskSerialize>, errors::ConnectorError> {
let response = get_webhook_object_from_body(request.body)
.change_context(errors::ConnectorError::WebhookEventTypeNotFound)?;
Ok(Box::new(response))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/zsl.rs" role="context" start="383" end="391">
fn get_webhook_event_type(
&self,
request: &IncomingWebhookRequestDetails<'_>,
) -> CustomResult<IncomingWebhookEvent, errors::ConnectorError> {
let notif = get_webhook_object_from_body(request.body)
.change_context(errors::ConnectorError::WebhookEventTypeNotFound)?;
Ok(get_status(notif.status))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/paypal/transformers.rs" role="context" start="396" end="399">
pub enum Value {
Amount(OrderRequestAmount),
Items(Vec<ItemDetails>),
}
<file_sep path="hyperswitch/crates/api_models/src/payment_methods.rs" role="context" start="1670" end="1670">
type Value = PaymentMethodListRequest;
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/hyperswitch_connectors/src/connectors/zsl/transformers.rs<|crate|> hyperswitch_connectors<|connector|> zsl anchor=try_from kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/zsl/transformers.rs" role="context" start="418" end="462">
fn try_from(
item: ResponseRouterData<F, ZslWebhookResponse, PaymentsSyncData, PaymentsResponseData>,
) -> Result<Self, Self::Error> {
let paid_amount = item
.response
.consr_paid_amt
.parse::<i64>()
.change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
if item.response.status == "0" {
Ok(Self {
status: enums::AttemptStatus::Charged,
amount_captured: Some(paid_amount),
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(item.response.txn_id.clone()),
redirection_data: Box::new(None),
mandate_reference: Box::new(None),
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: Some(item.response.mer_ref.clone()),
incremental_authorization_allowed: None,
charges: None,
}),
..item.data
})
} else {
let error_reason =
ZslResponseStatus::try_from(item.response.status.clone())?.to_string();
Ok(Self {
status: enums::AttemptStatus::Failure,
response: Err(ErrorResponse {
code: item.response.status.clone(),
message: error_reason.clone(),
reason: Some(error_reason.clone()),
status_code: item.http_code,
attempt_status: Some(enums::AttemptStatus::Failure),
connector_transaction_id: Some(item.response.mer_ref.clone()),
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
}),
..item.data
})
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/zsl/transformers.rs" role="context" start="417" end="417">
use common_enums::enums;
use hyperswitch_domain_models::{
payment_method_data::{BankTransferData, PaymentMethodData},
router_data::{ConnectorAuthType, ErrorResponse, RouterData},
router_request_types::{PaymentsSyncData, ResponseId},
router_response_types::{PaymentsResponseData, RedirectForm},
types,
};
use crate::{
types::ResponseRouterData,
utils::{
get_amount_as_string, get_unimplemented_payment_method_error_message,
PaymentsAuthorizeRequestData, RouterData as _,
},
};
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/zsl/transformers.rs" role="context" start="895" end="941">
pub fn calculate_signature(
enctype: EncodingType,
signature_data: ZslSignatureType,
) -> Result<Secret<String>, error_stack::Report<errors::ConnectorError>> {
let signature_data = match signature_data {
ZslSignatureType::RequestSignature {
txn_amt,
ccy,
mer_ref,
mer_id,
mer_txn_date,
key,
} => format!("{txn_amt}{ccy}{mer_ref}{mer_id}{mer_txn_date}{key}"),
ZslSignatureType::ResponseSignature {
status,
txn_url,
mer_ref,
mer_id,
key,
} => {
format!("{status}{txn_url}{mer_ref}{mer_id}{key}")
}
ZslSignatureType::WebhookSignature {
status,
txn_id,
txn_date,
paid_ccy,
paid_amt,
mer_ref,
mer_id,
key,
} => format!("{status}{txn_id}{txn_date}{paid_ccy}{paid_amt}{mer_ref}{mer_id}{key}"),
};
let message = signature_data.as_bytes();
let encoded_data = match enctype {
EncodingType::MD5 => hex::encode(
common_utils::crypto::Md5
.generate_digest(message)
.change_context(errors::ConnectorError::RequestEncodingFailed)?,
),
EncodingType::Sha1 => {
hex::encode(digest::digest(&digest::SHA1_FOR_LEGACY_USE_ONLY, message))
}
};
Ok(Secret::new(encoded_data))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/zsl/transformers.rs" role="context" start="467" end="663">
fn try_from(status: String) -> Result<Self, Self::Error> {
match status.as_str() {
"0" => Ok(Self::Normal),
"1000" => Ok(Self::InternalError),
"1001" => Ok(Self::BreakDownMessageError),
"1002" => Ok(Self::FormatError),
"1004" => Ok(Self::InvalidTransaction),
"1005" => Ok(Self::TransactionCountryNotFound),
"1006" => Ok(Self::MerchantIdNotFound),
"1007" => Ok(Self::AccountDisabled),
"1008" => Ok(Self::DuplicateMerchantReference),
"1009" => Ok(Self::InvalidPayAmount),
"1010" => Ok(Self::PayAmountNotFound),
"1011" => Ok(Self::InvalidCurrencyCode),
"1012" => Ok(Self::CurrencyCodeNotFound),
"1013" => Ok(Self::ReferenceNotFound),
"1014" => Ok(Self::TransmissionTimeNotFound),
"1015" => Ok(Self::PayMethodNotFound),
"1016" => Ok(Self::BankCodeNotFound),
"1017" => Ok(Self::InvalidShowPayPage),
"1018" => Ok(Self::ShowPayPageNotFound),
"1019" => Ok(Self::SuccessUrlNotFound),
"1020" => Ok(Self::SuccessCallbackUrlNotFound),
"1021" => Ok(Self::FailUrlNotFound),
"1022" => Ok(Self::FailCallbackUrlNotFound),
"1023" => Ok(Self::MacNotFound),
"1025" => Ok(Self::OriginalTransactionNotFound),
"1026" => Ok(Self::DeblockDataError),
"1028" => Ok(Self::PspAckNotYetReturn),
"1029" => Ok(Self::BankBranchNameNotFound),
"1030" => Ok(Self::BankAccountIDNotFound),
"1031" => Ok(Self::BankAccountNameNotFound),
"1032" => Ok(Self::IdentityIDNotFound),
"1033" => Ok(Self::ErrorConnectingToPsp),
"1034" => Ok(Self::CountryPspNotAvailable),
"1035" => Ok(Self::UnsupportedPayAmount),
"1036" => Ok(Self::RecordMismatch),
"1037" => Ok(Self::NoRecord),
"1038" => Ok(Self::PspError),
"1039" => Ok(Self::UnsupportedEncryptionType),
"1040" => Ok(Self::ExceedTransactionLimitCount),
"1041" => Ok(Self::ExceedTransactionLimitAmount),
"1042" => Ok(Self::ExceedTransactionAccountLimitCount),
"1043" => Ok(Self::ExceedTransactionAccountLimitAmount),
"1044" => Ok(Self::ExchangeRateError),
"1045" => Ok(Self::InvalidEncoding),
"1046" => Ok(Self::CustomerNameNotFound),
"1047" => Ok(Self::CustomerFamilyNameNotFound),
"1048" => Ok(Self::CustomerTelPhoneNotFound),
"1049" => Ok(Self::InsufficientFund),
"1050" => Ok(Self::ServiceCodeIsMissing),
"1051" => Ok(Self::CurrencyIdNotMatch),
"1052" => Ok(Self::NoPendingRecord),
"1053" => Ok(Self::NoLoadBalancerRuleDefineForTransaction),
"1054" => Ok(Self::NoPaymentProviderAvailable),
"1055" => Ok(Self::UnsupportedPayMethod),
"1056" => Ok(Self::PendingTransaction),
"1057" => Ok(Self::OtherError1059),
"1058" => Ok(Self::OtherError1058),
"1059" => Ok(Self::OtherError1059),
"1084" => Ok(Self::InvalidRequestId),
"5043" => Ok(Self::BeneficiaryBankAccountIsNotAvailable),
"5053" => Ok(Self::BaidNotFound),
"5057" => Ok(Self::InvalidBaid),
"5059" => Ok(Self::InvalidBaidStatus),
"5107" => Ok(Self::AutoUploadBankDisabled),
"5108" => Ok(Self::InvalidNature),
"5109" => Ok(Self::SmsCreateDateNotFound),
"5110" => Ok(Self::InvalidSmsCreateDate),
"5111" => Ok(Self::RecordNotFound),
"5112" => Ok(Self::InsufficientBaidAvailableBalance),
"5113" => Ok(Self::ExceedTxnAmountLimit),
"5114" => Ok(Self::BaidBalanceNotFound),
"5115" => Ok(Self::AutoUploadIndicatorNotFound),
"5116" => Ok(Self::InvalidBankAcctStatus),
"5117" => Ok(Self::InvalidAutoUploadIndicator),
"5118" => Ok(Self::InvalidPidStatus),
"5119" => Ok(Self::InvalidProviderStatus),
"5120" => Ok(Self::InvalidBankAccountSystemSwitchEnabled),
"5121" => Ok(Self::AutoUploadProviderDisabled),
"5122" => Ok(Self::AutoUploadBankNotFound),
"5123" => Ok(Self::AutoUploadBankAcctNotFound),
"5124" => Ok(Self::AutoUploadProviderNotFound),
"5125" => Ok(Self::UnsupportedBankCode),
"5126" => Ok(Self::BalanceOverrideIndicatorNotFound),
"5127" => Ok(Self::InvalidBalanceOverrideIndicator),
"10000" => Ok(Self::VernoInvalid),
"10001" => Ok(Self::ServiceCodeInvalid),
"10002" => Ok(Self::PspResponseSignatureIsNotValid),
"10003" => Ok(Self::ProcessTypeNotFound),
"10004" => Ok(Self::ProcessCodeNotFound),
"10005" => Ok(Self::EnctypeNotFound),
"10006" => Ok(Self::VernoNotFound),
"10007" => Ok(Self::DepositBankNotFound),
"10008" => Ok(Self::DepositFlowNotFound),
"10009" => Ok(Self::CustDepositDateNotFound),
"10010" => Ok(Self::CustTagNotFound),
"10011" => Ok(Self::CountryValueInvalid),
"10012" => Ok(Self::CurrencyCodeValueInvalid),
"10013" => Ok(Self::MerTxnDateInvalid),
"10014" => Ok(Self::CustDepositDateInvalid),
"10015" => Ok(Self::TxnAmtInvalid),
"10016" => Ok(Self::SuccessCallbackUrlInvalid),
"10017" => Ok(Self::DepositFlowInvalid),
"10018" => Ok(Self::ProcessTypeInvalid),
"10019" => Ok(Self::ProcessCodeInvalid),
"10020" => Ok(Self::UnsupportedMerRefLength),
"10021" => Ok(Self::DepositBankLengthOverLimit),
"10022" => Ok(Self::CustTagLengthOverLimit),
"10023" => Ok(Self::SignatureLengthOverLimit),
"10024" => Ok(Self::RequestContainInvalidTag),
"10025" => Ok(Self::RequestSignatureNotMatch),
"10026" => Ok(Self::InvalidCustomer),
"10027" => Ok(Self::SchemeNotFound),
"10028" => Ok(Self::PspResponseFieldsMissing),
"10029" => Ok(Self::PspResponseMerRefNotMatchWithRequestMerRef),
"10030" => Ok(Self::PspResponseMerIdNotMatchWithRequestMerId),
"10031" => Ok(Self::UpdateDepositFailAfterResponse),
"10032" => Ok(Self::UpdateUsedLimitTransactionCountFailAfterSuccessResponse),
"10033" => Ok(Self::UpdateCustomerLastDepositRecordAfterSuccessResponse),
"10034" => Ok(Self::CreateDepositFail),
"10035" => Ok(Self::CreateDepositMsgFail),
"10036" => Ok(Self::UpdateStatusSubStatusFail),
"10037" => Ok(Self::AddDepositRecordToSchemeAccount),
"10038" => Ok(Self::EmptyResponse),
"10039" => Ok(Self::AubConfirmErrorFromPh),
"10040" => Ok(Self::ProviderEmailAddressNotFound),
"10041" => Ok(Self::AubConnectionTimeout),
"10042" => Ok(Self::AubConnectionIssue),
"10043" => Ok(Self::AubMsgTypeMissing),
"10044" => Ok(Self::AubMsgCodeMissing),
"10045" => Ok(Self::AubVersionMissing),
"10046" => Ok(Self::AubEncTypeMissing),
"10047" => Ok(Self::AubSignMissing),
"10048" => Ok(Self::AubInfoMissing),
"10049" => Ok(Self::AubErrorCodeMissing),
"10050" => Ok(Self::AubMsgTypeInvalid),
"10051" => Ok(Self::AubMsgCodeInvalid),
"10052" => Ok(Self::AubBaidMissing),
"10053" => Ok(Self::AubResponseSignNotMatch),
"10054" => Ok(Self::SmsConnectionTimeout),
"10055" => Ok(Self::SmsConnectionIssue),
"10056" => Ok(Self::SmsConfirmErrorFromPh),
"10057" => Ok(Self::SmsMsgTypeMissing),
"10058" => Ok(Self::SmsMsgCodeMissing),
"10059" => Ok(Self::SmsVersionMissing),
"10060" => Ok(Self::SmsEncTypeMissing),
"10061" => Ok(Self::SmsSignMissing),
"10062" => Ok(Self::SmsInfoMissing),
"10063" => Ok(Self::SmsErrorCodeMissing),
"10064" => Ok(Self::SmsMsgTypeInvalid),
"10065" => Ok(Self::SmsMsgCodeInvalid),
"10066" => Ok(Self::SmsResponseSignNotMatch),
"10067" => Ok(Self::SmsRequestReachMaximumLimit),
"10068" => Ok(Self::SyncConnectionTimeout),
"10069" => Ok(Self::SyncConnectionIssue),
"10070" => Ok(Self::SyncConfirmErrorFromPh),
"10071" => Ok(Self::SyncMsgTypeMissing),
"10072" => Ok(Self::SyncMsgCodeMissing),
"10073" => Ok(Self::SyncVersionMissing),
"10074" => Ok(Self::SyncEncTypeMissing),
"10075" => Ok(Self::SyncSignMissing),
"10076" => Ok(Self::SyncInfoMissing),
"10077" => Ok(Self::SyncErrorCodeMissing),
"10078" => Ok(Self::SyncMsgTypeInvalid),
"10079" => Ok(Self::SyncMsgCodeInvalid),
"10080" => Ok(Self::SyncResponseSignNotMatch),
"10081" => Ok(Self::AccountExpired),
"10082" => Ok(Self::ExceedMaxMinAmount),
"10083" => Ok(Self::WholeNumberAmountLessThanOne),
"10084" => Ok(Self::AddDepositRecordToSchemeChannel),
"10085" => Ok(Self::UpdateUtilizedAmountFailAfterSuccessResponse),
"10086" => Ok(Self::PidResponseInvalidFormat),
"10087" => Ok(Self::PspNameNotFound),
"10088" => Ok(Self::LangIsMissing),
"10089" => Ok(Self::FailureCallbackUrlInvalid),
"10090" => Ok(Self::SuccessRedirectUrlInvalid),
"10091" => Ok(Self::FailureRedirectUrlInvalid),
"10092" => Ok(Self::LangValueInvalid),
"10093" => Ok(Self::OnlineDepositSessionTimeout),
"10094" => Ok(Self::AccessPaymentPageRouteFieldMissing),
"10095" => Ok(Self::AmountNotMatch),
"10096" => Ok(Self::PidCallbackFieldsMissing),
"10097" => Ok(Self::TokenNotMatch),
"10098" => Ok(Self::OperationDuplicated),
"10099" => Ok(Self::PayPageDomainNotAvailable),
"10100" => Ok(Self::PayPageConfirmSignatureNotMatch),
"10101" => Ok(Self::PaymentPageConfirmationFieldMissing),
"10102" => Ok(Self::MultipleCallbackFromPsp),
"10103" => Ok(Self::PidNotAvailable),
"10104" => Ok(Self::PidDepositUrlNotValidOrEmp),
"10105" => Ok(Self::PspSelfRedirectTagNotValid),
"20000" => Ok(Self::InternalError20000),
"20001" => Ok(Self::DepositTimeout),
_ => Err(errors::ConnectorError::ResponseHandlingFailed.into()),
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/zsl/transformers.rs" role="context" start="406" end="412">
pub(crate) fn get_status(status: String) -> api_models::webhooks::IncomingWebhookEvent {
match status.as_str() {
//any response with status != 0 are a failed deposit transaction
"0" => api_models::webhooks::IncomingWebhookEvent::PaymentIntentSuccess,
_ => api_models::webhooks::IncomingWebhookEvent::PaymentIntentFailure,
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/zsl/transformers.rs" role="context" start="300" end="381">
fn try_from(
item: ResponseRouterData<F, ZslPaymentsResponse, T, PaymentsResponseData>,
) -> Result<Self, Self::Error> {
if item.response.status.eq("0") && !item.response.txn_url.is_empty() {
let auth_type = ZslAuthType::try_from(&item.data.connector_auth_type)?;
let key: Secret<String> = auth_type.api_key;
let mer_id = auth_type.merchant_id;
let calculated_signature = calculate_signature(
item.response.enctype,
ZslSignatureType::ResponseSignature {
status: item.response.status.clone(),
txn_url: item.response.txn_url.clone(),
mer_ref: item.response.mer_ref.clone(),
mer_id: mer_id.clone().expose(),
key: key.expose(),
},
)?;
if calculated_signature.clone().eq(&item.response.signature) {
let decoded_redirect_url_bytes: Vec<u8> = base64::engine::general_purpose::STANDARD
.decode(item.response.txn_url.clone())
.change_context(errors::ConnectorError::RequestEncodingFailed)?;
let redirect_url = String::from_utf8(decoded_redirect_url_bytes)
.change_context(errors::ConnectorError::RequestEncodingFailed)?;
Ok(Self {
status: enums::AttemptStatus::AuthenticationPending, // Redirect is always expected after success response
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::NoResponseId,
redirection_data: Box::new(Some(RedirectForm::Form {
endpoint: redirect_url,
method: Method::Get,
form_fields: HashMap::new(),
})),
mandate_reference: Box::new(None),
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: Some(item.response.mer_ref.clone()),
incremental_authorization_allowed: None,
charges: None,
}),
..item.data
})
} else {
// When the signature check fails
Ok(Self {
status: enums::AttemptStatus::Failure,
response: Err(ErrorResponse {
code: NO_ERROR_CODE.to_string(),
message: auth_error::INVALID_SIGNATURE.to_string(),
reason: Some(auth_error::INVALID_SIGNATURE.to_string()),
status_code: item.http_code,
attempt_status: Some(enums::AttemptStatus::Failure),
connector_transaction_id: Some(item.response.mer_ref.clone()),
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
}),
..item.data
})
}
} else {
let error_reason =
ZslResponseStatus::try_from(item.response.status.clone())?.to_string();
Ok(Self {
status: enums::AttemptStatus::Failure,
response: Err(ErrorResponse {
code: item.response.status.clone(),
message: error_reason.clone(),
reason: Some(error_reason.clone()),
status_code: item.http_code,
attempt_status: Some(enums::AttemptStatus::Failure),
connector_transaction_id: Some(item.response.mer_ref.clone()),
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
}),
..item.data
})
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/zsl/transformers.rs" role="context" start="668" end="860">
pub enum ZslResponseStatus {
Normal,
InternalError,
BreakDownMessageError,
FormatError,
InvalidTransaction,
TransactionCountryNotFound,
MerchantIdNotFound,
AccountDisabled,
DuplicateMerchantReference,
InvalidPayAmount,
PayAmountNotFound,
InvalidCurrencyCode,
CurrencyCodeNotFound,
ReferenceNotFound,
TransmissionTimeNotFound,
PayMethodNotFound,
BankCodeNotFound,
InvalidShowPayPage,
ShowPayPageNotFound,
SuccessUrlNotFound,
SuccessCallbackUrlNotFound,
FailUrlNotFound,
FailCallbackUrlNotFound,
MacNotFound,
OriginalTransactionNotFound,
DeblockDataError,
PspAckNotYetReturn,
BankBranchNameNotFound,
BankAccountIDNotFound,
BankAccountNameNotFound,
IdentityIDNotFound,
ErrorConnectingToPsp,
CountryPspNotAvailable,
UnsupportedPayAmount,
RecordMismatch,
NoRecord,
PspError,
UnsupportedEncryptionType,
ExceedTransactionLimitCount,
ExceedTransactionLimitAmount,
ExceedTransactionAccountLimitCount,
ExceedTransactionAccountLimitAmount,
ExchangeRateError,
InvalidEncoding,
CustomerNameNotFound,
CustomerFamilyNameNotFound,
CustomerTelPhoneNotFound,
InsufficientFund,
ServiceCodeIsMissing,
CurrencyIdNotMatch,
NoPendingRecord,
NoLoadBalancerRuleDefineForTransaction,
NoPaymentProviderAvailable,
UnsupportedPayMethod,
PendingTransaction,
OtherError1059,
OtherError1058,
InvalidRequestId,
BeneficiaryBankAccountIsNotAvailable,
BaidNotFound,
InvalidBaid,
InvalidBaidStatus,
AutoUploadBankDisabled,
InvalidNature,
SmsCreateDateNotFound,
InvalidSmsCreateDate,
RecordNotFound,
InsufficientBaidAvailableBalance,
ExceedTxnAmountLimit,
BaidBalanceNotFound,
AutoUploadIndicatorNotFound,
InvalidBankAcctStatus,
InvalidAutoUploadIndicator,
InvalidPidStatus,
InvalidProviderStatus,
InvalidBankAccountSystemSwitchEnabled,
AutoUploadProviderDisabled,
AutoUploadBankNotFound,
AutoUploadBankAcctNotFound,
AutoUploadProviderNotFound,
UnsupportedBankCode,
BalanceOverrideIndicatorNotFound,
InvalidBalanceOverrideIndicator,
VernoInvalid,
ServiceCodeInvalid,
PspResponseSignatureIsNotValid,
ProcessTypeNotFound,
ProcessCodeNotFound,
EnctypeNotFound,
VernoNotFound,
DepositBankNotFound,
DepositFlowNotFound,
CustDepositDateNotFound,
CustTagNotFound,
CountryValueInvalid,
CurrencyCodeValueInvalid,
MerTxnDateInvalid,
CustDepositDateInvalid,
TxnAmtInvalid,
SuccessCallbackUrlInvalid,
DepositFlowInvalid,
ProcessTypeInvalid,
ProcessCodeInvalid,
UnsupportedMerRefLength,
DepositBankLengthOverLimit,
CustTagLengthOverLimit,
SignatureLengthOverLimit,
RequestContainInvalidTag,
RequestSignatureNotMatch,
InvalidCustomer,
SchemeNotFound,
PspResponseFieldsMissing,
PspResponseMerRefNotMatchWithRequestMerRef,
PspResponseMerIdNotMatchWithRequestMerId,
UpdateDepositFailAfterResponse,
UpdateUsedLimitTransactionCountFailAfterSuccessResponse,
UpdateCustomerLastDepositRecordAfterSuccessResponse,
CreateDepositFail,
CreateDepositMsgFail,
UpdateStatusSubStatusFail,
AddDepositRecordToSchemeAccount,
EmptyResponse,
AubConfirmErrorFromPh,
ProviderEmailAddressNotFound,
AubConnectionTimeout,
AubConnectionIssue,
AubMsgTypeMissing,
AubMsgCodeMissing,
AubVersionMissing,
AubEncTypeMissing,
AubSignMissing,
AubInfoMissing,
AubErrorCodeMissing,
AubMsgTypeInvalid,
AubMsgCodeInvalid,
AubBaidMissing,
AubResponseSignNotMatch,
SmsConnectionTimeout,
SmsConnectionIssue,
SmsConfirmErrorFromPh,
SmsMsgTypeMissing,
SmsMsgCodeMissing,
SmsVersionMissing,
SmsEncTypeMissing,
SmsSignMissing,
SmsInfoMissing,
SmsErrorCodeMissing,
SmsMsgTypeInvalid,
SmsMsgCodeInvalid,
SmsResponseSignNotMatch,
SmsRequestReachMaximumLimit,
SyncConnectionTimeout,
SyncConnectionIssue,
SyncConfirmErrorFromPh,
SyncMsgTypeMissing,
SyncMsgCodeMissing,
SyncVersionMissing,
SyncEncTypeMissing,
SyncSignMissing,
SyncInfoMissing,
SyncErrorCodeMissing,
SyncMsgTypeInvalid,
SyncMsgCodeInvalid,
SyncResponseSignNotMatch,
AccountExpired,
ExceedMaxMinAmount,
WholeNumberAmountLessThanOne,
AddDepositRecordToSchemeChannel,
UpdateUtilizedAmountFailAfterSuccessResponse,
PidResponseInvalidFormat,
PspNameNotFound,
LangIsMissing,
FailureCallbackUrlInvalid,
SuccessRedirectUrlInvalid,
FailureRedirectUrlInvalid,
LangValueInvalid,
OnlineDepositSessionTimeout,
AccessPaymentPageRouteFieldMissing,
AmountNotMatch,
PidCallbackFieldsMissing,
TokenNotMatch,
OperationDuplicated,
PayPageDomainNotAvailable,
PayPageConfirmSignatureNotMatch,
PaymentPageConfirmationFieldMissing,
MultipleCallbackFromPsp,
PidNotAvailable,
PidDepositUrlNotValidOrEmp,
PspSelfRedirectTagNotValid,
InternalError20000,
DepositTimeout,
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/zsl/transformers.rs" role="context" start="40" end="40">
type Error = error_stack::Report<errors::ConnectorError>;
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/aci/transformers.rs" role="context" start="642" end="642">
type Err = error_stack::Report<errors::ConnectorError>;
<file_sep path="hyperswitch/crates/api_models/src/errors/types.rs" role="context" start="42" end="52">
struct ErrorResponse<'a> {
#[serde(rename = "type")]
error_type: &'static str,
message: Cow<'a, str>,
code: String,
#[serde(flatten)]
extra: &'a Option<Extra>,
#[cfg(feature = "detailed_errors")]
#[serde(skip_serializing_if = "Option::is_none")]
stacktrace: Option<&'a serde_json::Value>,
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/router/tests/connectors/cashtocode.rs<|crate|> router<|connector|> cashtocode anchor=get_payment_authorize_data kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/router/tests/connectors/cashtocode.rs" role="context" start="41" end="79">
fn get_payment_authorize_data(
payment_method_type: Option<enums::PaymentMethodType>,
payment_method_data: domain::PaymentMethodData,
) -> Option<types::PaymentsAuthorizeData> {
let cust_id = id_type::CustomerId::try_from(std::borrow::Cow::from("John Doe"));
Some(types::PaymentsAuthorizeData {
amount: 1000,
currency: enums::Currency::EUR,
payment_method_data,
confirm: true,
statement_descriptor_suffix: None,
statement_descriptor: None,
setup_future_usage: None,
mandate_id: None,
off_session: None,
setup_mandate_details: None,
capture_method: None,
browser_info: None,
order_details: None,
order_category: None,
email: None,
customer_name: None,
payment_experience: None,
payment_method_type,
session_token: None,
enrolled_for_3ds: false,
related_transaction_id: None,
router_return_url: Some(String::from("https://google.com")),
webhook_url: None,
complete_authorize_url: None,
customer_id: cust_id.ok(),
surcharge_details: None,
request_incremental_authorization: false,
metadata: None,
authentication_data: None,
customer_acceptance: None,
..utils::PaymentAuthorizeType::default().0
})
}
<file_sep path="hyperswitch/crates/router/tests/connectors/cashtocode.rs" role="context" start="40" end="40">
use router::types::{self, domain, storage::enums};
<file_sep path="hyperswitch/crates/router/tests/connectors/cashtocode.rs" role="context" start="103" end="118">
async fn should_fetch_pay_url_classic() {
let authorize_response = CONNECTOR
.make_payment(
CashtocodeTest::get_payment_authorize_data(
Some(enums::PaymentMethodType::ClassicReward),
domain::payments::PaymentMethodData::Reward,
),
CashtocodeTest::get_payment_info(),
)
.await
.unwrap();
assert_eq!(
authorize_response.status,
enums::AttemptStatus::AuthenticationPending
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/cashtocode.rs" role="context" start="81" end="98">
fn get_payment_info() -> Option<utils::PaymentInfo> {
Some(utils::PaymentInfo {
address: Some(types::PaymentAddress::new(
None,
Some(Address {
address: Some(AddressDetails {
country: Some(api_models::enums::CountryAlpha2::US),
..Default::default()
}),
phone: None,
email: None,
}),
None,
None,
)),
..Default::default()
})
}
<file_sep path="hyperswitch/crates/router/tests/connectors/cashtocode.rs" role="context" start="33" end="35">
fn get_name(&self) -> String {
"cashtocode".to_string()
}
<file_sep path="hyperswitch/crates/router/tests/connectors/cashtocode.rs" role="context" start="24" end="31">
fn get_auth_token(&self) -> types::ConnectorAuthType {
utils::to_connector_auth_type(
connector_auth::ConnectorAuthentication::new()
.cashtocode
.expect("Missing connector authentication configuration")
.into(),
)
}
<file_sep path="hyperswitch/crates/router/tests/connectors/cashtocode.rs" role="context" start="121" end="136">
async fn should_fetch_pay_url_evoucher() {
let authorize_response = CONNECTOR
.make_payment(
CashtocodeTest::get_payment_authorize_data(
Some(enums::PaymentMethodType::Evoucher),
domain::payments::PaymentMethodData::Reward,
),
CashtocodeTest::get_payment_info(),
)
.await
.unwrap();
assert_eq!(
authorize_response.status,
enums::AttemptStatus::AuthenticationPending
);
}
<file_sep path="hyperswitch/crates/router/src/compatibility/stripe/customers/types.rs" role="context" start="202" end="207">
pub struct PaymentMethodData {
pub id: Option<String>,
pub object: &'static str,
pub card: Option<CardDetails>,
pub created: Option<time::PrimitiveDateTime>,
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/hyperswitch_connectors/src/connectors/cashtocode/transformers.rs<|crate|> hyperswitch_connectors<|connector|> cashtocode anchor=from kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=1<|meta_end|>
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/cashtocode/transformers.rs" role="context" start="169" end="174">
fn from(item: CashtocodePaymentStatus) -> Self {
match item {
CashtocodePaymentStatus::Succeeded => Self::Charged,
CashtocodePaymentStatus::Processing => Self::AuthenticationPending,
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/cashtocode/transformers.rs" role="context" start="238" end="291">
fn try_from(
item: ResponseRouterData<
F,
CashtocodePaymentsResponse,
PaymentsAuthorizeData,
PaymentsResponseData,
>,
) -> Result<Self, Self::Error> {
let (status, response) = match item.response {
CashtocodePaymentsResponse::CashtoCodeError(error_data) => (
enums::AttemptStatus::Failure,
Err(ErrorResponse {
code: error_data.error.to_string(),
status_code: item.http_code,
message: error_data.error_description.clone(),
reason: Some(error_data.error_description),
attempt_status: None,
connector_transaction_id: None,
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
}),
),
CashtocodePaymentsResponse::CashtoCodeData(response_data) => {
let payment_method_type = item
.data
.request
.payment_method_type
.ok_or(errors::ConnectorError::MissingPaymentMethodType)?;
let redirection_data = get_redirect_form_data(payment_method_type, response_data)?;
(
enums::AttemptStatus::AuthenticationPending,
Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(
item.data.attempt_id.clone(),
),
redirection_data: Box::new(Some(redirection_data)),
mandate_reference: Box::new(None),
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: None,
incremental_authorization_allowed: None,
charges: None,
}),
)
}
};
Ok(Self {
status,
response,
..item.data
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/cashtocode/transformers.rs" role="context" start="205" end="225">
fn get_redirect_form_data(
payment_method_type: enums::PaymentMethodType,
response_data: CashtocodePaymentsResponseData,
) -> CustomResult<RedirectForm, errors::ConnectorError> {
match payment_method_type {
enums::PaymentMethodType::ClassicReward => Ok(RedirectForm::Form {
//redirect form is manually constructed because the connector for this pm type expects query params in the url
endpoint: response_data.pay_url.to_string(),
method: Method::Post,
form_fields: Default::default(),
}),
enums::PaymentMethodType::Evoucher => Ok(RedirectForm::from((
//here the pay url gets parsed, and query params are sent as formfields as the connector expects
response_data.pay_url,
Method::Get,
))),
_ => Err(errors::ConnectorError::NotImplemented(
utils::get_unimplemented_payment_method_error_message("CashToCode"),
))?,
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/cashtocode/transformers.rs" role="context" start="137" end="157">
fn try_from(value: (&ConnectorAuthType, &enums::Currency)) -> Result<Self, Self::Error> {
let (auth_type, currency) = value;
if let ConnectorAuthType::CurrencyAuthKey { auth_key_map } = auth_type {
if let Some(identity_auth_key) = auth_key_map.get(currency) {
let cashtocode_auth: Self = identity_auth_key
.to_owned()
.parse_value("CashtocodeAuth")
.change_context(errors::ConnectorError::FailedToObtainAuthType)?;
Ok(cashtocode_auth)
} else {
Err(errors::ConnectorError::CurrencyNotSupported {
message: currency.to_string(),
connector: "CashToCode",
}
.into())
}
} else {
Err(errors::ConnectorError::FailedToObtainAuthType.into())
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/cashtocode/transformers.rs" role="context" start="108" end="131">
fn try_from(auth_type: &ConnectorAuthType) -> Result<Self, Self::Error> {
match auth_type {
ConnectorAuthType::CurrencyAuthKey { auth_key_map } => {
let transformed_auths = auth_key_map
.iter()
.map(|(currency, identity_auth_key)| {
let cashtocode_auth = identity_auth_key
.to_owned()
.parse_value::<CashtocodeAuth>("CashtocodeAuth")
.change_context(errors::ConnectorError::InvalidDataFormat {
field_name: "auth_key_map",
})?;
Ok((currency.to_owned(), cashtocode_auth))
})
.collect::<Result<_, Self::Error>>()?;
Ok(Self {
auths: transformed_auths,
})
}
_ => Err(errors::ConnectorError::FailedToObtainAuthType.into()),
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/cashtocode/transformers.rs" role="context" start="162" end="166">
pub enum CashtocodePaymentStatus {
Succeeded,
#[default]
Processing,
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/hyperswitch_connectors/src/connectors/cashtocode.rs<|crate|> hyperswitch_connectors<|connector|> cashtocode anchor=get_url kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=1<|meta_end|>
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/cashtocode.rs" role="context" start="224" end="233">
fn get_url(
&self,
_req: &PaymentsAuthorizeRouterData,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
Ok(format!(
"{}/merchant/paytokens",
connectors.cashtocode.base_url
))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/cashtocode.rs" role="context" start="223" end="223">
use common_utils::{
errors::CustomResult,
ext_traits::ByteSliceExt,
request::{Method, Request, RequestBuilder, RequestContent},
types::{AmountConvertor, FloatMajorUnit, FloatMajorUnitForConnector},
};
use hyperswitch_domain_models::{
api::ApplicationResponse,
router_data::{AccessToken, ErrorResponse, RouterData},
router_flow_types::{
access_token_auth::AccessTokenAuth,
payments::{Authorize, Capture, PSync, PaymentMethodToken, Session, SetupMandate, Void},
refunds::{Execute, RSync},
},
router_request_types::{
AccessTokenRequestData, PaymentMethodTokenizationData, PaymentsAuthorizeData,
PaymentsCancelData, PaymentsCaptureData, PaymentsSessionData, PaymentsSyncData,
RefundsData, SetupMandateRequestData,
},
router_response_types::{PaymentsResponseData, RefundsResponseData},
types::{PaymentsAuthorizeRouterData, PaymentsSyncRouterData},
};
use hyperswitch_interfaces::{
api::{
self, ConnectorCommon, ConnectorCommonExt, ConnectorIntegration, ConnectorSpecifications,
ConnectorValidation,
},
configs::Connectors,
errors,
events::connector_api_logs::ConnectorEvent,
types::{PaymentsAuthorizeType, Response},
webhooks::{self, IncomingWebhookFlowError},
};
use transformers as cashtocode;
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/cashtocode.rs" role="context" start="249" end="265">
fn build_request(
&self,
req: &PaymentsAuthorizeRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Ok(Some(
RequestBuilder::new()
.method(Method::Post)
.url(&PaymentsAuthorizeType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(PaymentsAuthorizeType::get_headers(self, req, connectors)?)
.set_body(PaymentsAuthorizeType::get_request_body(
self, req, connectors,
)?)
.build(),
))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/cashtocode.rs" role="context" start="235" end="247">
fn get_request_body(
&self,
req: &PaymentsAuthorizeRouterData,
_connectors: &Connectors,
) -> CustomResult<RequestContent, errors::ConnectorError> {
let amount = utils::convert_amount(
self.amount_converter,
req.request.minor_amount,
req.request.currency,
)?;
let connector_req = cashtocode::CashtocodePaymentsRequest::try_from((req, amount))?;
Ok(RequestContent::Json(Box::new(connector_req)))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/cashtocode.rs" role="context" start="220" end="222">
fn get_content_type(&self) -> &'static str {
self.common_get_content_type()
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/cashtocode.rs" role="context" start="197" end="218">
fn get_headers(
&self,
req: &PaymentsAuthorizeRouterData,
_connectors: &Connectors,
) -> CustomResult<Vec<(String, masking::Maskable<String>)>, errors::ConnectorError> {
let mut header = vec![(
headers::CONTENT_TYPE.to_string(),
PaymentsAuthorizeType::get_content_type(self)
.to_owned()
.into(),
)];
let auth_type = transformers::CashtocodeAuth::try_from((
&req.connector_auth_type,
&req.request.currency,
))?;
let mut api_key = get_b64_auth_cashtocode(req.request.payment_method_type, &auth_type)?;
header.append(&mut api_key);
Ok(header)
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/hyperswitch_connectors/src/connectors/cashtocode.rs<|crate|> hyperswitch_connectors<|connector|> cashtocode anchor=get_webhook_resource_object kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/cashtocode.rs" role="context" start="417" end="427">
fn get_webhook_resource_object(
&self,
request: &webhooks::IncomingWebhookRequestDetails<'_>,
) -> CustomResult<Box<dyn masking::ErasedMaskSerialize>, errors::ConnectorError> {
let webhook: transformers::CashtocodeIncomingWebhook = request
.body
.parse_struct("CashtocodeIncomingWebhook")
.change_context(errors::ConnectorError::WebhookBodyDecodingFailed)?;
Ok(Box::new(webhook))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/cashtocode.rs" role="context" start="416" end="416">
use common_utils::{
errors::CustomResult,
ext_traits::ByteSliceExt,
request::{Method, Request, RequestBuilder, RequestContent},
types::{AmountConvertor, FloatMajorUnit, FloatMajorUnitForConnector},
};
use hyperswitch_interfaces::{
api::{
self, ConnectorCommon, ConnectorCommonExt, ConnectorIntegration, ConnectorSpecifications,
ConnectorValidation,
},
configs::Connectors,
errors,
events::connector_api_logs::ConnectorEvent,
types::{PaymentsAuthorizeType, Response},
webhooks::{self, IncomingWebhookFlowError},
};
use masking::{Mask, PeekInterface, Secret};
use transformers as cashtocode;
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/cashtocode.rs" role="context" start="446" end="456">
fn build_request(
&self,
_req: &RouterData<Execute, RefundsData, RefundsResponseData>,
_connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Err(errors::ConnectorError::FlowNotSupported {
flow: "Refunds".to_string(),
connector: "Cashtocode".to_string(),
}
.into())
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/cashtocode.rs" role="context" start="429" end="442">
fn get_webhook_api_response(
&self,
request: &webhooks::IncomingWebhookRequestDetails<'_>,
_error_kind: Option<IncomingWebhookFlowError>,
) -> CustomResult<ApplicationResponse<serde_json::Value>, errors::ConnectorError> {
let status = "EXECUTED".to_string();
let obj: transformers::CashtocodePaymentsSyncResponse = request
.body
.parse_struct("CashtocodePaymentsSyncResponse")
.change_context(errors::ConnectorError::WebhookReferenceIdNotFound)?;
let response: serde_json::Value =
serde_json::json!({ "status": status, "transactionId" : obj.transaction_id});
Ok(ApplicationResponse::Json(response))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/cashtocode.rs" role="context" start="410" end="415">
fn get_webhook_event_type(
&self,
_request: &webhooks::IncomingWebhookRequestDetails<'_>,
) -> CustomResult<api_models::webhooks::IncomingWebhookEvent, errors::ConnectorError> {
Ok(api_models::webhooks::IncomingWebhookEvent::PaymentIntentSuccess)
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/cashtocode.rs" role="context" start="396" end="408">
fn get_webhook_object_reference_id(
&self,
request: &webhooks::IncomingWebhookRequestDetails<'_>,
) -> CustomResult<api_models::webhooks::ObjectReferenceId, errors::ConnectorError> {
let webhook: transformers::CashtocodePaymentsSyncResponse = request
.body
.parse_struct("CashtocodePaymentsSyncResponse")
.change_context(errors::ConnectorError::WebhookReferenceIdNotFound)?;
Ok(api_models::webhooks::ObjectReferenceId::PaymentId(
api_models::payments::PaymentIdType::ConnectorTransactionId(webhook.transaction_id),
))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/cashtocode.rs" role="context" start="49" end="53">
pub fn new() -> &'static Self {
&Self {
amount_converter: &FloatMajorUnitForConnector,
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/cashtocode/transformers.rs" role="context" start="329" end="336">
pub struct CashtocodeIncomingWebhook {
pub amount: FloatMajorUnit,
pub currency: String,
pub foreign_transaction_id: String,
#[serde(rename = "type")]
pub event_type: String,
pub transaction_id: String,
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/hyperswitch_connectors/src/connectors/cashtocode.rs<|crate|> hyperswitch_connectors<|connector|> cashtocode anchor=construct_basic_auth kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=1<|meta_end|>
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/cashtocode.rs" role="context" start="73" end="88">
fn construct_basic_auth(
username: Option<Secret<String>>,
password: Option<Secret<String>>,
) -> Result<masking::Maskable<String>, errors::ConnectorError> {
let username = username.ok_or(errors::ConnectorError::FailedToObtainAuthType)?;
let password = password.ok_or(errors::ConnectorError::FailedToObtainAuthType)?;
Ok(format!(
"Basic {}",
base64::engine::general_purpose::STANDARD.encode(format!(
"{}:{}",
username.peek(),
password.peek()
))
)
.into_masked())
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/cashtocode.rs" role="context" start="72" end="72">
use common_utils::{
errors::CustomResult,
ext_traits::ByteSliceExt,
request::{Method, Request, RequestBuilder, RequestContent},
types::{AmountConvertor, FloatMajorUnit, FloatMajorUnitForConnector},
};
use hyperswitch_interfaces::{
api::{
self, ConnectorCommon, ConnectorCommonExt, ConnectorIntegration, ConnectorSpecifications,
ConnectorValidation,
},
configs::Connectors,
errors,
events::connector_api_logs::ConnectorEvent,
types::{PaymentsAuthorizeType, Response},
webhooks::{self, IncomingWebhookFlowError},
};
use masking::{Mask, PeekInterface, Secret};
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/cashtocode.rs" role="context" start="117" end="119">
fn id(&self) -> &'static str {
"cashtocode"
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/cashtocode.rs" role="context" start="69" end="103">
fn get_b64_auth_cashtocode(
payment_method_type: Option<enums::PaymentMethodType>,
auth_type: &transformers::CashtocodeAuth,
) -> CustomResult<Vec<(String, masking::Maskable<String>)>, errors::ConnectorError> {
fn construct_basic_auth(
username: Option<Secret<String>>,
password: Option<Secret<String>>,
) -> Result<masking::Maskable<String>, errors::ConnectorError> {
let username = username.ok_or(errors::ConnectorError::FailedToObtainAuthType)?;
let password = password.ok_or(errors::ConnectorError::FailedToObtainAuthType)?;
Ok(format!(
"Basic {}",
base64::engine::general_purpose::STANDARD.encode(format!(
"{}:{}",
username.peek(),
password.peek()
))
)
.into_masked())
}
let auth_header = match payment_method_type {
Some(enums::PaymentMethodType::ClassicReward) => construct_basic_auth(
auth_type.username_classic.to_owned(),
auth_type.password_classic.to_owned(),
),
Some(enums::PaymentMethodType::Evoucher) => construct_basic_auth(
auth_type.username_evoucher.to_owned(),
auth_type.password_evoucher.to_owned(),
),
_ => return Err(errors::ConnectorError::MissingPaymentMethodType)?,
}?;
Ok(vec![(headers::AUTHORIZATION.to_string(), auth_header)])
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/cashtocode.rs" role="context" start="49" end="53">
pub fn new() -> &'static Self {
&Self {
amount_converter: &FloatMajorUnitForConnector,
}
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/router/tests/connectors/taxjar.rs<|crate|> router<|connector|> taxjar anchor=should_partially_refund_succeeded_payment kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/router/tests/connectors/taxjar.rs" role="context" start="243" end="259">
async fn should_partially_refund_succeeded_payment() {
let refund_response = CONNECTOR
.make_payment_and_refund(
payment_method_details(),
Some(types::RefundsData {
refund_amount: 50,
..utils::PaymentRefundType::default().0
}),
get_default_payment_info(),
)
.await
.unwrap();
assert_eq!(
refund_response.response.unwrap().refund_status,
enums::RefundStatus::Success,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/taxjar.rs" role="context" start="242" end="242">
use router::types::{self, api, domain, storage::enums};
<file_sep path="hyperswitch/crates/router/tests/connectors/taxjar.rs" role="context" start="278" end="296">
async fn should_sync_refund() {
let refund_response = CONNECTOR
.make_payment_and_refund(payment_method_details(), None, get_default_payment_info())
.await
.unwrap();
let response = CONNECTOR
.rsync_retry_till_status_matches(
enums::RefundStatus::Success,
refund_response.response.unwrap().connector_refund_id,
None,
get_default_payment_info(),
)
.await
.unwrap();
assert_eq!(
response.response.unwrap().refund_status,
enums::RefundStatus::Success,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/taxjar.rs" role="context" start="263" end="274">
async fn should_refund_succeeded_payment_multiple_times() {
CONNECTOR
.make_payment_and_multiple_refund(
payment_method_details(),
Some(types::RefundsData {
refund_amount: 50,
..utils::PaymentRefundType::default().0
}),
get_default_payment_info(),
)
.await;
}
<file_sep path="hyperswitch/crates/router/tests/connectors/taxjar.rs" role="context" start="230" end="239">
async fn should_refund_auto_captured_payment() {
let response = CONNECTOR
.make_payment_and_refund(payment_method_details(), None, get_default_payment_info())
.await
.unwrap();
assert_eq!(
response.response.unwrap().refund_status,
enums::RefundStatus::Success,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/taxjar.rs" role="context" start="203" end="226">
async fn should_sync_auto_captured_payment() {
let authorize_response = CONNECTOR
.make_payment(payment_method_details(), get_default_payment_info())
.await
.unwrap();
assert_eq!(authorize_response.status, enums::AttemptStatus::Charged);
let txn_id = utils::get_connector_transaction_id(authorize_response.response);
assert_ne!(txn_id, None, "Empty connector transaction id");
let response = CONNECTOR
.psync_retry_till_status_matches(
enums::AttemptStatus::Charged,
Some(types::PaymentsSyncData {
connector_transaction_id: types::ResponseId::ConnectorTransactionId(
txn_id.unwrap(),
),
capture_method: Some(enums::CaptureMethod::Automatic),
..Default::default()
}),
get_default_payment_info(),
)
.await
.unwrap();
assert_eq!(response.status, enums::AttemptStatus::Charged,);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/taxjar.rs" role="context" start="37" end="39">
fn get_default_payment_info() -> Option<utils::PaymentInfo> {
None
}
<file_sep path="hyperswitch/crates/router/tests/connectors/taxjar.rs" role="context" start="41" end="43">
fn payment_method_details() -> Option<types::PaymentsAuthorizeData> {
None
}
<file_sep path="hyperswitch/crates/router/src/connector/dummyconnector/transformers.rs" role="context" start="304" end="309">
pub enum RefundStatus {
Succeeded,
Failed,
#[default]
Processing,
}
<file_sep path="hyperswitch/crates/api_models/src/refunds.rs" role="context" start="378" end="384">
pub enum RefundStatus {
Succeeded,
Failed,
#[default]
Pending,
Review,
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/router/tests/connectors/opennode.rs<|crate|> router<|connector|> opennode anchor=should_only_authorize_payment kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=1<|meta_end|>
<file_sep path="hyperswitch/crates/router/tests/connectors/opennode.rs" role="context" start="110" end="124">
async fn should_only_authorize_payment() {
let response = CONNECTOR
.authorize_payment(payment_method_details(), get_default_payment_info())
.await
.expect("Authorize payment response");
assert_eq!(response.status, enums::AttemptStatus::AuthenticationPending);
let resp = response.response.ok().unwrap();
let endpoint = match resp {
types::PaymentsResponseData::TransactionResponse {
redirection_data, ..
} => Some(redirection_data),
_ => None,
};
assert!(endpoint.is_some())
}
<file_sep path="hyperswitch/crates/router/tests/connectors/opennode.rs" role="context" start="109" end="109">
use router::types::{self, api, domain, storage::enums};
<file_sep path="hyperswitch/crates/router/tests/connectors/opennode.rs" role="context" start="147" end="162">
async fn should_sync_unresolved_payment() {
let response = CONNECTOR
.psync_retry_till_status_matches(
enums::AttemptStatus::Authorized,
Some(types::PaymentsSyncData {
connector_transaction_id: types::ResponseId::ConnectorTransactionId(
"4cf63e6b-5135-49cb-997f-6e0b30fecebc".to_string(),
),
..Default::default()
}),
get_default_payment_info(),
)
.await
.expect("PSync response");
assert_eq!(response.status, enums::AttemptStatus::Unresolved);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/opennode.rs" role="context" start="128" end="143">
async fn should_sync_authorized_payment() {
let response = CONNECTOR
.psync_retry_till_status_matches(
enums::AttemptStatus::Authorized,
Some(types::PaymentsSyncData {
connector_transaction_id: types::ResponseId::ConnectorTransactionId(
"5adebfb1-802e-432b-8b42-5db4b754b2eb".to_string(),
),
..Default::default()
}),
get_default_payment_info(),
)
.await
.expect("PSync response");
assert_eq!(response.status, enums::AttemptStatus::Charged);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/opennode.rs" role="context" start="68" end="106">
fn payment_method_details() -> Option<types::PaymentsAuthorizeData> {
Some(types::PaymentsAuthorizeData {
amount: 1,
currency: enums::Currency::USD,
payment_method_data: domain::PaymentMethodData::Crypto(domain::CryptoData {
pay_currency: None,
network: None,
}),
confirm: true,
statement_descriptor_suffix: None,
statement_descriptor: None,
setup_future_usage: None,
mandate_id: None,
off_session: None,
setup_mandate_details: None,
// capture_method: Some(capture_method),
browser_info: None,
order_details: None,
order_category: None,
email: None,
customer_name: None,
payment_experience: None,
payment_method_type: None,
session_token: None,
enrolled_for_3ds: false,
related_transaction_id: None,
router_return_url: Some(String::from("https://google.com/")),
webhook_url: Some(String::from("https://google.com/")),
complete_authorize_url: None,
capture_method: None,
customer_id: None,
surcharge_details: None,
request_incremental_authorization: false,
metadata: None,
authentication_data: None,
customer_acceptance: None,
..utils::PaymentAuthorizeType::default().0
})
}
<file_sep path="hyperswitch/crates/router/tests/connectors/opennode.rs" role="context" start="40" end="66">
fn get_default_payment_info() -> Option<utils::PaymentInfo> {
Some(utils::PaymentInfo {
address: Some(types::PaymentAddress::new(
None,
Some(Address {
address: Some(AddressDetails {
first_name: Some(Secret::new("first".to_string())),
last_name: Some(Secret::new("last".to_string())),
line1: Some(Secret::new("line1".to_string())),
line2: Some(Secret::new("line2".to_string())),
city: Some("city".to_string()),
zip: Some(Secret::new("zip".to_string())),
country: Some(api_models::enums::CountryAlpha2::IN),
..Default::default()
}),
phone: Some(PhoneDetails {
number: Some(Secret::new("9123456789".to_string())),
country_code: Some("+91".to_string()),
}),
email: None,
}),
None,
None,
)),
..Default::default()
})
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/hyperswitch_connectors/src/connectors/opennode/transformers.rs<|crate|> hyperswitch_connectors<|connector|> opennode anchor=try_from kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/opennode/transformers.rs" role="context" start="211" end="221">
fn try_from(
item: RefundsResponseRouterData<Execute, RefundResponse>,
) -> Result<Self, Self::Error> {
Ok(Self {
response: Ok(RefundsResponseData {
connector_refund_id: item.response.id.to_string(),
refund_status: enums::RefundStatus::from(item.response.status),
}),
..item.data
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/opennode/transformers.rs" role="context" start="210" end="210">
use common_enums::{enums, AttemptStatus};
use hyperswitch_domain_models::{
router_data::{ConnectorAuthType, RouterData},
router_flow_types::refunds::{Execute, RSync},
router_request_types::ResponseId,
router_response_types::{PaymentsResponseData, RedirectForm, RefundsResponseData},
types::{PaymentsAuthorizeRouterData, RefundsRouterData},
};
use crate::{
types::{RefundsResponseRouterData, ResponseRouterData},
utils::{PaymentsAuthorizeRequestData, RouterData as OtherRouterData},
};
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/opennode/transformers.rs" role="context" start="245" end="265">
fn get_crypto_specific_payment_data(
item: &OpennodeRouterData<&PaymentsAuthorizeRouterData>,
) -> Result<OpennodePaymentsRequest, error_stack::Report<errors::ConnectorError>> {
let amount = item.amount;
let currency = item.router_data.request.currency.to_string();
let description = item.router_data.get_description()?;
let auto_settle = true;
let success_url = item.router_data.request.get_router_return_url()?;
let callback_url = item.router_data.request.get_webhook_url()?;
let order_id = item.router_data.connector_request_reference_id.clone();
Ok(OpennodePaymentsRequest {
amount,
currency,
description,
auto_settle,
success_url,
callback_url,
order_id,
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/opennode/transformers.rs" role="context" start="226" end="236">
fn try_from(
item: RefundsResponseRouterData<RSync, RefundResponse>,
) -> Result<Self, Self::Error> {
Ok(Self {
response: Ok(RefundsResponseData {
connector_refund_id: item.response.id.to_string(),
refund_status: enums::RefundStatus::from(item.response.status),
}),
..item.data
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/opennode/transformers.rs" role="context" start="194" end="199">
fn from(item: RefundStatus) -> Self {
match item {
RefundStatus::Refunded => Self::Success,
RefundStatus::Processing => Self::Pending,
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/opennode/transformers.rs" role="context" start="176" end="180">
fn try_from(item: &OpennodeRouterData<&RefundsRouterData<F>>) -> Result<Self, Self::Error> {
Ok(Self {
amount: item.router_data.request.refund_amount,
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/opennode/transformers.rs" role="context" start="28" end="28">
type Error = error_stack::Report<errors::ConnectorError>;
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/opennode/transformers.rs" role="context" start="204" end="207">
pub struct RefundResponse {
id: String,
status: RefundStatus,
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/chargebee/transformers.rs" role="context" start="193" end="198">
pub enum RefundStatus {
Succeeded,
Failed,
#[default]
Processing,
}
<file_sep path="hyperswitch/crates/api_models/src/refunds.rs" role="context" start="378" end="384">
pub enum RefundStatus {
Succeeded,
Failed,
#[default]
Pending,
Review,
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/hyperswitch_connectors/src/connectors/opennode.rs<|crate|> hyperswitch_connectors<|connector|> opennode anchor=get_request_body kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/opennode.rs" role="context" start="195" end="208">
fn get_request_body(
&self,
req: &PaymentsAuthorizeRouterData,
_connectors: &Connectors,
) -> CustomResult<RequestContent, errors::ConnectorError> {
let connector_router_data = opennode::OpennodeRouterData::try_from((
&self.get_currency_unit(),
req.request.currency,
req.request.amount,
req,
))?;
let connector_req = opennode::OpennodePaymentsRequest::try_from(&connector_router_data)?;
Ok(RequestContent::Json(Box::new(connector_req)))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/opennode.rs" role="context" start="194" end="194">
use common_utils::{
crypto,
errors::CustomResult,
ext_traits::BytesExt,
request::{Method, Request, RequestBuilder, RequestContent},
};
use hyperswitch_domain_models::{
router_data::{AccessToken, ConnectorAuthType, ErrorResponse, RouterData},
router_flow_types::{
access_token_auth::AccessTokenAuth,
payments::{Authorize, Capture, PSync, PaymentMethodToken, Session, SetupMandate, Void},
refunds::{Execute, RSync},
},
router_request_types::{
AccessTokenRequestData, PaymentMethodTokenizationData, PaymentsAuthorizeData,
PaymentsCancelData, PaymentsCaptureData, PaymentsSessionData, PaymentsSyncData,
RefundsData, SetupMandateRequestData,
},
router_response_types::{PaymentsResponseData, RefundsResponseData},
types::{
PaymentsAuthorizeRouterData, PaymentsCaptureRouterData, PaymentsSyncRouterData,
RefundsRouterData,
},
};
use hyperswitch_interfaces::{
api::{
self, ConnectorCommon, ConnectorCommonExt, ConnectorIntegration, ConnectorSpecifications,
ConnectorValidation,
},
configs::Connectors,
consts, errors,
events::connector_api_logs::ConnectorEvent,
types::{PaymentsAuthorizeType, PaymentsSyncType, Response},
webhooks::{self, IncomingWebhook},
};
use transformers as opennode;
use self::opennode::OpennodeWebhookDetails;
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/opennode.rs" role="context" start="227" end="247">
fn handle_response(
&self,
data: &PaymentsAuthorizeRouterData,
event_builder: Option<&mut ConnectorEvent>,
res: Response,
) -> CustomResult<PaymentsAuthorizeRouterData, errors::ConnectorError> {
let response: opennode::OpennodePaymentsResponse = res
.response
.parse_struct("Opennode PaymentsAuthorizeResponse")
.change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
event_builder.map(|i| i.set_response_body(&response));
router_env::logger::info!(connector_response=?response);
RouterData::try_from(ResponseRouterData {
response,
data: data.clone(),
http_code: res.status_code,
})
.change_context(errors::ConnectorError::ResponseHandlingFailed)
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/opennode.rs" role="context" start="210" end="225">
fn build_request(
&self,
req: &PaymentsAuthorizeRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Ok(Some(
RequestBuilder::new()
.method(Method::Post)
.url(&PaymentsAuthorizeType::get_url(self, req, connectors)?)
.headers(PaymentsAuthorizeType::get_headers(self, req, connectors)?)
.set_body(PaymentsAuthorizeType::get_request_body(
self, req, connectors,
)?)
.build(),
))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/opennode.rs" role="context" start="187" end="193">
fn get_url(
&self,
_req: &PaymentsAuthorizeRouterData,
_connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
Ok(format!("{}/v1/charges", self.base_url(_connectors)))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/opennode.rs" role="context" start="183" end="185">
fn get_content_type(&self) -> &'static str {
self.common_get_content_type()
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/opennode/transformers.rs" role="context" start="22" end="25">
pub struct OpennodeRouterData<T> {
pub amount: i64,
pub router_data: T,
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/hyperswitch_connectors/src/connectors/opennode/transformers.rs<|crate|> hyperswitch_connectors<|connector|> opennode anchor=try_from kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/opennode/transformers.rs" role="context" start="124" end="163">
fn try_from(
item: ResponseRouterData<F, OpennodePaymentsResponse, T, PaymentsResponseData>,
) -> Result<Self, Self::Error> {
let form_fields = HashMap::new();
let redirection_data = RedirectForm::Form {
endpoint: item.response.data.hosted_checkout_url.to_string(),
method: Method::Get,
form_fields,
};
let connector_id = ResponseId::ConnectorTransactionId(item.response.data.id);
let attempt_status = item.response.data.status;
let response_data = if attempt_status != OpennodePaymentStatus::Underpaid {
Ok(PaymentsResponseData::TransactionResponse {
resource_id: connector_id,
redirection_data: Box::new(Some(redirection_data)),
mandate_reference: Box::new(None),
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: item.response.data.order_id,
incremental_authorization_allowed: None,
charges: None,
})
} else {
Ok(PaymentsResponseData::TransactionUnresolvedResponse {
resource_id: connector_id,
reason: Some(api_models::enums::UnresolvedResponseReason {
code: "UNDERPAID".to_string(),
message:
"Please check the transaction in opennode dashboard and resolve manually"
.to_string(),
}),
connector_response_reference_id: item.response.data.order_id,
})
};
Ok(Self {
status: AttemptStatus::from(attempt_status),
response: response_data,
..item.data
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/opennode/transformers.rs" role="context" start="123" end="123">
use common_enums::{enums, AttemptStatus};
use hyperswitch_domain_models::{
router_data::{ConnectorAuthType, RouterData},
router_flow_types::refunds::{Execute, RSync},
router_request_types::ResponseId,
router_response_types::{PaymentsResponseData, RedirectForm, RefundsResponseData},
types::{PaymentsAuthorizeRouterData, RefundsRouterData},
};
use crate::{
types::{RefundsResponseRouterData, ResponseRouterData},
utils::{PaymentsAuthorizeRequestData, RouterData as OtherRouterData},
};
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/opennode/transformers.rs" role="context" start="194" end="199">
fn from(item: RefundStatus) -> Self {
match item {
RefundStatus::Refunded => Self::Success,
RefundStatus::Processing => Self::Pending,
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/opennode/transformers.rs" role="context" start="176" end="180">
fn try_from(item: &OpennodeRouterData<&RefundsRouterData<F>>) -> Result<Self, Self::Error> {
Ok(Self {
amount: item.router_data.request.refund_amount,
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/opennode/transformers.rs" role="context" start="95" end="103">
fn from(item: OpennodePaymentStatus) -> Self {
match item {
OpennodePaymentStatus::Unpaid => Self::AuthenticationPending,
OpennodePaymentStatus::Paid => Self::Charged,
OpennodePaymentStatus::Expired => Self::Failure,
OpennodePaymentStatus::Underpaid => Self::Unresolved,
_ => Self::Pending,
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/opennode/transformers.rs" role="context" start="69" end="76">
fn try_from(auth_type: &ConnectorAuthType) -> Result<Self, Self::Error> {
match auth_type {
ConnectorAuthType::HeaderKey { api_key } => Ok(Self {
api_key: api_key.to_owned(),
}),
_ => Err(errors::ConnectorError::FailedToObtainAuthType.into()),
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/opennode/transformers.rs" role="context" start="28" end="28">
type Error = error_stack::Report<errors::ConnectorError>;
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/opennode/transformers.rs" role="context" start="116" end="118">
pub struct OpennodePaymentsResponse {
data: OpennodePaymentsResponseData,
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/globalpay/requests.rs" role="context" start="685" end="688">
pub enum Method {
Ksn,
Ktb,
}
<file_sep path="hyperswitch/crates/api_models/src/enums.rs" role="context" start="190" end="194">
pub struct UnresolvedResponseReason {
pub code: String,
/// A message to merchant to give hint on next action he/she should do to resolve
pub message: String,
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/router/tests/connectors/wise.rs<|crate|> router<|connector|> wise anchor=should_create_payout_recipient kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/router/tests/connectors/wise.rs" role="context" start="92" end="103">
async fn should_create_payout_recipient() {
let payout_type = enums::PayoutType::Bank;
let payment_info = WiseTest::get_payout_info();
let response = CONNECTOR
.create_payout_recipient(payout_type, payment_info)
.await
.expect("Payout recipient creation response");
assert_eq!(
response.status.unwrap(),
enums::PayoutStatus::RequiresCreation
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/wise.rs" role="context" start="91" end="91">
use router::{
types,
types::{api, storage::enums, PaymentAddress},
};
<file_sep path="hyperswitch/crates/router/tests/connectors/wise.rs" role="context" start="135" end="152">
async fn should_create_and_fulfill_bacs_payout() {
let payout_type = enums::PayoutType::Bank;
let payout_info = WiseTest::get_payout_info();
// Create recipient
let recipient_res = CONNECTOR
.create_payout_recipient(payout_type.to_owned(), payout_info.to_owned())
.await
.expect("Payout recipient response");
assert_eq!(
recipient_res.status.unwrap(),
enums::PayoutStatus::RequiresCreation
);
let response = CONNECTOR
.create_and_fulfill_payout(recipient_res.connector_payout_id, payout_type, payout_info)
.await
.expect("Payout bank creation and fulfill response");
assert_eq!(response.status.unwrap(), enums::PayoutStatus::Success);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/wise.rs" role="context" start="108" end="130">
async fn should_create_bacs_payout() {
let payout_type = enums::PayoutType::Bank;
let payout_info = WiseTest::get_payout_info();
// Create recipient
let recipient_res = CONNECTOR
.create_payout_recipient(payout_type.to_owned(), payout_info.to_owned())
.await
.expect("Payout recipient response");
assert_eq!(
recipient_res.status.unwrap(),
enums::PayoutStatus::RequiresCreation
);
// Create payout
let create_res: types::PayoutsResponseData = CONNECTOR
.create_payout(recipient_res.connector_payout_id, payout_type, payout_info)
.await
.expect("Payout bank creation response");
assert_eq!(
create_res.status.unwrap(),
enums::PayoutStatus::RequiresFulfillment
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/wise.rs" role="context" start="53" end="83">
fn get_payout_info() -> Option<PaymentInfo> {
Some(PaymentInfo {
currency: Some(enums::Currency::GBP),
address: Some(PaymentAddress::new(
None,
Some(Address {
address: Some(AddressDetails {
country: Some(api_models::enums::CountryAlpha2::GB),
city: Some("London".to_string()),
zip: Some(Secret::new("10025".to_string())),
line1: Some(Secret::new("50 Branson Ave".to_string())),
..Default::default()
}),
phone: None,
email: None,
}),
None,
None,
)),
payout_method_data: Some(api::PayoutMethodData::Bank(api::payouts::BankPayout::Bacs(
api::BacsBankTransfer {
bank_sort_code: "231470".to_string().into(),
bank_account_number: "28821822".to_string().into(),
bank_name: Some("Deutsche Bank".to_string()),
bank_country_code: Some(enums::CountryAlpha2::NL),
bank_city: Some("Amsterdam".to_string()),
},
))),
..Default::default()
})
}
<file_sep path="hyperswitch/crates/router/tests/connectors/wise.rs" role="context" start="47" end="49">
fn get_name(&self) -> String {
"wise".to_string()
}
<file_sep path="hyperswitch/crates/router/tests/connectors/wise.rs" role="context" start="13" end="13">
struct WiseTest;
<file_sep path="hyperswitch/migrations/2024-07-31-063531_alter_customer_id_in_payouts/up.sql" role="context" start="1" end="9">
ALTER TABLE payouts
ALTER COLUMN customer_id
DROP NOT NULL,
ALTER COLUMN address_id
DROP NOT NULL;
ALTER TABLE payout_attempt
ALTER COLUMN customer_id
DROP NOT NULL,
<file_sep path="hyperswitch/crates/api_models/src/payouts.rs" role="context" start="262" end="267">
pub enum Bank {
Ach(AchBankTransfer),
Bacs(BacsBankTransfer),
Sepa(SepaBankTransfer),
Pix(PixBankTransfer),
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/router/tests/connectors/wise.rs<|crate|> router<|connector|> wise anchor=get_auth_token kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/router/tests/connectors/wise.rs" role="context" start="38" end="45">
fn get_auth_token(&self) -> types::ConnectorAuthType {
utils::to_connector_auth_type(
connector_auth::ConnectorAuthentication::new()
.wise
.expect("Missing connector authentication configuration")
.into(),
)
}
<file_sep path="hyperswitch/crates/router/tests/connectors/wise.rs" role="context" start="37" end="37">
use router::{
types,
types::{api, storage::enums, PaymentAddress},
};
use crate::{
connector_auth,
utils::{self, ConnectorActions, PaymentInfo},
};
<file_sep path="hyperswitch/crates/router/tests/connectors/wise.rs" role="context" start="53" end="83">
fn get_payout_info() -> Option<PaymentInfo> {
Some(PaymentInfo {
currency: Some(enums::Currency::GBP),
address: Some(PaymentAddress::new(
None,
Some(Address {
address: Some(AddressDetails {
country: Some(api_models::enums::CountryAlpha2::GB),
city: Some("London".to_string()),
zip: Some(Secret::new("10025".to_string())),
line1: Some(Secret::new("50 Branson Ave".to_string())),
..Default::default()
}),
phone: None,
email: None,
}),
None,
None,
)),
payout_method_data: Some(api::PayoutMethodData::Bank(api::payouts::BankPayout::Bacs(
api::BacsBankTransfer {
bank_sort_code: "231470".to_string().into(),
bank_account_number: "28821822".to_string().into(),
bank_name: Some("Deutsche Bank".to_string()),
bank_country_code: Some(enums::CountryAlpha2::NL),
bank_city: Some("Amsterdam".to_string()),
},
))),
..Default::default()
})
}
<file_sep path="hyperswitch/crates/router/tests/connectors/wise.rs" role="context" start="47" end="49">
fn get_name(&self) -> String {
"wise".to_string()
}
<file_sep path="hyperswitch/crates/router/tests/connectors/wise.rs" role="context" start="28" end="36">
fn get_payout_data(&self) -> Option<api::ConnectorData> {
use router::connector::Wise;
Some(utils::construct_connector_data_old(
Box::new(Wise::new()),
types::Connector::Wise,
api::GetToken::Connector,
None,
))
}
<file_sep path="hyperswitch/crates/router/tests/connectors/wise.rs" role="context" start="18" end="26">
fn get_data(&self) -> api::ConnectorData {
use router::connector::Adyen;
utils::construct_connector_data_old(
Box::new(Adyen::new()),
types::Connector::Adyen,
api::GetToken::Connector,
None,
)
}
<file_sep path="hyperswitch/crates/api_models/src/admin.rs" role="context" start="1017" end="1046">
pub enum ConnectorAuthType {
TemporaryAuth,
HeaderKey {
api_key: Secret<String>,
},
BodyKey {
api_key: Secret<String>,
key1: Secret<String>,
},
SignatureKey {
api_key: Secret<String>,
key1: Secret<String>,
api_secret: Secret<String>,
},
MultiAuthKey {
api_key: Secret<String>,
key1: Secret<String>,
api_secret: Secret<String>,
key2: Secret<String>,
},
CurrencyAuthKey {
auth_key_map: HashMap<common_enums::Currency, pii::SecretSerdeValue>,
},
CertificateAuth {
certificate: Secret<String>,
private_key: Secret<String>,
},
#[default]
NoKey,
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/router/tests/connectors/wise.rs<|crate|> router<|connector|> wise anchor=get_data kind=fn pack=symbol_neighborhood lang=rust role_window=k2 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/router/tests/connectors/wise.rs" role="context" start="18" end="26">
fn get_data(&self) -> api::ConnectorData {
use router::connector::Adyen;
utils::construct_connector_data_old(
Box::new(Adyen::new()),
types::Connector::Adyen,
api::GetToken::Connector,
None,
)
}
<file_sep path="hyperswitch/crates/router/tests/connectors/wise.rs" role="context" start="17" end="17">
use masking::Secret;
use router::{
types,
types::{api, storage::enums, PaymentAddress},
};
use crate::{
connector_auth,
utils::{self, ConnectorActions, PaymentInfo},
};
<file_sep path="hyperswitch/crates/router/tests/connectors/wise.rs" role="context" start="38" end="45">
fn get_auth_token(&self) -> types::ConnectorAuthType {
utils::to_connector_auth_type(
connector_auth::ConnectorAuthentication::new()
.wise
.expect("Missing connector authentication configuration")
.into(),
)
}
<file_sep path="hyperswitch/crates/router/tests/connectors/wise.rs" role="context" start="28" end="36">
fn get_payout_data(&self) -> Option<api::ConnectorData> {
use router::connector::Wise;
Some(utils::construct_connector_data_old(
Box::new(Wise::new()),
types::Connector::Wise,
api::GetToken::Connector,
None,
))
}
<file_sep path="hyperswitch/crates/router/src/types/api.rs" role="context" start="104" end="111">
pub enum GetToken {
GpayMetadata,
SamsungPayMetadata,
ApplePayMetadata,
PaypalSdkMetadata,
PazeMetadata,
Connector,
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/router/tests/connectors/wise.rs<|crate|> router<|connector|> wise anchor=get_payout_data kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/router/tests/connectors/wise.rs" role="context" start="28" end="36">
fn get_payout_data(&self) -> Option<api::ConnectorData> {
use router::connector::Wise;
Some(utils::construct_connector_data_old(
Box::new(Wise::new()),
types::Connector::Wise,
api::GetToken::Connector,
None,
))
}
<file_sep path="hyperswitch/crates/router/tests/connectors/wise.rs" role="context" start="27" end="27">
use masking::Secret;
use router::{
types,
types::{api, storage::enums, PaymentAddress},
};
use crate::{
connector_auth,
utils::{self, ConnectorActions, PaymentInfo},
};
<file_sep path="hyperswitch/crates/router/tests/connectors/wise.rs" role="context" start="47" end="49">
fn get_name(&self) -> String {
"wise".to_string()
}
<file_sep path="hyperswitch/crates/router/tests/connectors/wise.rs" role="context" start="38" end="45">
fn get_auth_token(&self) -> types::ConnectorAuthType {
utils::to_connector_auth_type(
connector_auth::ConnectorAuthentication::new()
.wise
.expect("Missing connector authentication configuration")
.into(),
)
}
<file_sep path="hyperswitch/crates/router/tests/connectors/wise.rs" role="context" start="18" end="26">
fn get_data(&self) -> api::ConnectorData {
use router::connector::Adyen;
utils::construct_connector_data_old(
Box::new(Adyen::new()),
types::Connector::Adyen,
api::GetToken::Connector,
None,
)
}
<file_sep path="hyperswitch/crates/router/src/connector/wise.rs" role="context" start="32" end="34">
pub struct Wise {
amount_converter: &'static (dyn AmountConvertor<Output = MinorUnit> + Sync),
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/router/tests/connectors/netcetera.rs<|crate|> router<|connector|> netcetera anchor=should_partially_refund_manually_captured_payment kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/router/tests/connectors/netcetera.rs" role="context" start="144" end="161">
async fn should_partially_refund_manually_captured_payment() {
let response = CONNECTOR
.capture_payment_and_refund(
payment_method_details(),
None,
Some(types::RefundsData {
refund_amount: 50,
..utils::PaymentRefundType::default().0
}),
get_default_payment_info(),
)
.await
.unwrap();
assert_eq!(
response.response.unwrap().refund_status,
enums::RefundStatus::Success,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/netcetera.rs" role="context" start="143" end="143">
use router::types::{self, storage::enums};
<file_sep path="hyperswitch/crates/router/tests/connectors/netcetera.rs" role="context" start="192" end="198">
async fn should_make_payment() {
let authorize_response = CONNECTOR
.make_payment(payment_method_details(), get_default_payment_info())
.await
.unwrap();
assert_eq!(authorize_response.status, enums::AttemptStatus::Charged);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/netcetera.rs" role="context" start="165" end="188">
async fn should_sync_manually_captured_refund() {
let refund_response = CONNECTOR
.capture_payment_and_refund(
payment_method_details(),
None,
None,
get_default_payment_info(),
)
.await
.unwrap();
let response = CONNECTOR
.rsync_retry_till_status_matches(
enums::RefundStatus::Success,
refund_response.response.unwrap().connector_refund_id,
None,
get_default_payment_info(),
)
.await
.unwrap();
assert_eq!(
response.response.unwrap().refund_status,
enums::RefundStatus::Success,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/netcetera.rs" role="context" start="126" end="140">
async fn should_refund_manually_captured_payment() {
let response = CONNECTOR
.capture_payment_and_refund(
payment_method_details(),
None,
None,
get_default_payment_info(),
)
.await
.unwrap();
assert_eq!(
response.response.unwrap().refund_status,
enums::RefundStatus::Success,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/netcetera.rs" role="context" start="108" end="122">
async fn should_void_authorized_payment() {
let response = CONNECTOR
.authorize_and_void_payment(
payment_method_details(),
Some(types::PaymentsCancelData {
connector_transaction_id: String::from(""),
cancellation_reason: Some("requested_by_customer".to_string()),
..Default::default()
}),
get_default_payment_info(),
)
.await
.expect("Void payment response");
assert_eq!(response.status, enums::AttemptStatus::Voided);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/netcetera.rs" role="context" start="36" end="38">
fn get_default_payment_info() -> Option<utils::PaymentInfo> {
None
}
<file_sep path="hyperswitch/crates/router/tests/connectors/netcetera.rs" role="context" start="40" end="42">
fn payment_method_details() -> Option<types::PaymentsAuthorizeData> {
None
}
<file_sep path="hyperswitch/crates/router/src/connector/dummyconnector/transformers.rs" role="context" start="304" end="309">
pub enum RefundStatus {
Succeeded,
Failed,
#[default]
Processing,
}
<file_sep path="hyperswitch/crates/api_models/src/refunds.rs" role="context" start="378" end="384">
pub enum RefundStatus {
Succeeded,
Failed,
#[default]
Pending,
Review,
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/router/tests/connectors/wellsfargopayout.rs<|crate|> router<|connector|> wellsfargopayout anchor=should_partially_refund_manually_captured_payment kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/router/tests/connectors/wellsfargopayout.rs" role="context" start="145" end="162">
async fn should_partially_refund_manually_captured_payment() {
let response = CONNECTOR
.capture_payment_and_refund(
payment_method_details(),
None,
Some(types::RefundsData {
refund_amount: 50,
..utils::PaymentRefundType::default().0
}),
get_default_payment_info(),
)
.await
.unwrap();
assert_eq!(
response.response.unwrap().refund_status,
enums::RefundStatus::Success,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/wellsfargopayout.rs" role="context" start="144" end="144">
use router::types::{self, api, storage::enums};
<file_sep path="hyperswitch/crates/router/tests/connectors/wellsfargopayout.rs" role="context" start="193" end="199">
async fn should_make_payment() {
let authorize_response = CONNECTOR
.make_payment(payment_method_details(), get_default_payment_info())
.await
.unwrap();
assert_eq!(authorize_response.status, enums::AttemptStatus::Charged);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/wellsfargopayout.rs" role="context" start="166" end="189">
async fn should_sync_manually_captured_refund() {
let refund_response = CONNECTOR
.capture_payment_and_refund(
payment_method_details(),
None,
None,
get_default_payment_info(),
)
.await
.unwrap();
let response = CONNECTOR
.rsync_retry_till_status_matches(
enums::RefundStatus::Success,
refund_response.response.unwrap().connector_refund_id,
None,
get_default_payment_info(),
)
.await
.unwrap();
assert_eq!(
response.response.unwrap().refund_status,
enums::RefundStatus::Success,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/wellsfargopayout.rs" role="context" start="127" end="141">
async fn should_refund_manually_captured_payment() {
let response = CONNECTOR
.capture_payment_and_refund(
payment_method_details(),
None,
None,
get_default_payment_info(),
)
.await
.unwrap();
assert_eq!(
response.response.unwrap().refund_status,
enums::RefundStatus::Success,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/wellsfargopayout.rs" role="context" start="109" end="123">
async fn should_void_authorized_payment() {
let response = CONNECTOR
.authorize_and_void_payment(
payment_method_details(),
Some(types::PaymentsCancelData {
connector_transaction_id: String::from(""),
cancellation_reason: Some("requested_by_customer".to_string()),
..Default::default()
}),
get_default_payment_info(),
)
.await
.expect("Void payment response");
assert_eq!(response.status, enums::AttemptStatus::Voided);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/wellsfargopayout.rs" role="context" start="41" end="43">
fn payment_method_details() -> Option<types::PaymentsAuthorizeData> {
None
}
<file_sep path="hyperswitch/crates/router/tests/connectors/wellsfargopayout.rs" role="context" start="37" end="39">
fn get_default_payment_info() -> Option<utils::PaymentInfo> {
None
}
<file_sep path="hyperswitch/crates/router/src/connector/dummyconnector/transformers.rs" role="context" start="304" end="309">
pub enum RefundStatus {
Succeeded,
Failed,
#[default]
Processing,
}
<file_sep path="hyperswitch/crates/api_models/src/refunds.rs" role="context" start="378" end="384">
pub enum RefundStatus {
Succeeded,
Failed,
#[default]
Pending,
Review,
}
<file_sep path="hyperswitch/postman/collection-dir/powertranz/Flow Testcases/Happy Cases/Scenario1-Create payment with confirm true/Payments - Create/event.test.js" role="context" start="61" end="78">
"INFO - Unable to assign variable {{client_secret}}, as jsonData.client_secret is undefined.",
);
}
// Response body should have value "succeeded" for "status"
if (jsonData?.status) {
pm.test(
"[POST]::/payments - Content check if value for 'status' matches 'succeeded'",
function () {
pm.expect(jsonData.status).to.eql("succeeded");
},
);
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/router/tests/connectors/dummyconnector.rs<|crate|> router<|connector|> dummyconnector anchor=should_partially_refund_manually_captured_payment kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/router/tests/connectors/dummyconnector.rs" role="context" start="148" end="165">
async fn should_partially_refund_manually_captured_payment() {
let response = CONNECTOR
.capture_payment_and_refund(
payment_method_details(),
None,
Some(types::RefundsData {
refund_amount: 50,
..utils::PaymentRefundType::default().0
}),
get_default_payment_info(),
)
.await
.unwrap();
assert_eq!(
response.response.unwrap().refund_status,
enums::RefundStatus::Success,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/dummyconnector.rs" role="context" start="147" end="147">
use router::types::{self, domain, storage::enums};
<file_sep path="hyperswitch/crates/router/tests/connectors/dummyconnector.rs" role="context" start="196" end="202">
async fn should_make_payment() {
let authorize_response = CONNECTOR
.make_payment(payment_method_details(), get_default_payment_info())
.await
.unwrap();
assert_eq!(authorize_response.status, enums::AttemptStatus::Charged);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/dummyconnector.rs" role="context" start="169" end="192">
async fn should_sync_manually_captured_refund() {
let refund_response = CONNECTOR
.capture_payment_and_refund(
payment_method_details(),
None,
None,
get_default_payment_info(),
)
.await
.unwrap();
let response = CONNECTOR
.rsync_retry_till_status_matches(
enums::RefundStatus::Success,
refund_response.response.unwrap().connector_refund_id,
None,
get_default_payment_info(),
)
.await
.unwrap();
assert_eq!(
response.response.unwrap().refund_status,
enums::RefundStatus::Success,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/dummyconnector.rs" role="context" start="130" end="144">
async fn should_refund_manually_captured_payment() {
let response = CONNECTOR
.capture_payment_and_refund(
payment_method_details(),
None,
None,
get_default_payment_info(),
)
.await
.unwrap();
assert_eq!(
response.response.unwrap().refund_status,
enums::RefundStatus::Success,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/dummyconnector.rs" role="context" start="112" end="126">
async fn should_void_authorized_payment() {
let response = CONNECTOR
.authorize_and_void_payment(
payment_method_details(),
Some(types::PaymentsCancelData {
connector_transaction_id: String::from(""),
cancellation_reason: Some("requested_by_customer".to_string()),
..Default::default()
}),
get_default_payment_info(),
)
.await
.expect("Void payment response");
assert_eq!(response.status, enums::AttemptStatus::Voided);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/dummyconnector.rs" role="context" start="40" end="42">
fn get_default_payment_info() -> Option<utils::PaymentInfo> {
None
}
<file_sep path="hyperswitch/crates/router/tests/connectors/dummyconnector.rs" role="context" start="44" end="46">
fn payment_method_details() -> Option<types::PaymentsAuthorizeData> {
None
}
<file_sep path="hyperswitch/crates/router/src/connector/dummyconnector/transformers.rs" role="context" start="304" end="309">
pub enum RefundStatus {
Succeeded,
Failed,
#[default]
Processing,
}
<file_sep path="hyperswitch/crates/api_models/src/refunds.rs" role="context" start="378" end="384">
pub enum RefundStatus {
Succeeded,
Failed,
#[default]
Pending,
Review,
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/router/tests/connectors/payone.rs<|crate|> router<|connector|> payone anchor=should_partially_refund_manually_captured_payment kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/router/tests/connectors/payone.rs" role="context" start="145" end="162">
async fn should_partially_refund_manually_captured_payment() {
let response = CONNECTOR
.capture_payment_and_refund(
payment_method_details(),
None,
Some(types::RefundsData {
refund_amount: 50,
..utils::PaymentRefundType::default().0
}),
get_default_payment_info(),
)
.await
.unwrap();
assert_eq!(
response.response.unwrap().refund_status,
enums::RefundStatus::Success,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/payone.rs" role="context" start="144" end="144">
use router::types::{self, domain, storage::enums};
<file_sep path="hyperswitch/crates/router/tests/connectors/payone.rs" role="context" start="193" end="199">
async fn should_make_payment() {
let authorize_response = CONNECTOR
.make_payment(payment_method_details(), get_default_payment_info())
.await
.unwrap();
assert_eq!(authorize_response.status, enums::AttemptStatus::Charged);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/payone.rs" role="context" start="166" end="189">
async fn should_sync_manually_captured_refund() {
let refund_response = CONNECTOR
.capture_payment_and_refund(
payment_method_details(),
None,
None,
get_default_payment_info(),
)
.await
.unwrap();
let response = CONNECTOR
.rsync_retry_till_status_matches(
enums::RefundStatus::Success,
refund_response.response.unwrap().connector_refund_id,
None,
get_default_payment_info(),
)
.await
.unwrap();
assert_eq!(
response.response.unwrap().refund_status,
enums::RefundStatus::Success,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/payone.rs" role="context" start="127" end="141">
async fn should_refund_manually_captured_payment() {
let response = CONNECTOR
.capture_payment_and_refund(
payment_method_details(),
None,
None,
get_default_payment_info(),
)
.await
.unwrap();
assert_eq!(
response.response.unwrap().refund_status,
enums::RefundStatus::Success,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/payone.rs" role="context" start="109" end="123">
async fn should_void_authorized_payment() {
let response = CONNECTOR
.authorize_and_void_payment(
payment_method_details(),
Some(types::PaymentsCancelData {
connector_transaction_id: String::from(""),
cancellation_reason: Some("requested_by_customer".to_string()),
..Default::default()
}),
get_default_payment_info(),
)
.await
.expect("Void payment response");
assert_eq!(response.status, enums::AttemptStatus::Voided);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/payone.rs" role="context" start="37" end="39">
fn get_default_payment_info() -> Option<utils::PaymentInfo> {
None
}
<file_sep path="hyperswitch/crates/router/tests/connectors/payone.rs" role="context" start="41" end="43">
fn payment_method_details() -> Option<types::PaymentsAuthorizeData> {
None
}
<file_sep path="hyperswitch/crates/router/src/connector/dummyconnector/transformers.rs" role="context" start="304" end="309">
pub enum RefundStatus {
Succeeded,
Failed,
#[default]
Processing,
}
<file_sep path="hyperswitch/crates/api_models/src/refunds.rs" role="context" start="378" end="384">
pub enum RefundStatus {
Succeeded,
Failed,
#[default]
Pending,
Review,
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/router/tests/connectors/plaid.rs<|crate|> router<|connector|> plaid anchor=should_partially_refund_manually_captured_payment kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/router/tests/connectors/plaid.rs" role="context" start="146" end="163">
async fn should_partially_refund_manually_captured_payment() {
let response = CONNECTOR
.capture_payment_and_refund(
payment_method_details(),
None,
Some(types::RefundsData {
refund_amount: 50,
..utils::PaymentRefundType::default().0
}),
get_default_payment_info(),
)
.await
.unwrap();
assert_eq!(
response.response.unwrap().refund_status,
enums::RefundStatus::Success,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/plaid.rs" role="context" start="145" end="145">
use router::types::{self, api, domain, storage::enums};
<file_sep path="hyperswitch/crates/router/tests/connectors/plaid.rs" role="context" start="194" end="200">
async fn should_make_payment() {
let authorize_response = CONNECTOR
.make_payment(payment_method_details(), get_default_payment_info())
.await
.unwrap();
assert_eq!(authorize_response.status, enums::AttemptStatus::Charged);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/plaid.rs" role="context" start="167" end="190">
async fn should_sync_manually_captured_refund() {
let refund_response = CONNECTOR
.capture_payment_and_refund(
payment_method_details(),
None,
None,
get_default_payment_info(),
)
.await
.unwrap();
let response = CONNECTOR
.rsync_retry_till_status_matches(
enums::RefundStatus::Success,
refund_response.response.unwrap().connector_refund_id,
None,
get_default_payment_info(),
)
.await
.unwrap();
assert_eq!(
response.response.unwrap().refund_status,
enums::RefundStatus::Success,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/plaid.rs" role="context" start="128" end="142">
async fn should_refund_manually_captured_payment() {
let response = CONNECTOR
.capture_payment_and_refund(
payment_method_details(),
None,
None,
get_default_payment_info(),
)
.await
.unwrap();
assert_eq!(
response.response.unwrap().refund_status,
enums::RefundStatus::Success,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/plaid.rs" role="context" start="110" end="124">
async fn should_void_authorized_payment() {
let response = CONNECTOR
.authorize_and_void_payment(
payment_method_details(),
Some(types::PaymentsCancelData {
connector_transaction_id: String::from(""),
cancellation_reason: Some("requested_by_customer".to_string()),
..Default::default()
}),
get_default_payment_info(),
)
.await
.expect("Void payment response");
assert_eq!(response.status, enums::AttemptStatus::Voided);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/plaid.rs" role="context" start="42" end="44">
fn payment_method_details() -> Option<types::PaymentsAuthorizeData> {
None
}
<file_sep path="hyperswitch/crates/router/tests/connectors/plaid.rs" role="context" start="38" end="40">
fn get_default_payment_info() -> Option<utils::PaymentInfo> {
None
}
<file_sep path="hyperswitch/crates/router/src/connector/dummyconnector/transformers.rs" role="context" start="304" end="309">
pub enum RefundStatus {
Succeeded,
Failed,
#[default]
Processing,
}
<file_sep path="hyperswitch/crates/api_models/src/refunds.rs" role="context" start="378" end="384">
pub enum RefundStatus {
Succeeded,
Failed,
#[default]
Pending,
Review,
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/router/tests/connectors/ebanx.rs<|crate|> router<|connector|> ebanx anchor=should_partially_refund_manually_captured_payment kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/router/tests/connectors/ebanx.rs" role="context" start="145" end="162">
async fn should_partially_refund_manually_captured_payment() {
let response = CONNECTOR
.capture_payment_and_refund(
payment_method_details(),
None,
Some(types::RefundsData {
refund_amount: 50,
..utils::PaymentRefundType::default().0
}),
get_default_payment_info(),
)
.await
.unwrap();
assert_eq!(
response.response.unwrap().refund_status,
enums::RefundStatus::Success,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/ebanx.rs" role="context" start="144" end="144">
use router::types::{self, storage::enums};
<file_sep path="hyperswitch/crates/router/tests/connectors/ebanx.rs" role="context" start="193" end="199">
async fn should_make_payment() {
let authorize_response = CONNECTOR
.make_payment(payment_method_details(), get_default_payment_info())
.await
.unwrap();
assert_eq!(authorize_response.status, enums::AttemptStatus::Charged);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/ebanx.rs" role="context" start="166" end="189">
async fn should_sync_manually_captured_refund() {
let refund_response = CONNECTOR
.capture_payment_and_refund(
payment_method_details(),
None,
None,
get_default_payment_info(),
)
.await
.unwrap();
let response = CONNECTOR
.rsync_retry_till_status_matches(
enums::RefundStatus::Success,
refund_response.response.unwrap().connector_refund_id,
None,
get_default_payment_info(),
)
.await
.unwrap();
assert_eq!(
response.response.unwrap().refund_status,
enums::RefundStatus::Success,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/ebanx.rs" role="context" start="127" end="141">
async fn should_refund_manually_captured_payment() {
let response = CONNECTOR
.capture_payment_and_refund(
payment_method_details(),
None,
None,
get_default_payment_info(),
)
.await
.unwrap();
assert_eq!(
response.response.unwrap().refund_status,
enums::RefundStatus::Success,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/ebanx.rs" role="context" start="109" end="123">
async fn should_void_authorized_payment() {
let response = CONNECTOR
.authorize_and_void_payment(
payment_method_details(),
Some(types::PaymentsCancelData {
connector_transaction_id: String::from(""),
cancellation_reason: Some("requested_by_customer".to_string()),
..Default::default()
}),
get_default_payment_info(),
)
.await
.expect("Void payment response");
assert_eq!(response.status, enums::AttemptStatus::Voided);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/ebanx.rs" role="context" start="41" end="43">
fn payment_method_details() -> Option<types::PaymentsAuthorizeData> {
None
}
<file_sep path="hyperswitch/crates/router/tests/connectors/ebanx.rs" role="context" start="37" end="39">
fn get_default_payment_info() -> Option<utils::PaymentInfo> {
None
}
<file_sep path="hyperswitch/crates/router/src/connector/dummyconnector/transformers.rs" role="context" start="304" end="309">
pub enum RefundStatus {
Succeeded,
Failed,
#[default]
Processing,
}
<file_sep path="hyperswitch/crates/api_models/src/refunds.rs" role="context" start="378" end="384">
pub enum RefundStatus {
Succeeded,
Failed,
#[default]
Pending,
Review,
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/test_utils/tests/connectors/selenium.rs<|crate|> test_utils<|connector|> selenium anchor=get_saved_testcases kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/selenium.rs" role="context" start="784" end="797">
fn get_saved_testcases() -> serde_json::Value {
let env_value = env::var("CONNECTOR_TESTS_FILE_PATH").ok();
if env_value.is_none() {
return serde_json::json!("");
}
let path = env_value.unwrap();
let mut file = &std::fs::File::open(path).expect("Failed to open file");
let mut contents = String::new();
file.read_to_string(&mut contents)
.expect("Failed to read file");
// Parse the JSON data
serde_json::from_str(&contents).expect("Failed to parse JSON")
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/selenium.rs" role="context" start="783" end="783">
use std::{
collections::{HashMap, HashSet},
env,
io::Read,
path::{MAIN_SEPARATOR, MAIN_SEPARATOR_STR},
time::Duration,
};
use serde_json::json;
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/selenium.rs" role="context" start="807" end="825">
pub fn should_ignore_test(name: &str) -> bool {
let conf = get_saved_testcases()
.get("tests_to_ignore")
.unwrap_or(&json!([]))
.clone();
let tests_to_ignore: HashSet<String> =
serde_json::from_value(conf).unwrap_or_else(|_| HashSet::new());
let modules: Vec<_> = name.split("::").collect();
let file_match = format!(
"{}::*",
<&str>::clone(modules.get(1).expect("Error obtaining module path segment"))
);
let module_name = modules
.get(1..3)
.expect("Error obtaining module path segment")
.join("::");
// Ignore if it matches patterns like nuvei_ui::*, nuvei_ui::should_make_nuvei_eps_payment_test
tests_to_ignore.contains(&file_match) || tests_to_ignore.contains(&module_name)
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/selenium.rs" role="context" start="798" end="805">
fn get_configs() -> connector_auth::ConnectorAuthentication {
let path =
env::var("CONNECTOR_AUTH_FILE_PATH").expect("connector authentication file path not set");
toml::from_str(
&std::fs::read_to_string(path).expect("connector authentication config file not found"),
)
.expect("Failed to read connector authentication config file")
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/selenium.rs" role="context" start="711" end="714">
async fn is_element_present(driver: &WebDriver, by: By) -> WebDriverResult<bool> {
let element = driver.query(by).first().await?;
element.is_present().await
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/selenium.rs" role="context" start="704" end="710">
async fn is_text_present(driver: &WebDriver, key: &str) -> WebDriverResult<bool> {
let mut xpath = "//*[contains(text(),'".to_owned();
xpath.push_str(key);
xpath.push_str("')]");
let result = driver.query(By::XPath(&xpath)).first().await?;
result.is_present().await
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/selenium.rs" role="context" start="72" end="74">
fn get_saved_testcases(&self) -> serde_json::Value {
get_saved_testcases()
}
<file_sep path="hyperswitch/crates/api_models/src/payment_methods.rs" role="context" start="1670" end="1670">
type Value = PaymentMethodListRequest;
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/test_utils/tests/connectors/selenium.rs<|crate|> test_utils<|connector|> selenium anchor=get_configs kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/selenium.rs" role="context" start="75" end="77">
fn get_configs(&self) -> connector_auth::ConnectorAuthentication {
get_configs()
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/selenium.rs" role="context" start="97" end="367">
async fn complete_actions(
&self,
driver: &WebDriver,
actions: Vec<Event<'_>>,
) -> Result<(), WebDriverError> {
for action in actions {
match action {
Event::Assert(assert) => match assert {
Assert::Contains(selector, text) => match selector {
Selector::QueryParamStr => {
let url = driver.current_url().await?;
assert!(url.query().unwrap().contains(text))
}
_ => assert!(driver.title().await?.contains(text)),
},
Assert::ContainsAny(selector, search_keys) => match selector {
Selector::QueryParamStr => {
let url = driver.current_url().await?;
assert!(search_keys
.iter()
.any(|key| url.query().unwrap().contains(key)))
}
_ => assert!(driver.title().await?.contains(search_keys.first().unwrap())),
},
Assert::EitherOfThemExist(text_1, text_2) => assert!(
is_text_present_now(driver, text_1).await?
|| is_text_present_now(driver, text_2).await?
),
Assert::Eq(_selector, text) => assert_eq!(driver.title().await?, text),
Assert::IsPresent(text) => {
assert!(is_text_present(driver, text).await?)
}
Assert::IsElePresent(selector) => {
assert!(is_element_present(driver, selector).await?)
}
Assert::IsPresentNow(text) => {
assert!(is_text_present_now(driver, text).await?)
}
},
Event::RunIf(con_event, events) => match con_event {
Assert::Contains(selector, text) => match selector {
Selector::QueryParamStr => {
let url = driver.current_url().await?;
if url.query().unwrap().contains(text) {
self.complete_actions(driver, events).await?;
}
}
_ => assert!(driver.title().await?.contains(text)),
},
Assert::ContainsAny(selector, keys) => match selector {
Selector::QueryParamStr => {
let url = driver.current_url().await?;
if keys.iter().any(|key| url.query().unwrap().contains(key)) {
self.complete_actions(driver, events).await?;
}
}
_ => assert!(driver.title().await?.contains(keys.first().unwrap())),
},
Assert::Eq(_selector, text) => {
if text == driver.title().await? {
self.complete_actions(driver, events).await?;
}
}
Assert::EitherOfThemExist(text_1, text_2) => {
if is_text_present_now(driver, text_1).await.is_ok()
|| is_text_present_now(driver, text_2).await.is_ok()
{
self.complete_actions(driver, events).await?;
}
}
Assert::IsPresent(text) => {
if is_text_present(driver, text).await.is_ok() {
self.complete_actions(driver, events).await?;
}
}
Assert::IsElePresent(text) => {
if is_element_present(driver, text).await.is_ok() {
self.complete_actions(driver, events).await?;
}
}
Assert::IsPresentNow(text) => {
if is_text_present_now(driver, text).await.is_ok() {
self.complete_actions(driver, events).await?;
}
}
},
Event::EitherOr(con_event, success, failure) => match con_event {
Assert::Contains(selector, text) => match selector {
Selector::QueryParamStr => {
let url = driver.current_url().await?;
self.complete_actions(
driver,
if url.query().unwrap().contains(text) {
success
} else {
failure
},
)
.await?;
}
_ => assert!(driver.title().await?.contains(text)),
},
Assert::ContainsAny(selector, keys) => match selector {
Selector::QueryParamStr => {
let url = driver.current_url().await?;
self.complete_actions(
driver,
if keys.iter().any(|key| url.query().unwrap().contains(key)) {
success
} else {
failure
},
)
.await?;
}
_ => assert!(driver.title().await?.contains(keys.first().unwrap())),
},
Assert::Eq(_selector, text) => {
self.complete_actions(
driver,
if text == driver.title().await? {
success
} else {
failure
},
)
.await?;
}
Assert::EitherOfThemExist(text_1, text_2) => {
self.complete_actions(
driver,
if is_text_present_now(driver, text_1).await.is_ok()
|| is_text_present_now(driver, text_2).await.is_ok()
{
success
} else {
failure
},
)
.await?;
}
Assert::IsPresent(text) => {
self.complete_actions(
driver,
if is_text_present(driver, text).await.is_ok() {
success
} else {
failure
},
)
.await?;
}
Assert::IsElePresent(by) => {
self.complete_actions(
driver,
if is_element_present(driver, by).await.is_ok() {
success
} else {
failure
},
)
.await?;
}
Assert::IsPresentNow(text) => {
self.complete_actions(
driver,
if is_text_present_now(driver, text).await.is_ok() {
success
} else {
failure
},
)
.await?;
}
},
Event::Trigger(trigger) => match trigger {
Trigger::Goto(url) => {
let saved_tests =
serde_json::to_string(&self.get_saved_testcases()).unwrap();
let conf = serde_json::to_string(&self.get_configs()).unwrap();
let configs = self.get_configs().automation_configs.unwrap();
let hs_base_url = configs
.hs_base_url
.unwrap_or_else(|| "http://localhost:8080".to_string());
let configs_url = configs.configs_url.unwrap();
let hs_api_keys = configs.hs_api_keys.unwrap();
let test_env = configs.hs_test_env.unwrap();
let script = &[
format!("localStorage.configs='{configs_url}'").as_str(),
format!("localStorage.current_env='{test_env}'").as_str(),
"localStorage.hs_api_key=''",
format!("localStorage.hs_api_keys='{hs_api_keys}'").as_str(),
format!("localStorage.base_url='{hs_base_url}'").as_str(),
format!("localStorage.hs_api_configs='{conf}'").as_str(),
format!("localStorage.saved_payments=JSON.stringify({saved_tests})")
.as_str(),
"localStorage.force_sync='true'",
format!(
"localStorage.current_connector=\"{}\";",
self.get_connector_name().clone()
)
.as_str(),
]
.join(";");
driver.goto(url).await?;
driver.execute(script, Vec::new()).await?;
}
Trigger::Click(by) => {
self.retry_click(3, 5, driver, by.clone()).await?;
}
Trigger::ClickNth(by, n) => {
let ele = driver.query(by).all().await?.into_iter().nth(n).unwrap();
ele.wait_until().enabled().await?;
ele.wait_until().displayed().await?;
ele.wait_until().clickable().await?;
ele.scroll_into_view().await?;
ele.click().await?;
}
Trigger::Find(by) => {
driver.find(by).await?;
}
Trigger::Query(by) => {
driver.query(by).first().await?;
}
Trigger::SendKeys(by, input) => {
let ele = driver.query(by).first().await?;
ele.wait_until().displayed().await?;
ele.send_keys(&input).await?;
}
Trigger::SelectOption(by, input) => {
let ele = driver.query(by).first().await?;
let select_element = SelectElement::new(&ele).await?;
select_element.select_by_partial_text(input).await?;
}
Trigger::ChangeQueryParam(param, value) => {
let mut url = driver.current_url().await?;
let mut hash_query: HashMap<String, String> =
url.query_pairs().into_owned().collect();
hash_query.insert(param.to_string(), value.to_string());
let url_str = serde_urlencoded::to_string(hash_query)
.expect("Query Param update failed");
url.set_query(Some(&url_str));
driver.goto(url.as_str()).await?;
}
Trigger::Sleep(seconds) => {
tokio::time::sleep(Duration::from_secs(seconds)).await;
}
Trigger::SwitchTab(position) => match position {
Position::Next => {
let windows = driver.windows().await?;
if let Some(window) = windows.iter().next_back() {
driver.switch_to_window(window.to_owned()).await?;
}
}
Position::Prev => {
let windows = driver.windows().await?;
if let Some(window) = windows.into_iter().next() {
driver.switch_to_window(window.to_owned()).await?;
}
}
},
Trigger::SwitchFrame(by) => {
let iframe = driver.query(by).first().await?;
iframe.wait_until().displayed().await?;
iframe.clone().enter_frame().await?;
}
},
}
}
Ok(())
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/selenium.rs" role="context" start="78" end="95">
async fn retry_click(
&self,
times: i32,
interval: u64,
driver: &WebDriver,
by: By,
) -> Result<(), WebDriverError> {
let mut res = Ok(());
for _i in 0..times {
res = self.click_element(driver, by.clone()).await;
if res.is_err() {
tokio::time::sleep(Duration::from_secs(interval)).await;
} else {
break;
}
}
return res;
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/selenium.rs" role="context" start="72" end="74">
fn get_saved_testcases(&self) -> serde_json::Value {
get_saved_testcases()
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/selenium.rs" role="context" start="798" end="805">
fn get_configs() -> connector_auth::ConnectorAuthentication {
let path =
env::var("CONNECTOR_AUTH_FILE_PATH").expect("connector authentication file path not set");
toml::from_str(
&std::fs::read_to_string(path).expect("connector authentication config file not found"),
)
.expect("Failed to read connector authentication config file")
}
<file_sep path="hyperswitch/crates/test_utils/src/connector_auth.rs" role="context" start="7" end="114">
pub struct ConnectorAuthentication {
pub aci: Option<BodyKey>,
#[cfg(not(feature = "payouts"))]
pub adyen: Option<BodyKey>,
#[cfg(feature = "payouts")]
pub adyenplatform: Option<HeaderKey>,
#[cfg(feature = "payouts")]
pub adyen: Option<SignatureKey>,
#[cfg(not(feature = "payouts"))]
pub adyen_uk: Option<BodyKey>,
#[cfg(feature = "payouts")]
pub adyen_uk: Option<SignatureKey>,
pub airwallex: Option<BodyKey>,
pub amazonpay: Option<HeaderKey>,
pub authorizedotnet: Option<BodyKey>,
pub bambora: Option<BodyKey>,
pub bamboraapac: Option<HeaderKey>,
pub bankofamerica: Option<SignatureKey>,
pub billwerk: Option<HeaderKey>,
pub bitpay: Option<HeaderKey>,
pub bluesnap: Option<BodyKey>,
pub boku: Option<BodyKey>,
pub cashtocode: Option<BodyKey>,
pub chargebee: Option<HeaderKey>,
pub checkout: Option<SignatureKey>,
pub coinbase: Option<HeaderKey>,
pub coingate: Option<HeaderKey>,
pub cryptopay: Option<BodyKey>,
pub cybersource: Option<SignatureKey>,
pub datatrans: Option<HeaderKey>,
pub deutschebank: Option<SignatureKey>,
pub digitalvirgo: Option<HeaderKey>,
pub dlocal: Option<SignatureKey>,
#[cfg(feature = "dummy_connector")]
pub dummyconnector: Option<HeaderKey>,
pub ebanx: Option<HeaderKey>,
pub elavon: Option<HeaderKey>,
pub facilitapay: Option<BodyKey>,
pub fiserv: Option<SignatureKey>,
pub fiservemea: Option<HeaderKey>,
pub fiuu: Option<HeaderKey>,
pub forte: Option<MultiAuthKey>,
pub getnet: Option<HeaderKey>,
pub globalpay: Option<BodyKey>,
pub globepay: Option<BodyKey>,
pub gocardless: Option<HeaderKey>,
pub gpayments: Option<HeaderKey>,
pub helcim: Option<HeaderKey>,
pub hipay: Option<HeaderKey>,
pub iatapay: Option<SignatureKey>,
pub inespay: Option<HeaderKey>,
pub itaubank: Option<MultiAuthKey>,
pub jpmorgan: Option<BodyKey>,
pub juspaythreedsserver: Option<HeaderKey>,
pub mifinity: Option<HeaderKey>,
pub mollie: Option<BodyKey>,
pub moneris: Option<SignatureKey>,
pub multisafepay: Option<HeaderKey>,
pub netcetera: Option<HeaderKey>,
pub nexinets: Option<BodyKey>,
pub nexixpay: Option<HeaderKey>,
pub nomupay: Option<BodyKey>,
pub noon: Option<SignatureKey>,
pub novalnet: Option<HeaderKey>,
pub nmi: Option<HeaderKey>,
pub nuvei: Option<SignatureKey>,
pub opayo: Option<HeaderKey>,
pub opennode: Option<HeaderKey>,
pub paybox: Option<HeaderKey>,
pub payeezy: Option<SignatureKey>,
pub payme: Option<BodyKey>,
pub payone: Option<HeaderKey>,
pub paypal: Option<BodyKey>,
pub paystack: Option<HeaderKey>,
pub payu: Option<BodyKey>,
pub placetopay: Option<BodyKey>,
pub plaid: Option<BodyKey>,
pub powertranz: Option<BodyKey>,
pub prophetpay: Option<HeaderKey>,
pub rapyd: Option<BodyKey>,
pub razorpay: Option<BodyKey>,
pub recurly: Option<HeaderKey>,
pub redsys: Option<HeaderKey>,
pub shift4: Option<HeaderKey>,
pub square: Option<BodyKey>,
pub stax: Option<HeaderKey>,
pub stripe: Option<HeaderKey>,
pub stripebilling: Option<HeaderKey>,
pub taxjar: Option<HeaderKey>,
pub threedsecureio: Option<HeaderKey>,
pub thunes: Option<HeaderKey>,
pub stripe_au: Option<HeaderKey>,
pub stripe_uk: Option<HeaderKey>,
pub trustpay: Option<SignatureKey>,
pub tsys: Option<SignatureKey>,
pub unified_authentication_service: Option<HeaderKey>,
pub volt: Option<HeaderKey>,
pub wellsfargo: Option<HeaderKey>,
// pub wellsfargopayout: Option<HeaderKey>,
pub wise: Option<BodyKey>,
pub worldpay: Option<BodyKey>,
pub xendit: Option<HeaderKey>,
pub worldline: Option<SignatureKey>,
pub zen: Option<HeaderKey>,
pub zsl: Option<BodyKey>,
pub automation_configs: Option<AutomationConfigs>,
pub users: Option<UsersConfigs>,
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/test_utils/tests/connectors/selenium.rs<|crate|> test_utils<|connector|> selenium anchor=get_saved_testcases kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/selenium.rs" role="context" start="72" end="74">
fn get_saved_testcases(&self) -> serde_json::Value {
get_saved_testcases()
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/selenium.rs" role="context" start="71" end="71">
use serde_json::json;
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/selenium.rs" role="context" start="78" end="95">
async fn retry_click(
&self,
times: i32,
interval: u64,
driver: &WebDriver,
by: By,
) -> Result<(), WebDriverError> {
let mut res = Ok(());
for _i in 0..times {
res = self.click_element(driver, by.clone()).await;
if res.is_err() {
tokio::time::sleep(Duration::from_secs(interval)).await;
} else {
break;
}
}
return res;
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/selenium.rs" role="context" start="75" end="77">
fn get_configs(&self) -> connector_auth::ConnectorAuthentication {
get_configs()
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/selenium.rs" role="context" start="784" end="797">
fn get_saved_testcases() -> serde_json::Value {
let env_value = env::var("CONNECTOR_TESTS_FILE_PATH").ok();
if env_value.is_none() {
return serde_json::json!("");
}
let path = env_value.unwrap();
let mut file = &std::fs::File::open(path).expect("Failed to open file");
let mut contents = String::new();
file.read_to_string(&mut contents)
.expect("Failed to read file");
// Parse the JSON data
serde_json::from_str(&contents).expect("Failed to parse JSON")
}
<file_sep path="hyperswitch/crates/api_models/src/payment_methods.rs" role="context" start="1670" end="1670">
type Value = PaymentMethodListRequest;
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/test_utils/tests/connectors/selenium.rs<|crate|> test_utils<|connector|> selenium anchor=is_element_present kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=1<|meta_end|>
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/selenium.rs" role="context" start="711" end="714">
async fn is_element_present(driver: &WebDriver, by: By) -> WebDriverResult<bool> {
let element = driver.query(by).first().await?;
element.is_present().await
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/selenium.rs" role="context" start="798" end="805">
fn get_configs() -> connector_auth::ConnectorAuthentication {
let path =
env::var("CONNECTOR_AUTH_FILE_PATH").expect("connector authentication file path not set");
toml::from_str(
&std::fs::read_to_string(path).expect("connector authentication config file not found"),
)
.expect("Failed to read connector authentication config file")
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/selenium.rs" role="context" start="784" end="797">
fn get_saved_testcases() -> serde_json::Value {
let env_value = env::var("CONNECTOR_TESTS_FILE_PATH").ok();
if env_value.is_none() {
return serde_json::json!("");
}
let path = env_value.unwrap();
let mut file = &std::fs::File::open(path).expect("Failed to open file");
let mut contents = String::new();
file.read_to_string(&mut contents)
.expect("Failed to read file");
// Parse the JSON data
serde_json::from_str(&contents).expect("Failed to parse JSON")
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/selenium.rs" role="context" start="704" end="710">
async fn is_text_present(driver: &WebDriver, key: &str) -> WebDriverResult<bool> {
let mut xpath = "//*[contains(text(),'".to_owned();
xpath.push_str(key);
xpath.push_str("')]");
let result = driver.query(By::XPath(&xpath)).first().await?;
result.is_present().await
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/selenium.rs" role="context" start="693" end="703">
async fn is_text_present_now(driver: &WebDriver, key: &str) -> WebDriverResult<bool> {
let mut xpath = "//*[contains(text(),'".to_owned();
xpath.push_str(key);
xpath.push_str("')]");
let result = driver.find(By::XPath(&xpath)).await?;
let display: &str = &result.css_value("display").await?;
if display.is_empty() || display == "none" {
return Err(WebDriverError::CustomError("Element is hidden".to_string()));
}
result.is_present().await
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/selenium.rs" role="context" start="97" end="367">
async fn complete_actions(
&self,
driver: &WebDriver,
actions: Vec<Event<'_>>,
) -> Result<(), WebDriverError> {
for action in actions {
match action {
Event::Assert(assert) => match assert {
Assert::Contains(selector, text) => match selector {
Selector::QueryParamStr => {
let url = driver.current_url().await?;
assert!(url.query().unwrap().contains(text))
}
_ => assert!(driver.title().await?.contains(text)),
},
Assert::ContainsAny(selector, search_keys) => match selector {
Selector::QueryParamStr => {
let url = driver.current_url().await?;
assert!(search_keys
.iter()
.any(|key| url.query().unwrap().contains(key)))
}
_ => assert!(driver.title().await?.contains(search_keys.first().unwrap())),
},
Assert::EitherOfThemExist(text_1, text_2) => assert!(
is_text_present_now(driver, text_1).await?
|| is_text_present_now(driver, text_2).await?
),
Assert::Eq(_selector, text) => assert_eq!(driver.title().await?, text),
Assert::IsPresent(text) => {
assert!(is_text_present(driver, text).await?)
}
Assert::IsElePresent(selector) => {
assert!(is_element_present(driver, selector).await?)
}
Assert::IsPresentNow(text) => {
assert!(is_text_present_now(driver, text).await?)
}
},
Event::RunIf(con_event, events) => match con_event {
Assert::Contains(selector, text) => match selector {
Selector::QueryParamStr => {
let url = driver.current_url().await?;
if url.query().unwrap().contains(text) {
self.complete_actions(driver, events).await?;
}
}
_ => assert!(driver.title().await?.contains(text)),
},
Assert::ContainsAny(selector, keys) => match selector {
Selector::QueryParamStr => {
let url = driver.current_url().await?;
if keys.iter().any(|key| url.query().unwrap().contains(key)) {
self.complete_actions(driver, events).await?;
}
}
_ => assert!(driver.title().await?.contains(keys.first().unwrap())),
},
Assert::Eq(_selector, text) => {
if text == driver.title().await? {
self.complete_actions(driver, events).await?;
}
}
Assert::EitherOfThemExist(text_1, text_2) => {
if is_text_present_now(driver, text_1).await.is_ok()
|| is_text_present_now(driver, text_2).await.is_ok()
{
self.complete_actions(driver, events).await?;
}
}
Assert::IsPresent(text) => {
if is_text_present(driver, text).await.is_ok() {
self.complete_actions(driver, events).await?;
}
}
Assert::IsElePresent(text) => {
if is_element_present(driver, text).await.is_ok() {
self.complete_actions(driver, events).await?;
}
}
Assert::IsPresentNow(text) => {
if is_text_present_now(driver, text).await.is_ok() {
self.complete_actions(driver, events).await?;
}
}
},
Event::EitherOr(con_event, success, failure) => match con_event {
Assert::Contains(selector, text) => match selector {
Selector::QueryParamStr => {
let url = driver.current_url().await?;
self.complete_actions(
driver,
if url.query().unwrap().contains(text) {
success
} else {
failure
},
)
.await?;
}
_ => assert!(driver.title().await?.contains(text)),
},
Assert::ContainsAny(selector, keys) => match selector {
Selector::QueryParamStr => {
let url = driver.current_url().await?;
self.complete_actions(
driver,
if keys.iter().any(|key| url.query().unwrap().contains(key)) {
success
} else {
failure
},
)
.await?;
}
_ => assert!(driver.title().await?.contains(keys.first().unwrap())),
},
Assert::Eq(_selector, text) => {
self.complete_actions(
driver,
if text == driver.title().await? {
success
} else {
failure
},
)
.await?;
}
Assert::EitherOfThemExist(text_1, text_2) => {
self.complete_actions(
driver,
if is_text_present_now(driver, text_1).await.is_ok()
|| is_text_present_now(driver, text_2).await.is_ok()
{
success
} else {
failure
},
)
.await?;
}
Assert::IsPresent(text) => {
self.complete_actions(
driver,
if is_text_present(driver, text).await.is_ok() {
success
} else {
failure
},
)
.await?;
}
Assert::IsElePresent(by) => {
self.complete_actions(
driver,
if is_element_present(driver, by).await.is_ok() {
success
} else {
failure
},
)
.await?;
}
Assert::IsPresentNow(text) => {
self.complete_actions(
driver,
if is_text_present_now(driver, text).await.is_ok() {
success
} else {
failure
},
)
.await?;
}
},
Event::Trigger(trigger) => match trigger {
Trigger::Goto(url) => {
let saved_tests =
serde_json::to_string(&self.get_saved_testcases()).unwrap();
let conf = serde_json::to_string(&self.get_configs()).unwrap();
let configs = self.get_configs().automation_configs.unwrap();
let hs_base_url = configs
.hs_base_url
.unwrap_or_else(|| "http://localhost:8080".to_string());
let configs_url = configs.configs_url.unwrap();
let hs_api_keys = configs.hs_api_keys.unwrap();
let test_env = configs.hs_test_env.unwrap();
let script = &[
format!("localStorage.configs='{configs_url}'").as_str(),
format!("localStorage.current_env='{test_env}'").as_str(),
"localStorage.hs_api_key=''",
format!("localStorage.hs_api_keys='{hs_api_keys}'").as_str(),
format!("localStorage.base_url='{hs_base_url}'").as_str(),
format!("localStorage.hs_api_configs='{conf}'").as_str(),
format!("localStorage.saved_payments=JSON.stringify({saved_tests})")
.as_str(),
"localStorage.force_sync='true'",
format!(
"localStorage.current_connector=\"{}\";",
self.get_connector_name().clone()
)
.as_str(),
]
.join(";");
driver.goto(url).await?;
driver.execute(script, Vec::new()).await?;
}
Trigger::Click(by) => {
self.retry_click(3, 5, driver, by.clone()).await?;
}
Trigger::ClickNth(by, n) => {
let ele = driver.query(by).all().await?.into_iter().nth(n).unwrap();
ele.wait_until().enabled().await?;
ele.wait_until().displayed().await?;
ele.wait_until().clickable().await?;
ele.scroll_into_view().await?;
ele.click().await?;
}
Trigger::Find(by) => {
driver.find(by).await?;
}
Trigger::Query(by) => {
driver.query(by).first().await?;
}
Trigger::SendKeys(by, input) => {
let ele = driver.query(by).first().await?;
ele.wait_until().displayed().await?;
ele.send_keys(&input).await?;
}
Trigger::SelectOption(by, input) => {
let ele = driver.query(by).first().await?;
let select_element = SelectElement::new(&ele).await?;
select_element.select_by_partial_text(input).await?;
}
Trigger::ChangeQueryParam(param, value) => {
let mut url = driver.current_url().await?;
let mut hash_query: HashMap<String, String> =
url.query_pairs().into_owned().collect();
hash_query.insert(param.to_string(), value.to_string());
let url_str = serde_urlencoded::to_string(hash_query)
.expect("Query Param update failed");
url.set_query(Some(&url_str));
driver.goto(url.as_str()).await?;
}
Trigger::Sleep(seconds) => {
tokio::time::sleep(Duration::from_secs(seconds)).await;
}
Trigger::SwitchTab(position) => match position {
Position::Next => {
let windows = driver.windows().await?;
if let Some(window) = windows.iter().next_back() {
driver.switch_to_window(window.to_owned()).await?;
}
}
Position::Prev => {
let windows = driver.windows().await?;
if let Some(window) = windows.into_iter().next() {
driver.switch_to_window(window.to_owned()).await?;
}
}
},
Trigger::SwitchFrame(by) => {
let iframe = driver.query(by).first().await?;
iframe.wait_until().displayed().await?;
iframe.clone().enter_frame().await?;
}
},
}
}
Ok(())
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/test_utils/tests/connectors/selenium.rs<|crate|> test_utils<|connector|> selenium anchor=is_text_present kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=1<|meta_end|>
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/selenium.rs" role="context" start="704" end="710">
async fn is_text_present(driver: &WebDriver, key: &str) -> WebDriverResult<bool> {
let mut xpath = "//*[contains(text(),'".to_owned();
xpath.push_str(key);
xpath.push_str("')]");
let result = driver.query(By::XPath(&xpath)).first().await?;
result.is_present().await
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/selenium.rs" role="context" start="784" end="797">
fn get_saved_testcases() -> serde_json::Value {
let env_value = env::var("CONNECTOR_TESTS_FILE_PATH").ok();
if env_value.is_none() {
return serde_json::json!("");
}
let path = env_value.unwrap();
let mut file = &std::fs::File::open(path).expect("Failed to open file");
let mut contents = String::new();
file.read_to_string(&mut contents)
.expect("Failed to read file");
// Parse the JSON data
serde_json::from_str(&contents).expect("Failed to parse JSON")
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/selenium.rs" role="context" start="711" end="714">
async fn is_element_present(driver: &WebDriver, by: By) -> WebDriverResult<bool> {
let element = driver.query(by).first().await?;
element.is_present().await
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/selenium.rs" role="context" start="693" end="703">
async fn is_text_present_now(driver: &WebDriver, key: &str) -> WebDriverResult<bool> {
let mut xpath = "//*[contains(text(),'".to_owned();
xpath.push_str(key);
xpath.push_str("')]");
let result = driver.find(By::XPath(&xpath)).await?;
let display: &str = &result.css_value("display").await?;
if display.is_empty() || display == "none" {
return Err(WebDriverError::CustomError("Element is hidden".to_string()));
}
result.is_present().await
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/selenium.rs" role="context" start="630" end="691">
async fn make_clearpay_payment(
&self,
driver: WebDriver,
url: &str,
actions: Vec<Event<'_>>,
) -> Result<(), WebDriverError> {
self.complete_actions(
&driver,
vec![
Event::Trigger(Trigger::Goto(url)),
Event::Trigger(Trigger::Click(By::Id("card-submit-btn"))),
Event::Trigger(Trigger::Sleep(5)),
Event::RunIf(
Assert::IsPresentNow("Manage Cookies"),
vec![
Event::Trigger(Trigger::Click(By::Css("button.cookie-setting-link"))),
Event::Trigger(Trigger::Click(By::Id("accept-recommended-btn-handler"))),
],
),
],
)
.await?;
let (email, pass) = (
&self
.get_configs()
.automation_configs
.unwrap()
.clearpay_email
.unwrap(),
&self
.get_configs()
.automation_configs
.unwrap()
.clearpay_pass
.unwrap(),
);
let mut clearpay_actions = vec![
Event::Trigger(Trigger::Sleep(3)),
Event::EitherOr(
Assert::IsPresent("Please enter your password"),
vec![
Event::Trigger(Trigger::SendKeys(By::Css("input[name='password']"), pass)),
Event::Trigger(Trigger::Click(By::Css("button[type='submit']"))),
],
vec![
Event::Trigger(Trigger::SendKeys(
By::Css("input[name='identifier']"),
email,
)),
Event::Trigger(Trigger::Click(By::Css("button[type='submit']"))),
Event::Trigger(Trigger::Sleep(3)),
Event::Trigger(Trigger::SendKeys(By::Css("input[name='password']"), pass)),
Event::Trigger(Trigger::Click(By::Css("button[type='submit']"))),
],
),
Event::Trigger(Trigger::Click(By::Css(
"button[data-testid='summary-button']",
))),
];
clearpay_actions.extend(actions);
self.complete_actions(&driver, clearpay_actions).await
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/selenium.rs" role="context" start="97" end="367">
async fn complete_actions(
&self,
driver: &WebDriver,
actions: Vec<Event<'_>>,
) -> Result<(), WebDriverError> {
for action in actions {
match action {
Event::Assert(assert) => match assert {
Assert::Contains(selector, text) => match selector {
Selector::QueryParamStr => {
let url = driver.current_url().await?;
assert!(url.query().unwrap().contains(text))
}
_ => assert!(driver.title().await?.contains(text)),
},
Assert::ContainsAny(selector, search_keys) => match selector {
Selector::QueryParamStr => {
let url = driver.current_url().await?;
assert!(search_keys
.iter()
.any(|key| url.query().unwrap().contains(key)))
}
_ => assert!(driver.title().await?.contains(search_keys.first().unwrap())),
},
Assert::EitherOfThemExist(text_1, text_2) => assert!(
is_text_present_now(driver, text_1).await?
|| is_text_present_now(driver, text_2).await?
),
Assert::Eq(_selector, text) => assert_eq!(driver.title().await?, text),
Assert::IsPresent(text) => {
assert!(is_text_present(driver, text).await?)
}
Assert::IsElePresent(selector) => {
assert!(is_element_present(driver, selector).await?)
}
Assert::IsPresentNow(text) => {
assert!(is_text_present_now(driver, text).await?)
}
},
Event::RunIf(con_event, events) => match con_event {
Assert::Contains(selector, text) => match selector {
Selector::QueryParamStr => {
let url = driver.current_url().await?;
if url.query().unwrap().contains(text) {
self.complete_actions(driver, events).await?;
}
}
_ => assert!(driver.title().await?.contains(text)),
},
Assert::ContainsAny(selector, keys) => match selector {
Selector::QueryParamStr => {
let url = driver.current_url().await?;
if keys.iter().any(|key| url.query().unwrap().contains(key)) {
self.complete_actions(driver, events).await?;
}
}
_ => assert!(driver.title().await?.contains(keys.first().unwrap())),
},
Assert::Eq(_selector, text) => {
if text == driver.title().await? {
self.complete_actions(driver, events).await?;
}
}
Assert::EitherOfThemExist(text_1, text_2) => {
if is_text_present_now(driver, text_1).await.is_ok()
|| is_text_present_now(driver, text_2).await.is_ok()
{
self.complete_actions(driver, events).await?;
}
}
Assert::IsPresent(text) => {
if is_text_present(driver, text).await.is_ok() {
self.complete_actions(driver, events).await?;
}
}
Assert::IsElePresent(text) => {
if is_element_present(driver, text).await.is_ok() {
self.complete_actions(driver, events).await?;
}
}
Assert::IsPresentNow(text) => {
if is_text_present_now(driver, text).await.is_ok() {
self.complete_actions(driver, events).await?;
}
}
},
Event::EitherOr(con_event, success, failure) => match con_event {
Assert::Contains(selector, text) => match selector {
Selector::QueryParamStr => {
let url = driver.current_url().await?;
self.complete_actions(
driver,
if url.query().unwrap().contains(text) {
success
} else {
failure
},
)
.await?;
}
_ => assert!(driver.title().await?.contains(text)),
},
Assert::ContainsAny(selector, keys) => match selector {
Selector::QueryParamStr => {
let url = driver.current_url().await?;
self.complete_actions(
driver,
if keys.iter().any(|key| url.query().unwrap().contains(key)) {
success
} else {
failure
},
)
.await?;
}
_ => assert!(driver.title().await?.contains(keys.first().unwrap())),
},
Assert::Eq(_selector, text) => {
self.complete_actions(
driver,
if text == driver.title().await? {
success
} else {
failure
},
)
.await?;
}
Assert::EitherOfThemExist(text_1, text_2) => {
self.complete_actions(
driver,
if is_text_present_now(driver, text_1).await.is_ok()
|| is_text_present_now(driver, text_2).await.is_ok()
{
success
} else {
failure
},
)
.await?;
}
Assert::IsPresent(text) => {
self.complete_actions(
driver,
if is_text_present(driver, text).await.is_ok() {
success
} else {
failure
},
)
.await?;
}
Assert::IsElePresent(by) => {
self.complete_actions(
driver,
if is_element_present(driver, by).await.is_ok() {
success
} else {
failure
},
)
.await?;
}
Assert::IsPresentNow(text) => {
self.complete_actions(
driver,
if is_text_present_now(driver, text).await.is_ok() {
success
} else {
failure
},
)
.await?;
}
},
Event::Trigger(trigger) => match trigger {
Trigger::Goto(url) => {
let saved_tests =
serde_json::to_string(&self.get_saved_testcases()).unwrap();
let conf = serde_json::to_string(&self.get_configs()).unwrap();
let configs = self.get_configs().automation_configs.unwrap();
let hs_base_url = configs
.hs_base_url
.unwrap_or_else(|| "http://localhost:8080".to_string());
let configs_url = configs.configs_url.unwrap();
let hs_api_keys = configs.hs_api_keys.unwrap();
let test_env = configs.hs_test_env.unwrap();
let script = &[
format!("localStorage.configs='{configs_url}'").as_str(),
format!("localStorage.current_env='{test_env}'").as_str(),
"localStorage.hs_api_key=''",
format!("localStorage.hs_api_keys='{hs_api_keys}'").as_str(),
format!("localStorage.base_url='{hs_base_url}'").as_str(),
format!("localStorage.hs_api_configs='{conf}'").as_str(),
format!("localStorage.saved_payments=JSON.stringify({saved_tests})")
.as_str(),
"localStorage.force_sync='true'",
format!(
"localStorage.current_connector=\"{}\";",
self.get_connector_name().clone()
)
.as_str(),
]
.join(";");
driver.goto(url).await?;
driver.execute(script, Vec::new()).await?;
}
Trigger::Click(by) => {
self.retry_click(3, 5, driver, by.clone()).await?;
}
Trigger::ClickNth(by, n) => {
let ele = driver.query(by).all().await?.into_iter().nth(n).unwrap();
ele.wait_until().enabled().await?;
ele.wait_until().displayed().await?;
ele.wait_until().clickable().await?;
ele.scroll_into_view().await?;
ele.click().await?;
}
Trigger::Find(by) => {
driver.find(by).await?;
}
Trigger::Query(by) => {
driver.query(by).first().await?;
}
Trigger::SendKeys(by, input) => {
let ele = driver.query(by).first().await?;
ele.wait_until().displayed().await?;
ele.send_keys(&input).await?;
}
Trigger::SelectOption(by, input) => {
let ele = driver.query(by).first().await?;
let select_element = SelectElement::new(&ele).await?;
select_element.select_by_partial_text(input).await?;
}
Trigger::ChangeQueryParam(param, value) => {
let mut url = driver.current_url().await?;
let mut hash_query: HashMap<String, String> =
url.query_pairs().into_owned().collect();
hash_query.insert(param.to_string(), value.to_string());
let url_str = serde_urlencoded::to_string(hash_query)
.expect("Query Param update failed");
url.set_query(Some(&url_str));
driver.goto(url.as_str()).await?;
}
Trigger::Sleep(seconds) => {
tokio::time::sleep(Duration::from_secs(seconds)).await;
}
Trigger::SwitchTab(position) => match position {
Position::Next => {
let windows = driver.windows().await?;
if let Some(window) = windows.iter().next_back() {
driver.switch_to_window(window.to_owned()).await?;
}
}
Position::Prev => {
let windows = driver.windows().await?;
if let Some(window) = windows.into_iter().next() {
driver.switch_to_window(window.to_owned()).await?;
}
}
},
Trigger::SwitchFrame(by) => {
let iframe = driver.query(by).first().await?;
iframe.wait_until().displayed().await?;
iframe.clone().enter_frame().await?;
}
},
}
}
Ok(())
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/test_utils/tests/connectors/selenium.rs<|crate|> test_utils<|connector|> selenium anchor=get_configs kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/selenium.rs" role="context" start="798" end="805">
fn get_configs() -> connector_auth::ConnectorAuthentication {
let path =
env::var("CONNECTOR_AUTH_FILE_PATH").expect("connector authentication file path not set");
toml::from_str(
&std::fs::read_to_string(path).expect("connector authentication config file not found"),
)
.expect("Failed to read connector authentication config file")
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/selenium.rs" role="context" start="797" end="797">
use std::{
collections::{HashMap, HashSet},
env,
io::Read,
path::{MAIN_SEPARATOR, MAIN_SEPARATOR_STR},
time::Duration,
};
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/selenium.rs" role="context" start="827" end="829">
pub fn get_browser() -> String {
"firefox".to_string()
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/selenium.rs" role="context" start="807" end="825">
pub fn should_ignore_test(name: &str) -> bool {
let conf = get_saved_testcases()
.get("tests_to_ignore")
.unwrap_or(&json!([]))
.clone();
let tests_to_ignore: HashSet<String> =
serde_json::from_value(conf).unwrap_or_else(|_| HashSet::new());
let modules: Vec<_> = name.split("::").collect();
let file_match = format!(
"{}::*",
<&str>::clone(modules.get(1).expect("Error obtaining module path segment"))
);
let module_name = modules
.get(1..3)
.expect("Error obtaining module path segment")
.join("::");
// Ignore if it matches patterns like nuvei_ui::*, nuvei_ui::should_make_nuvei_eps_payment_test
tests_to_ignore.contains(&file_match) || tests_to_ignore.contains(&module_name)
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/selenium.rs" role="context" start="784" end="797">
fn get_saved_testcases() -> serde_json::Value {
let env_value = env::var("CONNECTOR_TESTS_FILE_PATH").ok();
if env_value.is_none() {
return serde_json::json!("");
}
let path = env_value.unwrap();
let mut file = &std::fs::File::open(path).expect("Failed to open file");
let mut contents = String::new();
file.read_to_string(&mut contents)
.expect("Failed to read file");
// Parse the JSON data
serde_json::from_str(&contents).expect("Failed to parse JSON")
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/selenium.rs" role="context" start="711" end="714">
async fn is_element_present(driver: &WebDriver, by: By) -> WebDriverResult<bool> {
let element = driver.query(by).first().await?;
element.is_present().await
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/selenium.rs" role="context" start="75" end="77">
fn get_configs(&self) -> connector_auth::ConnectorAuthentication {
get_configs()
}
<file_sep path="hyperswitch/crates/test_utils/src/connector_auth.rs" role="context" start="7" end="114">
pub struct ConnectorAuthentication {
pub aci: Option<BodyKey>,
#[cfg(not(feature = "payouts"))]
pub adyen: Option<BodyKey>,
#[cfg(feature = "payouts")]
pub adyenplatform: Option<HeaderKey>,
#[cfg(feature = "payouts")]
pub adyen: Option<SignatureKey>,
#[cfg(not(feature = "payouts"))]
pub adyen_uk: Option<BodyKey>,
#[cfg(feature = "payouts")]
pub adyen_uk: Option<SignatureKey>,
pub airwallex: Option<BodyKey>,
pub amazonpay: Option<HeaderKey>,
pub authorizedotnet: Option<BodyKey>,
pub bambora: Option<BodyKey>,
pub bamboraapac: Option<HeaderKey>,
pub bankofamerica: Option<SignatureKey>,
pub billwerk: Option<HeaderKey>,
pub bitpay: Option<HeaderKey>,
pub bluesnap: Option<BodyKey>,
pub boku: Option<BodyKey>,
pub cashtocode: Option<BodyKey>,
pub chargebee: Option<HeaderKey>,
pub checkout: Option<SignatureKey>,
pub coinbase: Option<HeaderKey>,
pub coingate: Option<HeaderKey>,
pub cryptopay: Option<BodyKey>,
pub cybersource: Option<SignatureKey>,
pub datatrans: Option<HeaderKey>,
pub deutschebank: Option<SignatureKey>,
pub digitalvirgo: Option<HeaderKey>,
pub dlocal: Option<SignatureKey>,
#[cfg(feature = "dummy_connector")]
pub dummyconnector: Option<HeaderKey>,
pub ebanx: Option<HeaderKey>,
pub elavon: Option<HeaderKey>,
pub facilitapay: Option<BodyKey>,
pub fiserv: Option<SignatureKey>,
pub fiservemea: Option<HeaderKey>,
pub fiuu: Option<HeaderKey>,
pub forte: Option<MultiAuthKey>,
pub getnet: Option<HeaderKey>,
pub globalpay: Option<BodyKey>,
pub globepay: Option<BodyKey>,
pub gocardless: Option<HeaderKey>,
pub gpayments: Option<HeaderKey>,
pub helcim: Option<HeaderKey>,
pub hipay: Option<HeaderKey>,
pub iatapay: Option<SignatureKey>,
pub inespay: Option<HeaderKey>,
pub itaubank: Option<MultiAuthKey>,
pub jpmorgan: Option<BodyKey>,
pub juspaythreedsserver: Option<HeaderKey>,
pub mifinity: Option<HeaderKey>,
pub mollie: Option<BodyKey>,
pub moneris: Option<SignatureKey>,
pub multisafepay: Option<HeaderKey>,
pub netcetera: Option<HeaderKey>,
pub nexinets: Option<BodyKey>,
pub nexixpay: Option<HeaderKey>,
pub nomupay: Option<BodyKey>,
pub noon: Option<SignatureKey>,
pub novalnet: Option<HeaderKey>,
pub nmi: Option<HeaderKey>,
pub nuvei: Option<SignatureKey>,
pub opayo: Option<HeaderKey>,
pub opennode: Option<HeaderKey>,
pub paybox: Option<HeaderKey>,
pub payeezy: Option<SignatureKey>,
pub payme: Option<BodyKey>,
pub payone: Option<HeaderKey>,
pub paypal: Option<BodyKey>,
pub paystack: Option<HeaderKey>,
pub payu: Option<BodyKey>,
pub placetopay: Option<BodyKey>,
pub plaid: Option<BodyKey>,
pub powertranz: Option<BodyKey>,
pub prophetpay: Option<HeaderKey>,
pub rapyd: Option<BodyKey>,
pub razorpay: Option<BodyKey>,
pub recurly: Option<HeaderKey>,
pub redsys: Option<HeaderKey>,
pub shift4: Option<HeaderKey>,
pub square: Option<BodyKey>,
pub stax: Option<HeaderKey>,
pub stripe: Option<HeaderKey>,
pub stripebilling: Option<HeaderKey>,
pub taxjar: Option<HeaderKey>,
pub threedsecureio: Option<HeaderKey>,
pub thunes: Option<HeaderKey>,
pub stripe_au: Option<HeaderKey>,
pub stripe_uk: Option<HeaderKey>,
pub trustpay: Option<SignatureKey>,
pub tsys: Option<SignatureKey>,
pub unified_authentication_service: Option<HeaderKey>,
pub volt: Option<HeaderKey>,
pub wellsfargo: Option<HeaderKey>,
// pub wellsfargopayout: Option<HeaderKey>,
pub wise: Option<BodyKey>,
pub worldpay: Option<BodyKey>,
pub xendit: Option<HeaderKey>,
pub worldline: Option<SignatureKey>,
pub zen: Option<HeaderKey>,
pub zsl: Option<BodyKey>,
pub automation_configs: Option<AutomationConfigs>,
pub users: Option<UsersConfigs>,
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/test_utils/tests/connectors/selenium.rs<|crate|> test_utils<|connector|> selenium anchor=is_text_present_now kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=1<|meta_end|>
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/selenium.rs" role="context" start="693" end="703">
async fn is_text_present_now(driver: &WebDriver, key: &str) -> WebDriverResult<bool> {
let mut xpath = "//*[contains(text(),'".to_owned();
xpath.push_str(key);
xpath.push_str("')]");
let result = driver.find(By::XPath(&xpath)).await?;
let display: &str = &result.css_value("display").await?;
if display.is_empty() || display == "none" {
return Err(WebDriverError::CustomError("Element is hidden".to_string()));
}
result.is_present().await
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/selenium.rs" role="context" start="711" end="714">
async fn is_element_present(driver: &WebDriver, by: By) -> WebDriverResult<bool> {
let element = driver.query(by).first().await?;
element.is_present().await
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/selenium.rs" role="context" start="704" end="710">
async fn is_text_present(driver: &WebDriver, key: &str) -> WebDriverResult<bool> {
let mut xpath = "//*[contains(text(),'".to_owned();
xpath.push_str(key);
xpath.push_str("')]");
let result = driver.query(By::XPath(&xpath)).first().await?;
result.is_present().await
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/selenium.rs" role="context" start="630" end="691">
async fn make_clearpay_payment(
&self,
driver: WebDriver,
url: &str,
actions: Vec<Event<'_>>,
) -> Result<(), WebDriverError> {
self.complete_actions(
&driver,
vec![
Event::Trigger(Trigger::Goto(url)),
Event::Trigger(Trigger::Click(By::Id("card-submit-btn"))),
Event::Trigger(Trigger::Sleep(5)),
Event::RunIf(
Assert::IsPresentNow("Manage Cookies"),
vec![
Event::Trigger(Trigger::Click(By::Css("button.cookie-setting-link"))),
Event::Trigger(Trigger::Click(By::Id("accept-recommended-btn-handler"))),
],
),
],
)
.await?;
let (email, pass) = (
&self
.get_configs()
.automation_configs
.unwrap()
.clearpay_email
.unwrap(),
&self
.get_configs()
.automation_configs
.unwrap()
.clearpay_pass
.unwrap(),
);
let mut clearpay_actions = vec![
Event::Trigger(Trigger::Sleep(3)),
Event::EitherOr(
Assert::IsPresent("Please enter your password"),
vec![
Event::Trigger(Trigger::SendKeys(By::Css("input[name='password']"), pass)),
Event::Trigger(Trigger::Click(By::Css("button[type='submit']"))),
],
vec![
Event::Trigger(Trigger::SendKeys(
By::Css("input[name='identifier']"),
email,
)),
Event::Trigger(Trigger::Click(By::Css("button[type='submit']"))),
Event::Trigger(Trigger::Sleep(3)),
Event::Trigger(Trigger::SendKeys(By::Css("input[name='password']"), pass)),
Event::Trigger(Trigger::Click(By::Css("button[type='submit']"))),
],
),
Event::Trigger(Trigger::Click(By::Css(
"button[data-testid='summary-button']",
))),
];
clearpay_actions.extend(actions);
self.complete_actions(&driver, clearpay_actions).await
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/selenium.rs" role="context" start="582" end="629">
async fn execute_paypal_steps(
&self,
web_driver: WebDriver,
url: &str,
actions: Vec<Event<'_>>,
) -> Result<(), WebDriverError> {
self.complete_actions(
&web_driver,
vec![
Event::Trigger(Trigger::Goto(url)),
Event::Trigger(Trigger::Click(By::Id("card-submit-btn"))),
],
)
.await?;
let (email, pass) = (
&self
.get_configs()
.automation_configs
.unwrap()
.pypl_email
.unwrap(),
&self
.get_configs()
.automation_configs
.unwrap()
.pypl_pass
.unwrap(),
);
let mut pypl_actions = vec![
Event::Trigger(Trigger::Sleep(8)),
Event::RunIf(
Assert::IsPresentNow("Enter your email address to get started"),
vec![
Event::Trigger(Trigger::SendKeys(By::Id("email"), email)),
Event::Trigger(Trigger::Click(By::Id("btnNext"))),
],
),
Event::RunIf(
Assert::IsPresentNow("Password"),
vec![
Event::Trigger(Trigger::SendKeys(By::Id("password"), pass)),
Event::Trigger(Trigger::Click(By::Id("btnLogin"))),
],
),
];
pypl_actions.extend(actions);
self.complete_actions(&web_driver, pypl_actions).await
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/selenium.rs" role="context" start="97" end="367">
async fn complete_actions(
&self,
driver: &WebDriver,
actions: Vec<Event<'_>>,
) -> Result<(), WebDriverError> {
for action in actions {
match action {
Event::Assert(assert) => match assert {
Assert::Contains(selector, text) => match selector {
Selector::QueryParamStr => {
let url = driver.current_url().await?;
assert!(url.query().unwrap().contains(text))
}
_ => assert!(driver.title().await?.contains(text)),
},
Assert::ContainsAny(selector, search_keys) => match selector {
Selector::QueryParamStr => {
let url = driver.current_url().await?;
assert!(search_keys
.iter()
.any(|key| url.query().unwrap().contains(key)))
}
_ => assert!(driver.title().await?.contains(search_keys.first().unwrap())),
},
Assert::EitherOfThemExist(text_1, text_2) => assert!(
is_text_present_now(driver, text_1).await?
|| is_text_present_now(driver, text_2).await?
),
Assert::Eq(_selector, text) => assert_eq!(driver.title().await?, text),
Assert::IsPresent(text) => {
assert!(is_text_present(driver, text).await?)
}
Assert::IsElePresent(selector) => {
assert!(is_element_present(driver, selector).await?)
}
Assert::IsPresentNow(text) => {
assert!(is_text_present_now(driver, text).await?)
}
},
Event::RunIf(con_event, events) => match con_event {
Assert::Contains(selector, text) => match selector {
Selector::QueryParamStr => {
let url = driver.current_url().await?;
if url.query().unwrap().contains(text) {
self.complete_actions(driver, events).await?;
}
}
_ => assert!(driver.title().await?.contains(text)),
},
Assert::ContainsAny(selector, keys) => match selector {
Selector::QueryParamStr => {
let url = driver.current_url().await?;
if keys.iter().any(|key| url.query().unwrap().contains(key)) {
self.complete_actions(driver, events).await?;
}
}
_ => assert!(driver.title().await?.contains(keys.first().unwrap())),
},
Assert::Eq(_selector, text) => {
if text == driver.title().await? {
self.complete_actions(driver, events).await?;
}
}
Assert::EitherOfThemExist(text_1, text_2) => {
if is_text_present_now(driver, text_1).await.is_ok()
|| is_text_present_now(driver, text_2).await.is_ok()
{
self.complete_actions(driver, events).await?;
}
}
Assert::IsPresent(text) => {
if is_text_present(driver, text).await.is_ok() {
self.complete_actions(driver, events).await?;
}
}
Assert::IsElePresent(text) => {
if is_element_present(driver, text).await.is_ok() {
self.complete_actions(driver, events).await?;
}
}
Assert::IsPresentNow(text) => {
if is_text_present_now(driver, text).await.is_ok() {
self.complete_actions(driver, events).await?;
}
}
},
Event::EitherOr(con_event, success, failure) => match con_event {
Assert::Contains(selector, text) => match selector {
Selector::QueryParamStr => {
let url = driver.current_url().await?;
self.complete_actions(
driver,
if url.query().unwrap().contains(text) {
success
} else {
failure
},
)
.await?;
}
_ => assert!(driver.title().await?.contains(text)),
},
Assert::ContainsAny(selector, keys) => match selector {
Selector::QueryParamStr => {
let url = driver.current_url().await?;
self.complete_actions(
driver,
if keys.iter().any(|key| url.query().unwrap().contains(key)) {
success
} else {
failure
},
)
.await?;
}
_ => assert!(driver.title().await?.contains(keys.first().unwrap())),
},
Assert::Eq(_selector, text) => {
self.complete_actions(
driver,
if text == driver.title().await? {
success
} else {
failure
},
)
.await?;
}
Assert::EitherOfThemExist(text_1, text_2) => {
self.complete_actions(
driver,
if is_text_present_now(driver, text_1).await.is_ok()
|| is_text_present_now(driver, text_2).await.is_ok()
{
success
} else {
failure
},
)
.await?;
}
Assert::IsPresent(text) => {
self.complete_actions(
driver,
if is_text_present(driver, text).await.is_ok() {
success
} else {
failure
},
)
.await?;
}
Assert::IsElePresent(by) => {
self.complete_actions(
driver,
if is_element_present(driver, by).await.is_ok() {
success
} else {
failure
},
)
.await?;
}
Assert::IsPresentNow(text) => {
self.complete_actions(
driver,
if is_text_present_now(driver, text).await.is_ok() {
success
} else {
failure
},
)
.await?;
}
},
Event::Trigger(trigger) => match trigger {
Trigger::Goto(url) => {
let saved_tests =
serde_json::to_string(&self.get_saved_testcases()).unwrap();
let conf = serde_json::to_string(&self.get_configs()).unwrap();
let configs = self.get_configs().automation_configs.unwrap();
let hs_base_url = configs
.hs_base_url
.unwrap_or_else(|| "http://localhost:8080".to_string());
let configs_url = configs.configs_url.unwrap();
let hs_api_keys = configs.hs_api_keys.unwrap();
let test_env = configs.hs_test_env.unwrap();
let script = &[
format!("localStorage.configs='{configs_url}'").as_str(),
format!("localStorage.current_env='{test_env}'").as_str(),
"localStorage.hs_api_key=''",
format!("localStorage.hs_api_keys='{hs_api_keys}'").as_str(),
format!("localStorage.base_url='{hs_base_url}'").as_str(),
format!("localStorage.hs_api_configs='{conf}'").as_str(),
format!("localStorage.saved_payments=JSON.stringify({saved_tests})")
.as_str(),
"localStorage.force_sync='true'",
format!(
"localStorage.current_connector=\"{}\";",
self.get_connector_name().clone()
)
.as_str(),
]
.join(";");
driver.goto(url).await?;
driver.execute(script, Vec::new()).await?;
}
Trigger::Click(by) => {
self.retry_click(3, 5, driver, by.clone()).await?;
}
Trigger::ClickNth(by, n) => {
let ele = driver.query(by).all().await?.into_iter().nth(n).unwrap();
ele.wait_until().enabled().await?;
ele.wait_until().displayed().await?;
ele.wait_until().clickable().await?;
ele.scroll_into_view().await?;
ele.click().await?;
}
Trigger::Find(by) => {
driver.find(by).await?;
}
Trigger::Query(by) => {
driver.query(by).first().await?;
}
Trigger::SendKeys(by, input) => {
let ele = driver.query(by).first().await?;
ele.wait_until().displayed().await?;
ele.send_keys(&input).await?;
}
Trigger::SelectOption(by, input) => {
let ele = driver.query(by).first().await?;
let select_element = SelectElement::new(&ele).await?;
select_element.select_by_partial_text(input).await?;
}
Trigger::ChangeQueryParam(param, value) => {
let mut url = driver.current_url().await?;
let mut hash_query: HashMap<String, String> =
url.query_pairs().into_owned().collect();
hash_query.insert(param.to_string(), value.to_string());
let url_str = serde_urlencoded::to_string(hash_query)
.expect("Query Param update failed");
url.set_query(Some(&url_str));
driver.goto(url.as_str()).await?;
}
Trigger::Sleep(seconds) => {
tokio::time::sleep(Duration::from_secs(seconds)).await;
}
Trigger::SwitchTab(position) => match position {
Position::Next => {
let windows = driver.windows().await?;
if let Some(window) = windows.iter().next_back() {
driver.switch_to_window(window.to_owned()).await?;
}
}
Position::Prev => {
let windows = driver.windows().await?;
if let Some(window) = windows.into_iter().next() {
driver.switch_to_window(window.to_owned()).await?;
}
}
},
Trigger::SwitchFrame(by) => {
let iframe = driver.query(by).first().await?;
iframe.wait_until().displayed().await?;
iframe.clone().enter_frame().await?;
}
},
}
}
Ok(())
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/test_utils/tests/connectors/selenium.rs<|crate|> test_utils<|connector|> selenium anchor=should_ignore_test kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=1<|meta_end|>
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/selenium.rs" role="context" start="807" end="825">
pub fn should_ignore_test(name: &str) -> bool {
let conf = get_saved_testcases()
.get("tests_to_ignore")
.unwrap_or(&json!([]))
.clone();
let tests_to_ignore: HashSet<String> =
serde_json::from_value(conf).unwrap_or_else(|_| HashSet::new());
let modules: Vec<_> = name.split("::").collect();
let file_match = format!(
"{}::*",
<&str>::clone(modules.get(1).expect("Error obtaining module path segment"))
);
let module_name = modules
.get(1..3)
.expect("Error obtaining module path segment")
.join("::");
// Ignore if it matches patterns like nuvei_ui::*, nuvei_ui::should_make_nuvei_eps_payment_test
tests_to_ignore.contains(&file_match) || tests_to_ignore.contains(&module_name)
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/selenium.rs" role="context" start="806" end="806">
use std::{
collections::{HashMap, HashSet},
env,
io::Read,
path::{MAIN_SEPARATOR, MAIN_SEPARATOR_STR},
time::Duration,
};
use serde_json::json;
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/selenium.rs" role="context" start="832" end="855">
pub fn make_capabilities(browser: &str) -> Capabilities {
match browser {
"firefox" => {
let mut caps = DesiredCapabilities::firefox();
let ignore_profile = env::var("IGNORE_BROWSER_PROFILE").ok();
if ignore_profile.is_none() || ignore_profile.unwrap() == "false" {
let profile_path = &format!("-profile={}", get_firefox_profile_path().unwrap());
caps.add_firefox_arg(profile_path).unwrap();
} else {
let profile_path = &format!("-profile={}", get_firefox_profile_path().unwrap());
caps.add_firefox_arg(profile_path).unwrap();
caps.add_firefox_arg("--headless").ok();
}
caps.into()
}
"chrome" => {
let mut caps = DesiredCapabilities::chrome();
let profile_path = &format!("user-data-dir={}", get_chrome_profile_path().unwrap());
caps.add_chrome_arg(profile_path).unwrap();
caps.into()
}
&_ => DesiredCapabilities::safari().into(),
}
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/selenium.rs" role="context" start="827" end="829">
pub fn get_browser() -> String {
"firefox".to_string()
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/selenium.rs" role="context" start="798" end="805">
fn get_configs() -> connector_auth::ConnectorAuthentication {
let path =
env::var("CONNECTOR_AUTH_FILE_PATH").expect("connector authentication file path not set");
toml::from_str(
&std::fs::read_to_string(path).expect("connector authentication config file not found"),
)
.expect("Failed to read connector authentication config file")
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/selenium.rs" role="context" start="784" end="797">
fn get_saved_testcases() -> serde_json::Value {
let env_value = env::var("CONNECTOR_TESTS_FILE_PATH").ok();
if env_value.is_none() {
return serde_json::json!("");
}
let path = env_value.unwrap();
let mut file = &std::fs::File::open(path).expect("Failed to open file");
let mut contents = String::new();
file.read_to_string(&mut contents)
.expect("Failed to read file");
// Parse the JSON data
serde_json::from_str(&contents).expect("Failed to parse JSON")
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/test_utils/tests/connectors/selenium.rs<|crate|> test_utils<|connector|> selenium anchor=make_url kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=1<|meta_end|>
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/selenium.rs" role="context" start="900" end="906">
pub fn make_url(browser: &str) -> &'static str {
match browser {
"firefox" => "http://localhost:4444",
"chrome" => "http://localhost:9515",
&_ => "",
}
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/selenium.rs" role="context" start="908" end="926">
pub fn handle_test_error(
res: Result<Result<(), WebDriverError>, Box<dyn std::any::Any + Send>>,
) -> bool {
match res {
Ok(Ok(_)) => true,
Ok(Err(web_driver_error)) => {
eprintln!("test future failed to resolve: {:?}", web_driver_error);
false
}
Err(e) => {
if let Some(web_driver_error) = e.downcast_ref::<WebDriverError>() {
eprintln!("test future panicked: {:?}", web_driver_error);
} else {
eprintln!("test future panicked; an assertion probably failed");
}
false
}
}
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/selenium.rs" role="context" start="875" end="898">
fn get_firefox_profile_path() -> Result<String, WebDriverError> {
let exe = env::current_exe()?;
let dir = exe.parent().expect("Executable must be in some directory");
let mut base_path = dir
.to_str()
.map(|str| {
let mut fp = str.split(MAIN_SEPARATOR).collect::<Vec<_>>();
fp.truncate(3);
fp.join(MAIN_SEPARATOR_STR)
})
.unwrap();
if env::consts::OS == "macos" {
base_path.push_str(r#"/Library/Application Support/Firefox/Profiles/hs-test"#);
//Issue: 1573
} else if env::consts::OS == "linux" {
if let Some(home_dir) = env::var_os("HOME") {
if let Some(home_path) = home_dir.to_str() {
let profile_path = format!("{}/.mozilla/firefox/hs-test", home_path);
return Ok(profile_path);
}
}
}
Ok(base_path)
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/selenium.rs" role="context" start="857" end="873">
fn get_chrome_profile_path() -> Result<String, WebDriverError> {
let exe = env::current_exe()?;
let dir = exe.parent().expect("Executable must be in some directory");
let mut base_path = dir
.to_str()
.map(|str| {
let mut fp = str.split(MAIN_SEPARATOR).collect::<Vec<_>>();
fp.truncate(3);
fp.join(MAIN_SEPARATOR_STR)
})
.unwrap();
if env::consts::OS == "macos" {
base_path.push_str(r"/Library/Application\ Support/Google/Chrome/Default");
//Issue: 1573
} // We're only using Firefox on Ubuntu runner
Ok(base_path)
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/test_utils/tests/connectors/selenium.rs<|crate|> test_utils<|connector|> selenium anchor=make_gpay_payment kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/selenium.rs" role="context" start="406" end="413">
async fn make_gpay_payment(
&self,
web_driver: WebDriver,
url: &str,
actions: Vec<Event<'_>>,
) -> Result<(), WebDriverError> {
self.execute_gpay_steps(web_driver, url, actions).await
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/selenium.rs" role="context" start="461" end="509">
async fn make_affirm_payment(
&self,
driver: WebDriver,
url: &str,
actions: Vec<Event<'_>>,
) -> Result<(), WebDriverError> {
self.complete_actions(
&driver,
vec![
Event::Trigger(Trigger::Goto(url)),
Event::Trigger(Trigger::Click(By::Id("card-submit-btn"))),
],
)
.await?;
let mut affirm_actions = vec![
Event::RunIf(
Assert::IsPresent("Big purchase? No problem."),
vec![
Event::Trigger(Trigger::SendKeys(
By::Css("input[data-testid='phone-number-field']"),
"(833) 549-5574", // any test phone number accepted by affirm
)),
Event::Trigger(Trigger::Click(By::Css(
"button[data-testid='submit-button']",
))),
Event::Trigger(Trigger::SendKeys(
By::Css("input[data-testid='phone-pin-field']"),
"1234",
)),
],
),
Event::Trigger(Trigger::Click(By::Css(
"button[data-testid='skip-payment-button']",
))),
Event::Trigger(Trigger::Click(By::Css("div[data-testid='indicator']"))),
Event::Trigger(Trigger::Click(By::Css(
"button[data-testid='submit-button']",
))),
Event::Trigger(Trigger::Click(By::Css("div[data-testid='indicator']"))),
Event::Trigger(Trigger::Click(By::Css(
"div[data-testid='disclosure-checkbox-indicator']",
))),
Event::Trigger(Trigger::Click(By::Css(
"button[data-testid='submit-button']",
))),
];
affirm_actions.extend(actions);
self.complete_actions(&driver, affirm_actions).await
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/selenium.rs" role="context" start="414" end="460">
async fn execute_gpay_steps(
&self,
web_driver: WebDriver,
url: &str,
actions: Vec<Event<'_>>,
) -> Result<(), WebDriverError> {
let config = self.get_configs().automation_configs.unwrap();
let (email, pass) = (&config.gmail_email.unwrap(), &config.gmail_pass.unwrap());
let default_actions = vec![
Event::Trigger(Trigger::Goto(url)),
Event::Trigger(Trigger::Click(By::Css(".gpay-button"))),
Event::Trigger(Trigger::SwitchTab(Position::Next)),
Event::Trigger(Trigger::Sleep(5)),
Event::RunIf(
Assert::EitherOfThemExist("Use your Google Account", "Sign in"),
vec![
Event::Trigger(Trigger::SendKeys(By::Id("identifierId"), email)),
Event::Trigger(Trigger::ClickNth(By::Tag("button"), 2)),
Event::EitherOr(
Assert::IsPresent("Welcome"),
vec![
Event::Trigger(Trigger::SendKeys(By::Name("Passwd"), pass)),
Event::Trigger(Trigger::Sleep(2)),
Event::Trigger(Trigger::Click(By::Id("passwordNext"))),
Event::Trigger(Trigger::Sleep(10)),
],
vec![
Event::Trigger(Trigger::SendKeys(By::Id("identifierId"), email)),
Event::Trigger(Trigger::ClickNth(By::Tag("button"), 2)),
Event::Trigger(Trigger::SendKeys(By::Name("Passwd"), pass)),
Event::Trigger(Trigger::Sleep(2)),
Event::Trigger(Trigger::Click(By::Id("passwordNext"))),
Event::Trigger(Trigger::Sleep(10)),
],
),
],
),
Event::Trigger(Trigger::SwitchFrame(By::Css(
".bootstrapperIframeContainerElement iframe",
))),
Event::Assert(Assert::IsPresent("Gpay Tester")),
Event::Trigger(Trigger::Click(By::ClassName("jfk-button-action"))),
Event::Trigger(Trigger::SwitchTab(Position::Prev)),
];
self.complete_actions(&web_driver, default_actions).await?;
self.complete_actions(&web_driver, actions).await
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/selenium.rs" role="context" start="393" end="405">
async fn execute_steps(
&self,
web_driver: WebDriver,
actions: Vec<Event<'_>>,
) -> Result<(), WebDriverError> {
let config = self.get_configs().automation_configs.unwrap();
if config.run_minimum_steps.unwrap() {
self.complete_actions(&web_driver, actions.get(..3).unwrap().to_vec())
.await
} else {
self.complete_actions(&web_driver, actions).await
}
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/selenium.rs" role="context" start="378" end="392">
async fn make_redirection_payment(
&self,
web_driver: WebDriver,
actions: Vec<Event<'_>>,
) -> Result<(), WebDriverError> {
// To support failure retries
let result = self
.execute_steps(web_driver.clone(), actions.clone())
.await;
if result.is_err() {
self.execute_steps(web_driver, actions).await
} else {
result
}
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/selenium.rs" role="context" start="24" end="29">
pub enum Event<'a> {
RunIf(Assert<'a>, Vec<Event<'a>>),
EitherOr(Assert<'a>, Vec<Event<'a>>, Vec<Event<'a>>),
Assert(Assert<'a>),
Trigger(Trigger<'a>),
}
<file_sep path="hyperswitch/migrations/2022-09-29-084920_create_initial_tables/up.sql" role="context" start="279" end="295">
phone_country_code VARCHAR(255),
description VARCHAR(255),
address JSON,
created_at TIMESTAMP NOT NULL DEFAULT now()::TIMESTAMP,
metadata JSON,
PRIMARY KEY (customer_id, merchant_id)
);
CREATE TABLE events (
id SERIAL PRIMARY KEY,
event_id VARCHAR(255) NOT NULL,
event_type "EventType" NOT NULL,
event_class "EventClass" NOT NULL,
is_webhook_notified BOOLEAN NOT NULL DEFAULT FALSE,
intent_reference_id VARCHAR(255),
primary_object_id VARCHAR(255) NOT NULL,
primary_object_type "EventObjectType" NOT NULL,
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/hyperswitch_connectors/src/connectors/ctp_mastercard.rs<|crate|> hyperswitch_connectors<|connector|> ctp_mastercard anchor=base_url kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=1<|meta_end|>
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/ctp_mastercard.rs" role="context" start="74" end="76">
fn base_url<'a>(&self, _connectors: &'a Connectors) -> &'a str {
""
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/ctp_mastercard.rs" role="context" start="73" end="73">
use hyperswitch_interfaces::{
api::{
self, ConnectorCommon, ConnectorCommonExt, ConnectorIntegration, ConnectorSpecifications,
ConnectorValidation,
},
configs::Connectors,
errors, webhooks,
};
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/ctp_mastercard.rs" role="context" start="114" end="119">
fn get_webhook_event_type(
&self,
_request: &webhooks::IncomingWebhookRequestDetails<'_>,
) -> CustomResult<api_models::webhooks::IncomingWebhookEvent, errors::ConnectorError> {
Err(report!(errors::ConnectorError::WebhooksNotImplemented))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/ctp_mastercard.rs" role="context" start="107" end="112">
fn get_webhook_object_reference_id(
&self,
_request: &webhooks::IncomingWebhookRequestDetails<'_>,
) -> CustomResult<api_models::webhooks::ObjectReferenceId, errors::ConnectorError> {
Err(report!(errors::ConnectorError::WebhooksNotImplemented))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/ctp_mastercard.rs" role="context" start="70" end="72">
fn id(&self) -> &'static str {
"ctp_mastercard"
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/ctp_mastercard.rs" role="context" start="54" end="66">
fn build_headers(
&self,
req: &RouterData<Flow, Request, Response>,
_connectors: &Connectors,
) -> CustomResult<Vec<(String, masking::Maskable<String>)>, errors::ConnectorError> {
let mut header = vec![(
headers::CONTENT_TYPE.to_string(),
self.get_content_type().to_string().into(),
)];
let mut api_key = self.get_auth_header(&req.connector_auth_type)?;
header.append(&mut api_key);
Ok(header)
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/hyperswitch_connectors/src/connectors/ctp_mastercard.rs<|crate|> hyperswitch_connectors<|connector|> ctp_mastercard anchor=get_webhook_resource_object kind=fn pack=symbol_neighborhood lang=rust role_window=k2 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/ctp_mastercard.rs" role="context" start="121" end="126">
fn get_webhook_resource_object(
&self,
_request: &webhooks::IncomingWebhookRequestDetails<'_>,
) -> CustomResult<Box<dyn masking::ErasedMaskSerialize>, errors::ConnectorError> {
Err(report!(errors::ConnectorError::WebhooksNotImplemented))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/ctp_mastercard.rs" role="context" start="120" end="120">
use common_utils::errors::CustomResult;
use error_stack::report;
use hyperswitch_interfaces::{
api::{
self, ConnectorCommon, ConnectorCommonExt, ConnectorIntegration, ConnectorSpecifications,
ConnectorValidation,
},
configs::Connectors,
errors, webhooks,
};
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/ctp_mastercard.rs" role="context" start="114" end="119">
fn get_webhook_event_type(
&self,
_request: &webhooks::IncomingWebhookRequestDetails<'_>,
) -> CustomResult<api_models::webhooks::IncomingWebhookEvent, errors::ConnectorError> {
Err(report!(errors::ConnectorError::WebhooksNotImplemented))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/ctp_mastercard.rs" role="context" start="107" end="112">
fn get_webhook_object_reference_id(
&self,
_request: &webhooks::IncomingWebhookRequestDetails<'_>,
) -> CustomResult<api_models::webhooks::ObjectReferenceId, errors::ConnectorError> {
Err(report!(errors::ConnectorError::WebhooksNotImplemented))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/aci/transformers.rs" role="context" start="642" end="642">
type Err = error_stack::Report<errors::ConnectorError>;
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/hyperswitch_connectors/src/connectors/ctp_mastercard.rs<|crate|> hyperswitch_connectors<|connector|> ctp_mastercard anchor=get_webhook_event_type kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/ctp_mastercard.rs" role="context" start="114" end="119">
fn get_webhook_event_type(
&self,
_request: &webhooks::IncomingWebhookRequestDetails<'_>,
) -> CustomResult<api_models::webhooks::IncomingWebhookEvent, errors::ConnectorError> {
Err(report!(errors::ConnectorError::WebhooksNotImplemented))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/ctp_mastercard.rs" role="context" start="113" end="113">
use common_utils::errors::CustomResult;
use error_stack::report;
use hyperswitch_interfaces::{
api::{
self, ConnectorCommon, ConnectorCommonExt, ConnectorIntegration, ConnectorSpecifications,
ConnectorValidation,
},
configs::Connectors,
errors, webhooks,
};
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/ctp_mastercard.rs" role="context" start="121" end="126">
fn get_webhook_resource_object(
&self,
_request: &webhooks::IncomingWebhookRequestDetails<'_>,
) -> CustomResult<Box<dyn masking::ErasedMaskSerialize>, errors::ConnectorError> {
Err(report!(errors::ConnectorError::WebhooksNotImplemented))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/ctp_mastercard.rs" role="context" start="107" end="112">
fn get_webhook_object_reference_id(
&self,
_request: &webhooks::IncomingWebhookRequestDetails<'_>,
) -> CustomResult<api_models::webhooks::ObjectReferenceId, errors::ConnectorError> {
Err(report!(errors::ConnectorError::WebhooksNotImplemented))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/ctp_mastercard.rs" role="context" start="74" end="76">
fn base_url<'a>(&self, _connectors: &'a Connectors) -> &'a str {
""
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/aci/transformers.rs" role="context" start="642" end="642">
type Err = error_stack::Report<errors::ConnectorError>;
<file_sep path="hyperswitch/crates/api_models/src/webhooks.rs" role="context" start="12" end="68">
pub enum IncomingWebhookEvent {
/// Authorization + Capture success
PaymentIntentFailure,
/// Authorization + Capture failure
PaymentIntentSuccess,
PaymentIntentProcessing,
PaymentIntentPartiallyFunded,
PaymentIntentCancelled,
PaymentIntentCancelFailure,
PaymentIntentAuthorizationSuccess,
PaymentIntentAuthorizationFailure,
PaymentIntentCaptureSuccess,
PaymentIntentCaptureFailure,
PaymentActionRequired,
EventNotSupported,
SourceChargeable,
SourceTransactionCreated,
RefundFailure,
RefundSuccess,
DisputeOpened,
DisputeExpired,
DisputeAccepted,
DisputeCancelled,
DisputeChallenged,
// dispute has been successfully challenged by the merchant
DisputeWon,
// dispute has been unsuccessfully challenged
DisputeLost,
MandateActive,
MandateRevoked,
EndpointVerification,
ExternalAuthenticationARes,
FrmApproved,
FrmRejected,
#[cfg(feature = "payouts")]
PayoutSuccess,
#[cfg(feature = "payouts")]
PayoutFailure,
#[cfg(feature = "payouts")]
PayoutProcessing,
#[cfg(feature = "payouts")]
PayoutCancelled,
#[cfg(feature = "payouts")]
PayoutCreated,
#[cfg(feature = "payouts")]
PayoutExpired,
#[cfg(feature = "payouts")]
PayoutReversed,
#[cfg(all(feature = "revenue_recovery", feature = "v2"))]
RecoveryPaymentFailure,
#[cfg(all(feature = "revenue_recovery", feature = "v2"))]
RecoveryPaymentSuccess,
#[cfg(all(feature = "revenue_recovery", feature = "v2"))]
RecoveryPaymentPending,
#[cfg(all(feature = "revenue_recovery", feature = "v2"))]
RecoveryInvoiceCancel,
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/hyperswitch_connectors/src/connectors/ctp_mastercard.rs<|crate|> hyperswitch_connectors<|connector|> ctp_mastercard anchor=get_webhook_object_reference_id kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/ctp_mastercard.rs" role="context" start="107" end="112">
fn get_webhook_object_reference_id(
&self,
_request: &webhooks::IncomingWebhookRequestDetails<'_>,
) -> CustomResult<api_models::webhooks::ObjectReferenceId, errors::ConnectorError> {
Err(report!(errors::ConnectorError::WebhooksNotImplemented))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/ctp_mastercard.rs" role="context" start="106" end="106">
use common_utils::errors::CustomResult;
use error_stack::report;
use hyperswitch_interfaces::{
api::{
self, ConnectorCommon, ConnectorCommonExt, ConnectorIntegration, ConnectorSpecifications,
ConnectorValidation,
},
configs::Connectors,
errors, webhooks,
};
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/ctp_mastercard.rs" role="context" start="121" end="126">
fn get_webhook_resource_object(
&self,
_request: &webhooks::IncomingWebhookRequestDetails<'_>,
) -> CustomResult<Box<dyn masking::ErasedMaskSerialize>, errors::ConnectorError> {
Err(report!(errors::ConnectorError::WebhooksNotImplemented))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/ctp_mastercard.rs" role="context" start="114" end="119">
fn get_webhook_event_type(
&self,
_request: &webhooks::IncomingWebhookRequestDetails<'_>,
) -> CustomResult<api_models::webhooks::IncomingWebhookEvent, errors::ConnectorError> {
Err(report!(errors::ConnectorError::WebhooksNotImplemented))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/ctp_mastercard.rs" role="context" start="74" end="76">
fn base_url<'a>(&self, _connectors: &'a Connectors) -> &'a str {
""
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/ctp_mastercard.rs" role="context" start="70" end="72">
fn id(&self) -> &'static str {
"ctp_mastercard"
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/aci/transformers.rs" role="context" start="642" end="642">
type Err = error_stack::Report<errors::ConnectorError>;
<file_sep path="hyperswitch/crates/api_models/src/webhooks.rs" role="context" start="247" end="256">
pub enum ObjectReferenceId {
PaymentId(payments::PaymentIdType),
RefundId(RefundIdType),
MandateId(MandateIdType),
ExternalAuthenticationID(AuthenticationIdType),
#[cfg(feature = "payouts")]
PayoutId(PayoutIdType),
#[cfg(all(feature = "revenue_recovery", feature = "v2"))]
InvoiceId(InvoiceIdType),
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/test_utils/tests/connectors/stripe_wh_ui.rs<|crate|> test_utils<|connector|> stripe_wh_ui anchor=get_connector_name kind=fn pack=symbol_neighborhood lang=rust role_window=k2 hops=1<|meta_end|>
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/stripe_wh_ui.rs" role="context" start="8" end="10">
fn get_connector_name(&self) -> String {
"stripe".to_string()
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/stripe_wh_ui.rs" role="context" start="31" end="33">
fn should_make_webhook_test() {
tester!(should_make_webhook);
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/stripe_wh_ui.rs" role="context" start="13" end="28">
async fn should_make_webhook(web_driver: WebDriver) -> Result<(), WebDriverError> {
let conn = StripeSeleniumTest {};
conn.make_webhook_test(
web_driver,
&format!("{CHECKOUT_BASE_URL}/saved/16"),
vec![
Event::Trigger(Trigger::Click(By::Id("card-submit-btn"))),
Event::Assert(Assert::IsPresent("status")),
Event::Assert(Assert::IsPresent("succeeded")),
],
10,
"succeeded",
)
.await?;
Ok(())
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/test_utils/tests/connectors/stripe_wh_ui.rs<|crate|> test_utils<|connector|> stripe_wh_ui anchor=should_make_webhook kind=fn pack=symbol_neighborhood lang=rust role_window=k2 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/stripe_wh_ui.rs" role="context" start="13" end="28">
async fn should_make_webhook(web_driver: WebDriver) -> Result<(), WebDriverError> {
let conn = StripeSeleniumTest {};
conn.make_webhook_test(
web_driver,
&format!("{CHECKOUT_BASE_URL}/saved/16"),
vec![
Event::Trigger(Trigger::Click(By::Id("card-submit-btn"))),
Event::Assert(Assert::IsPresent("status")),
Event::Assert(Assert::IsPresent("succeeded")),
],
10,
"succeeded",
)
.await?;
Ok(())
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/stripe_wh_ui.rs" role="context" start="31" end="33">
fn should_make_webhook_test() {
tester!(should_make_webhook);
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/stripe_wh_ui.rs" role="context" start="8" end="10">
fn get_connector_name(&self) -> String {
"stripe".to_string()
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/stripe_wh_ui.rs" role="context" start="5" end="5">
struct StripeSeleniumTest;
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/selenium.rs" role="context" start="24" end="29">
pub enum Event<'a> {
RunIf(Assert<'a>, Vec<Event<'a>>),
EitherOr(Assert<'a>, Vec<Event<'a>>, Vec<Event<'a>>),
Assert(Assert<'a>),
Trigger(Trigger<'a>),
}
<file_sep path="hyperswitch/migrations/2022-09-29-084920_create_initial_tables/up.sql" role="context" start="279" end="295">
phone_country_code VARCHAR(255),
description VARCHAR(255),
address JSON,
created_at TIMESTAMP NOT NULL DEFAULT now()::TIMESTAMP,
metadata JSON,
PRIMARY KEY (customer_id, merchant_id)
);
CREATE TABLE events (
id SERIAL PRIMARY KEY,
event_id VARCHAR(255) NOT NULL,
event_type "EventType" NOT NULL,
event_class "EventClass" NOT NULL,
is_webhook_notified BOOLEAN NOT NULL DEFAULT FALSE,
intent_reference_id VARCHAR(255),
primary_object_id VARCHAR(255) NOT NULL,
primary_object_type "EventObjectType" NOT NULL,
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/test_utils/tests/connectors/aci_ui.rs<|crate|> test_utils<|connector|> aci_ui anchor=get_connector_name kind=fn pack=symbol_neighborhood lang=rust role_window=k2 hops=1<|meta_end|>
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/aci_ui.rs" role="context" start="9" end="11">
fn get_connector_name(&self) -> String {
"aci".to_string()
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/aci_ui.rs" role="context" start="33" end="46">
async fn should_make_aci_alipay_payment(web_driver: WebDriver) -> Result<(), WebDriverError> {
let conn = AciSeleniumTest {};
conn.make_redirection_payment(
web_driver,
vec![
Event::Trigger(Trigger::Goto(&format!("{CHECKOUT_BASE_URL}/saved/213"))),
Event::Trigger(Trigger::Click(By::Id("card-submit-btn"))),
Event::Trigger(Trigger::Click(By::Id("submit-success"))),
Event::Assert(Assert::IsPresent("succeeded")),
],
)
.await?;
Ok(())
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/aci_ui.rs" role="context" start="14" end="31">
async fn should_make_aci_card_mandate_payment(web_driver: WebDriver) -> Result<(), WebDriverError> {
let conn = AciSeleniumTest {};
conn.make_redirection_payment(
web_driver,
vec![
Event::Trigger(Trigger::Goto(&format!("{CHECKOUT_BASE_URL}/saved/180"))),
Event::Trigger(Trigger::Click(By::Id("card-submit-btn"))),
Event::Assert(Assert::IsPresent("succeeded")),
Event::Assert(Assert::IsPresent("Mandate ID")),
Event::Assert(Assert::IsPresent("man_")), // mandate id starting with man_
Event::Trigger(Trigger::Click(By::Css("a.btn"))),
Event::Trigger(Trigger::Click(By::Id("card-submit-btn"))),
Event::Assert(Assert::IsPresent("succeeded")),
],
)
.await?;
Ok(())
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/test_utils/tests/connectors/aci_ui.rs<|crate|> test_utils<|connector|> aci_ui anchor=should_make_aci_eps_payment_test kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=1<|meta_end|>
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/aci_ui.rs" role="context" start="228" end="230">
fn should_make_aci_eps_payment_test() {
tester!(should_make_aci_eps_payment);
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/aci_ui.rs" role="context" start="240" end="242">
fn should_make_aci_sofort_payment_test() {
tester!(should_make_aci_sofort_payment);
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/aci_ui.rs" role="context" start="234" end="236">
fn should_make_aci_ideal_payment_test() {
tester!(should_make_aci_ideal_payment);
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/aci_ui.rs" role="context" start="222" end="224">
fn should_make_aci_interac_payment_test() {
tester!(should_make_aci_interac_payment);
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/aci_ui.rs" role="context" start="216" end="218">
fn should_make_aci_alipay_payment_test() {
tester!(should_make_aci_alipay_payment);
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/test_utils/tests/connectors/aci_ui.rs<|crate|> test_utils<|connector|> aci_ui anchor=should_make_aci_ideal_payment_test kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=1<|meta_end|>
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/aci_ui.rs" role="context" start="234" end="236">
fn should_make_aci_ideal_payment_test() {
tester!(should_make_aci_ideal_payment);
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/aci_ui.rs" role="context" start="246" end="248">
fn should_make_aci_giropay_payment_test() {
tester!(should_make_aci_giropay_payment);
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/aci_ui.rs" role="context" start="240" end="242">
fn should_make_aci_sofort_payment_test() {
tester!(should_make_aci_sofort_payment);
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/aci_ui.rs" role="context" start="228" end="230">
fn should_make_aci_eps_payment_test() {
tester!(should_make_aci_eps_payment);
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/aci_ui.rs" role="context" start="222" end="224">
fn should_make_aci_interac_payment_test() {
tester!(should_make_aci_interac_payment);
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/test_utils/tests/connectors/aci_ui.rs<|crate|> test_utils<|connector|> aci_ui anchor=should_make_aci_interac_payment_test kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=1<|meta_end|>
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/aci_ui.rs" role="context" start="222" end="224">
fn should_make_aci_interac_payment_test() {
tester!(should_make_aci_interac_payment);
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/aci_ui.rs" role="context" start="234" end="236">
fn should_make_aci_ideal_payment_test() {
tester!(should_make_aci_ideal_payment);
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/aci_ui.rs" role="context" start="228" end="230">
fn should_make_aci_eps_payment_test() {
tester!(should_make_aci_eps_payment);
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/aci_ui.rs" role="context" start="216" end="218">
fn should_make_aci_alipay_payment_test() {
tester!(should_make_aci_alipay_payment);
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/aci_ui.rs" role="context" start="210" end="212">
fn should_make_aci_card_mandate_payment_test() {
tester!(should_make_aci_card_mandate_payment);
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/test_utils/tests/connectors/aci_ui.rs<|crate|> test_utils<|connector|> aci_ui anchor=should_make_aci_trustly_payment_test kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=1<|meta_end|>
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/aci_ui.rs" role="context" start="252" end="254">
fn should_make_aci_trustly_payment_test() {
tester!(should_make_aci_trustly_payment);
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/aci_ui.rs" role="context" start="258" end="260">
fn should_make_aci_przelewy24_payment_test() {
tester!(should_make_aci_przelewy24_payment);
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/aci_ui.rs" role="context" start="246" end="248">
fn should_make_aci_giropay_payment_test() {
tester!(should_make_aci_giropay_payment);
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/aci_ui.rs" role="context" start="240" end="242">
fn should_make_aci_sofort_payment_test() {
tester!(should_make_aci_sofort_payment);
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/test_utils/tests/connectors/aci_ui.rs<|crate|> test_utils<|connector|> aci_ui anchor=should_make_aci_sofort_payment_test kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=1<|meta_end|>
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/aci_ui.rs" role="context" start="240" end="242">
fn should_make_aci_sofort_payment_test() {
tester!(should_make_aci_sofort_payment);
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/aci_ui.rs" role="context" start="252" end="254">
fn should_make_aci_trustly_payment_test() {
tester!(should_make_aci_trustly_payment);
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/aci_ui.rs" role="context" start="246" end="248">
fn should_make_aci_giropay_payment_test() {
tester!(should_make_aci_giropay_payment);
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/aci_ui.rs" role="context" start="234" end="236">
fn should_make_aci_ideal_payment_test() {
tester!(should_make_aci_ideal_payment);
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/aci_ui.rs" role="context" start="228" end="230">
fn should_make_aci_eps_payment_test() {
tester!(should_make_aci_eps_payment);
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/test_utils/tests/connectors/aci_ui.rs<|crate|> test_utils<|connector|> aci_ui anchor=should_make_aci_giropay_payment_test kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=1<|meta_end|>
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/aci_ui.rs" role="context" start="246" end="248">
fn should_make_aci_giropay_payment_test() {
tester!(should_make_aci_giropay_payment);
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/aci_ui.rs" role="context" start="258" end="260">
fn should_make_aci_przelewy24_payment_test() {
tester!(should_make_aci_przelewy24_payment);
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/aci_ui.rs" role="context" start="252" end="254">
fn should_make_aci_trustly_payment_test() {
tester!(should_make_aci_trustly_payment);
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/aci_ui.rs" role="context" start="240" end="242">
fn should_make_aci_sofort_payment_test() {
tester!(should_make_aci_sofort_payment);
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/aci_ui.rs" role="context" start="234" end="236">
fn should_make_aci_ideal_payment_test() {
tester!(should_make_aci_ideal_payment);
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/test_utils/tests/connectors/aci_ui.rs<|crate|> test_utils<|connector|> aci_ui anchor=should_make_aci_card_mandate_payment_test kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=1<|meta_end|>
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/aci_ui.rs" role="context" start="210" end="212">
fn should_make_aci_card_mandate_payment_test() {
tester!(should_make_aci_card_mandate_payment);
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/aci_ui.rs" role="context" start="222" end="224">
fn should_make_aci_interac_payment_test() {
tester!(should_make_aci_interac_payment);
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/aci_ui.rs" role="context" start="216" end="218">
fn should_make_aci_alipay_payment_test() {
tester!(should_make_aci_alipay_payment);
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/aci_ui.rs" role="context" start="187" end="206">
async fn should_make_aci_przelewy24_payment(web_driver: WebDriver) -> Result<(), WebDriverError> {
let conn = AciSeleniumTest {};
conn.make_redirection_payment(
web_driver,
vec![
Event::Trigger(Trigger::Goto(&format!("{CHECKOUT_BASE_URL}/saved/12"))),
Event::Trigger(Trigger::Click(By::Id("card-submit-btn"))),
Event::Trigger(Trigger::Click(By::Id("pf31"))),
Event::Trigger(Trigger::Click(By::Css(
"button.btn.btn-lg.btn-info.btn-block",
))),
Event::Trigger(Trigger::Click(By::Css(
"button.btn.btn-success.btn-lg.accept-button",
))),
Event::Assert(Assert::IsPresent("succeeded")),
],
)
.await?;
Ok(())
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/aci_ui.rs" role="context" start="141" end="185">
async fn should_make_aci_trustly_payment(web_driver: WebDriver) -> Result<(), WebDriverError> {
let conn = AciSeleniumTest {};
conn.make_redirection_payment(
web_driver,
vec![
Event::Trigger(Trigger::Goto(&format!("{CHECKOUT_BASE_URL}/saved/13"))),
Event::Trigger(Trigger::Click(By::Id("card-submit-btn"))),
Event::Trigger(Trigger::Sleep(2)),
Event::Trigger(Trigger::Click(By::XPath(
r#"//*[@id="app"]/div[1]/div/div[2]/div/ul/div[4]/div/div[1]/div[2]/div[1]/span"#,
))),
Event::Trigger(Trigger::Click(By::Css(
"button.sc-eJocfa.sc-oeezt.cDgdS.bptgBT",
))),
Event::Trigger(Trigger::SendKeys(
By::Css("input.sc-fXgAZx.hkChHq"),
"123456789",
)),
Event::Trigger(Trigger::Click(By::Css(
"button.sc-eJocfa.sc-oeezt.cDgdS.bptgBT",
))),
Event::Trigger(Trigger::SendKeys(
By::Css("input.sc-fXgAZx.hkChHq"),
"783213",
)),
Event::Trigger(Trigger::Click(By::Css(
"button.sc-eJocfa.sc-oeezt.cDgdS.bptgBT",
))),
Event::Trigger(Trigger::Click(By::Css("div.sc-jJMGnK.laKGqb"))),
Event::Trigger(Trigger::Click(By::Css(
"button.sc-eJocfa.sc-oeezt.cDgdS.bptgBT",
))),
Event::Trigger(Trigger::SendKeys(
By::Css("input.sc-fXgAZx.hkChHq"),
"355508",
)),
Event::Trigger(Trigger::Click(By::Css(
"button.sc-eJocfa.sc-oeezt.cDgdS.bptgBT",
))),
Event::Assert(Assert::IsPresent("succeeded")),
],
)
.await?;
Ok(())
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/test_utils/tests/connectors/aci_ui.rs<|crate|> test_utils<|connector|> aci_ui anchor=should_make_aci_przelewy24_payment_test kind=fn pack=symbol_neighborhood lang=rust role_window=k2 hops=1<|meta_end|>
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/aci_ui.rs" role="context" start="258" end="260">
fn should_make_aci_przelewy24_payment_test() {
tester!(should_make_aci_przelewy24_payment);
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/aci_ui.rs" role="context" start="252" end="254">
fn should_make_aci_trustly_payment_test() {
tester!(should_make_aci_trustly_payment);
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/aci_ui.rs" role="context" start="246" end="248">
fn should_make_aci_giropay_payment_test() {
tester!(should_make_aci_giropay_payment);
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/test_utils/tests/connectors/zen_ui.rs<|crate|> test_utils<|connector|> zen_ui anchor=get_connector_name kind=fn pack=symbol_neighborhood lang=rust role_window=k2 hops=1<|meta_end|>
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/zen_ui.rs" role="context" start="9" end="11">
fn get_connector_name(&self) -> String {
"zen".to_string()
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/zen_ui.rs" role="context" start="36" end="38">
fn should_make_zen_3ds_payment_test() {
tester!(should_make_zen_3ds_payment);
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/zen_ui.rs" role="context" start="14" end="32">
async fn should_make_zen_3ds_payment(web_driver: WebDriver) -> Result<(), WebDriverError> {
let mycon = ZenSeleniumTest {};
mycon
.make_redirection_payment(
web_driver,
vec![
Event::Trigger(Trigger::Goto(&format!("{CHECKOUT_BASE_URL}/saved/201"))),
Event::Trigger(Trigger::Click(By::Id("card-submit-btn"))),
Event::Trigger(Trigger::Sleep(10)), //url gets updated only after some time, so need this timeout to solve the issue
Event::Trigger(Trigger::SwitchFrame(By::Name("cko-3ds2-iframe"))),
Event::Trigger(Trigger::SendKeys(By::Id("password"), "Checkout1!")),
Event::Trigger(Trigger::Click(By::Id("txtButton"))),
Event::Trigger(Trigger::Sleep(3)),
Event::Assert(Assert::IsPresent("succeeded")),
],
)
.await?;
Ok(())
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/test_utils/tests/connectors/zen_ui.rs<|crate|> test_utils<|connector|> zen_ui anchor=should_make_zen_3ds_payment kind=fn pack=symbol_neighborhood lang=rust role_window=k2 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/zen_ui.rs" role="context" start="14" end="32">
async fn should_make_zen_3ds_payment(web_driver: WebDriver) -> Result<(), WebDriverError> {
let mycon = ZenSeleniumTest {};
mycon
.make_redirection_payment(
web_driver,
vec![
Event::Trigger(Trigger::Goto(&format!("{CHECKOUT_BASE_URL}/saved/201"))),
Event::Trigger(Trigger::Click(By::Id("card-submit-btn"))),
Event::Trigger(Trigger::Sleep(10)), //url gets updated only after some time, so need this timeout to solve the issue
Event::Trigger(Trigger::SwitchFrame(By::Name("cko-3ds2-iframe"))),
Event::Trigger(Trigger::SendKeys(By::Id("password"), "Checkout1!")),
Event::Trigger(Trigger::Click(By::Id("txtButton"))),
Event::Trigger(Trigger::Sleep(3)),
Event::Assert(Assert::IsPresent("succeeded")),
],
)
.await?;
Ok(())
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/zen_ui.rs" role="context" start="36" end="38">
fn should_make_zen_3ds_payment_test() {
tester!(should_make_zen_3ds_payment);
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/zen_ui.rs" role="context" start="9" end="11">
fn get_connector_name(&self) -> String {
"zen".to_string()
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/zen_ui.rs" role="context" start="6" end="6">
struct ZenSeleniumTest;
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/selenium.rs" role="context" start="24" end="29">
pub enum Event<'a> {
RunIf(Assert<'a>, Vec<Event<'a>>),
EitherOr(Assert<'a>, Vec<Event<'a>>, Vec<Event<'a>>),
Assert(Assert<'a>),
Trigger(Trigger<'a>),
}
<file_sep path="hyperswitch/migrations/2022-09-29-084920_create_initial_tables/up.sql" role="context" start="279" end="295">
phone_country_code VARCHAR(255),
description VARCHAR(255),
address JSON,
created_at TIMESTAMP NOT NULL DEFAULT now()::TIMESTAMP,
metadata JSON,
PRIMARY KEY (customer_id, merchant_id)
);
CREATE TABLE events (
id SERIAL PRIMARY KEY,
event_id VARCHAR(255) NOT NULL,
event_type "EventType" NOT NULL,
event_class "EventClass" NOT NULL,
is_webhook_notified BOOLEAN NOT NULL DEFAULT FALSE,
intent_reference_id VARCHAR(255),
primary_object_id VARCHAR(255) NOT NULL,
primary_object_type "EventObjectType" NOT NULL,
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/test_utils/tests/connectors/noon_ui.rs<|crate|> test_utils<|connector|> noon_ui anchor=get_connector_name kind=fn pack=symbol_neighborhood lang=rust role_window=k2 hops=1<|meta_end|>
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/noon_ui.rs" role="context" start="9" end="11">
fn get_connector_name(&self) -> String {
"noon".to_string()
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/noon_ui.rs" role="context" start="33" end="55">
async fn should_make_noon_3ds_mandate_payment(web_driver: WebDriver) -> Result<(), WebDriverError> {
let conn = NoonSeleniumTest {};
conn.make_redirection_payment(
web_driver,
vec![
Event::Trigger(Trigger::Goto(&format!("{CHECKOUT_BASE_URL}/saved/214"))),
Event::Trigger(Trigger::Click(By::Id("card-submit-btn"))),
Event::Trigger(Trigger::SwitchFrame(By::Id("redirectTo3ds1Frame"))),
Event::Trigger(Trigger::SwitchFrame(By::Css("iframe[frameborder='0']"))),
Event::Trigger(Trigger::SendKeys(By::Css("input.input-field"), "1234")),
Event::Trigger(Trigger::Click(By::Css("input.button.primary"))),
Event::Trigger(Trigger::Sleep(5)),
Event::Assert(Assert::IsPresent("succeeded")),
Event::Assert(Assert::IsPresent("Mandate ID")),
Event::Assert(Assert::IsPresent("man_")), // mandate id starting with man_
Event::Trigger(Trigger::Click(By::Css("a.btn"))),
Event::Trigger(Trigger::Click(By::Id("card-submit-btn"))),
Event::Assert(Assert::IsPresent("succeeded")),
],
)
.await?;
Ok(())
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/noon_ui.rs" role="context" start="14" end="31">
async fn should_make_noon_3ds_payment(web_driver: WebDriver) -> Result<(), WebDriverError> {
let conn = NoonSeleniumTest {};
conn.make_redirection_payment(
web_driver,
vec![
Event::Trigger(Trigger::Goto(&format!("{CHECKOUT_BASE_URL}/saved/176"))),
Event::Trigger(Trigger::Click(By::Id("card-submit-btn"))),
Event::Trigger(Trigger::SwitchFrame(By::Id("redirectTo3ds1Frame"))),
Event::Trigger(Trigger::SwitchFrame(By::Css("iframe[frameborder='0']"))),
Event::Trigger(Trigger::SendKeys(By::Css("input.input-field"), "1234")),
Event::Trigger(Trigger::Click(By::Css("input.button.primary"))),
Event::Trigger(Trigger::Sleep(5)),
Event::Assert(Assert::IsPresent("succeeded")),
],
)
.await?;
Ok(())
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/test_utils/tests/connectors/noon_ui.rs<|crate|> test_utils<|connector|> noon_ui anchor=should_make_noon_3ds_payment_test kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=1<|meta_end|>
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/noon_ui.rs" role="context" start="80" end="82">
fn should_make_noon_3ds_payment_test() {
tester!(should_make_noon_3ds_payment);
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/noon_ui.rs" role="context" start="92" end="94">
fn should_make_noon_non_3ds_mandate_payment_test() {
tester!(should_make_noon_non_3ds_mandate_payment);
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/noon_ui.rs" role="context" start="86" end="88">
fn should_make_noon_3ds_mandate_payment_test() {
tester!(should_make_noon_3ds_mandate_payment);
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/noon_ui.rs" role="context" start="57" end="76">
async fn should_make_noon_non_3ds_mandate_payment(
web_driver: WebDriver,
) -> Result<(), WebDriverError> {
let conn = NoonSeleniumTest {};
conn.make_redirection_payment(
web_driver,
vec![
Event::Trigger(Trigger::Goto(&format!("{CHECKOUT_BASE_URL}/saved/215"))),
Event::Trigger(Trigger::Click(By::Id("card-submit-btn"))),
Event::Assert(Assert::IsPresent("succeeded")),
Event::Assert(Assert::IsPresent("Mandate ID")),
Event::Assert(Assert::IsPresent("man_")), // mandate id starting with man_
Event::Trigger(Trigger::Click(By::Css("a.btn"))),
Event::Trigger(Trigger::Click(By::Id("card-submit-btn"))),
Event::Assert(Assert::IsPresent("succeeded")),
],
)
.await?;
Ok(())
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/noon_ui.rs" role="context" start="33" end="55">
async fn should_make_noon_3ds_mandate_payment(web_driver: WebDriver) -> Result<(), WebDriverError> {
let conn = NoonSeleniumTest {};
conn.make_redirection_payment(
web_driver,
vec![
Event::Trigger(Trigger::Goto(&format!("{CHECKOUT_BASE_URL}/saved/214"))),
Event::Trigger(Trigger::Click(By::Id("card-submit-btn"))),
Event::Trigger(Trigger::SwitchFrame(By::Id("redirectTo3ds1Frame"))),
Event::Trigger(Trigger::SwitchFrame(By::Css("iframe[frameborder='0']"))),
Event::Trigger(Trigger::SendKeys(By::Css("input.input-field"), "1234")),
Event::Trigger(Trigger::Click(By::Css("input.button.primary"))),
Event::Trigger(Trigger::Sleep(5)),
Event::Assert(Assert::IsPresent("succeeded")),
Event::Assert(Assert::IsPresent("Mandate ID")),
Event::Assert(Assert::IsPresent("man_")), // mandate id starting with man_
Event::Trigger(Trigger::Click(By::Css("a.btn"))),
Event::Trigger(Trigger::Click(By::Id("card-submit-btn"))),
Event::Assert(Assert::IsPresent("succeeded")),
],
)
.await?;
Ok(())
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/test_utils/tests/connectors/noon_ui.rs<|crate|> test_utils<|connector|> noon_ui anchor=should_make_noon_non_3ds_mandate_payment_test kind=fn pack=symbol_neighborhood lang=rust role_window=k2 hops=1<|meta_end|>
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/noon_ui.rs" role="context" start="92" end="94">
fn should_make_noon_non_3ds_mandate_payment_test() {
tester!(should_make_noon_non_3ds_mandate_payment);
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/noon_ui.rs" role="context" start="86" end="88">
fn should_make_noon_3ds_mandate_payment_test() {
tester!(should_make_noon_3ds_mandate_payment);
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/noon_ui.rs" role="context" start="80" end="82">
fn should_make_noon_3ds_payment_test() {
tester!(should_make_noon_3ds_payment);
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/test_utils/tests/connectors/noon_ui.rs<|crate|> test_utils<|connector|> noon_ui anchor=should_make_noon_non_3ds_mandate_payment kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/noon_ui.rs" role="context" start="57" end="76">
async fn should_make_noon_non_3ds_mandate_payment(
web_driver: WebDriver,
) -> Result<(), WebDriverError> {
let conn = NoonSeleniumTest {};
conn.make_redirection_payment(
web_driver,
vec![
Event::Trigger(Trigger::Goto(&format!("{CHECKOUT_BASE_URL}/saved/215"))),
Event::Trigger(Trigger::Click(By::Id("card-submit-btn"))),
Event::Assert(Assert::IsPresent("succeeded")),
Event::Assert(Assert::IsPresent("Mandate ID")),
Event::Assert(Assert::IsPresent("man_")), // mandate id starting with man_
Event::Trigger(Trigger::Click(By::Css("a.btn"))),
Event::Trigger(Trigger::Click(By::Id("card-submit-btn"))),
Event::Assert(Assert::IsPresent("succeeded")),
],
)
.await?;
Ok(())
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/noon_ui.rs" role="context" start="86" end="88">
fn should_make_noon_3ds_mandate_payment_test() {
tester!(should_make_noon_3ds_mandate_payment);
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/noon_ui.rs" role="context" start="80" end="82">
fn should_make_noon_3ds_payment_test() {
tester!(should_make_noon_3ds_payment);
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/noon_ui.rs" role="context" start="33" end="55">
async fn should_make_noon_3ds_mandate_payment(web_driver: WebDriver) -> Result<(), WebDriverError> {
let conn = NoonSeleniumTest {};
conn.make_redirection_payment(
web_driver,
vec![
Event::Trigger(Trigger::Goto(&format!("{CHECKOUT_BASE_URL}/saved/214"))),
Event::Trigger(Trigger::Click(By::Id("card-submit-btn"))),
Event::Trigger(Trigger::SwitchFrame(By::Id("redirectTo3ds1Frame"))),
Event::Trigger(Trigger::SwitchFrame(By::Css("iframe[frameborder='0']"))),
Event::Trigger(Trigger::SendKeys(By::Css("input.input-field"), "1234")),
Event::Trigger(Trigger::Click(By::Css("input.button.primary"))),
Event::Trigger(Trigger::Sleep(5)),
Event::Assert(Assert::IsPresent("succeeded")),
Event::Assert(Assert::IsPresent("Mandate ID")),
Event::Assert(Assert::IsPresent("man_")), // mandate id starting with man_
Event::Trigger(Trigger::Click(By::Css("a.btn"))),
Event::Trigger(Trigger::Click(By::Id("card-submit-btn"))),
Event::Assert(Assert::IsPresent("succeeded")),
],
)
.await?;
Ok(())
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/noon_ui.rs" role="context" start="14" end="31">
async fn should_make_noon_3ds_payment(web_driver: WebDriver) -> Result<(), WebDriverError> {
let conn = NoonSeleniumTest {};
conn.make_redirection_payment(
web_driver,
vec![
Event::Trigger(Trigger::Goto(&format!("{CHECKOUT_BASE_URL}/saved/176"))),
Event::Trigger(Trigger::Click(By::Id("card-submit-btn"))),
Event::Trigger(Trigger::SwitchFrame(By::Id("redirectTo3ds1Frame"))),
Event::Trigger(Trigger::SwitchFrame(By::Css("iframe[frameborder='0']"))),
Event::Trigger(Trigger::SendKeys(By::Css("input.input-field"), "1234")),
Event::Trigger(Trigger::Click(By::Css("input.button.primary"))),
Event::Trigger(Trigger::Sleep(5)),
Event::Assert(Assert::IsPresent("succeeded")),
],
)
.await?;
Ok(())
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/noon_ui.rs" role="context" start="6" end="6">
struct NoonSeleniumTest;
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/selenium.rs" role="context" start="24" end="29">
pub enum Event<'a> {
RunIf(Assert<'a>, Vec<Event<'a>>),
EitherOr(Assert<'a>, Vec<Event<'a>>, Vec<Event<'a>>),
Assert(Assert<'a>),
Trigger(Trigger<'a>),
}
<file_sep path="hyperswitch/migrations/2022-12-05-090521_single_use_mandate_fields/up.sql" role="context" start="1" end="4">
-- Your SQL goes here
ALTER TABLE mandate
ADD IF NOT EXISTS single_use_amount INTEGER DEFAULT NULL,
ADD IF NOT EXISTS single_use_currency "Currency" DEFAULT NULL;
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/test_utils/tests/connectors/noon_ui.rs<|crate|> test_utils<|connector|> noon_ui anchor=should_make_noon_3ds_payment kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/noon_ui.rs" role="context" start="14" end="31">
async fn should_make_noon_3ds_payment(web_driver: WebDriver) -> Result<(), WebDriverError> {
let conn = NoonSeleniumTest {};
conn.make_redirection_payment(
web_driver,
vec![
Event::Trigger(Trigger::Goto(&format!("{CHECKOUT_BASE_URL}/saved/176"))),
Event::Trigger(Trigger::Click(By::Id("card-submit-btn"))),
Event::Trigger(Trigger::SwitchFrame(By::Id("redirectTo3ds1Frame"))),
Event::Trigger(Trigger::SwitchFrame(By::Css("iframe[frameborder='0']"))),
Event::Trigger(Trigger::SendKeys(By::Css("input.input-field"), "1234")),
Event::Trigger(Trigger::Click(By::Css("input.button.primary"))),
Event::Trigger(Trigger::Sleep(5)),
Event::Assert(Assert::IsPresent("succeeded")),
],
)
.await?;
Ok(())
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/noon_ui.rs" role="context" start="57" end="76">
async fn should_make_noon_non_3ds_mandate_payment(
web_driver: WebDriver,
) -> Result<(), WebDriverError> {
let conn = NoonSeleniumTest {};
conn.make_redirection_payment(
web_driver,
vec![
Event::Trigger(Trigger::Goto(&format!("{CHECKOUT_BASE_URL}/saved/215"))),
Event::Trigger(Trigger::Click(By::Id("card-submit-btn"))),
Event::Assert(Assert::IsPresent("succeeded")),
Event::Assert(Assert::IsPresent("Mandate ID")),
Event::Assert(Assert::IsPresent("man_")), // mandate id starting with man_
Event::Trigger(Trigger::Click(By::Css("a.btn"))),
Event::Trigger(Trigger::Click(By::Id("card-submit-btn"))),
Event::Assert(Assert::IsPresent("succeeded")),
],
)
.await?;
Ok(())
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/noon_ui.rs" role="context" start="33" end="55">
async fn should_make_noon_3ds_mandate_payment(web_driver: WebDriver) -> Result<(), WebDriverError> {
let conn = NoonSeleniumTest {};
conn.make_redirection_payment(
web_driver,
vec![
Event::Trigger(Trigger::Goto(&format!("{CHECKOUT_BASE_URL}/saved/214"))),
Event::Trigger(Trigger::Click(By::Id("card-submit-btn"))),
Event::Trigger(Trigger::SwitchFrame(By::Id("redirectTo3ds1Frame"))),
Event::Trigger(Trigger::SwitchFrame(By::Css("iframe[frameborder='0']"))),
Event::Trigger(Trigger::SendKeys(By::Css("input.input-field"), "1234")),
Event::Trigger(Trigger::Click(By::Css("input.button.primary"))),
Event::Trigger(Trigger::Sleep(5)),
Event::Assert(Assert::IsPresent("succeeded")),
Event::Assert(Assert::IsPresent("Mandate ID")),
Event::Assert(Assert::IsPresent("man_")), // mandate id starting with man_
Event::Trigger(Trigger::Click(By::Css("a.btn"))),
Event::Trigger(Trigger::Click(By::Id("card-submit-btn"))),
Event::Assert(Assert::IsPresent("succeeded")),
],
)
.await?;
Ok(())
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/noon_ui.rs" role="context" start="9" end="11">
fn get_connector_name(&self) -> String {
"noon".to_string()
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/noon_ui.rs" role="context" start="6" end="6">
struct NoonSeleniumTest;
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/selenium.rs" role="context" start="24" end="29">
pub enum Event<'a> {
RunIf(Assert<'a>, Vec<Event<'a>>),
EitherOr(Assert<'a>, Vec<Event<'a>>, Vec<Event<'a>>),
Assert(Assert<'a>),
Trigger(Trigger<'a>),
}
<file_sep path="hyperswitch/migrations/2022-09-29-084920_create_initial_tables/up.sql" role="context" start="279" end="295">
phone_country_code VARCHAR(255),
description VARCHAR(255),
address JSON,
created_at TIMESTAMP NOT NULL DEFAULT now()::TIMESTAMP,
metadata JSON,
PRIMARY KEY (customer_id, merchant_id)
);
CREATE TABLE events (
id SERIAL PRIMARY KEY,
event_id VARCHAR(255) NOT NULL,
event_type "EventType" NOT NULL,
event_class "EventClass" NOT NULL,
is_webhook_notified BOOLEAN NOT NULL DEFAULT FALSE,
intent_reference_id VARCHAR(255),
primary_object_id VARCHAR(255) NOT NULL,
primary_object_type "EventObjectType" NOT NULL,
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/test_utils/tests/connectors/paypal_ui.rs<|crate|> test_utils<|connector|> paypal_ui anchor=get_connector_name kind=fn pack=symbol_neighborhood lang=rust role_window=k2 hops=1<|meta_end|>
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/paypal_ui.rs" role="context" start="9" end="11">
fn get_connector_name(&self) -> String {
"paypal".to_string()
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/paypal_ui.rs" role="context" start="34" end="47">
async fn should_make_paypal_ideal_payment(web_driver: WebDriver) -> Result<(), WebDriverError> {
let conn = PaypalSeleniumTest {};
conn.make_redirection_payment(
web_driver,
vec![
Event::Trigger(Trigger::Goto(&format!("{CHECKOUT_BASE_URL}/saved/181"))),
Event::Trigger(Trigger::Click(By::Id("card-submit-btn"))),
Event::Trigger(Trigger::Click(By::Name("Successful"))),
Event::Assert(Assert::IsPresent("processing")),
],
)
.await?;
Ok(())
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/paypal_ui.rs" role="context" start="14" end="32">
async fn should_make_paypal_paypal_wallet_payment(
web_driver: WebDriver,
) -> Result<(), WebDriverError> {
let conn = PaypalSeleniumTest {};
conn.make_paypal_payment(
web_driver,
&format!("{CHECKOUT_BASE_URL}/saved/21"),
vec![
Event::Trigger(Trigger::Click(By::Css("#payment-submit-btn"))),
Event::Assert(Assert::IsPresent("Google")),
Event::Assert(Assert::ContainsAny(
Selector::QueryParamStr,
vec!["status=processing"],
)),
],
)
.await?;
Ok(())
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/test_utils/tests/connectors/paypal_ui.rs<|crate|> test_utils<|connector|> paypal_ui anchor=should_make_paypal_eps_payment_test kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=1<|meta_end|>
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/paypal_ui.rs" role="context" start="114" end="116">
fn should_make_paypal_eps_payment_test() {
tester!(should_make_paypal_eps_payment);
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/paypal_ui.rs" role="context" start="120" end="122">
fn should_make_paypal_sofort_payment_test() {
tester!(should_make_paypal_sofort_payment);
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/paypal_ui.rs" role="context" start="108" end="110">
fn should_make_paypal_giropay_payment_test() {
tester!(should_make_paypal_giropay_payment);
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/paypal_ui.rs" role="context" start="102" end="104">
fn should_make_paypal_ideal_payment_test() {
tester!(should_make_paypal_ideal_payment);
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/test_utils/tests/connectors/paypal_ui.rs<|crate|> test_utils<|connector|> paypal_ui anchor=should_make_paypal_sofort_payment_test kind=fn pack=symbol_neighborhood lang=rust role_window=k2 hops=1<|meta_end|>
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/paypal_ui.rs" role="context" start="120" end="122">
fn should_make_paypal_sofort_payment_test() {
tester!(should_make_paypal_sofort_payment);
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/paypal_ui.rs" role="context" start="114" end="116">
fn should_make_paypal_eps_payment_test() {
tester!(should_make_paypal_eps_payment);
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/paypal_ui.rs" role="context" start="108" end="110">
fn should_make_paypal_giropay_payment_test() {
tester!(should_make_paypal_giropay_payment);
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/test_utils/tests/connectors/paypal_ui.rs<|crate|> test_utils<|connector|> paypal_ui anchor=should_make_paypal_paypal_wallet_payment_test kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=1<|meta_end|>
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/paypal_ui.rs" role="context" start="96" end="98">
fn should_make_paypal_paypal_wallet_payment_test() {
tester!(should_make_paypal_paypal_wallet_payment);
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/paypal_ui.rs" role="context" start="108" end="110">
fn should_make_paypal_giropay_payment_test() {
tester!(should_make_paypal_giropay_payment);
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/paypal_ui.rs" role="context" start="102" end="104">
fn should_make_paypal_ideal_payment_test() {
tester!(should_make_paypal_ideal_payment);
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/paypal_ui.rs" role="context" start="79" end="92">
async fn should_make_paypal_sofort_payment(web_driver: WebDriver) -> Result<(), WebDriverError> {
let conn = PaypalSeleniumTest {};
conn.make_redirection_payment(
web_driver,
vec![
Event::Trigger(Trigger::Goto(&format!("{CHECKOUT_BASE_URL}/saved/235"))),
Event::Trigger(Trigger::Click(By::Id("card-submit-btn"))),
Event::Trigger(Trigger::Click(By::Name("Successful"))),
Event::Assert(Assert::IsPresent("processing")),
],
)
.await?;
Ok(())
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/paypal_ui.rs" role="context" start="64" end="77">
async fn should_make_paypal_eps_payment(web_driver: WebDriver) -> Result<(), WebDriverError> {
let conn = PaypalSeleniumTest {};
conn.make_redirection_payment(
web_driver,
vec![
Event::Trigger(Trigger::Goto(&format!("{CHECKOUT_BASE_URL}/saved/234"))),
Event::Trigger(Trigger::Click(By::Id("card-submit-btn"))),
Event::Trigger(Trigger::Click(By::Name("Successful"))),
Event::Assert(Assert::IsPresent("processing")),
],
)
.await?;
Ok(())
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/test_utils/tests/connectors/paypal_ui.rs<|crate|> test_utils<|connector|> paypal_ui anchor=should_make_paypal_giropay_payment_test kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=1<|meta_end|>
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/paypal_ui.rs" role="context" start="108" end="110">
fn should_make_paypal_giropay_payment_test() {
tester!(should_make_paypal_giropay_payment);
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/paypal_ui.rs" role="context" start="120" end="122">
fn should_make_paypal_sofort_payment_test() {
tester!(should_make_paypal_sofort_payment);
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/paypal_ui.rs" role="context" start="114" end="116">
fn should_make_paypal_eps_payment_test() {
tester!(should_make_paypal_eps_payment);
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/paypal_ui.rs" role="context" start="102" end="104">
fn should_make_paypal_ideal_payment_test() {
tester!(should_make_paypal_ideal_payment);
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/paypal_ui.rs" role="context" start="96" end="98">
fn should_make_paypal_paypal_wallet_payment_test() {
tester!(should_make_paypal_paypal_wallet_payment);
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/test_utils/tests/connectors/paypal_ui.rs<|crate|> test_utils<|connector|> paypal_ui anchor=should_make_paypal_eps_payment kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/paypal_ui.rs" role="context" start="64" end="77">
async fn should_make_paypal_eps_payment(web_driver: WebDriver) -> Result<(), WebDriverError> {
let conn = PaypalSeleniumTest {};
conn.make_redirection_payment(
web_driver,
vec![
Event::Trigger(Trigger::Goto(&format!("{CHECKOUT_BASE_URL}/saved/234"))),
Event::Trigger(Trigger::Click(By::Id("card-submit-btn"))),
Event::Trigger(Trigger::Click(By::Name("Successful"))),
Event::Assert(Assert::IsPresent("processing")),
],
)
.await?;
Ok(())
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/paypal_ui.rs" role="context" start="96" end="98">
fn should_make_paypal_paypal_wallet_payment_test() {
tester!(should_make_paypal_paypal_wallet_payment);
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/paypal_ui.rs" role="context" start="79" end="92">
async fn should_make_paypal_sofort_payment(web_driver: WebDriver) -> Result<(), WebDriverError> {
let conn = PaypalSeleniumTest {};
conn.make_redirection_payment(
web_driver,
vec![
Event::Trigger(Trigger::Goto(&format!("{CHECKOUT_BASE_URL}/saved/235"))),
Event::Trigger(Trigger::Click(By::Id("card-submit-btn"))),
Event::Trigger(Trigger::Click(By::Name("Successful"))),
Event::Assert(Assert::IsPresent("processing")),
],
)
.await?;
Ok(())
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/paypal_ui.rs" role="context" start="49" end="62">
async fn should_make_paypal_giropay_payment(web_driver: WebDriver) -> Result<(), WebDriverError> {
let conn = PaypalSeleniumTest {};
conn.make_redirection_payment(
web_driver,
vec![
Event::Trigger(Trigger::Goto(&format!("{CHECKOUT_BASE_URL}/saved/233"))),
Event::Trigger(Trigger::Click(By::Id("card-submit-btn"))),
Event::Trigger(Trigger::Click(By::Name("Successful"))),
Event::Assert(Assert::IsPresent("processing")),
],
)
.await?;
Ok(())
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/paypal_ui.rs" role="context" start="34" end="47">
async fn should_make_paypal_ideal_payment(web_driver: WebDriver) -> Result<(), WebDriverError> {
let conn = PaypalSeleniumTest {};
conn.make_redirection_payment(
web_driver,
vec![
Event::Trigger(Trigger::Goto(&format!("{CHECKOUT_BASE_URL}/saved/181"))),
Event::Trigger(Trigger::Click(By::Id("card-submit-btn"))),
Event::Trigger(Trigger::Click(By::Name("Successful"))),
Event::Assert(Assert::IsPresent("processing")),
],
)
.await?;
Ok(())
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/paypal_ui.rs" role="context" start="6" end="6">
struct PaypalSeleniumTest;
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/selenium.rs" role="context" start="24" end="29">
pub enum Event<'a> {
RunIf(Assert<'a>, Vec<Event<'a>>),
EitherOr(Assert<'a>, Vec<Event<'a>>, Vec<Event<'a>>),
Assert(Assert<'a>),
Trigger(Trigger<'a>),
}
<file_sep path="hyperswitch/migrations/2022-09-29-084920_create_initial_tables/up.sql" role="context" start="279" end="295">
phone_country_code VARCHAR(255),
description VARCHAR(255),
address JSON,
created_at TIMESTAMP NOT NULL DEFAULT now()::TIMESTAMP,
metadata JSON,
PRIMARY KEY (customer_id, merchant_id)
);
CREATE TABLE events (
id SERIAL PRIMARY KEY,
event_id VARCHAR(255) NOT NULL,
event_type "EventType" NOT NULL,
event_class "EventClass" NOT NULL,
is_webhook_notified BOOLEAN NOT NULL DEFAULT FALSE,
intent_reference_id VARCHAR(255),
primary_object_id VARCHAR(255) NOT NULL,
primary_object_type "EventObjectType" NOT NULL,
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/test_utils/tests/connectors/paypal_ui.rs<|crate|> test_utils<|connector|> paypal_ui anchor=should_make_paypal_ideal_payment kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/paypal_ui.rs" role="context" start="34" end="47">
async fn should_make_paypal_ideal_payment(web_driver: WebDriver) -> Result<(), WebDriverError> {
let conn = PaypalSeleniumTest {};
conn.make_redirection_payment(
web_driver,
vec![
Event::Trigger(Trigger::Goto(&format!("{CHECKOUT_BASE_URL}/saved/181"))),
Event::Trigger(Trigger::Click(By::Id("card-submit-btn"))),
Event::Trigger(Trigger::Click(By::Name("Successful"))),
Event::Assert(Assert::IsPresent("processing")),
],
)
.await?;
Ok(())
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/paypal_ui.rs" role="context" start="64" end="77">
async fn should_make_paypal_eps_payment(web_driver: WebDriver) -> Result<(), WebDriverError> {
let conn = PaypalSeleniumTest {};
conn.make_redirection_payment(
web_driver,
vec![
Event::Trigger(Trigger::Goto(&format!("{CHECKOUT_BASE_URL}/saved/234"))),
Event::Trigger(Trigger::Click(By::Id("card-submit-btn"))),
Event::Trigger(Trigger::Click(By::Name("Successful"))),
Event::Assert(Assert::IsPresent("processing")),
],
)
.await?;
Ok(())
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/paypal_ui.rs" role="context" start="49" end="62">
async fn should_make_paypal_giropay_payment(web_driver: WebDriver) -> Result<(), WebDriverError> {
let conn = PaypalSeleniumTest {};
conn.make_redirection_payment(
web_driver,
vec![
Event::Trigger(Trigger::Goto(&format!("{CHECKOUT_BASE_URL}/saved/233"))),
Event::Trigger(Trigger::Click(By::Id("card-submit-btn"))),
Event::Trigger(Trigger::Click(By::Name("Successful"))),
Event::Assert(Assert::IsPresent("processing")),
],
)
.await?;
Ok(())
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/paypal_ui.rs" role="context" start="14" end="32">
async fn should_make_paypal_paypal_wallet_payment(
web_driver: WebDriver,
) -> Result<(), WebDriverError> {
let conn = PaypalSeleniumTest {};
conn.make_paypal_payment(
web_driver,
&format!("{CHECKOUT_BASE_URL}/saved/21"),
vec![
Event::Trigger(Trigger::Click(By::Css("#payment-submit-btn"))),
Event::Assert(Assert::IsPresent("Google")),
Event::Assert(Assert::ContainsAny(
Selector::QueryParamStr,
vec!["status=processing"],
)),
],
)
.await?;
Ok(())
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/paypal_ui.rs" role="context" start="9" end="11">
fn get_connector_name(&self) -> String {
"paypal".to_string()
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/paypal_ui.rs" role="context" start="6" end="6">
struct PaypalSeleniumTest;
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/selenium.rs" role="context" start="24" end="29">
pub enum Event<'a> {
RunIf(Assert<'a>, Vec<Event<'a>>),
EitherOr(Assert<'a>, Vec<Event<'a>>, Vec<Event<'a>>),
Assert(Assert<'a>),
Trigger(Trigger<'a>),
}
<file_sep path="hyperswitch/migrations/2022-09-29-084920_create_initial_tables/up.sql" role="context" start="279" end="295">
phone_country_code VARCHAR(255),
description VARCHAR(255),
address JSON,
created_at TIMESTAMP NOT NULL DEFAULT now()::TIMESTAMP,
metadata JSON,
PRIMARY KEY (customer_id, merchant_id)
);
CREATE TABLE events (
id SERIAL PRIMARY KEY,
event_id VARCHAR(255) NOT NULL,
event_type "EventType" NOT NULL,
event_class "EventClass" NOT NULL,
is_webhook_notified BOOLEAN NOT NULL DEFAULT FALSE,
intent_reference_id VARCHAR(255),
primary_object_id VARCHAR(255) NOT NULL,
primary_object_type "EventObjectType" NOT NULL,
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/test_utils/tests/connectors/checkout_wh_ui.rs<|crate|> test_utils<|connector|> checkout_wh_ui anchor=get_connector_name kind=fn pack=symbol_neighborhood lang=rust role_window=k2 hops=1<|meta_end|>
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/checkout_wh_ui.rs" role="context" start="8" end="10">
fn get_connector_name(&self) -> String {
"checkout".to_string()
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/checkout_wh_ui.rs" role="context" start="35" end="37">
fn should_make_webhook_test() {
tester!(should_make_webhook);
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/checkout_wh_ui.rs" role="context" start="13" end="32">
async fn should_make_webhook(web_driver: WebDriver) -> Result<(), WebDriverError> {
let conn = CheckoutSeleniumTest {};
conn.make_webhook_test(
web_driver,
&format!("{CHECKOUT_BASE_URL}/saved/18"),
vec![
Event::Trigger(Trigger::Click(By::Id("card-submit-btn"))),
Event::Trigger(Trigger::Sleep(8)),
Event::Assert(Assert::IsPresent("Google")),
Event::Assert(Assert::ContainsAny(
Selector::QueryParamStr,
vec!["status=succeeded", "status=processing"],
)),
],
10,
"succeeded",
)
.await?;
Ok(())
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/test_utils/tests/connectors/checkout_wh_ui.rs<|crate|> test_utils<|connector|> checkout_wh_ui anchor=should_make_webhook kind=fn pack=symbol_neighborhood lang=rust role_window=k2 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/checkout_wh_ui.rs" role="context" start="13" end="32">
async fn should_make_webhook(web_driver: WebDriver) -> Result<(), WebDriverError> {
let conn = CheckoutSeleniumTest {};
conn.make_webhook_test(
web_driver,
&format!("{CHECKOUT_BASE_URL}/saved/18"),
vec![
Event::Trigger(Trigger::Click(By::Id("card-submit-btn"))),
Event::Trigger(Trigger::Sleep(8)),
Event::Assert(Assert::IsPresent("Google")),
Event::Assert(Assert::ContainsAny(
Selector::QueryParamStr,
vec!["status=succeeded", "status=processing"],
)),
],
10,
"succeeded",
)
.await?;
Ok(())
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/checkout_wh_ui.rs" role="context" start="35" end="37">
fn should_make_webhook_test() {
tester!(should_make_webhook);
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/checkout_wh_ui.rs" role="context" start="8" end="10">
fn get_connector_name(&self) -> String {
"checkout".to_string()
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/checkout_wh_ui.rs" role="context" start="5" end="5">
struct CheckoutSeleniumTest;
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/selenium.rs" role="context" start="24" end="29">
pub enum Event<'a> {
RunIf(Assert<'a>, Vec<Event<'a>>),
EitherOr(Assert<'a>, Vec<Event<'a>>, Vec<Event<'a>>),
Assert(Assert<'a>),
Trigger(Trigger<'a>),
}
<file_sep path="hyperswitch/migrations/2022-09-29-084920_create_initial_tables/up.sql" role="context" start="279" end="295">
phone_country_code VARCHAR(255),
description VARCHAR(255),
address JSON,
created_at TIMESTAMP NOT NULL DEFAULT now()::TIMESTAMP,
metadata JSON,
PRIMARY KEY (customer_id, merchant_id)
);
CREATE TABLE events (
id SERIAL PRIMARY KEY,
event_id VARCHAR(255) NOT NULL,
event_type "EventType" NOT NULL,
event_class "EventClass" NOT NULL,
is_webhook_notified BOOLEAN NOT NULL DEFAULT FALSE,
intent_reference_id VARCHAR(255),
primary_object_id VARCHAR(255) NOT NULL,
primary_object_type "EventObjectType" NOT NULL,
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/test_utils/tests/connectors/stripe_ui.rs<|crate|> test_utils<|connector|> stripe_ui anchor=get_connector_name kind=fn pack=symbol_neighborhood lang=rust role_window=k2 hops=1<|meta_end|>
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/stripe_ui.rs" role="context" start="9" end="11">
fn get_connector_name(&self) -> String {
"stripe".to_string()
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/stripe_ui.rs" role="context" start="27" end="42">
async fn should_make_3ds_mandate_payment(c: WebDriver) -> Result<(), WebDriverError> {
let conn = StripeSeleniumTest {};
conn.make_redirection_payment(c, vec![
Event::Trigger(Trigger::Goto(&format!("{CHECKOUT_BASE_URL}/card?cname=CL-BRW1&ccnum=4000002500003155&expmonth=10&expyear=25&cvv=123&amount=10&country=US¤cy=USD&mandate_data[customer_acceptance][acceptance_type]=offline&mandate_data[customer_acceptance][accepted_at]=1963-05-03T04:07:52.723Z&mandate_data[customer_acceptance][online][ip_address]=127.0.0.1&mandate_data[customer_acceptance][online][user_agent]=amet%20irure%20esse&mandate_data[mandate_type][multi_use][amount]=700&mandate_data[mandate_type][multi_use][currency]=USD&return_url={CHECKOUT_BASE_URL}/payments"))),
Event::Trigger(Trigger::Click(By::Id("card-submit-btn"))),
Event::Trigger(Trigger::Click(By::Id("test-source-authorize-3ds"))),
Event::Assert(Assert::IsPresent("succeeded")),
Event::Assert(Assert::IsPresent("Mandate ID")),
Event::Assert(Assert::IsPresent("man_")),// mandate id starting with man_
Event::Trigger(Trigger::Click(By::Css("#pm-mandate-btn a"))),
Event::Trigger(Trigger::Click(By::Id("card-submit-btn"))),
Event::Assert(Assert::IsPresent("succeeded")),
]).await?;
Ok(())
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/stripe_ui.rs" role="context" start="14" end="25">
async fn should_make_3ds_payment(c: WebDriver) -> Result<(), WebDriverError> {
let conn = StripeSeleniumTest {};
conn.make_redirection_payment(c, vec![
Event::Trigger(Trigger::Goto(&format!("{CHECKOUT_BASE_URL}/card?cname=CL-BRW1&ccnum=4000000000003063&expmonth=10&expyear=25&cvv=123&amount=100&country=US¤cy=USD"))),
Event::Trigger(Trigger::Click(By::Id("card-submit-btn"))),
Event::Trigger(Trigger::Click(By::Id("test-source-authorize-3ds"))),
Event::Assert(Assert::IsPresent("Google")),
Event::Assert(Assert::Contains(Selector::QueryParamStr, "status=succeeded")),
]).await?;
Ok(())
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/test_utils/tests/connectors/stripe_ui.rs<|crate|> test_utils<|connector|> stripe_ui anchor=should_make_3ds_payment_test kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=1<|meta_end|>
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/stripe_ui.rs" role="context" start="397" end="399">
fn should_make_3ds_payment_test() {
tester!(should_make_3ds_payment);
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/stripe_ui.rs" role="context" start="409" end="411">
fn should_fail_recurring_payment_due_to_authentication_test() {
tester!(should_fail_recurring_payment_due_to_authentication);
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/stripe_ui.rs" role="context" start="403" end="405">
fn should_make_3ds_mandate_payment_test() {
tester!(should_make_3ds_mandate_payment);
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/stripe_ui.rs" role="context" start="382" end="393">
async fn should_make_stripe_affirm_paylater_payment(
driver: WebDriver,
) -> Result<(), WebDriverError> {
let conn = StripeSeleniumTest {};
conn.make_affirm_payment(
driver,
&format!("{CHECKOUT_BASE_URL}/saved/110"),
vec![Event::Assert(Assert::IsPresent("succeeded"))],
)
.await?;
Ok(())
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/stripe_ui.rs" role="context" start="367" end="380">
async fn should_make_stripe_sepa_bank_debit_payment(c: WebDriver) -> Result<(), WebDriverError> {
let conn = StripeSeleniumTest {};
conn.make_redirection_payment(
c,
vec![
Event::Trigger(Trigger::Goto(&format!("{CHECKOUT_BASE_URL}/saved/67"))),
Event::Trigger(Trigger::Click(By::Id("card-submit-btn"))),
Event::Assert(Assert::IsPresent("Status")),
Event::Assert(Assert::IsPresent("processing")),
],
)
.await?;
Ok(())
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/test_utils/tests/connectors/stripe_ui.rs<|crate|> test_utils<|connector|> stripe_ui anchor=should_make_stripe_eps_bank_redirect_payment_test kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=1<|meta_end|>
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/stripe_ui.rs" role="context" start="464" end="466">
fn should_make_stripe_eps_bank_redirect_payment_test() {
tester!(should_make_stripe_eps_bank_redirect_payment);
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/stripe_ui.rs" role="context" start="476" end="478">
fn should_make_stripe_p24_redirect_payment_test() {
tester!(should_make_stripe_p24_redirect_payment);
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/stripe_ui.rs" role="context" start="470" end="472">
fn should_make_stripe_bancontact_card_redirect_payment_test() {
tester!(should_make_stripe_bancontact_card_redirect_payment);
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/stripe_ui.rs" role="context" start="458" end="460">
fn should_make_stripe_giropay_bank_redirect_payment_test() {
tester!(should_make_stripe_giropay_bank_redirect_payment);
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/stripe_ui.rs" role="context" start="452" end="454">
fn should_make_stripe_ideal_bank_redirect_payment_test() {
tester!(should_make_stripe_ideal_bank_redirect_payment);
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/test_utils/tests/connectors/stripe_ui.rs<|crate|> test_utils<|connector|> stripe_ui anchor=should_make_stripe_klarna_payment_test kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=1<|meta_end|>
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/stripe_ui.rs" role="context" start="434" end="436">
fn should_make_stripe_klarna_payment_test() {
tester!(should_make_stripe_klarna_payment);
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/stripe_ui.rs" role="context" start="446" end="448">
fn should_make_stripe_alipay_payment_test() {
tester!(should_make_stripe_alipay_payment);
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/stripe_ui.rs" role="context" start="440" end="442">
fn should_make_afterpay_payment_test() {
tester!(should_make_afterpay_payment);
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/stripe_ui.rs" role="context" start="428" end="430">
fn should_make_gpay_mandate_payment_test() {
tester!(should_make_gpay_mandate_payment);
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/stripe_ui.rs" role="context" start="421" end="423">
fn should_make_gpay_payment_test() {
tester!(should_make_gpay_payment);
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/test_utils/tests/connectors/stripe_ui.rs<|crate|> test_utils<|connector|> stripe_ui anchor=should_make_gpay_mandate_payment_test kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=1<|meta_end|>
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/stripe_ui.rs" role="context" start="428" end="430">
fn should_make_gpay_mandate_payment_test() {
tester!(should_make_gpay_mandate_payment);
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/stripe_ui.rs" role="context" start="440" end="442">
fn should_make_afterpay_payment_test() {
tester!(should_make_afterpay_payment);
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/stripe_ui.rs" role="context" start="434" end="436">
fn should_make_stripe_klarna_payment_test() {
tester!(should_make_stripe_klarna_payment);
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/stripe_ui.rs" role="context" start="421" end="423">
fn should_make_gpay_payment_test() {
tester!(should_make_gpay_payment);
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/stripe_ui.rs" role="context" start="415" end="417">
fn should_make_3ds_mandate_with_zero_dollar_payment_test() {
tester!(should_make_3ds_mandate_with_zero_dollar_payment);
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/test_utils/tests/connectors/stripe_ui.rs<|crate|> test_utils<|connector|> stripe_ui anchor=should_make_stripe_affirm_paylater_payment_test kind=fn pack=symbol_neighborhood lang=rust role_window=k2 hops=1<|meta_end|>
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/stripe_ui.rs" role="context" start="500" end="502">
fn should_make_stripe_affirm_paylater_payment_test() {
tester!(should_make_stripe_affirm_paylater_payment);
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/stripe_ui.rs" role="context" start="494" end="496">
fn should_make_stripe_sepa_bank_debit_payment_test() {
tester!(should_make_stripe_sepa_bank_debit_payment);
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/stripe_ui.rs" role="context" start="488" end="490">
fn should_make_stripe_ach_bank_debit_payment_test() {
tester!(should_make_stripe_ach_bank_debit_payment);
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/test_utils/tests/connectors/stripe_ui.rs<|crate|> test_utils<|connector|> stripe_ui anchor=should_make_stripe_p24_redirect_payment_test kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=1<|meta_end|>
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/stripe_ui.rs" role="context" start="476" end="478">
fn should_make_stripe_p24_redirect_payment_test() {
tester!(should_make_stripe_p24_redirect_payment);
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/stripe_ui.rs" role="context" start="488" end="490">
fn should_make_stripe_ach_bank_debit_payment_test() {
tester!(should_make_stripe_ach_bank_debit_payment);
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/stripe_ui.rs" role="context" start="482" end="484">
fn should_make_stripe_sofort_redirect_payment_test() {
tester!(should_make_stripe_sofort_redirect_payment);
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/stripe_ui.rs" role="context" start="470" end="472">
fn should_make_stripe_bancontact_card_redirect_payment_test() {
tester!(should_make_stripe_bancontact_card_redirect_payment);
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/stripe_ui.rs" role="context" start="464" end="466">
fn should_make_stripe_eps_bank_redirect_payment_test() {
tester!(should_make_stripe_eps_bank_redirect_payment);
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/test_utils/tests/connectors/checkout_ui.rs<|crate|> test_utils<|connector|> checkout_ui anchor=get_connector_name kind=fn pack=symbol_neighborhood lang=rust role_window=k2 hops=1<|meta_end|>
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/checkout_ui.rs" role="context" start="9" end="11">
fn get_connector_name(&self) -> String {
"checkout".to_string()
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/checkout_ui.rs" role="context" start="34" end="56">
async fn should_make_3ds_payment(c: WebDriver) -> Result<(), WebDriverError> {
let mycon = CheckoutSeleniumTest {};
mycon
.make_redirection_payment(
c,
vec![
Event::Trigger(Trigger::Goto(&format!("{CHECKOUT_BASE_URL}/saved/20"))),
Event::Trigger(Trigger::Click(By::Id("card-submit-btn"))),
Event::Trigger(Trigger::Sleep(5)), //url gets updated only after some time, so need this timeout to solve the issue
Event::Trigger(Trigger::SwitchFrame(By::Name("cko-3ds2-iframe"))),
Event::Trigger(Trigger::SendKeys(By::Id("password"), "Checkout1!")),
Event::Trigger(Trigger::Click(By::Id("txtButton"))),
Event::Trigger(Trigger::Sleep(2)),
Event::Assert(Assert::IsPresent("Google")),
Event::Assert(Assert::ContainsAny(
Selector::QueryParamStr,
vec!["status=succeeded", "status=processing"],
)),
],
)
.await?;
Ok(())
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/checkout_ui.rs" role="context" start="14" end="32">
async fn should_make_frictionless_3ds_payment(c: WebDriver) -> Result<(), WebDriverError> {
let mycon = CheckoutSeleniumTest {};
mycon
.make_redirection_payment(
c,
vec![
Event::Trigger(Trigger::Goto(&format!("{CHECKOUT_BASE_URL}/saved/18"))),
Event::Trigger(Trigger::Click(By::Id("card-submit-btn"))),
Event::Assert(Assert::IsPresent("Google Search")),
Event::Trigger(Trigger::Sleep(5)), //url gets updated only after some time, so need this timeout to solve the issue
Event::Assert(Assert::ContainsAny(
Selector::QueryParamStr,
vec!["status=succeeded", "status=processing"],
)),
],
)
.await?;
Ok(())
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/test_utils/tests/connectors/checkout_ui.rs<|crate|> test_utils<|connector|> checkout_ui anchor=should_make_3ds_payment_test kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=1<|meta_end|>
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/checkout_ui.rs" role="context" start="89" end="91">
fn should_make_3ds_payment_test() {
tester!(should_make_3ds_payment);
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/checkout_ui.rs" role="context" start="96" end="98">
fn should_make_gpay_payment_test() {
tester!(should_make_gpay_payment);
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/checkout_ui.rs" role="context" start="83" end="85">
fn should_make_frictionless_3ds_payment_test() {
tester!(should_make_frictionless_3ds_payment);
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/checkout_ui.rs" role="context" start="58" end="79">
async fn should_make_gpay_payment(c: WebDriver) -> Result<(), WebDriverError> {
let mycon = CheckoutSeleniumTest {};
mycon
.make_redirection_payment(
c,
vec![
Event::Trigger(Trigger::Goto(&format!("{CHECKOUT_BASE_URL}/saved/73"))),
Event::Trigger(Trigger::Click(By::Id("card-submit-btn"))),
Event::Trigger(Trigger::Sleep(10)), //url gets updated only after some time, so need this timeout to solve the issue
Event::Trigger(Trigger::SwitchFrame(By::Name("cko-3ds2-iframe"))),
Event::Trigger(Trigger::SendKeys(By::Id("password"), "Checkout1!")),
Event::Trigger(Trigger::Click(By::Id("txtButton"))),
Event::Assert(Assert::IsPresent("Google")),
Event::Assert(Assert::ContainsAny(
Selector::QueryParamStr,
vec!["status=succeeded", "status=processing"],
)),
],
)
.await?;
Ok(())
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/test_utils/tests/connectors/checkout_ui.rs<|crate|> test_utils<|connector|> checkout_ui anchor=should_make_frictionless_3ds_payment_test kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=1<|meta_end|>
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/checkout_ui.rs" role="context" start="83" end="85">
fn should_make_frictionless_3ds_payment_test() {
tester!(should_make_frictionless_3ds_payment);
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/checkout_ui.rs" role="context" start="96" end="98">
fn should_make_gpay_payment_test() {
tester!(should_make_gpay_payment);
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/checkout_ui.rs" role="context" start="89" end="91">
fn should_make_3ds_payment_test() {
tester!(should_make_3ds_payment);
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/checkout_ui.rs" role="context" start="58" end="79">
async fn should_make_gpay_payment(c: WebDriver) -> Result<(), WebDriverError> {
let mycon = CheckoutSeleniumTest {};
mycon
.make_redirection_payment(
c,
vec![
Event::Trigger(Trigger::Goto(&format!("{CHECKOUT_BASE_URL}/saved/73"))),
Event::Trigger(Trigger::Click(By::Id("card-submit-btn"))),
Event::Trigger(Trigger::Sleep(10)), //url gets updated only after some time, so need this timeout to solve the issue
Event::Trigger(Trigger::SwitchFrame(By::Name("cko-3ds2-iframe"))),
Event::Trigger(Trigger::SendKeys(By::Id("password"), "Checkout1!")),
Event::Trigger(Trigger::Click(By::Id("txtButton"))),
Event::Assert(Assert::IsPresent("Google")),
Event::Assert(Assert::ContainsAny(
Selector::QueryParamStr,
vec!["status=succeeded", "status=processing"],
)),
],
)
.await?;
Ok(())
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/checkout_ui.rs" role="context" start="34" end="56">
async fn should_make_3ds_payment(c: WebDriver) -> Result<(), WebDriverError> {
let mycon = CheckoutSeleniumTest {};
mycon
.make_redirection_payment(
c,
vec![
Event::Trigger(Trigger::Goto(&format!("{CHECKOUT_BASE_URL}/saved/20"))),
Event::Trigger(Trigger::Click(By::Id("card-submit-btn"))),
Event::Trigger(Trigger::Sleep(5)), //url gets updated only after some time, so need this timeout to solve the issue
Event::Trigger(Trigger::SwitchFrame(By::Name("cko-3ds2-iframe"))),
Event::Trigger(Trigger::SendKeys(By::Id("password"), "Checkout1!")),
Event::Trigger(Trigger::Click(By::Id("txtButton"))),
Event::Trigger(Trigger::Sleep(2)),
Event::Assert(Assert::IsPresent("Google")),
Event::Assert(Assert::ContainsAny(
Selector::QueryParamStr,
vec!["status=succeeded", "status=processing"],
)),
],
)
.await?;
Ok(())
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/test_utils/tests/connectors/checkout_ui.rs<|crate|> test_utils<|connector|> checkout_ui anchor=should_make_frictionless_3ds_payment kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/checkout_ui.rs" role="context" start="14" end="32">
async fn should_make_frictionless_3ds_payment(c: WebDriver) -> Result<(), WebDriverError> {
let mycon = CheckoutSeleniumTest {};
mycon
.make_redirection_payment(
c,
vec![
Event::Trigger(Trigger::Goto(&format!("{CHECKOUT_BASE_URL}/saved/18"))),
Event::Trigger(Trigger::Click(By::Id("card-submit-btn"))),
Event::Assert(Assert::IsPresent("Google Search")),
Event::Trigger(Trigger::Sleep(5)), //url gets updated only after some time, so need this timeout to solve the issue
Event::Assert(Assert::ContainsAny(
Selector::QueryParamStr,
vec!["status=succeeded", "status=processing"],
)),
],
)
.await?;
Ok(())
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/checkout_ui.rs" role="context" start="58" end="79">
async fn should_make_gpay_payment(c: WebDriver) -> Result<(), WebDriverError> {
let mycon = CheckoutSeleniumTest {};
mycon
.make_redirection_payment(
c,
vec![
Event::Trigger(Trigger::Goto(&format!("{CHECKOUT_BASE_URL}/saved/73"))),
Event::Trigger(Trigger::Click(By::Id("card-submit-btn"))),
Event::Trigger(Trigger::Sleep(10)), //url gets updated only after some time, so need this timeout to solve the issue
Event::Trigger(Trigger::SwitchFrame(By::Name("cko-3ds2-iframe"))),
Event::Trigger(Trigger::SendKeys(By::Id("password"), "Checkout1!")),
Event::Trigger(Trigger::Click(By::Id("txtButton"))),
Event::Assert(Assert::IsPresent("Google")),
Event::Assert(Assert::ContainsAny(
Selector::QueryParamStr,
vec!["status=succeeded", "status=processing"],
)),
],
)
.await?;
Ok(())
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/checkout_ui.rs" role="context" start="34" end="56">
async fn should_make_3ds_payment(c: WebDriver) -> Result<(), WebDriverError> {
let mycon = CheckoutSeleniumTest {};
mycon
.make_redirection_payment(
c,
vec![
Event::Trigger(Trigger::Goto(&format!("{CHECKOUT_BASE_URL}/saved/20"))),
Event::Trigger(Trigger::Click(By::Id("card-submit-btn"))),
Event::Trigger(Trigger::Sleep(5)), //url gets updated only after some time, so need this timeout to solve the issue
Event::Trigger(Trigger::SwitchFrame(By::Name("cko-3ds2-iframe"))),
Event::Trigger(Trigger::SendKeys(By::Id("password"), "Checkout1!")),
Event::Trigger(Trigger::Click(By::Id("txtButton"))),
Event::Trigger(Trigger::Sleep(2)),
Event::Assert(Assert::IsPresent("Google")),
Event::Assert(Assert::ContainsAny(
Selector::QueryParamStr,
vec!["status=succeeded", "status=processing"],
)),
],
)
.await?;
Ok(())
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/checkout_ui.rs" role="context" start="9" end="11">
fn get_connector_name(&self) -> String {
"checkout".to_string()
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/checkout_ui.rs" role="context" start="6" end="6">
struct CheckoutSeleniumTest;
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/selenium.rs" role="context" start="24" end="29">
pub enum Event<'a> {
RunIf(Assert<'a>, Vec<Event<'a>>),
EitherOr(Assert<'a>, Vec<Event<'a>>, Vec<Event<'a>>),
Assert(Assert<'a>),
Trigger(Trigger<'a>),
}
<file_sep path="hyperswitch/migrations/2022-09-29-084920_create_initial_tables/up.sql" role="context" start="279" end="295">
phone_country_code VARCHAR(255),
description VARCHAR(255),
address JSON,
created_at TIMESTAMP NOT NULL DEFAULT now()::TIMESTAMP,
metadata JSON,
PRIMARY KEY (customer_id, merchant_id)
);
CREATE TABLE events (
id SERIAL PRIMARY KEY,
event_id VARCHAR(255) NOT NULL,
event_type "EventType" NOT NULL,
event_class "EventClass" NOT NULL,
is_webhook_notified BOOLEAN NOT NULL DEFAULT FALSE,
intent_reference_id VARCHAR(255),
primary_object_id VARCHAR(255) NOT NULL,
primary_object_type "EventObjectType" NOT NULL,
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/test_utils/tests/connectors/checkout_ui.rs<|crate|> test_utils<|connector|> checkout_ui anchor=should_make_gpay_payment kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/checkout_ui.rs" role="context" start="58" end="79">
async fn should_make_gpay_payment(c: WebDriver) -> Result<(), WebDriverError> {
let mycon = CheckoutSeleniumTest {};
mycon
.make_redirection_payment(
c,
vec![
Event::Trigger(Trigger::Goto(&format!("{CHECKOUT_BASE_URL}/saved/73"))),
Event::Trigger(Trigger::Click(By::Id("card-submit-btn"))),
Event::Trigger(Trigger::Sleep(10)), //url gets updated only after some time, so need this timeout to solve the issue
Event::Trigger(Trigger::SwitchFrame(By::Name("cko-3ds2-iframe"))),
Event::Trigger(Trigger::SendKeys(By::Id("password"), "Checkout1!")),
Event::Trigger(Trigger::Click(By::Id("txtButton"))),
Event::Assert(Assert::IsPresent("Google")),
Event::Assert(Assert::ContainsAny(
Selector::QueryParamStr,
vec!["status=succeeded", "status=processing"],
)),
],
)
.await?;
Ok(())
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/checkout_ui.rs" role="context" start="89" end="91">
fn should_make_3ds_payment_test() {
tester!(should_make_3ds_payment);
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/checkout_ui.rs" role="context" start="83" end="85">
fn should_make_frictionless_3ds_payment_test() {
tester!(should_make_frictionless_3ds_payment);
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/checkout_ui.rs" role="context" start="34" end="56">
async fn should_make_3ds_payment(c: WebDriver) -> Result<(), WebDriverError> {
let mycon = CheckoutSeleniumTest {};
mycon
.make_redirection_payment(
c,
vec![
Event::Trigger(Trigger::Goto(&format!("{CHECKOUT_BASE_URL}/saved/20"))),
Event::Trigger(Trigger::Click(By::Id("card-submit-btn"))),
Event::Trigger(Trigger::Sleep(5)), //url gets updated only after some time, so need this timeout to solve the issue
Event::Trigger(Trigger::SwitchFrame(By::Name("cko-3ds2-iframe"))),
Event::Trigger(Trigger::SendKeys(By::Id("password"), "Checkout1!")),
Event::Trigger(Trigger::Click(By::Id("txtButton"))),
Event::Trigger(Trigger::Sleep(2)),
Event::Assert(Assert::IsPresent("Google")),
Event::Assert(Assert::ContainsAny(
Selector::QueryParamStr,
vec!["status=succeeded", "status=processing"],
)),
],
)
.await?;
Ok(())
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/checkout_ui.rs" role="context" start="14" end="32">
async fn should_make_frictionless_3ds_payment(c: WebDriver) -> Result<(), WebDriverError> {
let mycon = CheckoutSeleniumTest {};
mycon
.make_redirection_payment(
c,
vec![
Event::Trigger(Trigger::Goto(&format!("{CHECKOUT_BASE_URL}/saved/18"))),
Event::Trigger(Trigger::Click(By::Id("card-submit-btn"))),
Event::Assert(Assert::IsPresent("Google Search")),
Event::Trigger(Trigger::Sleep(5)), //url gets updated only after some time, so need this timeout to solve the issue
Event::Assert(Assert::ContainsAny(
Selector::QueryParamStr,
vec!["status=succeeded", "status=processing"],
)),
],
)
.await?;
Ok(())
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/checkout_ui.rs" role="context" start="6" end="6">
struct CheckoutSeleniumTest;
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/selenium.rs" role="context" start="24" end="29">
pub enum Event<'a> {
RunIf(Assert<'a>, Vec<Event<'a>>),
EitherOr(Assert<'a>, Vec<Event<'a>>, Vec<Event<'a>>),
Assert(Assert<'a>),
Trigger(Trigger<'a>),
}
<file_sep path="hyperswitch/migrations/2022-09-29-084920_create_initial_tables/up.sql" role="context" start="279" end="295">
phone_country_code VARCHAR(255),
description VARCHAR(255),
address JSON,
created_at TIMESTAMP NOT NULL DEFAULT now()::TIMESTAMP,
metadata JSON,
PRIMARY KEY (customer_id, merchant_id)
);
CREATE TABLE events (
id SERIAL PRIMARY KEY,
event_id VARCHAR(255) NOT NULL,
event_type "EventType" NOT NULL,
event_class "EventClass" NOT NULL,
is_webhook_notified BOOLEAN NOT NULL DEFAULT FALSE,
intent_reference_id VARCHAR(255),
primary_object_id VARCHAR(255) NOT NULL,
primary_object_type "EventObjectType" NOT NULL,
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/router/tests/connectors/gpayments.rs<|crate|> router<|connector|> gpayments anchor=get_name kind=fn pack=symbol_neighborhood lang=rust role_window=k2 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/router/tests/connectors/gpayments.rs" role="context" start="31" end="33">
fn get_name(&self) -> String {
"gpayments".to_string()
}
<file_sep path="hyperswitch/crates/router/tests/connectors/gpayments.rs" role="context" start="22" end="29">
fn get_auth_token(&self) -> types::ConnectorAuthType {
utils::to_connector_auth_type(
connector_auth::ConnectorAuthentication::new()
.gpayments
.expect("Missing connector authentication configuration")
.into(),
)
}
<file_sep path="hyperswitch/crates/router/tests/connectors/gpayments.rs" role="context" start="11" end="20">
fn get_data(&self) -> types::api::ConnectorData {
use router::connector::Gpayments;
utils::construct_connector_data_old(
Box::new(Gpayments::new()),
types::Connector::Threedsecureio,
// Added as Dummy connector as template code is added for future usage
types::api::GetToken::Connector,
None,
)
}
<file_sep path="hyperswitch/postman/collection-dir/powertranz/Flow Testcases/Happy Cases/Scenario1-Create payment with confirm true/Payments - Create/event.test.js" role="context" start="61" end="78">
"INFO - Unable to assign variable {{client_secret}}, as jsonData.client_secret is undefined.",
);
}
// Response body should have value "succeeded" for "status"
if (jsonData?.status) {
pm.test(
"[POST]::/payments - Content check if value for 'status' matches 'succeeded'",
function () {
pm.expect(jsonData.status).to.eql("succeeded");
},
);
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/router/tests/connectors/gpayments.rs<|crate|> router<|connector|> gpayments anchor=get_auth_token kind=fn pack=symbol_neighborhood lang=rust role_window=k2 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/router/tests/connectors/gpayments.rs" role="context" start="22" end="29">
fn get_auth_token(&self) -> types::ConnectorAuthType {
utils::to_connector_auth_type(
connector_auth::ConnectorAuthentication::new()
.gpayments
.expect("Missing connector authentication configuration")
.into(),
)
}
<file_sep path="hyperswitch/crates/router/tests/connectors/gpayments.rs" role="context" start="21" end="21">
use router::types;
use crate::utils::{self, ConnectorActions};
<file_sep path="hyperswitch/crates/router/tests/connectors/gpayments.rs" role="context" start="31" end="33">
fn get_name(&self) -> String {
"gpayments".to_string()
}
<file_sep path="hyperswitch/crates/router/tests/connectors/gpayments.rs" role="context" start="11" end="20">
fn get_data(&self) -> types::api::ConnectorData {
use router::connector::Gpayments;
utils::construct_connector_data_old(
Box::new(Gpayments::new()),
types::Connector::Threedsecureio,
// Added as Dummy connector as template code is added for future usage
types::api::GetToken::Connector,
None,
)
}
<file_sep path="hyperswitch/crates/api_models/src/admin.rs" role="context" start="1017" end="1046">
pub enum ConnectorAuthType {
TemporaryAuth,
HeaderKey {
api_key: Secret<String>,
},
BodyKey {
api_key: Secret<String>,
key1: Secret<String>,
},
SignatureKey {
api_key: Secret<String>,
key1: Secret<String>,
api_secret: Secret<String>,
},
MultiAuthKey {
api_key: Secret<String>,
key1: Secret<String>,
api_secret: Secret<String>,
key2: Secret<String>,
},
CurrencyAuthKey {
auth_key_map: HashMap<common_enums::Currency, pii::SecretSerdeValue>,
},
CertificateAuth {
certificate: Secret<String>,
private_key: Secret<String>,
},
#[default]
NoKey,
}
<file_sep path="hyperswitch/postman/collection-dir/powertranz/Flow Testcases/Happy Cases/Scenario1-Create payment with confirm true/Payments - Create/event.test.js" role="context" start="61" end="78">
"INFO - Unable to assign variable {{client_secret}}, as jsonData.client_secret is undefined.",
);
}
// Response body should have value "succeeded" for "status"
if (jsonData?.status) {
pm.test(
"[POST]::/payments - Content check if value for 'status' matches 'succeeded'",
function () {
pm.expect(jsonData.status).to.eql("succeeded");
},
);
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/router/tests/connectors/gpayments.rs<|crate|> router<|connector|> gpayments anchor=get_data kind=fn pack=symbol_neighborhood lang=rust role_window=k2 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/router/tests/connectors/gpayments.rs" role="context" start="11" end="20">
fn get_data(&self) -> types::api::ConnectorData {
use router::connector::Gpayments;
utils::construct_connector_data_old(
Box::new(Gpayments::new()),
types::Connector::Threedsecureio,
// Added as Dummy connector as template code is added for future usage
types::api::GetToken::Connector,
None,
)
}
<file_sep path="hyperswitch/crates/router/tests/connectors/gpayments.rs" role="context" start="10" end="10">
use router::types;
use crate::utils::{self, ConnectorActions};
<file_sep path="hyperswitch/crates/router/tests/connectors/gpayments.rs" role="context" start="31" end="33">
fn get_name(&self) -> String {
"gpayments".to_string()
}
<file_sep path="hyperswitch/crates/router/tests/connectors/gpayments.rs" role="context" start="22" end="29">
fn get_auth_token(&self) -> types::ConnectorAuthType {
utils::to_connector_auth_type(
connector_auth::ConnectorAuthentication::new()
.gpayments
.expect("Missing connector authentication configuration")
.into(),
)
}
<file_sep path="hyperswitch/crates/router/src/types/api.rs" role="context" start="104" end="111">
pub enum GetToken {
GpayMetadata,
SamsungPayMetadata,
ApplePayMetadata,
PaypalSdkMetadata,
PazeMetadata,
Connector,
}
<file_sep path="hyperswitch/postman/collection-dir/powertranz/Flow Testcases/Happy Cases/Scenario1-Create payment with confirm true/Payments - Create/event.test.js" role="context" start="61" end="78">
"INFO - Unable to assign variable {{client_secret}}, as jsonData.client_secret is undefined.",
);
}
// Response body should have value "succeeded" for "status"
if (jsonData?.status) {
pm.test(
"[POST]::/payments - Content check if value for 'status' matches 'succeeded'",
function () {
pm.expect(jsonData.status).to.eql("succeeded");
},
);
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/test_utils/tests/connectors/payu_ui.rs<|crate|> test_utils<|connector|> payu_ui anchor=get_connector_name kind=fn pack=symbol_neighborhood lang=rust role_window=k2 hops=1<|meta_end|>
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/payu_ui.rs" role="context" start="9" end="11">
fn get_connector_name(&self) -> String {
"payu".to_string()
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/payu_ui.rs" role="context" start="30" end="39">
async fn should_make_gpay_payment(web_driver: WebDriver) -> Result<(), WebDriverError> {
let conn = PayUSeleniumTest {};
conn.make_gpay_payment(web_driver,
&format!("{CHECKOUT_BASE_URL}/gpay?gatewayname=payu&gatewaymerchantid=459551&amount=70.00&country=US¤cy=PLN"),
vec![
Event::Assert(Assert::IsPresent("Status")),
Event::Assert(Assert::IsPresent("processing")),
]).await?;
Ok(())
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/payu_ui.rs" role="context" start="14" end="28">
async fn should_make_no_3ds_card_payment(web_driver: WebDriver) -> Result<(), WebDriverError> {
let conn = PayUSeleniumTest {};
conn.make_redirection_payment(
web_driver,
vec![
Event::Trigger(Trigger::Goto(&format!("{CHECKOUT_BASE_URL}/saved/72"))),
Event::Trigger(Trigger::Click(By::Id("card-submit-btn"))),
Event::Trigger(Trigger::Sleep(1)),
Event::Assert(Assert::IsPresent("status")),
Event::Assert(Assert::IsPresent("processing")),
],
)
.await?;
Ok(())
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/test_utils/tests/connectors/payu_ui.rs<|crate|> test_utils<|connector|> payu_ui anchor=should_make_no_3ds_card_payment_test kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=1<|meta_end|>
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/payu_ui.rs" role="context" start="43" end="45">
fn should_make_no_3ds_card_payment_test() {
tester!(should_make_no_3ds_card_payment);
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/payu_ui.rs" role="context" start="50" end="52">
fn should_make_gpay_payment_test() {
tester!(should_make_gpay_payment);
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/payu_ui.rs" role="context" start="30" end="39">
async fn should_make_gpay_payment(web_driver: WebDriver) -> Result<(), WebDriverError> {
let conn = PayUSeleniumTest {};
conn.make_gpay_payment(web_driver,
&format!("{CHECKOUT_BASE_URL}/gpay?gatewayname=payu&gatewaymerchantid=459551&amount=70.00&country=US¤cy=PLN"),
vec![
Event::Assert(Assert::IsPresent("Status")),
Event::Assert(Assert::IsPresent("processing")),
]).await?;
Ok(())
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/payu_ui.rs" role="context" start="14" end="28">
async fn should_make_no_3ds_card_payment(web_driver: WebDriver) -> Result<(), WebDriverError> {
let conn = PayUSeleniumTest {};
conn.make_redirection_payment(
web_driver,
vec![
Event::Trigger(Trigger::Goto(&format!("{CHECKOUT_BASE_URL}/saved/72"))),
Event::Trigger(Trigger::Click(By::Id("card-submit-btn"))),
Event::Trigger(Trigger::Sleep(1)),
Event::Assert(Assert::IsPresent("status")),
Event::Assert(Assert::IsPresent("processing")),
],
)
.await?;
Ok(())
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/test_utils/tests/connectors/payu_ui.rs<|crate|> test_utils<|connector|> payu_ui anchor=should_make_gpay_payment kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/payu_ui.rs" role="context" start="30" end="39">
async fn should_make_gpay_payment(web_driver: WebDriver) -> Result<(), WebDriverError> {
let conn = PayUSeleniumTest {};
conn.make_gpay_payment(web_driver,
&format!("{CHECKOUT_BASE_URL}/gpay?gatewayname=payu&gatewaymerchantid=459551&amount=70.00&country=US¤cy=PLN"),
vec![
Event::Assert(Assert::IsPresent("Status")),
Event::Assert(Assert::IsPresent("processing")),
]).await?;
Ok(())
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/payu_ui.rs" role="context" start="50" end="52">
fn should_make_gpay_payment_test() {
tester!(should_make_gpay_payment);
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/payu_ui.rs" role="context" start="43" end="45">
fn should_make_no_3ds_card_payment_test() {
tester!(should_make_no_3ds_card_payment);
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/payu_ui.rs" role="context" start="14" end="28">
async fn should_make_no_3ds_card_payment(web_driver: WebDriver) -> Result<(), WebDriverError> {
let conn = PayUSeleniumTest {};
conn.make_redirection_payment(
web_driver,
vec![
Event::Trigger(Trigger::Goto(&format!("{CHECKOUT_BASE_URL}/saved/72"))),
Event::Trigger(Trigger::Click(By::Id("card-submit-btn"))),
Event::Trigger(Trigger::Sleep(1)),
Event::Assert(Assert::IsPresent("status")),
Event::Assert(Assert::IsPresent("processing")),
],
)
.await?;
Ok(())
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/payu_ui.rs" role="context" start="9" end="11">
fn get_connector_name(&self) -> String {
"payu".to_string()
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/payu_ui.rs" role="context" start="6" end="6">
struct PayUSeleniumTest;
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/selenium.rs" role="context" start="24" end="29">
pub enum Event<'a> {
RunIf(Assert<'a>, Vec<Event<'a>>),
EitherOr(Assert<'a>, Vec<Event<'a>>, Vec<Event<'a>>),
Assert(Assert<'a>),
Trigger(Trigger<'a>),
}
<file_sep path="hyperswitch/migrations/2022-09-29-084920_create_initial_tables/up.sql" role="context" start="279" end="295">
phone_country_code VARCHAR(255),
description VARCHAR(255),
address JSON,
created_at TIMESTAMP NOT NULL DEFAULT now()::TIMESTAMP,
metadata JSON,
PRIMARY KEY (customer_id, merchant_id)
);
CREATE TABLE events (
id SERIAL PRIMARY KEY,
event_id VARCHAR(255) NOT NULL,
event_type "EventType" NOT NULL,
event_class "EventClass" NOT NULL,
is_webhook_notified BOOLEAN NOT NULL DEFAULT FALSE,
intent_reference_id VARCHAR(255),
primary_object_id VARCHAR(255) NOT NULL,
primary_object_type "EventObjectType" NOT NULL,
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/test_utils/tests/connectors/globalpay_ui.rs<|crate|> test_utils<|connector|> globalpay_ui anchor=should_make_globalpay_eps_payment_test kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=1<|meta_end|>
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/globalpay_ui.rs" role="context" start="194" end="196">
fn should_make_globalpay_eps_payment_test() {
tester!(should_make_globalpay_eps_payment);
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/globalpay_ui.rs" role="context" start="200" end="202">
fn should_make_globalpay_sofort_payment_test() {
tester!(should_make_globalpay_sofort_payment);
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/globalpay_ui.rs" role="context" start="188" end="190">
fn should_make_globalpay_giropay_payment_test() {
tester!(should_make_globalpay_giropay_payment);
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/globalpay_ui.rs" role="context" start="182" end="184">
fn should_make_globalpay_ideal_payment_test() {
tester!(should_make_globalpay_ideal_payment);
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/test_utils/tests/connectors/globalpay_ui.rs<|crate|> test_utils<|connector|> globalpay_ui anchor=should_make_globalpay_ideal_payment_test kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=1<|meta_end|>
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/globalpay_ui.rs" role="context" start="182" end="184">
fn should_make_globalpay_ideal_payment_test() {
tester!(should_make_globalpay_ideal_payment);
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/globalpay_ui.rs" role="context" start="194" end="196">
fn should_make_globalpay_eps_payment_test() {
tester!(should_make_globalpay_eps_payment);
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/globalpay_ui.rs" role="context" start="188" end="190">
fn should_make_globalpay_giropay_payment_test() {
tester!(should_make_globalpay_giropay_payment);
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/globalpay_ui.rs" role="context" start="176" end="178">
fn should_make_globalpay_paypal_payment_test() {
tester!(should_make_globalpay_paypal_payment);
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/globalpay_ui.rs" role="context" start="170" end="172">
fn should_make_gpay_payment_test() {
tester!(should_make_gpay_payment);
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/test_utils/tests/connectors/globalpay_ui.rs<|crate|> test_utils<|connector|> globalpay_ui anchor=should_make_globalpay_paypal_payment_test kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=1<|meta_end|>
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/globalpay_ui.rs" role="context" start="176" end="178">
fn should_make_globalpay_paypal_payment_test() {
tester!(should_make_globalpay_paypal_payment);
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/globalpay_ui.rs" role="context" start="188" end="190">
fn should_make_globalpay_giropay_payment_test() {
tester!(should_make_globalpay_giropay_payment);
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/globalpay_ui.rs" role="context" start="182" end="184">
fn should_make_globalpay_ideal_payment_test() {
tester!(should_make_globalpay_ideal_payment);
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/globalpay_ui.rs" role="context" start="170" end="172">
fn should_make_gpay_payment_test() {
tester!(should_make_gpay_payment);
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/globalpay_ui.rs" role="context" start="126" end="166">
async fn should_make_globalpay_sofort_payment(driver: WebDriver) -> Result<(), WebDriverError> {
let conn = GlobalpaySeleniumTest {};
conn.make_redirection_payment(
driver,
vec![
Event::Trigger(Trigger::Goto(&format!("{CHECKOUT_BASE_URL}/saved/63"))),
Event::Trigger(Trigger::Click(By::Id("card-submit-btn"))),
Event::RunIf(
Assert::IsPresent("Wählen"),
vec![Event::Trigger(Trigger::Click(By::Css("p.description")))],
),
Event::Assert(Assert::IsPresent("Demo Bank")),
Event::Trigger(Trigger::SendKeys(
By::Id("BackendFormLOGINNAMEUSERID"),
"12345",
)),
Event::Trigger(Trigger::SendKeys(By::Id("BackendFormUSERPIN"), "1234")),
Event::Trigger(Trigger::Click(By::Css(
"button.button-right.primary.has-indicator",
))),
Event::RunIf(
Assert::IsPresent("Kontoauswahl"),
vec![Event::Trigger(Trigger::Click(By::Css(
"button.button-right.primary.has-indicator",
)))],
),
Event::Assert(Assert::IsPresent("PPRO Payment Services Ltd.")),
Event::Trigger(Trigger::SendKeys(By::Id("BackendFormTan"), "12345")),
Event::Trigger(Trigger::Click(By::Css(
"button.button-right.primary.has-indicator",
))),
Event::Assert(Assert::IsPresent("Google")),
Event::Assert(Assert::ContainsAny(
Selector::QueryParamStr,
vec!["status=succeeded", "status=processing"],
)),
],
)
.await?;
Ok(())
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/test_utils/tests/connectors/globalpay_ui.rs<|crate|> test_utils<|connector|> globalpay_ui anchor=should_make_globalpay_sofort_payment_test kind=fn pack=symbol_neighborhood lang=rust role_window=k2 hops=1<|meta_end|>
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/globalpay_ui.rs" role="context" start="200" end="202">
fn should_make_globalpay_sofort_payment_test() {
tester!(should_make_globalpay_sofort_payment);
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/globalpay_ui.rs" role="context" start="194" end="196">
fn should_make_globalpay_eps_payment_test() {
tester!(should_make_globalpay_eps_payment);
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/globalpay_ui.rs" role="context" start="188" end="190">
fn should_make_globalpay_giropay_payment_test() {
tester!(should_make_globalpay_giropay_payment);
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/test_utils/tests/connectors/globalpay_ui.rs<|crate|> test_utils<|connector|> globalpay_ui anchor=should_make_globalpay_giropay_payment_test kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=1<|meta_end|>
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/globalpay_ui.rs" role="context" start="188" end="190">
fn should_make_globalpay_giropay_payment_test() {
tester!(should_make_globalpay_giropay_payment);
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/globalpay_ui.rs" role="context" start="200" end="202">
fn should_make_globalpay_sofort_payment_test() {
tester!(should_make_globalpay_sofort_payment);
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/globalpay_ui.rs" role="context" start="194" end="196">
fn should_make_globalpay_eps_payment_test() {
tester!(should_make_globalpay_eps_payment);
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/globalpay_ui.rs" role="context" start="182" end="184">
fn should_make_globalpay_ideal_payment_test() {
tester!(should_make_globalpay_ideal_payment);
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/globalpay_ui.rs" role="context" start="176" end="178">
fn should_make_globalpay_paypal_payment_test() {
tester!(should_make_globalpay_paypal_payment);
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/test_utils/tests/connectors/globalpay_ui.rs<|crate|> test_utils<|connector|> globalpay_ui anchor=should_make_globalpay_ideal_payment kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/globalpay_ui.rs" role="context" start="48" end="72">
async fn should_make_globalpay_ideal_payment(driver: WebDriver) -> Result<(), WebDriverError> {
let conn = GlobalpaySeleniumTest {};
conn.make_redirection_payment(
driver,
vec![
Event::Trigger(Trigger::Goto(&format!("{CHECKOUT_BASE_URL}/saved/53"))),
Event::Trigger(Trigger::Click(By::Id("card-submit-btn"))),
Event::Assert(Assert::IsPresent("Choose your Bank")),
Event::Trigger(Trigger::Click(By::Css("button.btn.btn-primary"))),
Event::Assert(Assert::IsPresent("Login to your Online Banking Account")),
Event::Trigger(Trigger::Click(By::Css("button.btn.btn-primary"))),
Event::Assert(Assert::IsPresent("Transaction Authentication")),
Event::Trigger(Trigger::Click(By::Css("button.btn.btn-primary"))),
Event::Assert(Assert::IsPresent("Payment Successful")),
Event::Trigger(Trigger::Click(By::Css("button.btn.btn-primary"))),
Event::Assert(Assert::IsPresent("Google")),
Event::Assert(Assert::ContainsAny(
Selector::QueryParamStr,
vec!["status=succeeded", "status=processing"],
)),
],
)
.await?;
Ok(())
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/globalpay_ui.rs" role="context" start="100" end="124">
async fn should_make_globalpay_eps_payment(driver: WebDriver) -> Result<(), WebDriverError> {
let conn = GlobalpaySeleniumTest {};
conn.make_redirection_payment(
driver,
vec![
Event::Trigger(Trigger::Goto(&format!("{CHECKOUT_BASE_URL}/saved/50"))),
Event::Trigger(Trigger::Click(By::Id("card-submit-btn"))),
Event::Assert(Assert::IsPresent("Choose your Bank")),
Event::Trigger(Trigger::Click(By::Css("button.btn.btn-primary"))),
Event::Assert(Assert::IsPresent("Login to your Online Banking Account")),
Event::Trigger(Trigger::Click(By::Css("button.btn.btn-primary"))),
Event::Assert(Assert::IsPresent("Transaction Authentication")),
Event::Trigger(Trigger::Click(By::Css("button.btn.btn-primary"))),
Event::Assert(Assert::IsPresent("Payment Successful")),
Event::Trigger(Trigger::Click(By::Css("button.btn.btn-primary"))),
Event::Assert(Assert::IsPresent("Google")),
Event::Assert(Assert::ContainsAny(
Selector::QueryParamStr,
vec!["status=succeeded", "status=processing"],
)),
],
)
.await?;
Ok(())
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/globalpay_ui.rs" role="context" start="74" end="98">
async fn should_make_globalpay_giropay_payment(driver: WebDriver) -> Result<(), WebDriverError> {
let conn = GlobalpaySeleniumTest {};
conn.make_redirection_payment(
driver,
vec![
Event::Trigger(Trigger::Goto(&format!("{CHECKOUT_BASE_URL}/saved/59"))),
Event::Trigger(Trigger::Click(By::Id("card-submit-btn"))),
Event::Assert(Assert::IsPresent("Choose your Bank")),
Event::Trigger(Trigger::Click(By::Css("button.btn.btn-primary"))),
Event::Assert(Assert::IsPresent("Login to your Online Banking Account")),
Event::Trigger(Trigger::Click(By::Css("button.btn.btn-primary"))),
Event::Assert(Assert::IsPresent("Transaction Authentication")),
Event::Trigger(Trigger::Click(By::Css("button.btn.btn-primary"))),
Event::Assert(Assert::IsPresent("Payment Successful")),
Event::Trigger(Trigger::Click(By::Css("button.btn.btn-primary"))),
Event::Assert(Assert::IsPresent("Google")),
Event::Assert(Assert::ContainsAny(
Selector::QueryParamStr,
vec!["status=succeeded", "status=processing"],
)),
],
)
.await?;
Ok(())
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/globalpay_ui.rs" role="context" start="30" end="46">
async fn should_make_globalpay_paypal_payment(driver: WebDriver) -> Result<(), WebDriverError> {
let conn = GlobalpaySeleniumTest {};
conn.make_paypal_payment(
driver,
&format!("{CHECKOUT_BASE_URL}/saved/46"),
vec![
Event::Trigger(Trigger::Click(By::Id("payment-submit-btn"))),
Event::Assert(Assert::IsPresent("Google")),
Event::Assert(Assert::ContainsAny(
Selector::QueryParamStr,
vec!["status=succeeded"],
)),
],
)
.await?;
Ok(())
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/globalpay_ui.rs" role="context" start="14" end="28">
async fn should_make_gpay_payment(driver: WebDriver) -> Result<(), WebDriverError> {
let conn = GlobalpaySeleniumTest {};
let pub_key = conn
.get_configs()
.automation_configs
.unwrap()
.globalpay_gateway_merchant_id
.unwrap();
conn.make_gpay_payment(driver,
&format!("{CHECKOUT_BASE_URL}/gpay?amount=10.00&country=US¤cy=USD&gatewayname=globalpayments&gatewaymerchantid={pub_key}"),
vec![
Event::Assert(Assert::IsPresent("succeeded")),
]).await?;
Ok(())
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/globalpay_ui.rs" role="context" start="6" end="6">
struct GlobalpaySeleniumTest;
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/selenium.rs" role="context" start="24" end="29">
pub enum Event<'a> {
RunIf(Assert<'a>, Vec<Event<'a>>),
EitherOr(Assert<'a>, Vec<Event<'a>>, Vec<Event<'a>>),
Assert(Assert<'a>),
Trigger(Trigger<'a>),
}
<file_sep path="hyperswitch/migrations/2022-09-29-084920_create_initial_tables/up.sql" role="context" start="279" end="295">
phone_country_code VARCHAR(255),
description VARCHAR(255),
address JSON,
created_at TIMESTAMP NOT NULL DEFAULT now()::TIMESTAMP,
metadata JSON,
PRIMARY KEY (customer_id, merchant_id)
);
CREATE TABLE events (
id SERIAL PRIMARY KEY,
event_id VARCHAR(255) NOT NULL,
event_type "EventType" NOT NULL,
event_class "EventClass" NOT NULL,
is_webhook_notified BOOLEAN NOT NULL DEFAULT FALSE,
intent_reference_id VARCHAR(255),
primary_object_id VARCHAR(255) NOT NULL,
primary_object_type "EventObjectType" NOT NULL,
<file_sep path="hyperswitch/crates/api_models/src/payouts.rs" role="context" start="262" end="267">
pub enum Bank {
Ach(AchBankTransfer),
Bacs(BacsBankTransfer),
Sepa(SepaBankTransfer),
Pix(PixBankTransfer),
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/test_utils/tests/connectors/bambora_ui.rs<|crate|> test_utils<|connector|> bambora_ui anchor=should_make_3ds_payment_test kind=fn pack=symbol_neighborhood lang=rust role_window=k2 hops=1<|meta_end|>
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/bambora_ui.rs" role="context" start="32" end="34">
fn should_make_3ds_payment_test() {
tester!(should_make_3ds_payment);
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/bambora_ui.rs" role="context" start="14" end="28">
async fn should_make_3ds_payment(c: WebDriver) -> Result<(), WebDriverError> {
let mycon = BamboraSeleniumTest {};
mycon
.make_redirection_payment(
c,
vec![
Event::Trigger(Trigger::Goto(&format!("{CHECKOUT_BASE_URL}/saved/33"))),
Event::Trigger(Trigger::Click(By::Id("card-submit-btn"))),
Event::Trigger(Trigger::Click(By::Id("continue-transaction"))),
Event::Assert(Assert::IsPresent("succeeded")),
],
)
.await?;
Ok(())
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/bambora_ui.rs" role="context" start="9" end="11">
fn get_connector_name(&self) -> String {
"bambora".to_string()
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/test_utils/tests/connectors/bambora_ui.rs<|crate|> test_utils<|connector|> bambora_ui anchor=should_make_3ds_payment kind=fn pack=symbol_neighborhood lang=rust role_window=k2 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/bambora_ui.rs" role="context" start="14" end="28">
async fn should_make_3ds_payment(c: WebDriver) -> Result<(), WebDriverError> {
let mycon = BamboraSeleniumTest {};
mycon
.make_redirection_payment(
c,
vec![
Event::Trigger(Trigger::Goto(&format!("{CHECKOUT_BASE_URL}/saved/33"))),
Event::Trigger(Trigger::Click(By::Id("card-submit-btn"))),
Event::Trigger(Trigger::Click(By::Id("continue-transaction"))),
Event::Assert(Assert::IsPresent("succeeded")),
],
)
.await?;
Ok(())
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/bambora_ui.rs" role="context" start="32" end="34">
fn should_make_3ds_payment_test() {
tester!(should_make_3ds_payment);
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/bambora_ui.rs" role="context" start="9" end="11">
fn get_connector_name(&self) -> String {
"bambora".to_string()
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/bambora_ui.rs" role="context" start="6" end="6">
struct BamboraSeleniumTest;
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/selenium.rs" role="context" start="24" end="29">
pub enum Event<'a> {
RunIf(Assert<'a>, Vec<Event<'a>>),
EitherOr(Assert<'a>, Vec<Event<'a>>, Vec<Event<'a>>),
Assert(Assert<'a>),
Trigger(Trigger<'a>),
}
<file_sep path="hyperswitch/migrations/2022-09-29-084920_create_initial_tables/up.sql" role="context" start="279" end="295">
phone_country_code VARCHAR(255),
description VARCHAR(255),
address JSON,
created_at TIMESTAMP NOT NULL DEFAULT now()::TIMESTAMP,
metadata JSON,
PRIMARY KEY (customer_id, merchant_id)
);
CREATE TABLE events (
id SERIAL PRIMARY KEY,
event_id VARCHAR(255) NOT NULL,
event_type "EventType" NOT NULL,
event_class "EventClass" NOT NULL,
is_webhook_notified BOOLEAN NOT NULL DEFAULT FALSE,
intent_reference_id VARCHAR(255),
primary_object_id VARCHAR(255) NOT NULL,
primary_object_type "EventObjectType" NOT NULL,
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/test_utils/tests/connectors/worldline_ui.rs<|crate|> test_utils<|connector|> worldline_ui anchor=get_connector_name kind=fn pack=symbol_neighborhood lang=rust role_window=k2 hops=1<|meta_end|>
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/worldline_ui.rs" role="context" start="9" end="11">
fn get_connector_name(&self) -> String {
"worldline".to_string()
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/worldline_ui.rs" role="context" start="29" end="45">
async fn should_make_worldline_ideal_redirect_payment(c: WebDriver) -> Result<(), WebDriverError> {
let conn = WorldlineSeleniumTest {};
conn.make_redirection_payment(
c,
vec![
Event::Trigger(Trigger::Goto(&format!("{CHECKOUT_BASE_URL}/saved/49"))),
Event::Trigger(Trigger::Click(By::Id("card-submit-btn"))),
Event::Assert(Assert::IsPresent("Google")),
Event::Assert(Assert::ContainsAny(
Selector::QueryParamStr,
vec!["status=requires_customer_action", "status=succeeded"],
)),
],
)
.await?;
Ok(())
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/worldline_ui.rs" role="context" start="14" end="27">
async fn should_make_card_non_3ds_payment(c: WebDriver) -> Result<(), WebDriverError> {
let conn = WorldlineSeleniumTest {};
conn.make_redirection_payment(
c,
vec![
Event::Trigger(Trigger::Goto(&format!("{CHECKOUT_BASE_URL}/saved/71"))),
Event::Trigger(Trigger::Click(By::Id("card-submit-btn"))),
Event::Assert(Assert::IsPresent("status")),
Event::Assert(Assert::IsPresent("processing")),
],
)
.await?;
Ok(())
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/test_utils/tests/connectors/worldline_ui.rs<|crate|> test_utils<|connector|> worldline_ui anchor=should_make_card_non_3ds_payment_test kind=fn pack=symbol_neighborhood lang=rust role_window=k2 hops=1<|meta_end|>
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/worldline_ui.rs" role="context" start="82" end="84">
fn should_make_card_non_3ds_payment_test() {
tester!(should_make_card_non_3ds_payment);
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/worldline_ui.rs" role="context" start="76" end="78">
fn should_make_worldline_ideal_redirect_payment_test() {
tester!(should_make_worldline_ideal_redirect_payment);
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/worldline_ui.rs" role="context" start="70" end="72">
fn should_make_worldline_giropay_redirect_payment_test() {
tester!(should_make_worldline_giropay_redirect_payment);
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/test_utils/tests/connectors/worldline_ui.rs<|crate|> test_utils<|connector|> worldline_ui anchor=should_make_worldline_ideal_redirect_payment_test kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=1<|meta_end|>
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/worldline_ui.rs" role="context" start="76" end="78">
fn should_make_worldline_ideal_redirect_payment_test() {
tester!(should_make_worldline_ideal_redirect_payment);
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/worldline_ui.rs" role="context" start="82" end="84">
fn should_make_card_non_3ds_payment_test() {
tester!(should_make_card_non_3ds_payment);
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/worldline_ui.rs" role="context" start="70" end="72">
fn should_make_worldline_giropay_redirect_payment_test() {
tester!(should_make_worldline_giropay_redirect_payment);
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/worldline_ui.rs" role="context" start="47" end="65">
async fn should_make_worldline_giropay_redirect_payment(
c: WebDriver,
) -> Result<(), WebDriverError> {
let conn = WorldlineSeleniumTest {};
conn.make_redirection_payment(
c,
vec![
Event::Trigger(Trigger::Goto(&format!("{CHECKOUT_BASE_URL}/saved/48"))),
Event::Trigger(Trigger::Click(By::Id("card-submit-btn"))),
Event::Assert(Assert::IsPresent("Google")),
Event::Assert(Assert::ContainsAny(
Selector::QueryParamStr,
vec!["status=requires_customer_action", "status=succeeded"],
)),
],
)
.await?;
Ok(())
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/test_utils/tests/connectors/worldline_ui.rs<|crate|> test_utils<|connector|> worldline_ui anchor=should_make_worldline_giropay_redirect_payment kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/worldline_ui.rs" role="context" start="47" end="65">
async fn should_make_worldline_giropay_redirect_payment(
c: WebDriver,
) -> Result<(), WebDriverError> {
let conn = WorldlineSeleniumTest {};
conn.make_redirection_payment(
c,
vec![
Event::Trigger(Trigger::Goto(&format!("{CHECKOUT_BASE_URL}/saved/48"))),
Event::Trigger(Trigger::Click(By::Id("card-submit-btn"))),
Event::Assert(Assert::IsPresent("Google")),
Event::Assert(Assert::ContainsAny(
Selector::QueryParamStr,
vec!["status=requires_customer_action", "status=succeeded"],
)),
],
)
.await?;
Ok(())
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/worldline_ui.rs" role="context" start="76" end="78">
fn should_make_worldline_ideal_redirect_payment_test() {
tester!(should_make_worldline_ideal_redirect_payment);
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/worldline_ui.rs" role="context" start="70" end="72">
fn should_make_worldline_giropay_redirect_payment_test() {
tester!(should_make_worldline_giropay_redirect_payment);
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/worldline_ui.rs" role="context" start="29" end="45">
async fn should_make_worldline_ideal_redirect_payment(c: WebDriver) -> Result<(), WebDriverError> {
let conn = WorldlineSeleniumTest {};
conn.make_redirection_payment(
c,
vec![
Event::Trigger(Trigger::Goto(&format!("{CHECKOUT_BASE_URL}/saved/49"))),
Event::Trigger(Trigger::Click(By::Id("card-submit-btn"))),
Event::Assert(Assert::IsPresent("Google")),
Event::Assert(Assert::ContainsAny(
Selector::QueryParamStr,
vec!["status=requires_customer_action", "status=succeeded"],
)),
],
)
.await?;
Ok(())
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/worldline_ui.rs" role="context" start="14" end="27">
async fn should_make_card_non_3ds_payment(c: WebDriver) -> Result<(), WebDriverError> {
let conn = WorldlineSeleniumTest {};
conn.make_redirection_payment(
c,
vec![
Event::Trigger(Trigger::Goto(&format!("{CHECKOUT_BASE_URL}/saved/71"))),
Event::Trigger(Trigger::Click(By::Id("card-submit-btn"))),
Event::Assert(Assert::IsPresent("status")),
Event::Assert(Assert::IsPresent("processing")),
],
)
.await?;
Ok(())
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/worldline_ui.rs" role="context" start="6" end="6">
struct WorldlineSeleniumTest;
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/selenium.rs" role="context" start="24" end="29">
pub enum Event<'a> {
RunIf(Assert<'a>, Vec<Event<'a>>),
EitherOr(Assert<'a>, Vec<Event<'a>>, Vec<Event<'a>>),
Assert(Assert<'a>),
Trigger(Trigger<'a>),
}
<file_sep path="hyperswitch/migrations/2022-09-29-084920_create_initial_tables/up.sql" role="context" start="279" end="295">
phone_country_code VARCHAR(255),
description VARCHAR(255),
address JSON,
created_at TIMESTAMP NOT NULL DEFAULT now()::TIMESTAMP,
metadata JSON,
PRIMARY KEY (customer_id, merchant_id)
);
CREATE TABLE events (
id SERIAL PRIMARY KEY,
event_id VARCHAR(255) NOT NULL,
event_type "EventType" NOT NULL,
event_class "EventClass" NOT NULL,
is_webhook_notified BOOLEAN NOT NULL DEFAULT FALSE,
intent_reference_id VARCHAR(255),
primary_object_id VARCHAR(255) NOT NULL,
primary_object_type "EventObjectType" NOT NULL,
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/test_utils/tests/connectors/shift4_ui.rs<|crate|> test_utils<|connector|> shift4_ui anchor=should_make_sofort_payment_test kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=1<|meta_end|>
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/shift4_ui.rs" role="context" start="129" end="131">
fn should_make_sofort_payment_test() {
tester!(should_make_sofort_payment);
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/shift4_ui.rs" role="context" start="135" end="137">
fn should_make_eps_payment_test() {
tester!(should_make_eps_payment);
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/shift4_ui.rs" role="context" start="123" end="125">
fn should_make_ideal_payment_test() {
tester!(should_make_ideal_payment);
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/shift4_ui.rs" role="context" start="117" end="119">
fn should_make_giropay_payment_test() {
tester!(should_make_giropay_payment);
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/test_utils/tests/connectors/shift4_ui.rs<|crate|> test_utils<|connector|> shift4_ui anchor=should_make_3ds_payment_test kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=1<|meta_end|>
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/shift4_ui.rs" role="context" start="111" end="113">
fn should_make_3ds_payment_test() {
tester!(should_make_3ds_payment);
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/shift4_ui.rs" role="context" start="123" end="125">
fn should_make_ideal_payment_test() {
tester!(should_make_ideal_payment);
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/shift4_ui.rs" role="context" start="117" end="119">
fn should_make_giropay_payment_test() {
tester!(should_make_giropay_payment);
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/shift4_ui.rs" role="context" start="90" end="107">
async fn should_make_eps_payment(c: WebDriver) -> Result<(), WebDriverError> {
let conn = Shift4SeleniumTest {};
conn.make_redirection_payment(
c,
vec![
Event::Trigger(Trigger::Goto(&format!("{CHECKOUT_BASE_URL}/saved/157"))),
Event::Trigger(Trigger::Click(By::Id("card-submit-btn"))),
Event::Trigger(Trigger::Click(By::ClassName("btn-success"))),
Event::Assert(Assert::IsPresent("Google")),
Event::Assert(Assert::Contains(
Selector::QueryParamStr,
"status=succeeded",
)),
],
)
.await?;
Ok(())
}
<file_sep path="hyperswitch/crates/test_utils/tests/connectors/shift4_ui.rs" role="context" start="71" end="88">
async fn should_make_sofort_payment(c: WebDriver) -> Result<(), WebDriverError> {
let conn = Shift4SeleniumTest {};
conn.make_redirection_payment(
c,
vec![
Event::Trigger(Trigger::Goto(&format!("{CHECKOUT_BASE_URL}/saved/43"))),
Event::Trigger(Trigger::Click(By::Id("card-submit-btn"))),
Event::Trigger(Trigger::Click(By::ClassName("btn-success"))),
Event::Assert(Assert::IsPresent("Google")),
Event::Assert(Assert::Contains(
Selector::QueryParamStr,
"status=succeeded",
)),
],
)
.await?;
Ok(())
}
|
symbol_neighborhood
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.