id stringlengths 11 116 | type stringclasses 1 value | granularity stringclasses 4 values | content stringlengths 16 477k | metadata dict |
|---|---|---|---|---|
fn_clm_hyperswitch_constraint_graph_default_-1830864881707238091 | clm | function | // Repository: hyperswitch
// Crate: hyperswitch_constraint_graph
// Module: crates/hyperswitch_constraint_graph/src/types
// Implementation of CycleCheck for Default
fn default() -> Self {
Self::new()
}
| {
"crate": "hyperswitch_constraint_graph",
"file": null,
"file_size": null,
"is_async": false,
"is_pub": false,
"num_enums": null,
"num_structs": null,
"num_tables": null,
"score": 7705,
"total_crates": null
} |
fn_clm_hyperswitch_constraint_graph_from_-1830864881707238091 | clm | function | // Repository: hyperswitch
// Crate: hyperswitch_constraint_graph
// Module: crates/hyperswitch_constraint_graph/src/types
// Implementation of DomainIdentifier for From<String>
fn from(value: String) -> Self {
Self(value)
}
| {
"crate": "hyperswitch_constraint_graph",
"file": null,
"file_size": null,
"is_async": false,
"is_pub": false,
"num_enums": null,
"num_structs": null,
"num_tables": null,
"score": 2602,
"total_crates": null
} |
fn_clm_hyperswitch_constraint_graph_into_inner_-1830864881707238091 | clm | function | // Repository: hyperswitch
// Crate: hyperswitch_constraint_graph
// Module: crates/hyperswitch_constraint_graph/src/types
// Inherent implementation for DomainIdentifier
pub fn into_inner(&self) -> String {
self.0.clone()
}
| {
"crate": "hyperswitch_constraint_graph",
"file": null,
"file_size": null,
"is_async": false,
"is_pub": true,
"num_enums": null,
"num_structs": null,
"num_tables": null,
"score": 2063,
"total_crates": null
} |
fn_clm_hyperswitch_constraint_graph_deref_-1830864881707238091 | clm | function | // Repository: hyperswitch
// Crate: hyperswitch_constraint_graph
// Module: crates/hyperswitch_constraint_graph/src/types
// Implementation of CycleCheck for Deref
fn deref(&self) -> &Self::Target {
&self.0
}
| {
"crate": "hyperswitch_constraint_graph",
"file": null,
"file_size": null,
"is_async": false,
"is_pub": false,
"num_enums": null,
"num_structs": null,
"num_tables": null,
"score": 41,
"total_crates": null
} |
fn_clm_hyperswitch_constraint_graph_combine_-886650100889519262 | clm | function | // Repository: hyperswitch
// Crate: hyperswitch_constraint_graph
// Module: crates/hyperswitch_constraint_graph/src/graph
// Implementation of None for ConstraintGraph<V>
pub fn combine(g1: &Self, g2: &Self) -> Result<Self, GraphError<V>> {
let mut node_builder = builder::ConstraintGraphBuilder::new();
let mut g1_old2new_id = DenseMap::<NodeId, NodeId>::new();
let mut g2_old2new_id = DenseMap::<NodeId, NodeId>::new();
let mut g1_old2new_domain_id = DenseMap::<DomainId, DomainId>::new();
let mut g2_old2new_domain_id = DenseMap::<DomainId, DomainId>::new();
let add_domain = |node_builder: &mut builder::ConstraintGraphBuilder<V>,
domain: DomainInfo|
-> Result<DomainId, GraphError<V>> {
node_builder.make_domain(
domain.domain_identifier.into_inner(),
&domain.domain_description,
)
};
let add_node = |node_builder: &mut builder::ConstraintGraphBuilder<V>,
node: &Node<V>|
-> Result<NodeId, GraphError<V>> {
match &node.node_type {
NodeType::Value(node_value) => {
Ok(node_builder.make_value_node(node_value.clone(), None, None::<()>))
}
NodeType::AllAggregator => {
Ok(node_builder.make_all_aggregator(&[], None, None::<()>, None)?)
}
NodeType::AnyAggregator => {
Ok(node_builder.make_any_aggregator(&[], None, None::<()>, None)?)
}
NodeType::InAggregator(expected) => Ok(node_builder.make_in_aggregator(
expected.iter().cloned().collect(),
None,
None::<()>,
)?),
}
};
for (_old_domain_id, domain) in g1.domain.iter() {
let new_domain_id = add_domain(&mut node_builder, domain.clone())?;
g1_old2new_domain_id.push(new_domain_id);
}
for (_old_domain_id, domain) in g2.domain.iter() {
let new_domain_id = add_domain(&mut node_builder, domain.clone())?;
g2_old2new_domain_id.push(new_domain_id);
}
for (_old_node_id, node) in g1.nodes.iter() {
let new_node_id = add_node(&mut node_builder, node)?;
g1_old2new_id.push(new_node_id);
}
for (_old_node_id, node) in g2.nodes.iter() {
let new_node_id = add_node(&mut node_builder, node)?;
g2_old2new_id.push(new_node_id);
}
for edge in g1.edges.values() {
let new_pred_id = g1_old2new_id
.get(edge.pred)
.ok_or(GraphError::NodeNotFound)?;
let new_succ_id = g1_old2new_id
.get(edge.succ)
.ok_or(GraphError::NodeNotFound)?;
let domain_ident = edge
.domain
.map(|domain_id| g1.domain.get(domain_id).ok_or(GraphError::DomainNotFound))
.transpose()?
.map(|domain| domain.domain_identifier.clone());
node_builder.make_edge(
*new_pred_id,
*new_succ_id,
edge.strength,
edge.relation,
domain_ident,
)?;
}
for edge in g2.edges.values() {
let new_pred_id = g2_old2new_id
.get(edge.pred)
.ok_or(GraphError::NodeNotFound)?;
let new_succ_id = g2_old2new_id
.get(edge.succ)
.ok_or(GraphError::NodeNotFound)?;
let domain_ident = edge
.domain
.map(|domain_id| g2.domain.get(domain_id).ok_or(GraphError::DomainNotFound))
.transpose()?
.map(|domain| domain.domain_identifier.clone());
node_builder.make_edge(
*new_pred_id,
*new_succ_id,
edge.strength,
edge.relation,
domain_ident,
)?;
}
Ok(node_builder.build())
}
| {
"crate": "hyperswitch_constraint_graph",
"file": null,
"file_size": null,
"is_async": false,
"is_pub": true,
"num_enums": null,
"num_structs": null,
"num_tables": null,
"score": 132,
"total_crates": null
} |
fn_clm_hyperswitch_constraint_graph_validate_value_node_-886650100889519262 | clm | function | // Repository: hyperswitch
// Crate: hyperswitch_constraint_graph
// Module: crates/hyperswitch_constraint_graph/src/graph
// Implementation of None for ConstraintGraph<V>
fn validate_value_node<C>(
&self,
vald: CheckNodeContext<'_, V, C>,
val: &NodeValue<V>,
) -> Result<(), GraphError<V>>
where
C: CheckingContext<Value = V>,
{
let mut errors = Vec::<Weak<AnalysisTrace<V>>>::new();
let mut matched_one = false;
self.context_analysis(
vald.node_id,
vald.relation,
vald.strength,
vald.ctx,
val,
vald.memo,
)?;
for edge in self.get_predecessor_edges_by_domain(vald.node_id, vald.domains)? {
vald.cycle_map
.insert(vald.node_id, (vald.strength, vald.relation.into()));
let result = self.check_node_inner(
vald.ctx,
edge.pred,
edge.relation,
edge.strength,
vald.memo,
vald.cycle_map,
vald.domains,
);
if let Some((resolved_strength, resolved_relation)) =
vald.cycle_map.remove(&vald.node_id)
{
if resolved_relation == RelationResolution::Contradiction {
let err = Arc::new(AnalysisTrace::Contradiction {
relation: resolved_relation,
});
vald.memo.insert(
(vald.node_id, vald.relation, vald.strength),
Err(Arc::clone(&err)),
);
return Err(GraphError::AnalysisError(Arc::downgrade(&err)));
} else if resolved_strength != vald.strength {
self.context_analysis(
vald.node_id,
vald.relation,
resolved_strength,
vald.ctx,
val,
vald.memo,
)?
}
}
match (edge.strength, result) {
(Strength::Strong, Err(trace)) => {
let err = Arc::new(AnalysisTrace::Value {
value: val.clone(),
relation: vald.relation,
info: self.node_info.get(vald.node_id).copied().flatten(),
metadata: self.node_metadata.get(vald.node_id).cloned().flatten(),
predecessors: Some(error::ValueTracePredecessor::Mandatory(Box::new(
trace.get_analysis_trace()?,
))),
});
vald.memo.insert(
(vald.node_id, vald.relation, vald.strength),
Err(Arc::clone(&err)),
);
Err(GraphError::AnalysisError(Arc::downgrade(&err)))?;
}
(Strength::Strong, Ok(_)) => {
matched_one = true;
}
(Strength::Normal | Strength::Weak, Err(trace)) => {
errors.push(trace.get_analysis_trace()?);
}
(Strength::Normal | Strength::Weak, Ok(_)) => {
matched_one = true;
}
}
}
if matched_one || vald.node.preds.is_empty() {
vald.memo
.insert((vald.node_id, vald.relation, vald.strength), Ok(()));
Ok(())
} else {
let err = Arc::new(AnalysisTrace::Value {
value: val.clone(),
relation: vald.relation,
info: self.node_info.get(vald.node_id).copied().flatten(),
metadata: self.node_metadata.get(vald.node_id).cloned().flatten(),
predecessors: Some(error::ValueTracePredecessor::OneOf(errors.clone())),
});
vald.memo.insert(
(vald.node_id, vald.relation, vald.strength),
Err(Arc::clone(&err)),
);
Err(GraphError::AnalysisError(Arc::downgrade(&err)))
}
}
| {
"crate": "hyperswitch_constraint_graph",
"file": null,
"file_size": null,
"is_async": false,
"is_pub": false,
"num_enums": null,
"num_structs": null,
"num_tables": null,
"score": 103,
"total_crates": null
} |
fn_clm_hyperswitch_constraint_graph_validate_in_aggregator_-886650100889519262 | clm | function | // Repository: hyperswitch
// Crate: hyperswitch_constraint_graph
// Module: crates/hyperswitch_constraint_graph/src/graph
// Implementation of None for ConstraintGraph<V>
fn validate_in_aggregator<C>(
&self,
vald: CheckNodeContext<'_, V, C>,
expected: &FxHashSet<V>,
) -> Result<(), GraphError<V>>
where
C: CheckingContext<Value = V>,
{
let the_key = expected
.iter()
.next()
.ok_or_else(|| GraphError::MalformedGraph {
reason: "An OnlyIn aggregator node must have at least one expected value"
.to_string(),
})?
.get_key();
let ctx_vals = if let Some(vals) = vald.ctx.get_values_by_key(&the_key) {
vals
} else {
return if let Strength::Weak = vald.strength {
vald.memo
.insert((vald.node_id, vald.relation, vald.strength), Ok(()));
Ok(())
} else {
let err = Arc::new(AnalysisTrace::InAggregation {
expected: expected.iter().cloned().collect(),
found: None,
relation: vald.relation,
info: self.node_info.get(vald.node_id).copied().flatten(),
metadata: self.node_metadata.get(vald.node_id).cloned().flatten(),
});
vald.memo.insert(
(vald.node_id, vald.relation, vald.strength),
Err(Arc::clone(&err)),
);
Err(GraphError::AnalysisError(Arc::downgrade(&err)))
};
};
let relation_bool: bool = vald.relation.into();
for ctx_value in ctx_vals {
if expected.contains(&ctx_value) != relation_bool {
let err = Arc::new(AnalysisTrace::InAggregation {
expected: expected.iter().cloned().collect(),
found: Some(ctx_value.clone()),
relation: vald.relation,
info: self.node_info.get(vald.node_id).copied().flatten(),
metadata: self.node_metadata.get(vald.node_id).cloned().flatten(),
});
vald.memo.insert(
(vald.node_id, vald.relation, vald.strength),
Err(Arc::clone(&err)),
);
Err(GraphError::AnalysisError(Arc::downgrade(&err)))?;
}
}
vald.memo
.insert((vald.node_id, vald.relation, vald.strength), Ok(()));
Ok(())
}
| {
"crate": "hyperswitch_constraint_graph",
"file": null,
"file_size": null,
"is_async": false,
"is_pub": false,
"num_enums": null,
"num_structs": null,
"num_tables": null,
"score": 89,
"total_crates": null
} |
fn_clm_hyperswitch_constraint_graph_check_node_inner_-886650100889519262 | clm | function | // Repository: hyperswitch
// Crate: hyperswitch_constraint_graph
// Module: crates/hyperswitch_constraint_graph/src/graph
// Implementation of None for ConstraintGraph<V>
pub fn check_node_inner<C>(
&self,
ctx: &C,
node_id: NodeId,
relation: Relation,
strength: Strength,
memo: &mut Memoization<V>,
cycle_map: &mut CycleCheck,
domains: Option<&[DomainId]>,
) -> Result<(), GraphError<V>>
where
C: CheckingContext<Value = V>,
{
let node = self.nodes.get(node_id).ok_or(GraphError::NodeNotFound)?;
if let Some(already_memo) = memo.get(&(node_id, relation, strength)) {
already_memo
.clone()
.map_err(|err| GraphError::AnalysisError(Arc::downgrade(&err)))
} else if let Some((initial_strength, initial_relation)) = cycle_map.get(&node_id).copied()
{
let strength_relation = Strength::get_resolved_strength(initial_strength, strength);
let relation_resolve =
RelationResolution::get_resolved_relation(initial_relation, relation.into());
cycle_map.entry(node_id).and_modify(|value| {
value.0 = strength_relation;
value.1 = relation_resolve
});
Ok(())
} else {
let check_node_context = CheckNodeContext {
node,
node_id,
relation,
strength,
memo,
cycle_map,
ctx,
domains,
};
match &node.node_type {
NodeType::AllAggregator => self.validate_all_aggregator(check_node_context),
NodeType::AnyAggregator => self.validate_any_aggregator(check_node_context),
NodeType::InAggregator(expected) => {
self.validate_in_aggregator(check_node_context, expected)
}
NodeType::Value(val) => self.validate_value_node(check_node_context, val),
}
}
}
| {
"crate": "hyperswitch_constraint_graph",
"file": null,
"file_size": null,
"is_async": false,
"is_pub": true,
"num_enums": null,
"num_structs": null,
"num_tables": null,
"score": 66,
"total_crates": null
} |
fn_clm_hyperswitch_constraint_graph_validate_any_aggregator_-886650100889519262 | clm | function | // Repository: hyperswitch
// Crate: hyperswitch_constraint_graph
// Module: crates/hyperswitch_constraint_graph/src/graph
// Implementation of None for ConstraintGraph<V>
fn validate_any_aggregator<C>(
&self,
vald: CheckNodeContext<'_, V, C>,
) -> Result<(), GraphError<V>>
where
C: CheckingContext<Value = V>,
{
let mut unsatisfied = Vec::<Weak<AnalysisTrace<V>>>::new();
let mut matched_one = false;
for edge in self.get_predecessor_edges_by_domain(vald.node_id, vald.domains)? {
vald.cycle_map
.insert(vald.node_id, (vald.strength, vald.relation.into()));
if let Err(e) = self.check_node_inner(
vald.ctx,
edge.pred,
edge.relation,
edge.strength,
vald.memo,
vald.cycle_map,
vald.domains,
) {
unsatisfied.push(e.get_analysis_trace()?);
} else {
matched_one = true;
}
if let Some((_resolved_strength, resolved_relation)) =
vald.cycle_map.remove(&vald.node_id)
{
if resolved_relation == RelationResolution::Contradiction {
let err = Arc::new(AnalysisTrace::Contradiction {
relation: resolved_relation,
});
vald.memo.insert(
(vald.node_id, vald.relation, vald.strength),
Err(Arc::clone(&err)),
);
return Err(GraphError::AnalysisError(Arc::downgrade(&err)));
}
}
}
if matched_one || vald.node.preds.is_empty() {
vald.memo
.insert((vald.node_id, vald.relation, vald.strength), Ok(()));
Ok(())
} else {
let err = Arc::new(AnalysisTrace::AnyAggregation {
unsatisfied: unsatisfied.clone(),
info: self.node_info.get(vald.node_id).copied().flatten(),
metadata: self.node_metadata.get(vald.node_id).cloned().flatten(),
});
vald.memo.insert(
(vald.node_id, vald.relation, vald.strength),
Err(Arc::clone(&err)),
);
Err(GraphError::AnalysisError(Arc::downgrade(&err)))
}
}
| {
"crate": "hyperswitch_constraint_graph",
"file": null,
"file_size": null,
"is_async": false,
"is_pub": false,
"num_enums": null,
"num_structs": null,
"num_tables": null,
"score": 65,
"total_crates": null
} |
fn_clm_hyperswitch_constraint_graph_get_analysis_trace_7013651476471671645 | clm | function | // Repository: hyperswitch
// Crate: hyperswitch_constraint_graph
// Module: crates/hyperswitch_constraint_graph/src/error
// Inherent implementation for GraphError<V>
pub fn get_analysis_trace(self) -> Result<Weak<AnalysisTrace<V>>, Self> {
match self {
Self::AnalysisError(trace) => Ok(trace),
_ => Err(self),
}
}
| {
"crate": "hyperswitch_constraint_graph",
"file": null,
"file_size": null,
"is_async": false,
"is_pub": true,
"num_enums": null,
"num_structs": null,
"num_tables": null,
"score": 36,
"total_crates": null
} |
fn_clm_hyperswitch_constraint_graph_new_5992030244966742603 | clm | function | // Repository: hyperswitch
// Crate: hyperswitch_constraint_graph
// Module: crates/hyperswitch_constraint_graph/src/dense_map
// Inherent implementation for IntoIter<K, V>
fn new(iter: vec::IntoIter<V>) -> Self {
Self {
inner: iter.enumerate(),
_marker: PhantomData,
}
}
| {
"crate": "hyperswitch_constraint_graph",
"file": null,
"file_size": null,
"is_async": false,
"is_pub": false,
"num_enums": null,
"num_structs": null,
"num_tables": null,
"score": 14455,
"total_crates": null
} |
fn_clm_hyperswitch_constraint_graph_default_5992030244966742603 | clm | function | // Repository: hyperswitch
// Crate: hyperswitch_constraint_graph
// Module: crates/hyperswitch_constraint_graph/src/dense_map
// Implementation of DenseMap<K, V> for Default
fn default() -> Self {
Self::new()
}
| {
"crate": "hyperswitch_constraint_graph",
"file": null,
"file_size": null,
"is_async": false,
"is_pub": false,
"num_enums": null,
"num_structs": null,
"num_tables": null,
"score": 7705,
"total_crates": null
} |
fn_clm_hyperswitch_constraint_graph_iter_5992030244966742603 | clm | function | // Repository: hyperswitch
// Crate: hyperswitch_constraint_graph
// Module: crates/hyperswitch_constraint_graph/src/dense_map
// Inherent implementation for DenseMap<K, V>
pub fn iter(&self) -> Iter<'_, K, V> {
Iter::new(self.data.iter())
}
| {
"crate": "hyperswitch_constraint_graph",
"file": null,
"file_size": null,
"is_async": false,
"is_pub": true,
"num_enums": null,
"num_structs": null,
"num_tables": null,
"score": 2551,
"total_crates": null
} |
fn_clm_hyperswitch_constraint_graph_push_5992030244966742603 | clm | function | // Repository: hyperswitch
// Crate: hyperswitch_constraint_graph
// Module: crates/hyperswitch_constraint_graph/src/dense_map
// Inherent implementation for DenseMap<K, V>
pub fn push(&mut self, elem: V) -> K {
let curr_len = self.data.len();
self.data.push(elem);
K::with_id(curr_len)
}
| {
"crate": "hyperswitch_constraint_graph",
"file": null,
"file_size": null,
"is_async": false,
"is_pub": true,
"num_enums": null,
"num_structs": null,
"num_tables": null,
"score": 1500,
"total_crates": null
} |
fn_clm_hyperswitch_constraint_graph_into_iter_5992030244966742603 | clm | function | // Repository: hyperswitch
// Crate: hyperswitch_constraint_graph
// Module: crates/hyperswitch_constraint_graph/src/dense_map
// Implementation of DenseMap<K, V> for IntoIterator
fn into_iter(self) -> Self::IntoIter {
IntoIter::new(self.data.into_iter())
}
| {
"crate": "hyperswitch_constraint_graph",
"file": null,
"file_size": null,
"is_async": false,
"is_pub": false,
"num_enums": null,
"num_structs": null,
"num_tables": null,
"score": 1482,
"total_crates": null
} |
fn_clm_hyperswitch_constraint_graph_new_-9096457981246748646 | clm | function | // Repository: hyperswitch
// Crate: hyperswitch_constraint_graph
// Module: crates/hyperswitch_constraint_graph/src/builder
// Implementation of None for ConstraintGraphBuilder<V>
pub fn new() -> Self {
Self {
domain: DenseMap::new(),
nodes: DenseMap::new(),
edges: DenseMap::new(),
domain_identifier_map: FxHashMap::default(),
value_map: FxHashMap::default(),
edges_map: FxHashMap::default(),
node_info: DenseMap::new(),
node_metadata: DenseMap::new(),
}
}
| {
"crate": "hyperswitch_constraint_graph",
"file": null,
"file_size": null,
"is_async": false,
"is_pub": true,
"num_enums": null,
"num_structs": null,
"num_tables": null,
"score": 14479,
"total_crates": null
} |
fn_clm_hyperswitch_constraint_graph_from_-9096457981246748646 | clm | function | // Repository: hyperswitch
// Crate: hyperswitch_constraint_graph
// Module: crates/hyperswitch_constraint_graph/src/builder
// Implementation of DomainIdOrIdentifier for From<DomainId>
fn from(value: DomainId) -> Self {
Self::DomainId(value)
}
| {
"crate": "hyperswitch_constraint_graph",
"file": null,
"file_size": null,
"is_async": false,
"is_pub": false,
"num_enums": null,
"num_structs": null,
"num_tables": null,
"score": 2602,
"total_crates": null
} |
fn_clm_hyperswitch_constraint_graph_build_-9096457981246748646 | clm | function | // Repository: hyperswitch
// Crate: hyperswitch_constraint_graph
// Module: crates/hyperswitch_constraint_graph/src/builder
// Implementation of None for ConstraintGraphBuilder<V>
pub fn build(self) -> ConstraintGraph<V> {
ConstraintGraph {
domain: self.domain,
domain_identifier_map: self.domain_identifier_map,
nodes: self.nodes,
edges: self.edges,
value_map: self.value_map,
node_info: self.node_info,
node_metadata: self.node_metadata,
}
}
| {
"crate": "hyperswitch_constraint_graph",
"file": null,
"file_size": null,
"is_async": false,
"is_pub": true,
"num_enums": null,
"num_structs": null,
"num_tables": null,
"score": 582,
"total_crates": null
} |
fn_clm_hyperswitch_constraint_graph_make_value_node_-9096457981246748646 | clm | function | // Repository: hyperswitch
// Crate: hyperswitch_constraint_graph
// Module: crates/hyperswitch_constraint_graph/src/builder
// Implementation of None for ConstraintGraphBuilder<V>
pub fn make_value_node<M: Metadata>(
&mut self,
value: NodeValue<V>,
info: Option<&'static str>,
metadata: Option<M>,
) -> NodeId {
self.value_map.get(&value).copied().unwrap_or_else(|| {
let node_id = self.nodes.push(Node::new(NodeType::Value(value.clone())));
let _node_info_id = self.node_info.push(info);
let _node_metadata_id = self
.node_metadata
.push(metadata.map(|meta| -> Arc<dyn Metadata> { Arc::new(meta) }));
self.value_map.insert(value, node_id);
node_id
})
}
| {
"crate": "hyperswitch_constraint_graph",
"file": null,
"file_size": null,
"is_async": false,
"is_pub": true,
"num_enums": null,
"num_structs": null,
"num_tables": null,
"score": 138,
"total_crates": null
} |
fn_clm_hyperswitch_constraint_graph_make_edge_-9096457981246748646 | clm | function | // Repository: hyperswitch
// Crate: hyperswitch_constraint_graph
// Module: crates/hyperswitch_constraint_graph/src/builder
// Implementation of None for ConstraintGraphBuilder<V>
pub fn make_edge<T: Into<DomainIdOrIdentifier>>(
&mut self,
pred_id: NodeId,
succ_id: NodeId,
strength: Strength,
relation: Relation,
domain: Option<T>,
) -> Result<EdgeId, GraphError<V>> {
self.ensure_node_exists(pred_id)?;
self.ensure_node_exists(succ_id)?;
let domain_id = domain
.map(|d| match d.into() {
DomainIdOrIdentifier::DomainIdentifier(ident) => {
self.retrieve_domain_from_identifier(ident)
}
DomainIdOrIdentifier::DomainId(domain_id) => {
self.ensure_domain_exists(domain_id).map(|_| domain_id)
}
})
.transpose()?;
self.edges_map
.get(&(pred_id, succ_id, domain_id))
.copied()
.and_then(|edge_id| self.edges.get(edge_id).cloned().map(|edge| (edge_id, edge)))
.map_or_else(
|| {
let edge_id = self.edges.push(Edge {
strength,
relation,
pred: pred_id,
succ: succ_id,
domain: domain_id,
});
self.edges_map
.insert((pred_id, succ_id, domain_id), edge_id);
let pred = self
.nodes
.get_mut(pred_id)
.ok_or(GraphError::NodeNotFound)?;
pred.succs.push(edge_id);
let succ = self
.nodes
.get_mut(succ_id)
.ok_or(GraphError::NodeNotFound)?;
succ.preds.push(edge_id);
Ok(edge_id)
},
|(edge_id, edge)| {
if edge.strength == strength && edge.relation == relation {
Ok(edge_id)
} else {
Err(GraphError::ConflictingEdgeCreated)
}
},
)
}
| {
"crate": "hyperswitch_constraint_graph",
"file": null,
"file_size": null,
"is_async": false,
"is_pub": true,
"num_enums": null,
"num_structs": null,
"num_tables": null,
"score": 127,
"total_crates": null
} |
fn_clm_connector_configs_get_transformed_response_payload_4610886424550503462 | clm | function | // Repository: hyperswitch
// Crate: connector_configs
// Module: crates/connector_configs/src/response_modifier
// Implementation of None for ConnectorApiIntegrationPayload
pub fn get_transformed_response_payload(response: Self) -> DashboardRequestPayload {
let mut wallet_details: Vec<Provider> = Vec::new();
let mut bank_redirect_details: Vec<Provider> = Vec::new();
let mut pay_later_details: Vec<Provider> = Vec::new();
let mut debit_details: Vec<CardProvider> = Vec::new();
let mut credit_details: Vec<CardProvider> = Vec::new();
let mut bank_transfer_details: Vec<Provider> = Vec::new();
let mut crypto_details: Vec<Provider> = Vec::new();
let mut bank_debit_details: Vec<Provider> = Vec::new();
let mut reward_details: Vec<Provider> = Vec::new();
let mut real_time_payment_details: Vec<Provider> = Vec::new();
let mut upi_details: Vec<Provider> = Vec::new();
let mut voucher_details: Vec<Provider> = Vec::new();
let mut gift_card_details: Vec<Provider> = Vec::new();
let mut card_redirect_details: Vec<Provider> = Vec::new();
let mut open_banking_details: Vec<Provider> = Vec::new();
let mut mobile_payment_details: Vec<Provider> = Vec::new();
if let Some(payment_methods_enabled) = response.payment_methods_enabled.clone() {
for methods in payment_methods_enabled {
match methods.payment_method {
api_models::enums::PaymentMethod::Card => {
if let Some(payment_method_types) = methods.payment_method_types {
for method_type in payment_method_types {
match method_type.payment_method_type {
api_models::enums::PaymentMethodType::Credit => {
if let Some(card_networks) = method_type.card_networks {
for card in card_networks {
credit_details.push(CardProvider {
payment_method_type: card,
accepted_currencies: method_type
.accepted_currencies
.clone(),
accepted_countries: method_type
.accepted_countries
.clone(),
})
}
}
}
api_models::enums::PaymentMethodType::Debit => {
if let Some(card_networks) = method_type.card_networks {
for card in card_networks {
// debit_details.push(card)
debit_details.push(CardProvider {
payment_method_type: card,
accepted_currencies: method_type
.accepted_currencies
.clone(),
accepted_countries: method_type
.accepted_countries
.clone(),
})
}
}
}
_ => (),
}
}
}
}
api_models::enums::PaymentMethod::Wallet => {
if let Some(payment_method_types) = methods.payment_method_types {
for method_type in payment_method_types {
// wallet_details.push(method_type.payment_method_type)
wallet_details.push(Provider {
payment_method_type: method_type.payment_method_type,
accepted_currencies: method_type.accepted_currencies.clone(),
accepted_countries: method_type.accepted_countries.clone(),
payment_experience: method_type.payment_experience,
})
}
}
}
api_models::enums::PaymentMethod::BankRedirect => {
if let Some(payment_method_types) = methods.payment_method_types {
for method_type in payment_method_types {
bank_redirect_details.push(Provider {
payment_method_type: method_type.payment_method_type,
accepted_currencies: method_type.accepted_currencies.clone(),
accepted_countries: method_type.accepted_countries.clone(),
payment_experience: method_type.payment_experience,
})
}
}
}
api_models::enums::PaymentMethod::PayLater => {
if let Some(payment_method_types) = methods.payment_method_types {
for method_type in payment_method_types {
pay_later_details.push(Provider {
payment_method_type: method_type.payment_method_type,
accepted_currencies: method_type.accepted_currencies.clone(),
accepted_countries: method_type.accepted_countries.clone(),
payment_experience: method_type.payment_experience,
})
}
}
}
api_models::enums::PaymentMethod::BankTransfer => {
if let Some(payment_method_types) = methods.payment_method_types {
for method_type in payment_method_types {
bank_transfer_details.push(Provider {
payment_method_type: method_type.payment_method_type,
accepted_currencies: method_type.accepted_currencies.clone(),
accepted_countries: method_type.accepted_countries.clone(),
payment_experience: method_type.payment_experience,
})
}
}
}
api_models::enums::PaymentMethod::Crypto => {
if let Some(payment_method_types) = methods.payment_method_types {
for method_type in payment_method_types {
crypto_details.push(Provider {
payment_method_type: method_type.payment_method_type,
accepted_currencies: method_type.accepted_currencies.clone(),
accepted_countries: method_type.accepted_countries.clone(),
payment_experience: method_type.payment_experience,
})
}
}
}
api_models::enums::PaymentMethod::BankDebit => {
if let Some(payment_method_types) = methods.payment_method_types {
for method_type in payment_method_types {
bank_debit_details.push(Provider {
payment_method_type: method_type.payment_method_type,
accepted_currencies: method_type.accepted_currencies.clone(),
accepted_countries: method_type.accepted_countries.clone(),
payment_experience: method_type.payment_experience,
})
}
}
}
api_models::enums::PaymentMethod::Reward => {
if let Some(payment_method_types) = methods.payment_method_types {
for method_type in payment_method_types {
reward_details.push(Provider {
payment_method_type: method_type.payment_method_type,
accepted_currencies: method_type.accepted_currencies.clone(),
accepted_countries: method_type.accepted_countries.clone(),
payment_experience: method_type.payment_experience,
})
}
}
}
api_models::enums::PaymentMethod::RealTimePayment => {
if let Some(payment_method_types) = methods.payment_method_types {
for method_type in payment_method_types {
real_time_payment_details.push(Provider {
payment_method_type: method_type.payment_method_type,
accepted_currencies: method_type.accepted_currencies.clone(),
accepted_countries: method_type.accepted_countries.clone(),
payment_experience: method_type.payment_experience,
})
}
}
}
api_models::enums::PaymentMethod::OpenBanking => {
if let Some(payment_method_types) = methods.payment_method_types {
for method_type in payment_method_types {
open_banking_details.push(Provider {
payment_method_type: method_type.payment_method_type,
accepted_currencies: method_type.accepted_currencies.clone(),
accepted_countries: method_type.accepted_countries.clone(),
payment_experience: method_type.payment_experience,
})
}
}
}
api_models::enums::PaymentMethod::Upi => {
if let Some(payment_method_types) = methods.payment_method_types {
for method_type in payment_method_types {
upi_details.push(Provider {
payment_method_type: method_type.payment_method_type,
accepted_currencies: method_type.accepted_currencies.clone(),
accepted_countries: method_type.accepted_countries.clone(),
payment_experience: method_type.payment_experience,
})
}
}
}
api_models::enums::PaymentMethod::Voucher => {
if let Some(payment_method_types) = methods.payment_method_types {
for method_type in payment_method_types {
voucher_details.push(Provider {
payment_method_type: method_type.payment_method_type,
accepted_currencies: method_type.accepted_currencies.clone(),
accepted_countries: method_type.accepted_countries.clone(),
payment_experience: method_type.payment_experience,
})
}
}
}
api_models::enums::PaymentMethod::GiftCard => {
if let Some(payment_method_types) = methods.payment_method_types {
for method_type in payment_method_types {
gift_card_details.push(Provider {
payment_method_type: method_type.payment_method_type,
accepted_currencies: method_type.accepted_currencies.clone(),
accepted_countries: method_type.accepted_countries.clone(),
payment_experience: method_type.payment_experience,
})
}
}
}
api_models::enums::PaymentMethod::CardRedirect => {
if let Some(payment_method_types) = methods.payment_method_types {
for method_type in payment_method_types {
card_redirect_details.push(Provider {
payment_method_type: method_type.payment_method_type,
accepted_currencies: method_type.accepted_currencies.clone(),
accepted_countries: method_type.accepted_countries.clone(),
payment_experience: method_type.payment_experience,
})
}
}
}
api_models::enums::PaymentMethod::MobilePayment => {
if let Some(payment_method_types) = methods.payment_method_types {
for method_type in payment_method_types {
mobile_payment_details.push(Provider {
payment_method_type: method_type.payment_method_type,
accepted_currencies: method_type.accepted_currencies.clone(),
accepted_countries: method_type.accepted_countries.clone(),
payment_experience: method_type.payment_experience,
})
}
}
}
}
}
}
let open_banking = DashboardPaymentMethodPayload {
payment_method: api_models::enums::PaymentMethod::OpenBanking,
payment_method_type: api_models::enums::PaymentMethod::OpenBanking.to_string(),
provider: Some(open_banking_details),
card_provider: None,
};
let upi = DashboardPaymentMethodPayload {
payment_method: api_models::enums::PaymentMethod::Upi,
payment_method_type: api_models::enums::PaymentMethod::Upi.to_string(),
provider: Some(upi_details),
card_provider: None,
};
let voucher: DashboardPaymentMethodPayload = DashboardPaymentMethodPayload {
payment_method: api_models::enums::PaymentMethod::Voucher,
payment_method_type: api_models::enums::PaymentMethod::Voucher.to_string(),
provider: Some(voucher_details),
card_provider: None,
};
let gift_card: DashboardPaymentMethodPayload = DashboardPaymentMethodPayload {
payment_method: api_models::enums::PaymentMethod::GiftCard,
payment_method_type: api_models::enums::PaymentMethod::GiftCard.to_string(),
provider: Some(gift_card_details),
card_provider: None,
};
let reward = DashboardPaymentMethodPayload {
payment_method: api_models::enums::PaymentMethod::Reward,
payment_method_type: api_models::enums::PaymentMethod::Reward.to_string(),
provider: Some(reward_details),
card_provider: None,
};
let real_time_payment = DashboardPaymentMethodPayload {
payment_method: api_models::enums::PaymentMethod::RealTimePayment,
payment_method_type: api_models::enums::PaymentMethod::RealTimePayment.to_string(),
provider: Some(real_time_payment_details),
card_provider: None,
};
let wallet = DashboardPaymentMethodPayload {
payment_method: api_models::enums::PaymentMethod::Wallet,
payment_method_type: api_models::enums::PaymentMethod::Wallet.to_string(),
provider: Some(wallet_details),
card_provider: None,
};
let bank_redirect = DashboardPaymentMethodPayload {
payment_method: api_models::enums::PaymentMethod::BankRedirect,
payment_method_type: api_models::enums::PaymentMethod::BankRedirect.to_string(),
provider: Some(bank_redirect_details),
card_provider: None,
};
let bank_debit = DashboardPaymentMethodPayload {
payment_method: api_models::enums::PaymentMethod::BankDebit,
payment_method_type: api_models::enums::PaymentMethod::BankDebit.to_string(),
provider: Some(bank_debit_details),
card_provider: None,
};
let bank_transfer = DashboardPaymentMethodPayload {
payment_method: api_models::enums::PaymentMethod::BankTransfer,
payment_method_type: api_models::enums::PaymentMethod::BankTransfer.to_string(),
provider: Some(bank_transfer_details),
card_provider: None,
};
let crypto = DashboardPaymentMethodPayload {
payment_method: api_models::enums::PaymentMethod::Crypto,
payment_method_type: api_models::enums::PaymentMethod::Crypto.to_string(),
provider: Some(crypto_details),
card_provider: None,
};
let card_redirect = DashboardPaymentMethodPayload {
payment_method: api_models::enums::PaymentMethod::CardRedirect,
payment_method_type: api_models::enums::PaymentMethod::CardRedirect.to_string(),
provider: Some(card_redirect_details),
card_provider: None,
};
let pay_later = DashboardPaymentMethodPayload {
payment_method: api_models::enums::PaymentMethod::PayLater,
payment_method_type: api_models::enums::PaymentMethod::PayLater.to_string(),
provider: Some(pay_later_details),
card_provider: None,
};
let debit_details = DashboardPaymentMethodPayload {
payment_method: api_models::enums::PaymentMethod::Card,
payment_method_type: api_models::enums::PaymentMethodType::Debit.to_string(),
provider: None,
card_provider: Some(debit_details),
};
let credit_details = DashboardPaymentMethodPayload {
payment_method: api_models::enums::PaymentMethod::Card,
payment_method_type: api_models::enums::PaymentMethodType::Credit.to_string(),
provider: None,
card_provider: Some(credit_details),
};
DashboardRequestPayload {
connector: response.connector_name,
payment_methods_enabled: Some(vec![
open_banking,
upi,
voucher,
reward,
real_time_payment,
wallet,
bank_redirect,
bank_debit,
bank_transfer,
crypto,
card_redirect,
pay_later,
debit_details,
credit_details,
gift_card,
]),
metadata: response.metadata,
}
}
| {
"crate": "connector_configs",
"file": null,
"file_size": null,
"is_async": false,
"is_pub": true,
"num_enums": null,
"num_structs": null,
"num_tables": null,
"score": 181,
"total_crates": null
} |
fn_clm_connector_configs_create_connector_request_-7121648977238575553 | clm | function | // Repository: hyperswitch
// Crate: connector_configs
// Module: crates/connector_configs/src/transformer
// Implementation of None for DashboardRequestPayload
pub fn create_connector_request(
request: Self,
api_response: ConnectorApiIntegrationPayload,
) -> ConnectorApiIntegrationPayload {
let mut card_payment_method_types = Vec::new();
let mut payment_method_enabled = Vec::new();
if let Some(payment_methods_enabled) = request.payment_methods_enabled.clone() {
for payload in payment_methods_enabled {
match payload.payment_method {
PaymentMethod::Card => {
if let Some(card_provider) = payload.card_provider {
let payment_type =
PaymentMethodType::from_str(&payload.payment_method_type)
.map_err(|_| "Invalid key received".to_string());
if let Ok(payment_type) = payment_type {
for method in card_provider {
let data = payment_methods::RequestPaymentMethodTypes {
payment_method_type: payment_type,
card_networks: Some(vec![method.payment_method_type]),
minimum_amount: Some(MinorUnit::zero()),
maximum_amount: Some(MinorUnit::new(68607706)),
recurring_enabled: Some(true),
installment_payment_enabled: Some(false),
accepted_currencies: method.accepted_currencies,
accepted_countries: method.accepted_countries,
payment_experience: None,
};
card_payment_method_types.push(data)
}
}
}
}
PaymentMethod::BankRedirect
| PaymentMethod::Wallet
| PaymentMethod::PayLater
| PaymentMethod::BankTransfer
| PaymentMethod::Crypto
| PaymentMethod::BankDebit
| PaymentMethod::Reward
| PaymentMethod::RealTimePayment
| PaymentMethod::Upi
| PaymentMethod::Voucher
| PaymentMethod::GiftCard
| PaymentMethod::OpenBanking
| PaymentMethod::CardRedirect
| PaymentMethod::MobilePayment => {
if let Some(provider) = payload.provider {
let val = Self::transform_payment_method(
request.connector,
provider,
payload.payment_method,
);
if !val.is_empty() {
let methods = PaymentMethodsEnabled {
payment_method: payload.payment_method,
payment_method_types: Some(val),
};
payment_method_enabled.push(methods);
}
}
}
};
}
if !card_payment_method_types.is_empty() {
let card = PaymentMethodsEnabled {
payment_method: PaymentMethod::Card,
payment_method_types: Some(card_payment_method_types),
};
payment_method_enabled.push(card);
}
}
ConnectorApiIntegrationPayload {
connector_type: api_response.connector_type,
profile_id: api_response.profile_id,
connector_name: api_response.connector_name,
connector_label: api_response.connector_label,
merchant_connector_id: api_response.merchant_connector_id,
disabled: api_response.disabled,
test_mode: api_response.test_mode,
payment_methods_enabled: Some(payment_method_enabled),
connector_webhook_details: api_response.connector_webhook_details,
metadata: request.metadata,
}
}
| {
"crate": "connector_configs",
"file": null,
"file_size": null,
"is_async": false,
"is_pub": true,
"num_enums": null,
"num_structs": null,
"num_tables": null,
"score": 49,
"total_crates": null
} |
fn_clm_connector_configs_transform_payment_method_-7121648977238575553 | clm | function | // Repository: hyperswitch
// Crate: connector_configs
// Module: crates/connector_configs/src/transformer
// Implementation of None for DashboardRequestPayload
pub fn transform_payment_method(
connector: Connector,
provider: Vec<Provider>,
payment_method: PaymentMethod,
) -> Vec<payment_methods::RequestPaymentMethodTypes> {
let mut payment_method_types = Vec::new();
for method_type in provider {
let data = payment_methods::RequestPaymentMethodTypes {
payment_method_type: method_type.payment_method_type,
card_networks: None,
minimum_amount: Some(MinorUnit::zero()),
maximum_amount: Some(MinorUnit::new(68607706)),
recurring_enabled: Some(true),
installment_payment_enabled: Some(false),
accepted_currencies: method_type.accepted_currencies,
accepted_countries: method_type.accepted_countries,
payment_experience: Self::get_payment_experience(
connector,
method_type.payment_method_type,
payment_method,
method_type.payment_experience,
),
};
payment_method_types.push(data)
}
payment_method_types
}
| {
"crate": "connector_configs",
"file": null,
"file_size": null,
"is_async": false,
"is_pub": true,
"num_enums": null,
"num_structs": null,
"num_tables": null,
"score": 31,
"total_crates": null
} |
fn_clm_connector_configs_transform_card_-7121648977238575553 | clm | function | // Repository: hyperswitch
// Crate: connector_configs
// Module: crates/connector_configs/src/transformer
// Implementation of None for DashboardRequestPayload
pub fn transform_card(
payment_method_type: PaymentMethodType,
card_provider: Vec<api_models::enums::CardNetwork>,
) -> payment_methods::RequestPaymentMethodTypes {
payment_methods::RequestPaymentMethodTypes {
payment_method_type,
card_networks: Some(card_provider),
minimum_amount: Some(MinorUnit::zero()),
maximum_amount: Some(MinorUnit::new(68607706)),
recurring_enabled: Some(true),
installment_payment_enabled: Some(false),
accepted_currencies: None,
accepted_countries: None,
payment_experience: None,
}
}
| {
"crate": "connector_configs",
"file": null,
"file_size": null,
"is_async": false,
"is_pub": true,
"num_enums": null,
"num_structs": null,
"num_tables": null,
"score": 22,
"total_crates": null
} |
fn_clm_connector_configs_get_payment_experience_-7121648977238575553 | clm | function | // Repository: hyperswitch
// Crate: connector_configs
// Module: crates/connector_configs/src/transformer
// Implementation of None for DashboardRequestPayload
pub fn get_payment_experience(
connector: Connector,
payment_method_type: PaymentMethodType,
payment_method: PaymentMethod,
payment_experience: Option<api_models::enums::PaymentExperience>,
) -> Option<api_models::enums::PaymentExperience> {
match payment_method {
PaymentMethod::BankRedirect => None,
_ => match (connector, payment_method_type) {
#[cfg(feature = "dummy_connector")]
(Connector::DummyConnector4, _) | (Connector::DummyConnector7, _) => {
Some(api_models::enums::PaymentExperience::RedirectToUrl)
}
(Connector::Paypal, Paypal) => payment_experience,
(Connector::Klarna, Klarna) => payment_experience,
(Connector::Zen, GooglePay) | (Connector::Zen, ApplePay) => {
Some(api_models::enums::PaymentExperience::RedirectToUrl)
}
(Connector::Braintree, Paypal) => {
Some(api_models::enums::PaymentExperience::InvokeSdkClient)
}
(Connector::Globepay, AliPay)
| (Connector::Globepay, WeChatPay)
| (Connector::Stripe, WeChatPay) => {
Some(api_models::enums::PaymentExperience::DisplayQrCode)
}
(_, GooglePay)
| (_, ApplePay)
| (_, PaymentMethodType::SamsungPay)
| (_, PaymentMethodType::Paze)
| (_, PaymentMethodType::AmazonPay) => {
Some(api_models::enums::PaymentExperience::InvokeSdkClient)
}
(_, PaymentMethodType::DirectCarrierBilling) => {
Some(api_models::enums::PaymentExperience::CollectOtp)
}
(_, PaymentMethodType::Cashapp) | (_, PaymentMethodType::Swish) => {
Some(api_models::enums::PaymentExperience::DisplayQrCode)
}
_ => Some(api_models::enums::PaymentExperience::RedirectToUrl),
},
}
}
| {
"crate": "connector_configs",
"file": null,
"file_size": null,
"is_async": false,
"is_pub": true,
"num_enums": null,
"num_structs": null,
"num_tables": null,
"score": 21,
"total_crates": null
} |
fn_clm_connector_configs_new_-5346512585129188946 | clm | function | // Repository: hyperswitch
// Crate: connector_configs
// Module: crates/connector_configs/src/connector
// Inherent implementation for ConnectorConfig
fn new() -> Result<Self, String> {
let config_str = if cfg!(feature = "production") {
include_str!("../toml/production.toml")
} else if cfg!(feature = "sandbox") {
include_str!("../toml/sandbox.toml")
} else {
include_str!("../toml/development.toml")
};
let config = toml::from_str::<Self>(config_str);
match config {
Ok(data) => Ok(data),
Err(err) => Err(err.to_string()),
}
}
| {
"crate": "connector_configs",
"file": null,
"file_size": null,
"is_async": false,
"is_pub": false,
"num_enums": null,
"num_structs": null,
"num_tables": null,
"score": 14455,
"total_crates": null
} |
fn_clm_connector_configs_get_connector_config_-5346512585129188946 | clm | function | // Repository: hyperswitch
// Crate: connector_configs
// Module: crates/connector_configs/src/connector
// Inherent implementation for ConnectorConfig
pub fn get_connector_config(
connector: Connector,
) -> Result<Option<ConnectorTomlConfig>, String> {
let connector_data = Self::new()?;
match connector {
Connector::Aci => Ok(connector_data.aci),
Connector::Authipay => Ok(connector_data.authipay),
Connector::Adyen => Ok(connector_data.adyen),
Connector::Affirm => Ok(connector_data.affirm),
Connector::Adyenplatform => Err("Use get_payout_connector_config".to_string()),
Connector::Airwallex => Ok(connector_data.airwallex),
Connector::Amazonpay => Ok(connector_data.amazonpay),
Connector::Archipel => Ok(connector_data.archipel),
Connector::Authorizedotnet => Ok(connector_data.authorizedotnet),
Connector::Bamboraapac => Ok(connector_data.bamboraapac),
Connector::Bankofamerica => Ok(connector_data.bankofamerica),
Connector::Barclaycard => Ok(connector_data.barclaycard),
Connector::Billwerk => Ok(connector_data.billwerk),
Connector::Bitpay => Ok(connector_data.bitpay),
Connector::Bluesnap => Ok(connector_data.bluesnap),
Connector::Calida => Ok(connector_data.calida),
Connector::Blackhawknetwork => Ok(connector_data.blackhawknetwork),
Connector::Boku => Ok(connector_data.boku),
Connector::Braintree => Ok(connector_data.braintree),
Connector::Breadpay => Ok(connector_data.breadpay),
Connector::Cashtocode => Ok(connector_data.cashtocode),
Connector::Cardinal => Ok(connector_data.cardinal),
Connector::Celero => Ok(connector_data.celero),
Connector::Chargebee => Ok(connector_data.chargebee),
Connector::Checkbook => Ok(connector_data.checkbook),
Connector::Checkout => Ok(connector_data.checkout),
Connector::Coinbase => Ok(connector_data.coinbase),
Connector::Coingate => Ok(connector_data.coingate),
Connector::Cryptopay => Ok(connector_data.cryptopay),
Connector::CtpVisa => Ok(connector_data.ctp_visa),
Connector::Custombilling => Ok(connector_data.custombilling),
Connector::Cybersource => Ok(connector_data.cybersource),
#[cfg(feature = "dummy_connector")]
Connector::DummyBillingConnector => Ok(connector_data.dummy_connector),
Connector::Iatapay => Ok(connector_data.iatapay),
Connector::Itaubank => Ok(connector_data.itaubank),
Connector::Opennode => Ok(connector_data.opennode),
Connector::Bambora => Ok(connector_data.bambora),
Connector::Datatrans => Ok(connector_data.datatrans),
Connector::Deutschebank => Ok(connector_data.deutschebank),
Connector::Digitalvirgo => Ok(connector_data.digitalvirgo),
Connector::Dlocal => Ok(connector_data.dlocal),
Connector::Dwolla => Ok(connector_data.dwolla),
Connector::Ebanx => Ok(connector_data.ebanx_payout),
Connector::Elavon => Ok(connector_data.elavon),
Connector::Facilitapay => Ok(connector_data.facilitapay),
Connector::Finix => Ok(connector_data.finix),
Connector::Fiserv => Ok(connector_data.fiserv),
Connector::Fiservemea => Ok(connector_data.fiservemea),
Connector::Fiuu => Ok(connector_data.fiuu),
Connector::Flexiti => Ok(connector_data.flexiti),
Connector::Forte => Ok(connector_data.forte),
Connector::Getnet => Ok(connector_data.getnet),
Connector::Gigadat => Ok(connector_data.gigadat),
Connector::Globalpay => Ok(connector_data.globalpay),
Connector::Globepay => Ok(connector_data.globepay),
Connector::Gocardless => Ok(connector_data.gocardless),
Connector::Gpayments => Ok(connector_data.gpayments),
Connector::Hipay => Ok(connector_data.hipay),
Connector::HyperswitchVault => Ok(connector_data.hyperswitch_vault),
Connector::Helcim => Ok(connector_data.helcim),
Connector::Inespay => Ok(connector_data.inespay),
Connector::Jpmorgan => Ok(connector_data.jpmorgan),
Connector::Juspaythreedsserver => Ok(connector_data.juspaythreedsserver),
Connector::Klarna => Ok(connector_data.klarna),
Connector::Loonio => Ok(connector_data.loonio),
Connector::Mifinity => Ok(connector_data.mifinity),
Connector::Mollie => Ok(connector_data.mollie),
Connector::Moneris => Ok(connector_data.moneris),
Connector::Multisafepay => Ok(connector_data.multisafepay),
Connector::Nexinets => Ok(connector_data.nexinets),
Connector::Nexixpay => Ok(connector_data.nexixpay),
Connector::Prophetpay => Ok(connector_data.prophetpay),
Connector::Nmi => Ok(connector_data.nmi),
Connector::Nordea => Ok(connector_data.nordea),
Connector::Nomupay => Err("Use get_payout_connector_config".to_string()),
Connector::Novalnet => Ok(connector_data.novalnet),
Connector::Noon => Ok(connector_data.noon),
Connector::Nuvei => Ok(connector_data.nuvei),
Connector::Paybox => Ok(connector_data.paybox),
Connector::Payload => Ok(connector_data.payload),
Connector::Payme => Ok(connector_data.payme),
Connector::Payone => Err("Use get_payout_connector_config".to_string()),
Connector::Paypal => Ok(connector_data.paypal),
Connector::Paysafe => Ok(connector_data.paysafe),
Connector::Paystack => Ok(connector_data.paystack),
Connector::Payu => Ok(connector_data.payu),
Connector::Peachpayments => Ok(connector_data.peachpayments),
Connector::Placetopay => Ok(connector_data.placetopay),
Connector::Plaid => Ok(connector_data.plaid),
Connector::Powertranz => Ok(connector_data.powertranz),
Connector::Razorpay => Ok(connector_data.razorpay),
Connector::Rapyd => Ok(connector_data.rapyd),
Connector::Recurly => Ok(connector_data.recurly),
Connector::Redsys => Ok(connector_data.redsys),
Connector::Riskified => Ok(connector_data.riskified),
Connector::Santander => Ok(connector_data.santander),
Connector::Shift4 => Ok(connector_data.shift4),
Connector::Signifyd => Ok(connector_data.signifyd),
Connector::Silverflow => Ok(connector_data.silverflow),
Connector::Square => Ok(connector_data.square),
Connector::Stax => Ok(connector_data.stax),
Connector::Stripe => Ok(connector_data.stripe),
Connector::Stripebilling => Ok(connector_data.stripebilling),
Connector::Tesouro => Ok(connector_data.tesouro),
Connector::Tokenex => Ok(connector_data.tokenex),
Connector::Tokenio => Ok(connector_data.tokenio),
Connector::Trustpay => Ok(connector_data.trustpay),
Connector::Trustpayments => Ok(connector_data.trustpayments),
Connector::Threedsecureio => Ok(connector_data.threedsecureio),
Connector::Taxjar => Ok(connector_data.taxjar),
Connector::Tsys => Ok(connector_data.tsys),
Connector::Vgs => Ok(connector_data.vgs),
Connector::Volt => Ok(connector_data.volt),
Connector::Wellsfargo => Ok(connector_data.wellsfargo),
Connector::Wise => Err("Use get_payout_connector_config".to_string()),
Connector::Worldline => Ok(connector_data.worldline),
Connector::Worldpay => Ok(connector_data.worldpay),
Connector::Worldpayvantiv => Ok(connector_data.worldpayvantiv),
Connector::Worldpayxml => Ok(connector_data.worldpayxml),
Connector::Zen => Ok(connector_data.zen),
Connector::Zsl => Ok(connector_data.zsl),
#[cfg(feature = "dummy_connector")]
Connector::DummyConnector1 => Ok(connector_data.dummy_connector),
#[cfg(feature = "dummy_connector")]
Connector::DummyConnector2 => Ok(connector_data.dummy_connector),
#[cfg(feature = "dummy_connector")]
Connector::DummyConnector3 => Ok(connector_data.dummy_connector),
#[cfg(feature = "dummy_connector")]
Connector::DummyConnector4 => Ok(connector_data.stripe_test),
#[cfg(feature = "dummy_connector")]
Connector::DummyConnector5 => Ok(connector_data.dummy_connector),
#[cfg(feature = "dummy_connector")]
Connector::DummyConnector6 => Ok(connector_data.dummy_connector),
#[cfg(feature = "dummy_connector")]
Connector::DummyConnector7 => Ok(connector_data.paypal_test),
Connector::Netcetera => Ok(connector_data.netcetera),
Connector::CtpMastercard => Ok(connector_data.ctp_mastercard),
Connector::Xendit => Ok(connector_data.xendit),
Connector::Paytm => Ok(connector_data.paytm),
Connector::Phonepe => Ok(connector_data.phonepe),
}
}
| {
"crate": "connector_configs",
"file": null,
"file_size": null,
"is_async": false,
"is_pub": true,
"num_enums": null,
"num_structs": null,
"num_tables": null,
"score": 31,
"total_crates": null
} |
fn_clm_connector_configs_get_payout_connector_config_-5346512585129188946 | clm | function | // Repository: hyperswitch
// Crate: connector_configs
// Module: crates/connector_configs/src/connector
// Inherent implementation for ConnectorConfig
pub fn get_payout_connector_config(
connector: PayoutConnectors,
) -> Result<Option<ConnectorTomlConfig>, String> {
let connector_data = Self::new()?;
match connector {
PayoutConnectors::Adyen => Ok(connector_data.adyen_payout),
PayoutConnectors::Adyenplatform => Ok(connector_data.adyenplatform_payout),
PayoutConnectors::Cybersource => Ok(connector_data.cybersource_payout),
PayoutConnectors::Ebanx => Ok(connector_data.ebanx_payout),
PayoutConnectors::Gigadat => Ok(connector_data.gigadat_payout),
PayoutConnectors::Loonio => Ok(connector_data.loonio_payout),
PayoutConnectors::Nomupay => Ok(connector_data.nomupay_payout),
PayoutConnectors::Nuvei => Ok(connector_data.nuvei_payout),
PayoutConnectors::Payone => Ok(connector_data.payone_payout),
PayoutConnectors::Paypal => Ok(connector_data.paypal_payout),
PayoutConnectors::Stripe => Ok(connector_data.stripe_payout),
PayoutConnectors::Wise => Ok(connector_data.wise_payout),
PayoutConnectors::Worldpay => Ok(connector_data.worldpay_payout),
}
}
| {
"crate": "connector_configs",
"file": null,
"file_size": null,
"is_async": false,
"is_pub": true,
"num_enums": null,
"num_structs": null,
"num_tables": null,
"score": 23,
"total_crates": null
} |
fn_clm_connector_configs_get_authentication_connector_config_-5346512585129188946 | clm | function | // Repository: hyperswitch
// Crate: connector_configs
// Module: crates/connector_configs/src/connector
// Inherent implementation for ConnectorConfig
pub fn get_authentication_connector_config(
connector: AuthenticationConnectors,
) -> Result<Option<ConnectorTomlConfig>, String> {
let connector_data = Self::new()?;
match connector {
AuthenticationConnectors::Threedsecureio => Ok(connector_data.threedsecureio),
AuthenticationConnectors::Netcetera => Ok(connector_data.netcetera),
AuthenticationConnectors::Gpayments => Ok(connector_data.gpayments),
AuthenticationConnectors::CtpMastercard => Ok(connector_data.ctp_mastercard),
AuthenticationConnectors::CtpVisa => Ok(connector_data.ctp_visa),
AuthenticationConnectors::UnifiedAuthenticationService => {
Ok(connector_data.unified_authentication_service)
}
AuthenticationConnectors::Juspaythreedsserver => Ok(connector_data.juspaythreedsserver),
AuthenticationConnectors::Cardinal => Ok(connector_data.cardinal),
}
}
| {
"crate": "connector_configs",
"file": null,
"file_size": null,
"is_async": false,
"is_pub": true,
"num_enums": null,
"num_structs": null,
"num_tables": null,
"score": 23,
"total_crates": null
} |
fn_clm_connector_configs_get_tax_processor_config_-5346512585129188946 | clm | function | // Repository: hyperswitch
// Crate: connector_configs
// Module: crates/connector_configs/src/connector
// Inherent implementation for ConnectorConfig
pub fn get_tax_processor_config(
connector: TaxConnectors,
) -> Result<Option<ConnectorTomlConfig>, String> {
let connector_data = Self::new()?;
match connector {
TaxConnectors::Taxjar => Ok(connector_data.taxjar),
}
}
| {
"crate": "connector_configs",
"file": null,
"file_size": null,
"is_async": false,
"is_pub": true,
"num_enums": null,
"num_structs": null,
"num_tables": null,
"score": 23,
"total_crates": null
} |
fn_clm_test_utils_get_connector_name_3207857100754593099 | clm | function | // Repository: hyperswitch
// Crate: test_utils
// Module: crates/test_utils/tests/connectors/stripe_wh_ui
// Implementation of StripeSeleniumTest for SeleniumTest
fn get_connector_name(&self) -> String {
"stripe".to_string()
}
| {
"crate": "test_utils",
"file": null,
"file_size": null,
"is_async": false,
"is_pub": false,
"num_enums": null,
"num_structs": null,
"num_tables": null,
"score": 28,
"total_crates": null
} |
fn_clm_test_utils_should_make_webhook_3207857100754593099 | clm | function | // Repository: hyperswitch
// Crate: test_utils
// Module: crates/test_utils/tests/connectors/stripe_wh_ui
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(())
}
| {
"crate": "test_utils",
"file": null,
"file_size": null,
"is_async": false,
"is_pub": false,
"num_enums": null,
"num_structs": null,
"num_tables": null,
"score": 2,
"total_crates": null
} |
fn_clm_test_utils_should_make_webhook_test_3207857100754593099 | clm | function | // Repository: hyperswitch
// Crate: test_utils
// Module: crates/test_utils/tests/connectors/stripe_wh_ui
fn should_make_webhook_test() {
tester!(should_make_webhook);
}
| {
"crate": "test_utils",
"file": null,
"file_size": null,
"is_async": false,
"is_pub": false,
"num_enums": null,
"num_structs": null,
"num_tables": null,
"score": 0,
"total_crates": null
} |
fn_clm_test_utils_get_connector_name_2776967949788229755 | clm | function | // Repository: hyperswitch
// Crate: test_utils
// Module: crates/test_utils/tests/connectors/multisafepay_ui
// Implementation of MultisafepaySeleniumTest for SeleniumTest
fn get_connector_name(&self) -> String {
"multisafepay".to_string()
}
| {
"crate": "test_utils",
"file": null,
"file_size": null,
"is_async": false,
"is_pub": false,
"num_enums": null,
"num_structs": null,
"num_tables": null,
"score": 28,
"total_crates": null
} |
fn_clm_test_utils_should_make_multisafepay_3ds_payment_success_2776967949788229755 | clm | function | // Repository: hyperswitch
// Crate: test_utils
// Module: crates/test_utils/tests/connectors/multisafepay_ui
async fn should_make_multisafepay_3ds_payment_success(
web_driver: WebDriver,
) -> Result<(), WebDriverError> {
let conn = MultisafepaySeleniumTest {};
conn.make_redirection_payment(
web_driver,
vec![
Event::Trigger(Trigger::Goto(&format!("{CHECKOUT_BASE_URL}/saved/207"))),
Event::Trigger(Trigger::Click(By::Id("card-submit-btn"))),
Event::Assert(Assert::IsPresent("succeeded")),
],
)
.await?;
Ok(())
}
| {
"crate": "test_utils",
"file": null,
"file_size": null,
"is_async": false,
"is_pub": false,
"num_enums": null,
"num_structs": null,
"num_tables": null,
"score": 2,
"total_crates": null
} |
fn_clm_test_utils_should_make_multisafepay_3ds_payment_failed_2776967949788229755 | clm | function | // Repository: hyperswitch
// Crate: test_utils
// Module: crates/test_utils/tests/connectors/multisafepay_ui
async fn should_make_multisafepay_3ds_payment_failed(
web_driver: WebDriver,
) -> Result<(), WebDriverError> {
let conn = MultisafepaySeleniumTest {};
conn.make_redirection_payment(
web_driver,
vec![
Event::Trigger(Trigger::Goto(&format!("{CHECKOUT_BASE_URL}/saved/93"))),
Event::Trigger(Trigger::Click(By::Id("card-submit-btn"))),
Event::Assert(Assert::IsPresent("failed")),
],
)
.await?;
Ok(())
}
| {
"crate": "test_utils",
"file": null,
"file_size": null,
"is_async": false,
"is_pub": false,
"num_enums": null,
"num_structs": null,
"num_tables": null,
"score": 2,
"total_crates": null
} |
fn_clm_test_utils_should_make_gpay_payment_2776967949788229755 | clm | function | // Repository: hyperswitch
// Crate: test_utils
// Module: crates/test_utils/tests/connectors/multisafepay_ui
async fn should_make_gpay_payment(web_driver: WebDriver) -> Result<(), WebDriverError> {
let conn = MultisafepaySeleniumTest {};
conn.make_redirection_payment(
web_driver,
vec![
Event::Trigger(Trigger::Goto(&format!("{CHECKOUT_BASE_URL}/saved/153"))),
Event::Trigger(Trigger::Click(By::Id("card-submit-btn"))),
Event::Trigger(Trigger::Click(By::Css("button[class='btn btn-default']"))),
Event::Assert(Assert::IsPresent("succeeded")),
],
)
.await?;
Ok(())
}
| {
"crate": "test_utils",
"file": null,
"file_size": null,
"is_async": false,
"is_pub": false,
"num_enums": null,
"num_structs": null,
"num_tables": null,
"score": 2,
"total_crates": null
} |
fn_clm_test_utils_should_make_paypal_payment_2776967949788229755 | clm | function | // Repository: hyperswitch
// Crate: test_utils
// Module: crates/test_utils/tests/connectors/multisafepay_ui
async fn should_make_paypal_payment(web_driver: WebDriver) -> Result<(), WebDriverError> {
let conn = MultisafepaySeleniumTest {};
conn.make_redirection_payment(
web_driver,
vec![
Event::Trigger(Trigger::Goto(&format!("{CHECKOUT_BASE_URL}/saved/154"))),
Event::Trigger(Trigger::Click(By::Id("card-submit-btn"))),
Event::Trigger(Trigger::Click(By::Css(
"button[class='btn btn-msp-success btn-block']",
))),
Event::Assert(Assert::IsPresent("succeeded")),
],
)
.await?;
Ok(())
}
| {
"crate": "test_utils",
"file": null,
"file_size": null,
"is_async": false,
"is_pub": false,
"num_enums": null,
"num_structs": null,
"num_tables": null,
"score": 2,
"total_crates": null
} |
fn_clm_test_utils_get_connector_name_-9213772287725242437 | clm | function | // Repository: hyperswitch
// Crate: test_utils
// Module: crates/test_utils/tests/connectors/payu_ui
// Implementation of PayUSeleniumTest for SeleniumTest
fn get_connector_name(&self) -> String {
"payu".to_string()
}
| {
"crate": "test_utils",
"file": null,
"file_size": null,
"is_async": false,
"is_pub": false,
"num_enums": null,
"num_structs": null,
"num_tables": null,
"score": 28,
"total_crates": null
} |
fn_clm_test_utils_should_make_no_3ds_card_payment_-9213772287725242437 | clm | function | // Repository: hyperswitch
// Crate: test_utils
// Module: crates/test_utils/tests/connectors/payu_ui
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(())
}
| {
"crate": "test_utils",
"file": null,
"file_size": null,
"is_async": false,
"is_pub": false,
"num_enums": null,
"num_structs": null,
"num_tables": null,
"score": 2,
"total_crates": null
} |
fn_clm_test_utils_should_make_gpay_payment_-9213772287725242437 | clm | function | // Repository: hyperswitch
// Crate: test_utils
// Module: crates/test_utils/tests/connectors/payu_ui
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(())
}
| {
"crate": "test_utils",
"file": null,
"file_size": null,
"is_async": false,
"is_pub": false,
"num_enums": null,
"num_structs": null,
"num_tables": null,
"score": 2,
"total_crates": null
} |
fn_clm_test_utils_should_make_no_3ds_card_payment_test_-9213772287725242437 | clm | function | // Repository: hyperswitch
// Crate: test_utils
// Module: crates/test_utils/tests/connectors/payu_ui
fn should_make_no_3ds_card_payment_test() {
tester!(should_make_no_3ds_card_payment);
}
| {
"crate": "test_utils",
"file": null,
"file_size": null,
"is_async": false,
"is_pub": false,
"num_enums": null,
"num_structs": null,
"num_tables": null,
"score": 0,
"total_crates": null
} |
fn_clm_test_utils_should_make_gpay_payment_test_-9213772287725242437 | clm | function | // Repository: hyperswitch
// Crate: test_utils
// Module: crates/test_utils/tests/connectors/payu_ui
fn should_make_gpay_payment_test() {
tester!(should_make_gpay_payment);
}
| {
"crate": "test_utils",
"file": null,
"file_size": null,
"is_async": false,
"is_pub": false,
"num_enums": null,
"num_structs": null,
"num_tables": null,
"score": 0,
"total_crates": null
} |
fn_clm_test_utils_complete_actions_-5987297784469969278 | clm | function | // Repository: hyperswitch
// Crate: test_utils
// Module: crates/test_utils/tests/connectors/selenium
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(())
}
| {
"crate": "test_utils",
"file": null,
"file_size": null,
"is_async": false,
"is_pub": false,
"num_enums": null,
"num_structs": null,
"num_tables": null,
"score": 338,
"total_crates": null
} |
fn_clm_test_utils_make_redirection_payment_-5987297784469969278 | clm | function | // Repository: hyperswitch
// Crate: test_utils
// Module: crates/test_utils/tests/connectors/selenium
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
}
}
| {
"crate": "test_utils",
"file": null,
"file_size": null,
"is_async": false,
"is_pub": false,
"num_enums": null,
"num_structs": null,
"num_tables": null,
"score": 214,
"total_crates": null
} |
fn_clm_test_utils_make_webhook_test_-5987297784469969278 | clm | function | // Repository: hyperswitch
// Crate: test_utils
// Module: crates/test_utils/tests/connectors/selenium
async fn make_webhook_test(
&self,
web_driver: WebDriver,
payment_url: &str,
actions: Vec<Event<'_>>,
webhook_retry_time: u64,
webhook_status: &str,
) -> Result<(), WebDriverError> {
self.complete_actions(
&web_driver,
vec![Event::Trigger(Trigger::Goto(payment_url))],
)
.await?;
self.complete_actions(&web_driver, actions).await?; //additional actions needs to make a payment
self.complete_actions(
&web_driver,
vec![Event::Trigger(Trigger::Goto(&format!(
"{CHECKOUT_BASE_URL}/events"
)))],
)
.await?;
let element = web_driver.query(By::Css("h2.last-payment")).first().await?;
let payment_id = element.text().await?;
let retries = 3; // no of retry times
for _i in 0..retries {
let configs = self.get_configs().automation_configs.unwrap();
let outgoing_webhook_url = configs.hs_webhook_url.unwrap().to_string();
let client = reqwest::Client::new();
let response = client.get(outgoing_webhook_url).send().await.unwrap(); // get events from outgoing webhook endpoint
let body_text = response.text().await.unwrap();
let data: WebhookResponse = serde_json::from_str(&body_text).unwrap();
let last_three_events = data.data.get(data.data.len().saturating_sub(3)..).unwrap(); // Get the last three elements if available
for last_event in last_three_events {
let last_event_body = &last_event.step.request.body;
let decoded_bytes = base64::engine::general_purpose::STANDARD //decode the encoded outgoing webhook event
.decode(last_event_body)
.unwrap();
let decoded_str = String::from_utf8(decoded_bytes).unwrap();
let webhook_response: HsWebhookResponse =
serde_json::from_str(&decoded_str).unwrap();
if payment_id == webhook_response.content.object.payment_id
&& webhook_status == webhook_response.content.object.status
{
return Ok(());
}
}
self.complete_actions(
&web_driver,
vec![Event::Trigger(Trigger::Sleep(webhook_retry_time))],
)
.await?;
}
Err(WebDriverError::CustomError("Webhook Not Found".to_string()))
}
| {
"crate": "test_utils",
"file": null,
"file_size": null,
"is_async": false,
"is_pub": false,
"num_enums": null,
"num_structs": null,
"num_tables": null,
"score": 61,
"total_crates": null
} |
fn_clm_test_utils_get_configs_-5987297784469969278 | clm | function | // Repository: hyperswitch
// Crate: test_utils
// Module: crates/test_utils/tests/connectors/selenium
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")
}
| {
"crate": "test_utils",
"file": null,
"file_size": null,
"is_async": false,
"is_pub": false,
"num_enums": null,
"num_structs": null,
"num_tables": null,
"score": 51,
"total_crates": null
} |
fn_clm_test_utils_is_text_present_now_-5987297784469969278 | clm | function | // Repository: hyperswitch
// Crate: test_utils
// Module: crates/test_utils/tests/connectors/selenium
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
}
| {
"crate": "test_utils",
"file": null,
"file_size": null,
"is_async": false,
"is_pub": false,
"num_enums": null,
"num_structs": null,
"num_tables": null,
"score": 38,
"total_crates": null
} |
fn_clm_test_utils_get_connector_name_-2069100450059665771 | clm | function | // Repository: hyperswitch
// Crate: test_utils
// Module: crates/test_utils/tests/connectors/aci_ui
// Implementation of AciSeleniumTest for SeleniumTest
fn get_connector_name(&self) -> String {
"aci".to_string()
}
| {
"crate": "test_utils",
"file": null,
"file_size": null,
"is_async": false,
"is_pub": false,
"num_enums": null,
"num_structs": null,
"num_tables": null,
"score": 28,
"total_crates": null
} |
fn_clm_test_utils_should_make_aci_card_mandate_payment_-2069100450059665771 | clm | function | // Repository: hyperswitch
// Crate: test_utils
// Module: crates/test_utils/tests/connectors/aci_ui
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(())
}
| {
"crate": "test_utils",
"file": null,
"file_size": null,
"is_async": false,
"is_pub": false,
"num_enums": null,
"num_structs": null,
"num_tables": null,
"score": 2,
"total_crates": null
} |
fn_clm_test_utils_should_make_aci_alipay_payment_-2069100450059665771 | clm | function | // Repository: hyperswitch
// Crate: test_utils
// Module: crates/test_utils/tests/connectors/aci_ui
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(())
}
| {
"crate": "test_utils",
"file": null,
"file_size": null,
"is_async": false,
"is_pub": false,
"num_enums": null,
"num_structs": null,
"num_tables": null,
"score": 2,
"total_crates": null
} |
fn_clm_test_utils_should_make_aci_interac_payment_-2069100450059665771 | clm | function | // Repository: hyperswitch
// Crate: test_utils
// Module: crates/test_utils/tests/connectors/aci_ui
async fn should_make_aci_interac_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/14"))),
Event::Trigger(Trigger::Click(By::Id("card-submit-btn"))),
Event::Trigger(Trigger::Click(By::Css("input[value='Continue payment']"))),
Event::Trigger(Trigger::Click(By::Css("input[value='Confirm']"))),
Event::Assert(Assert::IsPresent("succeeded")),
],
)
.await?;
Ok(())
}
| {
"crate": "test_utils",
"file": null,
"file_size": null,
"is_async": false,
"is_pub": false,
"num_enums": null,
"num_structs": null,
"num_tables": null,
"score": 2,
"total_crates": null
} |
fn_clm_test_utils_should_make_aci_eps_payment_-2069100450059665771 | clm | function | // Repository: hyperswitch
// Crate: test_utils
// Module: crates/test_utils/tests/connectors/aci_ui
async fn should_make_aci_eps_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/208"))),
Event::Trigger(Trigger::Click(By::Id("card-submit-btn"))),
Event::Trigger(Trigger::Click(By::Css("input.button-body.button-short"))),
Event::Trigger(Trigger::Click(By::Css("input.button-body.button-short"))),
Event::Trigger(Trigger::Click(By::Css("input.button-body.button-short"))),
Event::Trigger(Trigger::Click(By::Css("input.button-body.button-middle"))),
Event::Assert(Assert::IsPresent("succeeded")),
],
)
.await?;
Ok(())
}
| {
"crate": "test_utils",
"file": null,
"file_size": null,
"is_async": false,
"is_pub": false,
"num_enums": null,
"num_structs": null,
"num_tables": null,
"score": 2,
"total_crates": null
} |
fn_clm_test_utils_get_connector_name_2671220971309568925 | clm | function | // Repository: hyperswitch
// Crate: test_utils
// Module: crates/test_utils/tests/connectors/authorizedotnet_ui
// Implementation of AuthorizedotnetSeleniumTest for SeleniumTest
fn get_connector_name(&self) -> String {
"authorizedotnet".to_string()
}
| {
"crate": "test_utils",
"file": null,
"file_size": null,
"is_async": false,
"is_pub": false,
"num_enums": null,
"num_structs": null,
"num_tables": null,
"score": 28,
"total_crates": null
} |
fn_clm_test_utils_should_make_gpay_payment_2671220971309568925 | clm | function | // Repository: hyperswitch
// Crate: test_utils
// Module: crates/test_utils/tests/connectors/authorizedotnet_ui
async fn should_make_gpay_payment(web_driver: WebDriver) -> Result<(), WebDriverError> {
let conn = AuthorizedotnetSeleniumTest {};
let amount = rand::thread_rng().gen_range(1..1000); //This connector detects it as fraudulent payment if the same amount is used for multiple payments so random amount is passed for testing
let pub_key = conn
.get_configs()
.automation_configs
.unwrap()
.authorizedotnet_gateway_merchant_id
.unwrap();
conn.make_gpay_payment(web_driver,
&format!("{CHECKOUT_BASE_URL}/gpay?gatewayname=authorizenet&gatewaymerchantid={pub_key}&amount={amount}&country=US¤cy=USD"),
vec![
Event::Assert(Assert::IsPresent("status")),
Event::Assert(Assert::IsPresent("processing")), // This connector status will be processing for one day
]).await?;
Ok(())
}
| {
"crate": "test_utils",
"file": null,
"file_size": null,
"is_async": false,
"is_pub": false,
"num_enums": null,
"num_structs": null,
"num_tables": null,
"score": 8,
"total_crates": null
} |
fn_clm_test_utils_should_make_paypal_payment_2671220971309568925 | clm | function | // Repository: hyperswitch
// Crate: test_utils
// Module: crates/test_utils/tests/connectors/authorizedotnet_ui
async fn should_make_paypal_payment(web_driver: WebDriver) -> Result<(), WebDriverError> {
let conn = AuthorizedotnetSeleniumTest {};
conn.make_paypal_payment(
web_driver,
&format!("{CHECKOUT_BASE_URL}/saved/156"),
vec![
Event::EitherOr(
Assert::IsElePresent(By::Css(".reviewButton")),
vec![Event::Trigger(Trigger::Click(By::Css(".reviewButton")))],
vec![Event::Trigger(Trigger::Click(By::Id("payment-submit-btn")))],
),
Event::Assert(Assert::IsPresent("status")),
Event::Assert(Assert::IsPresent("processing")), // This connector status will be processing for one day
],
)
.await?;
Ok(())
}
| {
"crate": "test_utils",
"file": null,
"file_size": null,
"is_async": false,
"is_pub": false,
"num_enums": null,
"num_structs": null,
"num_tables": null,
"score": 2,
"total_crates": null
} |
fn_clm_test_utils_should_make_gpay_payment_test_2671220971309568925 | clm | function | // Repository: hyperswitch
// Crate: test_utils
// Module: crates/test_utils/tests/connectors/authorizedotnet_ui
fn should_make_gpay_payment_test() {
tester!(should_make_gpay_payment);
}
| {
"crate": "test_utils",
"file": null,
"file_size": null,
"is_async": false,
"is_pub": false,
"num_enums": null,
"num_structs": null,
"num_tables": null,
"score": 0,
"total_crates": null
} |
fn_clm_test_utils_should_make_paypal_payment_test_2671220971309568925 | clm | function | // Repository: hyperswitch
// Crate: test_utils
// Module: crates/test_utils/tests/connectors/authorizedotnet_ui
fn should_make_paypal_payment_test() {
tester!(should_make_paypal_payment);
}
| {
"crate": "test_utils",
"file": null,
"file_size": null,
"is_async": false,
"is_pub": false,
"num_enums": null,
"num_structs": null,
"num_tables": null,
"score": 0,
"total_crates": null
} |
fn_clm_test_utils_get_connector_name_-4974219162943926285 | clm | function | // Repository: hyperswitch
// Crate: test_utils
// Module: crates/test_utils/tests/connectors/globalpay_ui
// Implementation of GlobalpaySeleniumTest for SeleniumTest
fn get_connector_name(&self) -> String {
"globalpay".to_string()
}
| {
"crate": "test_utils",
"file": null,
"file_size": null,
"is_async": false,
"is_pub": false,
"num_enums": null,
"num_structs": null,
"num_tables": null,
"score": 28,
"total_crates": null
} |
fn_clm_test_utils_should_make_gpay_payment_-4974219162943926285 | clm | function | // Repository: hyperswitch
// Crate: test_utils
// Module: crates/test_utils/tests/connectors/globalpay_ui
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(())
}
| {
"crate": "test_utils",
"file": null,
"file_size": null,
"is_async": false,
"is_pub": false,
"num_enums": null,
"num_structs": null,
"num_tables": null,
"score": 4,
"total_crates": null
} |
fn_clm_test_utils_should_make_globalpay_sofort_payment_-4974219162943926285 | clm | function | // Repository: hyperswitch
// Crate: test_utils
// Module: crates/test_utils/tests/connectors/globalpay_ui
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(())
}
| {
"crate": "test_utils",
"file": null,
"file_size": null,
"is_async": false,
"is_pub": false,
"num_enums": null,
"num_structs": null,
"num_tables": null,
"score": 4,
"total_crates": null
} |
fn_clm_test_utils_should_make_globalpay_paypal_payment_-4974219162943926285 | clm | function | // Repository: hyperswitch
// Crate: test_utils
// Module: crates/test_utils/tests/connectors/globalpay_ui
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(())
}
| {
"crate": "test_utils",
"file": null,
"file_size": null,
"is_async": false,
"is_pub": false,
"num_enums": null,
"num_structs": null,
"num_tables": null,
"score": 2,
"total_crates": null
} |
fn_clm_test_utils_should_make_globalpay_ideal_payment_-4974219162943926285 | clm | function | // Repository: hyperswitch
// Crate: test_utils
// Module: crates/test_utils/tests/connectors/globalpay_ui
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(())
}
| {
"crate": "test_utils",
"file": null,
"file_size": null,
"is_async": false,
"is_pub": false,
"num_enums": null,
"num_structs": null,
"num_tables": null,
"score": 2,
"total_crates": null
} |
fn_clm_test_utils_get_connector_name_4844944244503222801 | clm | function | // Repository: hyperswitch
// Crate: test_utils
// Module: crates/test_utils/tests/connectors/mollie_ui
// Implementation of MollieSeleniumTest for SeleniumTest
fn get_connector_name(&self) -> String {
"mollie".to_string()
}
| {
"crate": "test_utils",
"file": null,
"file_size": null,
"is_async": false,
"is_pub": false,
"num_enums": null,
"num_structs": null,
"num_tables": null,
"score": 28,
"total_crates": null
} |
fn_clm_test_utils_should_make_mollie_paypal_payment_4844944244503222801 | clm | function | // Repository: hyperswitch
// Crate: test_utils
// Module: crates/test_utils/tests/connectors/mollie_ui
async fn should_make_mollie_paypal_payment(web_driver: WebDriver) -> Result<(), WebDriverError> {
let conn = MollieSeleniumTest {};
conn.make_redirection_payment(
web_driver,
vec![
Event::Trigger(Trigger::Goto(&format!("{CHECKOUT_BASE_URL}/saved/32"))),
Event::Trigger(Trigger::Click(By::Id("card-submit-btn"))),
Event::Assert(Assert::IsPresent("Test profile")),
Event::Trigger(Trigger::Click(By::Css("input[value='paid']"))),
Event::Trigger(Trigger::Click(By::Css(
"button[class='button form__button']",
))),
Event::Assert(Assert::IsPresent("Google")),
Event::Assert(Assert::Contains(
Selector::QueryParamStr,
"status=succeeded",
)),
],
)
.await?;
Ok(())
}
| {
"crate": "test_utils",
"file": null,
"file_size": null,
"is_async": false,
"is_pub": false,
"num_enums": null,
"num_structs": null,
"num_tables": null,
"score": 2,
"total_crates": null
} |
fn_clm_test_utils_should_make_mollie_sofort_payment_4844944244503222801 | clm | function | // Repository: hyperswitch
// Crate: test_utils
// Module: crates/test_utils/tests/connectors/mollie_ui
async fn should_make_mollie_sofort_payment(web_driver: WebDriver) -> Result<(), WebDriverError> {
let conn = MollieSeleniumTest {};
conn.make_redirection_payment(
web_driver,
vec![
Event::Trigger(Trigger::Goto(&format!("{CHECKOUT_BASE_URL}/saved/29"))),
Event::Trigger(Trigger::Click(By::Id("card-submit-btn"))),
Event::Assert(Assert::IsPresent("Test profile")),
Event::Trigger(Trigger::Click(By::Css("input[value='paid']"))),
Event::Trigger(Trigger::Click(By::Css(
"button[class='button form__button']",
))),
Event::Assert(Assert::IsPresent("Google")),
Event::Assert(Assert::Contains(
Selector::QueryParamStr,
"status=succeeded",
)),
],
)
.await?;
Ok(())
}
| {
"crate": "test_utils",
"file": null,
"file_size": null,
"is_async": false,
"is_pub": false,
"num_enums": null,
"num_structs": null,
"num_tables": null,
"score": 2,
"total_crates": null
} |
fn_clm_test_utils_should_make_mollie_ideal_payment_4844944244503222801 | clm | function | // Repository: hyperswitch
// Crate: test_utils
// Module: crates/test_utils/tests/connectors/mollie_ui
async fn should_make_mollie_ideal_payment(web_driver: WebDriver) -> Result<(), WebDriverError> {
let conn: MollieSeleniumTest = MollieSeleniumTest {};
conn.make_redirection_payment(
web_driver,
vec![
Event::Trigger(Trigger::Goto(&format!("{CHECKOUT_BASE_URL}/saved/36"))),
Event::Trigger(Trigger::Click(By::Id("card-submit-btn"))),
Event::Assert(Assert::IsPresent("Test profile")),
Event::Trigger(Trigger::Click(By::ClassName(
"payment-method-list--bordered",
))),
Event::Assert(Assert::IsPresent("Test profile")),
Event::Trigger(Trigger::Click(By::Css("input[value='paid']"))),
Event::Trigger(Trigger::Click(By::Css(
"button[class='button form__button']",
))),
Event::Assert(Assert::IsPresent("succeeded")),
],
)
.await?;
Ok(())
}
| {
"crate": "test_utils",
"file": null,
"file_size": null,
"is_async": false,
"is_pub": false,
"num_enums": null,
"num_structs": null,
"num_tables": null,
"score": 2,
"total_crates": null
} |
fn_clm_test_utils_should_make_mollie_eps_payment_4844944244503222801 | clm | function | // Repository: hyperswitch
// Crate: test_utils
// Module: crates/test_utils/tests/connectors/mollie_ui
async fn should_make_mollie_eps_payment(web_driver: WebDriver) -> Result<(), WebDriverError> {
let conn = MollieSeleniumTest {};
conn.make_redirection_payment(
web_driver,
vec![
Event::Trigger(Trigger::Goto(&format!("{CHECKOUT_BASE_URL}/saved/38"))),
Event::Trigger(Trigger::Click(By::Id("card-submit-btn"))),
Event::Assert(Assert::IsPresent("Test profile")),
Event::Trigger(Trigger::Click(By::Css("input[value='paid']"))),
Event::Trigger(Trigger::Click(By::Css(
"button[class='button form__button']",
))),
Event::Assert(Assert::IsPresent("Google")),
Event::Assert(Assert::Contains(
Selector::QueryParamStr,
"status=succeeded",
)),
],
)
.await?;
Ok(())
}
| {
"crate": "test_utils",
"file": null,
"file_size": null,
"is_async": false,
"is_pub": false,
"num_enums": null,
"num_structs": null,
"num_tables": null,
"score": 2,
"total_crates": null
} |
fn_clm_test_utils_get_connector_name_-606391733409404698 | clm | function | // Repository: hyperswitch
// Crate: test_utils
// Module: crates/test_utils/tests/connectors/airwallex_ui
// Implementation of AirwallexSeleniumTest for SeleniumTest
fn get_connector_name(&self) -> String {
"airwallex".to_string()
}
| {
"crate": "test_utils",
"file": null,
"file_size": null,
"is_async": false,
"is_pub": false,
"num_enums": null,
"num_structs": null,
"num_tables": null,
"score": 28,
"total_crates": null
} |
fn_clm_test_utils_should_make_airwallex_gpay_payment_-606391733409404698 | clm | function | // Repository: hyperswitch
// Crate: test_utils
// Module: crates/test_utils/tests/connectors/airwallex_ui
async fn should_make_airwallex_gpay_payment(web_driver: WebDriver) -> Result<(), WebDriverError> {
let conn = AirwallexSeleniumTest {};
let merchant_name = conn
.get_configs()
.automation_configs
.unwrap()
.airwallex_merchant_name
.unwrap();
conn.make_gpay_payment(web_driver,
&format!("{CHECKOUT_BASE_URL}/gpay?gatewayname=airwallex&gatewaymerchantid={merchant_name}&amount=70.00&country=US¤cy=USD"),
vec![
Event::Trigger(Trigger::Query(By::ClassName("title"))),
Event::Assert(Assert::Eq(Selector::Title, "Airwallex - Create 3D Secure Payment")),
Event::Trigger(Trigger::SendKeys(By::Id("challengeDataEntry"), "1234")),
Event::Trigger(Trigger::Click(By::Id("submit"))),
Event::Assert(Assert::IsPresent("succeeded")),
]).await?;
Ok(())
}
| {
"crate": "test_utils",
"file": null,
"file_size": null,
"is_async": false,
"is_pub": false,
"num_enums": null,
"num_structs": null,
"num_tables": null,
"score": 4,
"total_crates": null
} |
fn_clm_test_utils_should_make_airwallex_3ds_payment_-606391733409404698 | clm | function | // Repository: hyperswitch
// Crate: test_utils
// Module: crates/test_utils/tests/connectors/airwallex_ui
async fn should_make_airwallex_3ds_payment(web_driver: WebDriver) -> Result<(), WebDriverError> {
let conn = AirwallexSeleniumTest {};
conn.make_redirection_payment(
web_driver,
vec![
Event::Trigger(Trigger::Goto(&format!("{CHECKOUT_BASE_URL}/saved/85"))),
Event::Trigger(Trigger::Click(By::Id("card-submit-btn"))),
Event::Trigger(Trigger::Query(By::ClassName("title"))),
Event::Assert(Assert::Eq(
Selector::Title,
"Airwallex - Create 3D Secure Payment",
)),
Event::Trigger(Trigger::SendKeys(By::Id("challengeDataEntry"), "1234")),
Event::Trigger(Trigger::Click(By::Id("submit"))),
Event::Assert(Assert::IsPresent("Google")),
Event::Assert(Assert::Contains(
Selector::QueryParamStr,
"status=succeeded",
)),
],
)
.await?;
Ok(())
}
| {
"crate": "test_utils",
"file": null,
"file_size": null,
"is_async": false,
"is_pub": false,
"num_enums": null,
"num_structs": null,
"num_tables": null,
"score": 2,
"total_crates": null
} |
fn_clm_test_utils_should_make_airwallex_3ds_payment_test_-606391733409404698 | clm | function | // Repository: hyperswitch
// Crate: test_utils
// Module: crates/test_utils/tests/connectors/airwallex_ui
fn should_make_airwallex_3ds_payment_test() {
tester!(should_make_airwallex_3ds_payment);
}
| {
"crate": "test_utils",
"file": null,
"file_size": null,
"is_async": false,
"is_pub": false,
"num_enums": null,
"num_structs": null,
"num_tables": null,
"score": 0,
"total_crates": null
} |
fn_clm_test_utils_should_make_airwallex_gpay_payment_test_-606391733409404698 | clm | function | // Repository: hyperswitch
// Crate: test_utils
// Module: crates/test_utils/tests/connectors/airwallex_ui
fn should_make_airwallex_gpay_payment_test() {
tester!(should_make_airwallex_gpay_payment);
}
| {
"crate": "test_utils",
"file": null,
"file_size": null,
"is_async": false,
"is_pub": false,
"num_enums": null,
"num_structs": null,
"num_tables": null,
"score": 0,
"total_crates": null
} |
fn_clm_test_utils_get_connector_name_7608519598242126204 | clm | function | // Repository: hyperswitch
// Crate: test_utils
// Module: crates/test_utils/tests/connectors/bambora_ui
// Implementation of BamboraSeleniumTest for SeleniumTest
fn get_connector_name(&self) -> String {
"bambora".to_string()
}
| {
"crate": "test_utils",
"file": null,
"file_size": null,
"is_async": false,
"is_pub": false,
"num_enums": null,
"num_structs": null,
"num_tables": null,
"score": 28,
"total_crates": null
} |
fn_clm_test_utils_should_make_3ds_payment_7608519598242126204 | clm | function | // Repository: hyperswitch
// Crate: test_utils
// Module: crates/test_utils/tests/connectors/bambora_ui
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(())
}
| {
"crate": "test_utils",
"file": null,
"file_size": null,
"is_async": false,
"is_pub": false,
"num_enums": null,
"num_structs": null,
"num_tables": null,
"score": 2,
"total_crates": null
} |
fn_clm_test_utils_should_make_3ds_payment_test_7608519598242126204 | clm | function | // Repository: hyperswitch
// Crate: test_utils
// Module: crates/test_utils/tests/connectors/bambora_ui
fn should_make_3ds_payment_test() {
tester!(should_make_3ds_payment);
}
| {
"crate": "test_utils",
"file": null,
"file_size": null,
"is_async": false,
"is_pub": false,
"num_enums": null,
"num_structs": null,
"num_tables": null,
"score": 0,
"total_crates": null
} |
fn_clm_test_utils_get_connector_name_7139485711615875695 | clm | function | // Repository: hyperswitch
// Crate: test_utils
// Module: crates/test_utils/tests/connectors/authorizedotnet_wh_ui
// Implementation of AuthorizedotnetSeleniumTest for SeleniumTest
fn get_connector_name(&self) -> String {
"authorizedotnet".to_string()
}
| {
"crate": "test_utils",
"file": null,
"file_size": null,
"is_async": false,
"is_pub": false,
"num_enums": null,
"num_structs": null,
"num_tables": null,
"score": 28,
"total_crates": null
} |
fn_clm_test_utils_should_make_webhook_7139485711615875695 | clm | function | // Repository: hyperswitch
// Crate: test_utils
// Module: crates/test_utils/tests/connectors/authorizedotnet_wh_ui
async fn should_make_webhook(web_driver: WebDriver) -> Result<(), WebDriverError> {
let conn = AuthorizedotnetSeleniumTest {};
let amount = rand::thread_rng().gen_range(50..1000); //This connector detects it as fraudulent payment if the same amount is used for multiple payments so random amount is passed for testing(
conn.make_webhook_test(
web_driver,
&format!("{CHECKOUT_BASE_URL}/saved/227?amount={amount}"),
vec![
Event::Trigger(Trigger::Click(By::Id("card-submit-btn"))),
Event::Assert(Assert::IsPresent("status")),
Event::Assert(Assert::IsPresent("processing")),
],
10,
"processing",
)
.await?;
Ok(())
}
| {
"crate": "test_utils",
"file": null,
"file_size": null,
"is_async": false,
"is_pub": false,
"num_enums": null,
"num_structs": null,
"num_tables": null,
"score": 6,
"total_crates": null
} |
fn_clm_test_utils_should_make_webhook_test_7139485711615875695 | clm | function | // Repository: hyperswitch
// Crate: test_utils
// Module: crates/test_utils/tests/connectors/authorizedotnet_wh_ui
fn should_make_webhook_test() {
tester!(should_make_webhook);
}
| {
"crate": "test_utils",
"file": null,
"file_size": null,
"is_async": false,
"is_pub": false,
"num_enums": null,
"num_structs": null,
"num_tables": null,
"score": 0,
"total_crates": null
} |
fn_clm_test_utils_get_connector_name_-9175647799858222266 | clm | function | // Repository: hyperswitch
// Crate: test_utils
// Module: crates/test_utils/tests/connectors/zen_ui
// Implementation of ZenSeleniumTest for SeleniumTest
fn get_connector_name(&self) -> String {
"zen".to_string()
}
| {
"crate": "test_utils",
"file": null,
"file_size": null,
"is_async": false,
"is_pub": false,
"num_enums": null,
"num_structs": null,
"num_tables": null,
"score": 28,
"total_crates": null
} |
fn_clm_test_utils_should_make_zen_3ds_payment_-9175647799858222266 | clm | function | // Repository: hyperswitch
// Crate: test_utils
// Module: crates/test_utils/tests/connectors/zen_ui
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(())
}
| {
"crate": "test_utils",
"file": null,
"file_size": null,
"is_async": false,
"is_pub": false,
"num_enums": null,
"num_structs": null,
"num_tables": null,
"score": 2,
"total_crates": null
} |
fn_clm_test_utils_should_make_zen_3ds_payment_test_-9175647799858222266 | clm | function | // Repository: hyperswitch
// Crate: test_utils
// Module: crates/test_utils/tests/connectors/zen_ui
fn should_make_zen_3ds_payment_test() {
tester!(should_make_zen_3ds_payment);
}
| {
"crate": "test_utils",
"file": null,
"file_size": null,
"is_async": false,
"is_pub": false,
"num_enums": null,
"num_structs": null,
"num_tables": null,
"score": 0,
"total_crates": null
} |
fn_clm_test_utils_get_connector_name_7616796182318303785 | clm | function | // Repository: hyperswitch
// Crate: test_utils
// Module: crates/test_utils/tests/connectors/bluesnap_wh_ui
// Implementation of BluesnapSeleniumTest for SeleniumTest
fn get_connector_name(&self) -> String {
"bluesnap".to_string()
}
| {
"crate": "test_utils",
"file": null,
"file_size": null,
"is_async": false,
"is_pub": false,
"num_enums": null,
"num_structs": null,
"num_tables": null,
"score": 28,
"total_crates": null
} |
fn_clm_test_utils_should_make_webhook_7616796182318303785 | clm | function | // Repository: hyperswitch
// Crate: test_utils
// Module: crates/test_utils/tests/connectors/bluesnap_wh_ui
async fn should_make_webhook(web_driver: WebDriver) -> Result<(), WebDriverError> {
let conn = BluesnapSeleniumTest {};
conn.make_webhook_test(
web_driver,
&format!("{CHECKOUT_BASE_URL}/saved/199"),
vec![
Event::Trigger(Trigger::Click(By::Id("card-submit-btn"))),
Event::Assert(Assert::IsPresent("succeeded")),
],
10,
"succeeded",
)
.await?;
Ok(())
}
| {
"crate": "test_utils",
"file": null,
"file_size": null,
"is_async": false,
"is_pub": false,
"num_enums": null,
"num_structs": null,
"num_tables": null,
"score": 2,
"total_crates": null
} |
fn_clm_test_utils_should_make_webhook_test_7616796182318303785 | clm | function | // Repository: hyperswitch
// Crate: test_utils
// Module: crates/test_utils/tests/connectors/bluesnap_wh_ui
fn should_make_webhook_test() {
tester!(should_make_webhook);
}
| {
"crate": "test_utils",
"file": null,
"file_size": null,
"is_async": false,
"is_pub": false,
"num_enums": null,
"num_structs": null,
"num_tables": null,
"score": 0,
"total_crates": null
} |
fn_clm_test_utils_get_connector_name_-7791938675623916858 | clm | function | // Repository: hyperswitch
// Crate: test_utils
// Module: crates/test_utils/tests/connectors/noon_ui
// Implementation of NoonSeleniumTest for SeleniumTest
fn get_connector_name(&self) -> String {
"noon".to_string()
}
| {
"crate": "test_utils",
"file": null,
"file_size": null,
"is_async": false,
"is_pub": false,
"num_enums": null,
"num_structs": null,
"num_tables": null,
"score": 28,
"total_crates": null
} |
fn_clm_test_utils_should_make_noon_3ds_payment_-7791938675623916858 | clm | function | // Repository: hyperswitch
// Crate: test_utils
// Module: crates/test_utils/tests/connectors/noon_ui
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(())
}
| {
"crate": "test_utils",
"file": null,
"file_size": null,
"is_async": false,
"is_pub": false,
"num_enums": null,
"num_structs": null,
"num_tables": null,
"score": 2,
"total_crates": null
} |
fn_clm_test_utils_should_make_noon_3ds_mandate_payment_-7791938675623916858 | clm | function | // Repository: hyperswitch
// Crate: test_utils
// Module: crates/test_utils/tests/connectors/noon_ui
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(())
}
| {
"crate": "test_utils",
"file": null,
"file_size": null,
"is_async": false,
"is_pub": false,
"num_enums": null,
"num_structs": null,
"num_tables": null,
"score": 2,
"total_crates": null
} |
fn_clm_test_utils_should_make_noon_non_3ds_mandate_payment_-7791938675623916858 | clm | function | // Repository: hyperswitch
// Crate: test_utils
// Module: crates/test_utils/tests/connectors/noon_ui
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(())
}
| {
"crate": "test_utils",
"file": null,
"file_size": null,
"is_async": false,
"is_pub": false,
"num_enums": null,
"num_structs": null,
"num_tables": null,
"score": 2,
"total_crates": null
} |
fn_clm_test_utils_should_make_noon_3ds_payment_test_-7791938675623916858 | clm | function | // Repository: hyperswitch
// Crate: test_utils
// Module: crates/test_utils/tests/connectors/noon_ui
fn should_make_noon_3ds_payment_test() {
tester!(should_make_noon_3ds_payment);
}
| {
"crate": "test_utils",
"file": null,
"file_size": null,
"is_async": false,
"is_pub": false,
"num_enums": null,
"num_structs": null,
"num_tables": null,
"score": 0,
"total_crates": null
} |
fn_clm_test_utils_get_connector_name_8881165102422017224 | clm | function | // Repository: hyperswitch
// Crate: test_utils
// Module: crates/test_utils/tests/connectors/worldline_ui
// Implementation of WorldlineSeleniumTest for SeleniumTest
fn get_connector_name(&self) -> String {
"worldline".to_string()
}
| {
"crate": "test_utils",
"file": null,
"file_size": null,
"is_async": false,
"is_pub": false,
"num_enums": null,
"num_structs": null,
"num_tables": null,
"score": 28,
"total_crates": null
} |
fn_clm_test_utils_should_make_card_non_3ds_payment_8881165102422017224 | clm | function | // Repository: hyperswitch
// Crate: test_utils
// Module: crates/test_utils/tests/connectors/worldline_ui
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(())
}
| {
"crate": "test_utils",
"file": null,
"file_size": null,
"is_async": false,
"is_pub": false,
"num_enums": null,
"num_structs": null,
"num_tables": null,
"score": 2,
"total_crates": null
} |
fn_clm_test_utils_should_make_worldline_ideal_redirect_payment_8881165102422017224 | clm | function | // Repository: hyperswitch
// Crate: test_utils
// Module: crates/test_utils/tests/connectors/worldline_ui
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(())
}
| {
"crate": "test_utils",
"file": null,
"file_size": null,
"is_async": false,
"is_pub": false,
"num_enums": null,
"num_structs": null,
"num_tables": null,
"score": 2,
"total_crates": null
} |
fn_clm_test_utils_should_make_worldline_giropay_redirect_payment_8881165102422017224 | clm | function | // Repository: hyperswitch
// Crate: test_utils
// Module: crates/test_utils/tests/connectors/worldline_ui
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(())
}
| {
"crate": "test_utils",
"file": null,
"file_size": null,
"is_async": false,
"is_pub": false,
"num_enums": null,
"num_structs": null,
"num_tables": null,
"score": 2,
"total_crates": null
} |
fn_clm_test_utils_should_make_worldline_giropay_redirect_payment_test_8881165102422017224 | clm | function | // Repository: hyperswitch
// Crate: test_utils
// Module: crates/test_utils/tests/connectors/worldline_ui
fn should_make_worldline_giropay_redirect_payment_test() {
tester!(should_make_worldline_giropay_redirect_payment);
}
| {
"crate": "test_utils",
"file": null,
"file_size": null,
"is_async": false,
"is_pub": false,
"num_enums": null,
"num_structs": null,
"num_tables": null,
"score": 0,
"total_crates": null
} |
fn_clm_test_utils_get_connector_name_-7236745121802367840 | clm | function | // Repository: hyperswitch
// Crate: test_utils
// Module: crates/test_utils/tests/connectors/adyen_uk_ui
// Implementation of AdyenSeleniumTest for SeleniumTest
fn get_connector_name(&self) -> String {
"adyen_uk".to_string()
}
| {
"crate": "test_utils",
"file": null,
"file_size": null,
"is_async": false,
"is_pub": false,
"num_enums": null,
"num_structs": null,
"num_tables": null,
"score": 28,
"total_crates": null
} |
fn_clm_test_utils_hould_make_adyen_bancontact_card_payment(_-7236745121802367840 | clm | function | // Repository: hyperswitch
// Crate: test_utils
// Module: crates/test_utils/tests/connectors/adyen_uk_ui
sync fn should_make_adyen_bancontact_card_payment(
web_driver: WebDriver,
) -> Result<(), WebDriverError> {
let conn = AdyenSeleniumTest {};
let user = &conn
.get_configs()
.automation_configs
.unwrap()
.adyen_bancontact_username
.unwrap();
let pass = &conn
.get_configs()
.automation_configs
.unwrap()
.adyen_bancontact_pass
.unwrap();
conn.make_redirection_payment(
web_driver,
vec![
Event::Trigger(Trigger::Goto(&format!("{CHECKOUT_BASE_URL}/saved/68"))),
Event::Trigger(Trigger::Click(By::Id("card-submit-btn"))),
Event::Trigger(Trigger::SendKeys(By::Id("username"), user)),
Event::Trigger(Trigger::SendKeys(By::Id("password"), pass)),
Event::Trigger(Trigger::Click(By::ClassName("button"))),
Event::Trigger(Trigger::Sleep(2)),
Event::Assert(Assert::IsPresent("succeeded")),
],
)
.await?;
Ok(())
}
| {
"crate": "test_utils",
"file": null,
"file_size": null,
"is_async": false,
"is_pub": false,
"num_enums": null,
"num_structs": null,
"num_tables": null,
"score": 16,
"total_crates": null
} |
fn_clm_test_utils_should_make_adyen_klarna_mandate_payment_-7236745121802367840 | clm | function | // Repository: hyperswitch
// Crate: test_utils
// Module: crates/test_utils/tests/connectors/adyen_uk_ui
async fn should_make_adyen_klarna_mandate_payment(
web_driver: WebDriver,
) -> Result<(), WebDriverError> {
let conn = AdyenSeleniumTest {};
conn.make_redirection_payment(
web_driver,
vec![
Event::Trigger(Trigger::Goto(&format!("{CHECKOUT_BASE_URL}/saved/195"))),
Event::Trigger(Trigger::Click(By::Id("card-submit-btn"))),
Event::Trigger(Trigger::SwitchFrame(By::Id("klarna-apf-iframe"))),
Event::Trigger(Trigger::Sleep(5)),
Event::Trigger(Trigger::Click(By::Id("signInWithBankId"))),
Event::Assert(Assert::IsPresent("Klart att betala")),
Event::EitherOr(
Assert::IsPresent("Klart att betala"),
vec![Event::Trigger(Trigger::Click(By::Css(
"button[data-testid='confirm-and-pay']",
)))],
vec![
Event::Trigger(Trigger::Click(By::Css(
"button[data-testid='SmoothCheckoutPopUp:skip']",
))),
Event::Trigger(Trigger::Click(By::Css(
"button[data-testid='confirm-and-pay']",
))),
],
),
Event::RunIf(
Assert::IsPresent("Färre klick, snabbare betalning"),
vec![Event::Trigger(Trigger::Click(By::Css(
"button[data-testid='SmoothCheckoutPopUp:enable']",
)))],
),
Event::Trigger(Trigger::SwitchTab(Position::Prev)),
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(())
}
| {
"crate": "test_utils",
"file": null,
"file_size": null,
"is_async": false,
"is_pub": false,
"num_enums": null,
"num_structs": null,
"num_tables": null,
"score": 4,
"total_crates": null
} |
fn_clm_test_utils_hould_make_adyen_alipay_hk_payment(_-7236745121802367840 | clm | function | // Repository: hyperswitch
// Crate: test_utils
// Module: crates/test_utils/tests/connectors/adyen_uk_ui
sync fn should_make_adyen_alipay_hk_payment(web_driver: WebDriver) -> Result<(), WebDriverError> {
let conn = AdyenSeleniumTest {};
conn.make_redirection_payment(
web_driver,
vec![
Event::Trigger(Trigger::Goto(&format!("{CHECKOUT_BASE_URL}/saved/162"))),
Event::Trigger(Trigger::Click(By::Id("card-submit-btn"))),
Event::EitherOr(
Assert::IsPresent("Payment Method Not Available"),
vec![Event::Assert(Assert::IsPresent(
"Please try again or select a different payment method",
))],
vec![
Event::Trigger(Trigger::Click(By::Css("button[value='authorised']"))),
Event::Assert(Assert::Contains(
Selector::QueryParamStr,
"status=succeeded",
)),
],
),
],
)
.await?;
Ok(())
}
| {
"crate": "test_utils",
"file": null,
"file_size": null,
"is_async": false,
"is_pub": false,
"num_enums": null,
"num_structs": null,
"num_tables": null,
"score": 4,
"total_crates": null
} |
fn_clm_test_utils_hould_make_adyen_bizum_payment(_-7236745121802367840 | clm | function | // Repository: hyperswitch
// Crate: test_utils
// Module: crates/test_utils/tests/connectors/adyen_uk_ui
sync fn should_make_adyen_bizum_payment(web_driver: WebDriver) -> Result<(), WebDriverError> {
let conn = AdyenSeleniumTest {};
conn.make_redirection_payment(
web_driver,
vec![
Event::Trigger(Trigger::Goto(&format!("{CHECKOUT_BASE_URL}/saved/186"))),
Event::Trigger(Trigger::Click(By::Id("card-submit-btn"))),
Event::Trigger(Trigger::SendKeys(By::Id("iPhBizInit"), "700000000")),
Event::Trigger(Trigger::Click(By::Id("bBizInit"))),
Event::Trigger(Trigger::Click(By::Css("input.btn.btn-lg.btn-continue"))),
Event::Assert(Assert::IsPresent("Google")),
Event::Assert(Assert::Contains(
Selector::QueryParamStr,
"status=succeeded",
)),
],
)
.await?;
Ok(())
}
| {
"crate": "test_utils",
"file": null,
"file_size": null,
"is_async": false,
"is_pub": false,
"num_enums": null,
"num_structs": null,
"num_tables": null,
"score": 4,
"total_crates": null
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.