private async Task ShouldMakePayPalPayment()
{
var paymentRequest = new PaymentRequest
{
Source = new RequestPayPalSource
{
InvoiceNumber = "CKO00001",
LogoUrl = "https://www.example.com/logo.jpg",
},
Currency = Currency.EUR,
Amount = 100,
};
var paymentResponse = await PreviousApi.PaymentsClient().RequestPayment(paymentRequest);
paymentResponse.ShouldNotBeNull();
paymentResponse.Links["self"].ShouldNotBeNull();
var payment = await PreviousApi.PaymentsClient().GetPaymentDetails(paymentResponse.Id);
payment.ShouldNotBeNull();
payment.Links["self"].ShouldNotBeNull();
payment.Source.ShouldBeOfType(typeof(AlternativePaymentSourceResponse));
var source = (AlternativePaymentSourceResponse)payment.Source;
source.Count.ShouldBePositive();
source.Type().ShouldBe(PaymentSourceType.PayPal);
}
protected async Task <PaymentResponse> MakeCardPayment(bool shouldCapture = false, long amount = 10L,
DateTime?captureOn = null)
{
if (!shouldCapture && captureOn != null)
{
throw new XunitException("CaptureOn was provided but the payment is not set for capture");
}
var requestCardSource = new RequestCardSource
{
Name = TestCardSource.Visa.Name,
Number = TestCardSource.Visa.Number,
ExpiryYear = TestCardSource.Visa.ExpiryYear,
ExpiryMonth = TestCardSource.Visa.ExpiryMonth,
Cvv = TestCardSource.Visa.Cvv,
BillingAddress = GetAddress(),
Phone = GetPhone()
};
var paymentRequest = new PaymentRequest
{
Source = requestCardSource,
Capture = shouldCapture,
Reference = Guid.NewGuid().ToString(),
Amount = amount,
Currency = Currency.GBP,
CaptureOn = captureOn
};
var paymentResponse = await PreviousApi.PaymentsClient().RequestPayment(paymentRequest);
paymentResponse.ShouldNotBeNull();
return(paymentResponse);
}
private async Task ShouldQueryDisputes()
{
var from = DateTime.UtcNow.Subtract(TimeSpan.FromHours(24));
var to = DateTime.Now; // local timezone
var request = new DisputesQueryFilter {
Limit = 250, To = to, From = from
};
var response = await PreviousApi.DisputesClient().Query(request);
response.ShouldNotBeNull();
response.Limit.ShouldBe(250);
response.Skip.ShouldNotBeNull();
response.TotalCount.ShouldNotBeNull();
response.To.ShouldNotBeNull();
response.From.ShouldNotBeNull();
if (response.TotalCount > 0)
{
var dispute = response.Data[0];
var disputeDetails = await PreviousApi.DisputesClient().GetDisputeDetails(dispute.Id);
disputeDetails.ShouldNotBeNull();
disputeDetails.Id.ShouldBe(dispute.Id);
disputeDetails.Category.ShouldBe(dispute.Category);
disputeDetails.Status.ShouldBe(dispute.Status);
disputeDetails.Amount.ShouldBe(dispute.Amount);
disputeDetails.ReasonCode.ShouldBe(dispute.ReasonCode);
disputeDetails.Payment.ShouldNotBeNull();
disputeDetails.Payment.Id.ShouldBe(dispute.PaymentId);
}
}
private async Task ShouldCreateAndUpdateCustomer()
{
//Create Customer
var request = new CustomerRequest
{
Email = GenerateRandomEmail(),
Name = "Customer",
Phone = new Phone
{
CountryCode = "1",
Number = "4155552671"
}
};
var customerResponse = await PreviousApi.CustomersClient().Create(request);
customerResponse.ShouldNotBeNull();
//Edit Customer
request.Email = GenerateRandomEmail();
request.Name = "Changed Name";
var customerId = customerResponse.Id;
await PreviousApi.CustomersClient().Update(customerId, request);
var customerDetails = await PreviousApi.CustomersClient().Get(customerId);
customerDetails.ShouldNotBeNull();
customerDetails.Email.ShouldBe(request.Email);
customerDetails.Name.ShouldBe(request.Name);
}
private async Task ShouldCreateAndGetHostedPayment()
{
var hostedPaymentRequest = CreateHostedPaymentRequest("ORD-123A");
var createResponse = await PreviousApi.HostedPaymentsClient().CreateHostedPaymentsPageSession(hostedPaymentRequest);
createResponse.ShouldNotBeNull();
createResponse.Id.ShouldNotBeNullOrEmpty();
createResponse.Reference.ShouldNotBeNullOrEmpty();
createResponse.Links.ShouldNotBeNull();
createResponse.Links.ContainsKey("redirect").ShouldBeTrue();
var getResponse = await PreviousApi.HostedPaymentsClient().GetHostedPaymentsPageDetails(createResponse.Id);
getResponse.ShouldNotBeNull();
getResponse.Id.ShouldNotBeNullOrEmpty();
getResponse.Reference.ShouldNotBeNullOrEmpty();
getResponse.Status.ShouldBe(HostedPaymentStatus.PaymentPending);
getResponse.Amount.ShouldNotBeNull();
getResponse.Billing.ShouldNotBeNull();
getResponse.Currency.ShouldBe(Currency.GBP);
getResponse.Customer.ShouldNotBeNull();
getResponse.Description.ShouldNotBeNullOrEmpty();
getResponse.FailureUrl.ShouldNotBeNull();
getResponse.SuccessUrl.ShouldNotBeNull();
getResponse.CancelUrl.ShouldNotBeNullOrEmpty();
getResponse.Links.Count.ShouldBe(2);
getResponse.Products.Count.ShouldBe(1);
}
private async Task ShouldCreateAndUpdateInstrument()
{
var createInstrumentResponse = await CreateTokenInstrument();
var updateInstrumentRequest = new UpdateInstrumentRequest
{
Name = "New Name",
ExpiryMonth = 12,
ExpiryYear = 2026,
};
var update = await PreviousApi.InstrumentsClient().Update(createInstrumentResponse.Id, updateInstrumentRequest);
update.ShouldNotBeNull();
update.HttpStatusCode.ShouldNotBeNull();
update.ResponseHeaders.ShouldNotBeNull();
update.Body.ShouldNotBeNull();
var retrieveInstrumentResponse = await PreviousApi.InstrumentsClient().Get(createInstrumentResponse.Id);
retrieveInstrumentResponse.ShouldNotBeNull();
retrieveInstrumentResponse.Name.ShouldBe("New Name");
retrieveInstrumentResponse.ExpiryMonth.ShouldBe(12);
retrieveInstrumentResponse.ExpiryYear.ShouldBe(2026);
}
private async Task ShouldMakeQPayPayment()
{
var paymentRequest = new PaymentRequest
{
Source = new RequestQPaySource
{
Quantity = 1,
Description = "QPay Demo Payment",
Language = "en",
NationalId = "070AYY010BU234M"
},
Currency = Currency.QAR,
Amount = 100,
};
var paymentResponse = await PreviousApi.PaymentsClient().RequestPayment(paymentRequest);
paymentResponse.ShouldNotBeNull();
paymentResponse.Status.ShouldBe(PaymentStatus.Pending);
paymentResponse.Links["self"].ShouldNotBeNull();
paymentResponse.Links["redirect"].ShouldNotBeNull();
var payment = await PreviousApi.PaymentsClient().GetPaymentDetails(paymentResponse.Id);
payment.ShouldNotBeNull();
payment.Status.ShouldBe(PaymentStatus.Pending);
payment.Links["self"].ShouldNotBeNull();
payment.Source.ShouldBeOfType(typeof(AlternativePaymentSourceResponse));
var source = (AlternativePaymentSourceResponse)payment.Source;
source.Count.ShouldBePositive();
source.Type().ShouldBe(PaymentSourceType.QPay);
}
private async Task ShouldCreateAndGetKlarnaSession()
{
var creditSessionRequest = new CreditSessionRequest()
{
PurchaseCountry = CountryCode.GB,
Currency = Currency.GBP,
Locale = "en-GB",
Amount = 1000,
TaxAmount = 1,
Products = new List <KlarnaProduct>()
{
new KlarnaProduct()
{
Name = "Brown leather belt",
Quantity = 1,
UnitPrice = 1000,
TaxRate = 0,
TotalAmount = 1000,
TotalTaxAmount = 0
}
}
};
var creditSessionResponse = await PreviousApi.KlarnaClient().CreateCreditSession(creditSessionRequest);
creditSessionResponse.ShouldNotBeNull();
creditSessionResponse.SessionId.ShouldNotBeNullOrEmpty();
creditSessionResponse.ClientToken.ShouldNotBeNullOrEmpty();
creditSessionResponse.PaymentMethodCategories.ShouldNotBeNull();
//creditSessionResponse.PaymentMethodCategories.Count.ShouldBePositive();
foreach (var paymentMethodCategory in creditSessionResponse.PaymentMethodCategories)
{
paymentMethodCategory.Name.ShouldNotBeNullOrEmpty();
paymentMethodCategory.Identifier.ShouldNotBeNullOrEmpty();
paymentMethodCategory.AssetUrls.ShouldNotBeNull();
paymentMethodCategory.AssetUrls.Descriptive.ShouldNotBeNullOrEmpty();
paymentMethodCategory.AssetUrls.Standard.ShouldNotBeNullOrEmpty();
}
var creditSession = await PreviousApi.KlarnaClient().GetCreditSession(creditSessionResponse.SessionId);
creditSession.ShouldNotBeNull();
creditSession.ClientToken.ShouldNotBeNullOrEmpty();
creditSession.PurchaseCountry.ShouldNotBeNull();
creditSession.Currency.ShouldNotBeNull();
creditSession.Locale.ShouldNotBeNull();
creditSession.Amount.ShouldNotBeNull();
creditSession.TaxAmount.ShouldNotBeNull();
creditSession.Products.ShouldNotBeNull();
foreach (var creditSessionProduct in creditSession.Products)
{
creditSessionProduct.Name.ShouldNotBeNullOrEmpty();
creditSessionProduct.Quantity.ShouldNotBeNull();
creditSessionProduct.UnitPrice.ShouldNotBeNull();
creditSessionProduct.TaxRate.ShouldNotBeNull();
creditSessionProduct.TotalAmount.ShouldNotBeNull();
creditSessionProduct.TotalTaxAmount.ShouldNotBeNull();
}
}
private async Task ShouldMakePoliPayment()
{
var paymentRequest = new PaymentRequest
{
Source = new RequestPoliSource(),
Currency = Currency.AUD,
Amount = 100,
};
var paymentResponse = await PreviousApi.PaymentsClient().RequestPayment(paymentRequest);
paymentResponse.ShouldNotBeNull();
paymentResponse.Status.ShouldBe(PaymentStatus.Declined);
paymentResponse.Links["self"].ShouldNotBeNull();
var payment = await PreviousApi.PaymentsClient().GetPaymentDetails(paymentResponse.Id);
payment.ShouldNotBeNull();
payment.Status.ShouldBe(PaymentStatus.Declined);
payment.Links["self"].ShouldNotBeNull();
payment.Source.ShouldBeOfType(typeof(AlternativePaymentSourceResponse));
var source = (AlternativePaymentSourceResponse)payment.Source;
source.Count.ShouldBePositive();
source.Type().ShouldBe(PaymentSourceType.Poli);
}
private async Task ShouldMakeBancontactPayment()
{
var paymentRequest = new PaymentRequest
{
Source = new RequestBancontactSource
{
PaymentCountry = CountryCode.BE,
AccountHolderName = "Bruce Wayne",
BillingDescriptor = "CKO Demo - bancontact",
},
Currency = Currency.EUR,
Amount = 100,
};
var paymentResponse = await PreviousApi.PaymentsClient().RequestPayment(paymentRequest);
paymentResponse.ShouldNotBeNull();
paymentResponse.Status.ShouldBe(PaymentStatus.Pending);
paymentResponse.Links["self"].ShouldNotBeNull();
paymentResponse.Links["redirect"].ShouldNotBeNull();
var payment = await PreviousApi.PaymentsClient().GetPaymentDetails(paymentResponse.Id);
payment.ShouldNotBeNull();
payment.Status.ShouldBe(PaymentStatus.Pending);
payment.Links["self"].ShouldNotBeNull();
payment.Source.ShouldBeOfType(typeof(AlternativePaymentSourceResponse));
var source = (AlternativePaymentSourceResponse)payment.Source;
source.Count.ShouldBePositive();
source.Type().ShouldBe(PaymentSourceType.Bancontact);
}
private async Task ShouldMakePrzelewy24Payment()
{
var paymentRequest = new PaymentRequest
{
Source = new RequestP24Source
{
PaymentCountry = CountryCode.PL,
AccountHolderName = "Bruce Wayne",
AccountHolderEmail = "*****@*****.**",
BillingDescriptor = "P24 Demo Payment"
},
Currency = Currency.PLN,
Amount = 100,
};
var paymentResponse = await PreviousApi.PaymentsClient().RequestPayment(paymentRequest);
paymentResponse.ShouldNotBeNull();
paymentResponse.Status.ShouldBe(PaymentStatus.Pending);
paymentResponse.Links["self"].ShouldNotBeNull();
paymentResponse.Links["redirect"].ShouldNotBeNull();
var payment = await PreviousApi.PaymentsClient().GetPaymentDetails(paymentResponse.Id);
payment.ShouldNotBeNull();
payment.Status.ShouldBe(PaymentStatus.Pending);
payment.Links["self"].ShouldNotBeNull();
payment.Source.ShouldBeOfType(typeof(AlternativePaymentSourceResponse));
var source = (AlternativePaymentSourceResponse)payment.Source;
source.Count.ShouldBePositive();
source.Type().ShouldBe(PaymentSourceType.Przelewy24);
}
private async Task ShouldRetrieveDefaultEventTypes()
{
var allEventTypesWrapper = await PreviousApi.EventsClient().RetrieveAllEventTypes();
var allEventTypes = allEventTypesWrapper.Items;
allEventTypes.ShouldNotBeNull();
allEventTypes.Count.ShouldBe(2);
allEventTypes[0].EventTypes.ShouldNotBeNull();
var versionOneEventTypesWrap = await PreviousApi.EventsClient().RetrieveAllEventTypes(allEventTypes[0].Version);
var versionOneEventTypes = versionOneEventTypesWrap.Items;
versionOneEventTypes.ShouldNotBeNull();
versionOneEventTypes.Count.ShouldBe(1);
versionOneEventTypes[0].Version.ShouldBe(allEventTypes[0].Version);
versionOneEventTypes[0].EventTypes.Count.ShouldBe(allEventTypes[0].EventTypes.Count);
var versionTwoEventTypesWrap = await PreviousApi.EventsClient().RetrieveAllEventTypes(allEventTypes[1].Version);
var versionTwoEventTypes = versionTwoEventTypesWrap.Items;
versionTwoEventTypes.ShouldNotBeNull();
versionTwoEventTypes.Count.ShouldBe(1);
versionTwoEventTypes[0].Version.ShouldBe(allEventTypes[1].Version);
versionTwoEventTypes[0].EventTypes.Count.ShouldBe(allEventTypes[1].EventTypes.Count);
}
private async Task ShouldMakeKnetPayment()
{
var paymentRequest = new PaymentRequest
{
Source = new RequestKnetSource
{
Language = "en",
},
Currency = Currency.KWD,
Amount = 100,
};
var paymentResponse = await PreviousApi.PaymentsClient().RequestPayment(paymentRequest);
paymentResponse.ShouldNotBeNull();
paymentResponse.Status.ShouldBe(PaymentStatus.Pending);
paymentResponse.Links["self"].ShouldNotBeNull();
paymentResponse.Links["redirect"].ShouldNotBeNull();
var payment = await PreviousApi.PaymentsClient().GetPaymentDetails(paymentResponse.Id);
payment.ShouldNotBeNull();
payment.Status.ShouldBe(PaymentStatus.Pending);
payment.Links["self"].ShouldNotBeNull();
payment.Source.ShouldBeOfType(typeof(AlternativePaymentSourceResponse));
var source = (AlternativePaymentSourceResponse)payment.Source;
source.Count.ShouldBePositive();
source.Type().ShouldBe(PaymentSourceType.KNet);
}
private async Task ShouldMakeBenefitPayPayment()
{
var paymentRequest = new PaymentRequest
{
Source = new RequestBenefitPaySource
{
IntegrationType = "mobile"
},
Currency = Currency.USD,
Amount = 100,
};
var paymentResponse = await PreviousApi.PaymentsClient().RequestPayment(paymentRequest);
paymentResponse.ShouldNotBeNull();
paymentResponse.Status.ShouldBe(PaymentStatus.Pending);
paymentResponse.Links["self"].ShouldNotBeNull();
paymentResponse.Links["redirect"].ShouldNotBeNull();
var payment = await PreviousApi.PaymentsClient().GetPaymentDetails(paymentResponse.Id);
payment.ShouldNotBeNull();
payment.Status.ShouldBe(PaymentStatus.Pending);
payment.Links["self"].ShouldNotBeNull();
payment.Source.ShouldBeOfType(typeof(AlternativePaymentSourceResponse));
var source = (AlternativePaymentSourceResponse)payment.Source;
source.Count.ShouldBePositive();
source.Type().ShouldBe(PaymentSourceType.BenefitPay);
}
private async Task ShouldCreateAndGetCustomer()
{
var request = new CustomerRequest
{
Email = GenerateRandomEmail(),
Name = "Customer",
Phone = new Phone
{
CountryCode = "1",
Number = "4155552671"
}
};
var customerResponse = await PreviousApi.CustomersClient().Create(request);
customerResponse.ShouldNotBeNull();
var customerDetails = await PreviousApi.CustomersClient().Get(customerResponse.Id);
customerDetails.ShouldNotBeNull();
customerDetails.Email.ShouldBe(request.Email);
customerDetails.Name.ShouldBe(request.Name);
customerDetails.Phone.ShouldNotBeNull();
customerDetails.DefaultId.ShouldBeNull();
customerDetails.Instruments.ShouldBeEmpty();
}
private async Task ShouldMakeEpsPayment()
{
var paymentRequest = new PaymentRequest
{
Source = new RequestEpsSource
{
Purpose = "Mens black t-shirt L",
},
Currency = Currency.EUR,
Amount = 100,
};
var paymentResponse = await PreviousApi.PaymentsClient().RequestPayment(paymentRequest);
paymentResponse.ShouldNotBeNull();
paymentResponse.Status.ShouldBe(PaymentStatus.Pending);
paymentResponse.Links["self"].ShouldNotBeNull();
paymentResponse.Links["redirect"].ShouldNotBeNull();
var payment = await PreviousApi.PaymentsClient().GetPaymentDetails(paymentResponse.Id);
payment.ShouldNotBeNull();
payment.Status.ShouldBe(PaymentStatus.Pending);
payment.Links["self"].ShouldNotBeNull();
payment.Source.ShouldBeOfType(typeof(AlternativePaymentSourceResponse));
var source = (AlternativePaymentSourceResponse)payment.Source;
source.Count.ShouldBePositive();
source.Type().ShouldBe(PaymentSourceType.EPS);
}
private async Task ShouldTestFullDisputesWorkflow()
{
//Make the payment
var payment = await MakeCardPayment(true, 1040L);
payment.ShouldNotBeNull();
var query = new DisputesQueryFilter {
PaymentId = payment.Id
};
//Query for dispute
DisputesQueryResponse queryResponse = await Retriable(async() =>
await PreviousApi.DisputesClient().Query(query), HasItems);
queryResponse.ShouldNotBeNull();
queryResponse.Data[0].PaymentId.ShouldBe(payment.Id);
//Upload dispute evidence
const string filePath = "./Resources/checkout.jpeg";
var fileResponse = await PreviousApi.DisputesClient().SubmitFile(filePath, "dispute_evidence");
//Provide dispute evidence
var disputeEvidenceRequest = new DisputeEvidenceRequest
{
ProofOfDeliveryOrServiceFile = fileResponse.Id,
ProofOfDeliveryOrServiceText = "proof of delivery or service text",
InvoiceOrReceiptFile = fileResponse.Id,
InvoiceOrReceiptText = "Copy of the invoice",
CustomerCommunicationFile = fileResponse.Id,
CustomerCommunicationText = "Copy of an email exchange with the cardholder",
AdditionalEvidenceFile = fileResponse.Id,
AdditionalEvidenceText = "Scanned document"
};
var disputeId = queryResponse.Data[0].Id;
var emptyResponse = await PreviousApi.DisputesClient().PutEvidence(disputeId, disputeEvidenceRequest);
emptyResponse.ShouldNotBeNull();
emptyResponse.HttpStatusCode.ShouldNotBeNull();
emptyResponse.ResponseHeaders.ShouldNotBeNull();
//Verify the dispute evidence
var evidence = await PreviousApi.DisputesClient().GetEvidence(disputeId);
evidence.ShouldNotBeNull();
evidence.ProofOfDeliveryOrServiceFile.ShouldBe(disputeEvidenceRequest.ProofOfDeliveryOrServiceFile);
evidence.ProofOfDeliveryOrServiceText.ShouldBe(disputeEvidenceRequest.ProofOfDeliveryOrServiceText);
evidence.InvoiceOrReceiptFile.ShouldBe(disputeEvidenceRequest.InvoiceOrReceiptFile);
evidence.InvoiceOrReceiptText.ShouldBe(disputeEvidenceRequest.InvoiceOrReceiptText);
evidence.CustomerCommunicationFile.ShouldBe(disputeEvidenceRequest.CustomerCommunicationFile);
evidence.CustomerCommunicationText.ShouldBe(disputeEvidenceRequest.CustomerCommunicationText);
evidence.AdditionalEvidenceFile.ShouldBe(disputeEvidenceRequest.AdditionalEvidenceFile);
evidence.AdditionalEvidenceText.ShouldBe(disputeEvidenceRequest.AdditionalEvidenceText);
//Submit the dispute
await PreviousApi.DisputesClient().SubmitEvidence(disputeId);
}
private async Task ShouldGetIssuers()
{
var idealInfo = await PreviousApi.IdealClient().GetIssuers();
idealInfo.ShouldNotBeNull();
idealInfo.GetSelfLink().ShouldNotBeNull();
idealInfo.Countries.ShouldNotBeNull();
idealInfo.Countries.Count.ShouldBePositive();
}
private async Task <WebhookResponse> RegisterWebhook(string url)
{
var webhookRequest = new WebhookRequest()
{
Url = url, ContentType = WebhookContentType.Json, EventTypes = _eventTypes
};
return(await PreviousApi.WebhooksClient().RegisterWebhook(webhookRequest));
}
private async Task <CreateInstrumentResponse> CreateTokenInstrument()
{
var phone = new Phone
{
CountryCode = "44",
Number = "020 222333"
};
var billingAddress = new Address
{
AddressLine1 = "CheckoutSdk.com",
AddressLine2 = "90 Tottenham Court Road",
City = "London",
State = "London",
Zip = "W1T 4TJ",
Country = CountryCode.GB
};
var cardTokenRequest = new CardTokenRequest
{
Name = TestCardSource.Visa.Name,
Number = TestCardSource.Visa.Number,
ExpiryYear = TestCardSource.Visa.ExpiryYear,
ExpiryMonth = TestCardSource.Visa.ExpiryMonth,
Cvv = TestCardSource.Visa.Cvv,
BillingAddress = billingAddress,
Phone = phone
};
var cardTokenResponse = await PreviousApi.TokensClient().Request(cardTokenRequest);
cardTokenResponse.ShouldNotBeNull();
var request = new CreateInstrumentRequest
{
Token = cardTokenResponse.Token,
Customer = new InstrumentCustomerRequest
{
Email = "*****@*****.**",
Name = "Bruce Wayne",
Default = true,
Phone = new Phone
{
CountryCode = "+1",
Number = "4155552671"
}
}
};
var createInstrumentResponse = await PreviousApi.InstrumentsClient().Create(request);
createInstrumentResponse.ShouldNotBeNull();
return(createInstrumentResponse);
}
private async Task ShouldGetPaymentDetails()
{
var paymentResponse = await MakeCardPayment(true);
var payment = await Retriable(async() =>
await PreviousApi.PaymentsClient().GetPaymentDetails(paymentResponse.Id));
payment.Id.ShouldNotBeNullOrEmpty();
payment.PaymentType.ShouldBe(PaymentType.Regular);
payment.RequestedOn.ShouldNotBeNull();
payment.Reference.ShouldNotBeNullOrEmpty();
payment.SchemeId.ShouldNotBeNullOrEmpty();
//payment.Status.ShouldBe(PaymentStatus.Captured);
payment.Amount.ShouldBe(10);
payment.Approved.ShouldBe(true);
payment.Currency.ShouldBe(Currency.GBP);
payment.ThreeDs.ShouldBeNull();
//payment.Eci.ShouldNotBeNullOrEmpty();
//Source
payment.Source.ShouldBeAssignableTo(typeof(ResponseCardSource));
var cardSourcePayment = (ResponseCardSource)payment.Source;
cardSourcePayment.Type().ShouldBe(PaymentSourceType.Card);
cardSourcePayment.Id.ShouldNotBeNullOrEmpty();
cardSourcePayment.AvsCheck.ShouldBe("S");
cardSourcePayment.CvvCheck.ShouldBe("Y");
cardSourcePayment.Bin.ShouldNotBeNull();
//cardSourcePayment.CardCategory.ShouldBe(CardCategory.Consumer);
//cardSourcePayment.CardType.ShouldBe(CardType.Credit);
cardSourcePayment.ExpiryMonth.ShouldNotBeNull();
cardSourcePayment.ExpiryYear.ShouldNotBeNull();
cardSourcePayment.Last4.ShouldNotBeNullOrEmpty();
cardSourcePayment.Scheme.ShouldNotBeNullOrEmpty();
cardSourcePayment.Name.ShouldNotBeNullOrEmpty();
cardSourcePayment.FastFunds.ShouldNotBeNullOrEmpty();
cardSourcePayment.Fingerprint.ShouldNotBeNullOrEmpty();
//cardSourcePayment.Issuer.ShouldNotBeNullOrEmpty();
//cardSourcePayment.IssuerCountry.ShouldBe(CountryCode.US);
cardSourcePayment.Payouts.ShouldBe(true);
//cardSourcePayment.ProductId.ShouldNotBeNullOrEmpty();
//cardSourcePayment.ProductType.ShouldNotBeNullOrEmpty();
//Customer
payment.Customer.ShouldNotBeNull();
payment.Customer.Id.ShouldNotBeNull();
payment.Customer.Name.ShouldNotBeNull();
//Risk
payment.Risk.Flagged.ShouldBe(false);
//Links
payment.GetSelfLink().ShouldNotBeNull();
payment.HasLink("actions").ShouldBeTrue();
//payment.HasLink("capture").ShouldBeFalse();
//payment.HasLink("void").ShouldBeFalse();
//Other
payment.BillingDescriptor.ShouldNotBeNull();
}
private async Task TestRequestPreAuthenticationRiskScan(RiskPaymentRequestSource requestSource)
{
var preAuthenticationAssessmentRequest = new PreAuthenticationAssessmentRequest()
{
Date = DateTime.Now,
Source = requestSource,
Customer = new Common.CustomerRequest()
{
Id = "Id",
Email = GenerateRandomEmail(),
Name = "name"
},
Payment = new RiskPayment()
{
Psp = "CheckoutSdk.com",
Id = "78453878"
},
Shipping = new RiskShippingDetails()
{
Address = new Address()
{
AddressLine1 = "CheckoutSdk.com",
AddressLine2 = "90 Tottenham Court Road",
City = "London",
State = "London",
Zip = "W1T 4TJ",
Country = CountryCode.GB
}
},
Reference = "ORD-1011-87AH",
Description = "Set of 3 masks",
Amount = 6540,
Device = new Device()
{
Ip = "90.197.169.245",
Location = new Location()
{
Longitude = "0.1313",
Latitude = "51.5107"
},
Type = "Phone",
Os = "ISO",
Model = "iPhone X",
Date = DateTime.Now,
}
};
var response = await PreviousApi.RiskClient()
.RequestPreAuthenticationRiskScan(preAuthenticationAssessmentRequest);
response.ShouldNotBeNull();
response.AssessmentId.ShouldNotBeNull();
response.Result.ShouldNotBeNull();
response.Result.Decision.ShouldNotBeNull();
}
private async Task ShouldGetInfo()
{
var idealInfo = await PreviousApi.IdealClient().GetInfo();
idealInfo.ShouldNotBeNull();
idealInfo.Links.ShouldNotBeNull();
idealInfo.Links.Self.ShouldNotBeNull();
idealInfo.Links.Issuers.ShouldNotBeNull();
idealInfo.Links.Curies.ShouldNotBeNull();
idealInfo.Links.Curies.Count.ShouldBePositive();
}
private async Task <WebhookResponse> RegisterWebhook()
{
var webhookRequest = new WebhookRequest()
{
Url = "https://checkout.com/webhooks",
ContentType = WebhookContentType.Json,
EventTypes = _paymentEventTypes
};
return(await PreviousApi.WebhooksClient().RegisterWebhook(webhookRequest));
}
private async Task ShouldCreateAndDeleteInstrument()
{
var createInstrumentResponse = await CreateTokenInstrument();
var emptyResponse = await PreviousApi.InstrumentsClient().Delete(createInstrumentResponse.Id);
emptyResponse.ShouldNotBeNull();
emptyResponse.HttpStatusCode.ShouldNotBeNull();
emptyResponse.ResponseHeaders.ShouldNotBeNull();
await AssertNotFound(PreviousApi.InstrumentsClient().Get(createInstrumentResponse.Id));
}
private async Task ShouldCreatePaymentLink()
{
var address = new Address
{
AddressLine1 = "CheckoutSdk.com",
AddressLine2 = "90 Tottenham Court Road",
City = "London",
State = "London",
Zip = "W1T 4TJ",
Country = CountryCode.GB
};
var paymentLinkRequest = new PaymentLinkRequest
{
Amount = 10,
Billing = new BillingInformation
{
Address = address
},
Capture = true,
CaptureOn = DateTime.Now,
Currency = Currency.GBP,
Customer = new CustomerRequest
{
Id = "Id",
Email = GenerateRandomEmail(),
Name = "name"
},
Description = "description",
ExpiresIn = 1,
Locale = "loc",
Reference = "ORD-123A",
ThreeDs = new ThreeDsRequest
{
Enabled = true,
AttemptN3D = false,
Eci = "05",
Cryptogram = "AgAAAAAAAIR8CQrXcIhbQAAAAAA",
Xid = "MDAwMDAwMDAwMDAwMDAwMzIyNzY=",
Version = "2.0.1",
ChallengeIndicator = ChallengeIndicatorType.NoPreference
},
PaymentType = PaymentType.Regular
};
var response = await PreviousApi.PaymentLinksClient().Create(paymentLinkRequest);
response.ShouldNotBeNull();
response.Id.ShouldNotBeNull();
response.Links.ShouldNotBeNull();
response.Links.Count.ShouldBe(2);
response.Reference.ShouldNotBeNull();
}
private async Task ShouldMakeFawryPayment()
{
var fawrySource = new RequestFawrySource
{
Description = "Fawry Demo Payment",
CustomerEmail = "*****@*****.**",
CustomerMobile = "01058375055",
Products = new List <FawryProduct>
{
new FawryProduct
{
ProductId = "0123456789",
Description = "Fawry Demo Product",
Price = 1000,
Quantity = 1
}
}
};
var paymentRequest = new PaymentRequest
{
Source = fawrySource,
Currency = Currency.EGP,
Amount = 1000,
Capture = true
};
var paymentResponse = await PreviousApi.PaymentsClient().RequestPayment(paymentRequest);
paymentResponse.ShouldNotBeNull();
paymentResponse.Status.ShouldBe(PaymentStatus.Pending);
paymentResponse.ResponseSummary.ShouldBeNull();
paymentResponse.Links["self"].ShouldNotBeNull();
paymentResponse.Links["approve"].ShouldNotBeNull();
paymentResponse.Links["cancel"].ShouldNotBeNull();
var payment = await PreviousApi.PaymentsClient().GetPaymentDetails(paymentResponse.Id);
payment.ShouldNotBeNull();
payment.Status.ShouldBe(PaymentStatus.Pending);
payment.Links["self"].ShouldNotBeNull();
payment.Links["approve"].ShouldNotBeNull();
payment.Links["cancel"].ShouldNotBeNull();
payment.Source.ShouldBeOfType(typeof(AlternativePaymentSourceResponse));
var source = (AlternativePaymentSourceResponse)payment.Source;
source.Count.ShouldBePositive();
source.Type().ShouldBe(PaymentSourceType.Fawry);
}
private async Task ShouldRetrieveEventsByPaymentId_andRetrieveEventById_andGetNotification()
{
var webhook = await RegisterWebhook();
var payment = await MakeCardPayment();
payment.ShouldNotBeNull();
var retrieveEventsRequest = new RetrieveEventsRequest {
PaymentId = payment.Id
};
//Retrieve events
EventsPageResponse events = await Retriable(async() =>
await PreviousApi.EventsClient().RetrieveEvents(retrieveEventsRequest));
events.ShouldNotBeNull();
events.TotalCount.ShouldBe(1);
events.Data.ShouldNotBeNull();
events.Data.Count.ShouldBe(1);
var summaryResponse = events.Data[0];
summaryResponse.Id.ShouldNotBeNull();
summaryResponse.CreatedOn.ShouldNotBeNull();
summaryResponse.Type.ShouldBe("payment_approved");
//Retrieve event
var eventResponse = await PreviousApi.EventsClient().RetrieveEvent(summaryResponse.Id);
eventResponse.ShouldNotBeNull();
eventResponse.Id.ShouldNotBeNull();
eventResponse.Data.ShouldNotBeNull();
eventResponse.Type.ShouldBe("payment_approved");
//Get notification
var eventNotification = await PreviousApi.EventsClient()
.RetrieveEventNotification(eventResponse.Id, eventResponse.Notifications[0].Id);
eventNotification.ShouldNotBeNull();
eventNotification.Id.ShouldNotBeNull();
eventNotification.Url.ShouldNotBeNull();
eventNotification.Success.ShouldNotBeNull();
// Retry Webhooks
// Webhooks are not being re attempted. Adding the call to ensure.
await PreviousApi.EventsClient().RetryWebhook(summaryResponse.Id, webhook.Id);
await PreviousApi.EventsClient().RetryAllWebhooks(summaryResponse.Id);
}
private async Task ShouldGetCustomerDetailsWithInstrument()
{
var cardTokenResponse = await PreviousApi.TokensClient().Request(GetCardTokenRequest());
cardTokenResponse.ShouldNotBeNull();
var request = new CreateInstrumentRequest
{
Token = cardTokenResponse.Token,
Customer = new InstrumentCustomerRequest
{
Email = "*****@*****.**",
Name = "Instrument Customer",
Default = true,
Phone = new Phone
{
CountryCode = "+1",
Number = "4155552671"
}
}
};
var createInstrumentResponse = await PreviousApi.InstrumentsClient().Create(request);
createInstrumentResponse.ShouldNotBeNull();
createInstrumentResponse.Customer.ShouldNotBeNull();
createInstrumentResponse.Customer.Id.ShouldNotBeNullOrEmpty();
CustomerDetailsResponse customerDetailsResponse = await PreviousApi.CustomersClient().Get(createInstrumentResponse.Customer.Id);
customerDetailsResponse.ShouldNotBeNull();
customerDetailsResponse.Instruments.ShouldNotBeNull();
customerDetailsResponse.Instruments.Count.ShouldBe(1);
InstrumentDetails instrumentDetails = customerDetailsResponse.Instruments[0];
createInstrumentResponse.Id.ShouldBe(instrumentDetails.Id);
createInstrumentResponse.Type.ShouldBe(InstrumentType.Card);
createInstrumentResponse.Fingerprint.ShouldBe(instrumentDetails.Fingerprint);
createInstrumentResponse.ExpiryMonth.ShouldBe(instrumentDetails.ExpiryMonth);
createInstrumentResponse.ExpiryYear.ShouldBe(instrumentDetails.ExpiryYear);
createInstrumentResponse.Scheme.ShouldBe(instrumentDetails.Scheme);
createInstrumentResponse.Last4.ShouldBe(instrumentDetails.Last4);
createInstrumentResponse.Bin.ShouldBe(instrumentDetails.Bin);
createInstrumentResponse.CardType.ShouldBe(CardType.Credit);
createInstrumentResponse.Issuer.ShouldBe(instrumentDetails.Issuer);
createInstrumentResponse.IssuerCountry.ShouldNotBeNull();
createInstrumentResponse.ProductId.ShouldBe(instrumentDetails.ProductId);
createInstrumentResponse.ProductType.ShouldBe(instrumentDetails.ProductType);
}
private async Task ShouldRequestCardToken()
{
var phone = new Phone {
CountryCode = "44", Number = "020 222333"
};
var billingAddress = new Address
{
AddressLine1 = "CheckoutSdk.com",
AddressLine2 = "90 Tottenham Court Road",
City = "London",
State = "London",
Zip = "W1T 4TJ",
Country = CountryCode.GB
};
var cardTokenRequest = new CardTokenRequest
{
Name = TestCardSource.Visa.Name,
Number = TestCardSource.Visa.Number,
ExpiryYear = TestCardSource.Visa.ExpiryYear,
ExpiryMonth = TestCardSource.Visa.ExpiryMonth,
Cvv = TestCardSource.Visa.Cvv,
BillingAddress = billingAddress,
Phone = phone
};
var cardTokenResponse = await PreviousApi.TokensClient().Request(cardTokenRequest);
cardTokenResponse.ShouldNotBeNull();
cardTokenResponse.Token.ShouldNotBeNullOrEmpty();
cardTokenResponse.Type.ShouldBe(TokenType.Card);
cardTokenResponse.ExpiryMonth.ShouldBe(cardTokenRequest.ExpiryMonth);
cardTokenResponse.ExpiryYear.ShouldBe(cardTokenRequest.ExpiryYear);
cardTokenResponse.ExpiresOn.ShouldNotBeNull();
cardTokenResponse.BillingAddress.ShouldNotBeNull();
cardTokenResponse.BillingAddress.AddressLine1.ShouldBe(cardTokenRequest.BillingAddress.AddressLine1);
cardTokenResponse.BillingAddress.AddressLine2.ShouldBe(cardTokenResponse.BillingAddress.AddressLine2);
cardTokenResponse.BillingAddress.City.ShouldBe(cardTokenRequest.BillingAddress.City);
cardTokenResponse.BillingAddress.State.ShouldBe(cardTokenRequest.BillingAddress.State);
cardTokenResponse.BillingAddress.Zip.ShouldBe(cardTokenRequest.BillingAddress.Zip);
cardTokenResponse.BillingAddress.Country.ShouldBe(cardTokenRequest.BillingAddress.Country);
cardTokenResponse.Phone.ShouldNotBeNull();
cardTokenResponse.Phone.CountryCode.ShouldBe(cardTokenRequest.Phone.CountryCode);
cardTokenResponse.Phone.Number.ShouldBe(cardTokenRequest.Phone.Number);
//cardTokenResponse.CardType.ShouldBe(CardType.Credit);
//cardTokenResponse.CardCategory.ShouldBe(CardCategory.Consumer);
}
