public void Update_CanUpdateToken()
{
Result <Customer> customerResult = gateway.Customer.Create(new CustomerRequest());
Assert.IsTrue(customerResult.IsSuccess());
var request = new PaymentMethodRequest
{
CustomerId = customerResult.Target.Id,
PaymentMethodNonce = Nonce.PayPalFuturePayment
};
Result <PaymentMethod> result = gateway.PaymentMethod.Create(request);
Assert.IsTrue(result.IsSuccess());
string newToken = Guid.NewGuid().ToString();
var updateRequest = new PayPalAccountRequest
{
Token = newToken
};
var updateResult = gateway.PayPalAccount.Update(result.Target.Token, updateRequest);
Assert.IsTrue(updateResult.IsSuccess());
Assert.AreEqual(newToken, updateResult.Target.Token);
}
//Update Customer on BrainTree with Payment Method Request
public string UpdateCustomerWithNewCardDuplicateCheck(UserCreditCards model)
{
bool DuplicateBool = false;
bool.TryParse(ConfigService.DuplicatePaymentMethod, out DuplicateBool);
bool VerifyBool = false;
bool.TryParse(ConfigService.VerifyCard, out VerifyBool);
PaymentMethodRequest request = new PaymentMethodRequest
{
CustomerId = model.UserId,
PaymentMethodNonce = model.ExternalCardIdNonce,
Options = new PaymentMethodOptionsRequest
{
FailOnDuplicatePaymentMethod = DuplicateBool,
VerifyCard = VerifyBool
},
};
Result <PaymentMethod> result = _Gateway.PaymentMethod.Create(request);
bool isSuccessful = result.IsSuccess();
if (isSuccessful == false)
{
throw new System.ArgumentException(result.Message);
}
return(result.Target.Token);
}
public void Find_FindsUsBankAccountWithToken()
{
Result<Customer> result = gateway.Customer.Create(new CustomerRequest());
Assert.IsTrue(result.IsSuccess());
string nonce = TestHelper.GenerateValidUsBankAccountNonce(gateway);
var request = new PaymentMethodRequest
{
CustomerId = result.Target.Id,
PaymentMethodNonce = nonce
};
Result<PaymentMethod> paymentMethodResult = gateway.PaymentMethod.Create(request);
Assert.IsTrue(paymentMethodResult.IsSuccess());
Assert.IsInstanceOf(typeof(UsBankAccount), paymentMethodResult.Target);
UsBankAccount usBankAccount = (UsBankAccount) paymentMethodResult.Target;
UsBankAccountGateway usBankAccountGateway = new UsBankAccountGateway(gateway);
usBankAccount = usBankAccountGateway.Find(usBankAccount.Token);
Assert.AreEqual("021000021", usBankAccount.RoutingNumber);
Assert.AreEqual("1234", usBankAccount.Last4);
Assert.AreEqual("checking", usBankAccount.AccountType);
Assert.AreEqual("PayPal Checking - 1234", usBankAccount.AccountDescription);
Assert.AreEqual("Dan Schulman", usBankAccount.AccountHolderName);
Assert.IsTrue(Regex.IsMatch(usBankAccount.BankName, ".*CHASE.*"));
}
public void Find_ReturnsPayPalAccountByToken()
{
Result <Customer> customerResult = gateway.Customer.Create(new CustomerRequest());
Assert.IsTrue(customerResult.IsSuccess());
var request = new PaymentMethodRequest
{
CustomerId = customerResult.Target.Id,
PaymentMethodNonce = Nonce.PayPalFuturePayment
};
Result <PaymentMethod> result = gateway.PaymentMethod.Create(request);
Assert.IsTrue(result.IsSuccess());
Assert.IsNotNull(result.Target.ImageUrl);
PayPalAccount found = gateway.PayPalAccount.Find(result.Target.Token);
Assert.IsNotNull(found);
Assert.IsNotNull(found.Email);
Assert.IsNotNull(found.ImageUrl);
Assert.IsNotNull(found.CreatedAt);
Assert.IsNotNull(found.UpdatedAt);
Assert.AreEqual(found.Email, ((PayPalAccount)result.Target).Email);
}
public void Update_UpdatesTheCoinbaseAccount()
{
var customer = gateway.Customer.Create().Target;
PaymentMethodRequest request = new PaymentMethodRequest()
{
CustomerId = customer.Id,
PaymentMethodNonce = Nonce.Coinbase
};
var coinbaseAccount = gateway.PaymentMethod.Create(request).Target;
var updateResult = gateway.PaymentMethod.Update(
coinbaseAccount.Token,
new PaymentMethodRequest
{
Options = new PaymentMethodOptionsRequest {
MakeDefault = true
}
});
Assert.IsTrue(updateResult.IsSuccess());
Assert.That(updateResult.Target, Is.InstanceOf(typeof(CoinbaseAccount)));
var updatedCoinbaseAccount = (CoinbaseAccount)updateResult.Target;
Assert.IsTrue(updatedCoinbaseAccount.IsDefault.Value);
}
public void Create_CreatesVenmoAccountWithNonce()
{
Result <Customer> result = gateway.Customer.Create(new CustomerRequest());
Assert.IsTrue(result.IsSuccess());
var request = new PaymentMethodRequest
{
CustomerId = result.Target.Id,
PaymentMethodNonce = Nonce.VenmoAccount
};
Result <PaymentMethod> paymentMethodResult = gateway.PaymentMethod.Create(request);
Assert.IsTrue(paymentMethodResult.IsSuccess());
VenmoAccount venmoAccount = (VenmoAccount)paymentMethodResult.Target;
Assert.IsNotNull(venmoAccount.Username);
Assert.IsNotNull(venmoAccount.VenmoUserId);
Assert.IsNotNull(venmoAccount.ImageUrl);
Assert.IsNotNull(venmoAccount.SourceDescription);
Assert.IsNotNull(venmoAccount.IsDefault);
Assert.IsNotNull(venmoAccount.CreatedAt);
Assert.IsNotNull(venmoAccount.UpdatedAt);
Assert.IsNotNull(venmoAccount.CustomerId);
Assert.IsNotNull(venmoAccount.Subscriptions);
}
public void Create_CanMakeDefaultAndSetToken()
{
Result <Customer> customerResult = gateway.Customer.Create(new CustomerRequest());
Assert.IsTrue(customerResult.IsSuccess());
var creditCardRequest = new CreditCardRequest
{
CustomerId = customerResult.Target.Id,
Number = "5105105105105100",
ExpirationDate = "05/12"
};
CreditCard creditCard = gateway.CreditCard.Create(creditCardRequest).Target;
Assert.IsTrue(creditCard.IsDefault.Value);
string nonce = TestHelper.GenerateUnlockedNonce(gateway);
Random random = new Random();
int randomNumber = random.Next(0, 10000);
var token = "token_" + randomNumber;
var request = new PaymentMethodRequest
{
CustomerId = customerResult.Target.Id,
PaymentMethodNonce = nonce,
Token = token,
Options = new PaymentMethodOptionsRequest
{
MakeDefault = true
}
};
Result <PaymentMethod> paymentMethodResult = gateway.PaymentMethod.Create(request);
Assert.IsTrue(paymentMethodResult.IsSuccess());
Assert.IsTrue(paymentMethodResult.Target.IsDefault.Value);
Assert.AreEqual(token, paymentMethodResult.Target.Token);
}
public void Create_CreatesAmexExpressCheckoutCardWithNonce()
{
Result <Customer> result = gateway.Customer.Create(new CustomerRequest());
Assert.IsTrue(result.IsSuccess());
var request = new PaymentMethodRequest
{
CustomerId = result.Target.Id,
PaymentMethodNonce = Nonce.AmexExpressCheckout
};
Result <PaymentMethod> paymentMethodResult = gateway.PaymentMethod.Create(request);
Assert.IsTrue(paymentMethodResult.IsSuccess());
Assert.IsNotNull(paymentMethodResult.Target.Token);
Assert.IsNotNull(paymentMethodResult.Target.ImageUrl);
Assert.IsInstanceOf(typeof(AmexExpressCheckoutCard), paymentMethodResult.Target);
AmexExpressCheckoutCard amexExpressCheckoutCard = (AmexExpressCheckoutCard)paymentMethodResult.Target;
Assert.IsNotNull(amexExpressCheckoutCard.CardType);
Assert.IsNotNull(amexExpressCheckoutCard.Bin);
Assert.IsNotNull(amexExpressCheckoutCard.ExpirationMonth);
Assert.IsNotNull(amexExpressCheckoutCard.ExpirationYear);
Assert.IsNotNull(amexExpressCheckoutCard.CardMemberNumber);
Assert.IsNotNull(amexExpressCheckoutCard.CardMemberExpiryDate);
Assert.IsNotNull(amexExpressCheckoutCard.ImageUrl);
Assert.IsNotNull(amexExpressCheckoutCard.SourceDescription);
Assert.IsNotNull(amexExpressCheckoutCard.IsDefault);
Assert.IsNotNull(amexExpressCheckoutCard.CreatedAt);
Assert.IsNotNull(amexExpressCheckoutCard.UpdatedAt);
Assert.IsNotNull(amexExpressCheckoutCard.Subscriptions);
}
public void Create_CreatesAndroidPayNetworkTokenWithNonce()
{
Result <Customer> result = gateway.Customer.Create(new CustomerRequest());
Assert.IsTrue(result.IsSuccess());
var request = new PaymentMethodRequest
{
CustomerId = result.Target.Id,
PaymentMethodNonce = Nonce.AndroidPayMasterCard
};
Result <PaymentMethod> paymentMethodResult = gateway.PaymentMethod.Create(request);
Assert.IsTrue(paymentMethodResult.IsSuccess());
Assert.IsNotNull(paymentMethodResult.Target.Token);
Assert.IsNotNull(paymentMethodResult.Target.ImageUrl);
Assert.IsInstanceOf(typeof(AndroidPayCard), paymentMethodResult.Target);
AndroidPayCard androidPayCard = (AndroidPayCard)paymentMethodResult.Target;
Assert.IsNotNull(androidPayCard.IsDefault);
Assert.IsNotNull(androidPayCard.CardType);
Assert.IsNotNull(androidPayCard.VirtualCardType);
Assert.IsNotNull(androidPayCard.SourceCardType);
Assert.IsNotNull(androidPayCard.SourceDescription);
Assert.IsNotNull(androidPayCard.Last4);
Assert.IsNotNull(androidPayCard.VirtualCardLast4);
Assert.IsNotNull(androidPayCard.SourceCardLast4);
Assert.IsNotNull(androidPayCard.Bin);
Assert.IsNotNull(androidPayCard.ExpirationMonth);
Assert.IsNotNull(androidPayCard.ExpirationYear);
Assert.IsNotNull(androidPayCard.GoogleTransactionId);
Assert.IsNotNull(androidPayCard.CreatedAt);
Assert.IsNotNull(androidPayCard.UpdatedAt);
Assert.IsNotNull(androidPayCard.Subscriptions);
}
public void Create_CreatesApplePayCardWithNonce()
{
Result <Customer> result = gateway.Customer.Create(new CustomerRequest());
Assert.IsTrue(result.IsSuccess());
var request = new PaymentMethodRequest
{
CustomerId = result.Target.Id,
PaymentMethodNonce = Nonce.ApplePayAmex
};
Result <PaymentMethod> paymentMethodResult = gateway.PaymentMethod.Create(request);
Assert.IsTrue(paymentMethodResult.IsSuccess());
Assert.IsNotNull(paymentMethodResult.Target.Token);
Assert.IsNotNull(paymentMethodResult.Target.ImageUrl);
Assert.IsInstanceOf(typeof(ApplePayCard), paymentMethodResult.Target);
ApplePayCard applePayCard = (ApplePayCard)paymentMethodResult.Target;
Assert.IsNotNull(applePayCard.CardType);
Assert.IsNotNull(applePayCard.ExpirationMonth);
Assert.IsNotNull(applePayCard.ExpirationYear);
Assert.IsNotNull(applePayCard.CreatedAt);
Assert.IsNotNull(applePayCard.UpdatedAt);
Assert.IsNotNull(applePayCard.Subscriptions);
Assert.IsNotNull(applePayCard.PaymentInstrumentName);
Assert.IsNotNull(applePayCard.SourceDescription);
Assert.IsNotNull(applePayCard.IsExpired);
Assert.AreEqual(result.Target.Id, applePayCard.CustomerId);
}
/// <summary>
/// Updates a payment method
/// </summary>
/// <param name="token">The payment method token</param>
/// <param name="request">
/// The request.
/// </param>
/// <returns>
/// The <see cref="Attempt"/>.
/// </returns>
public Attempt <PaymentMethod> Update(string token, PaymentMethodRequest request)
{
Mandate.ParameterNotNull(request, "request");
Updating.RaiseEvent(new SaveEventArgs <PaymentMethodRequest>(request), this);
var attempt = this.TryGetApiResult(() => this.BraintreeGateway.PaymentMethod.Update(token, request));
if (!attempt.Success)
{
return(Attempt <PaymentMethod> .Fail(attempt.Exception));
}
var result = attempt.Result;
if (result.IsSuccess())
{
var cacheKey = this.MakePaymentMethodCacheKey(token);
this.RuntimeCache.ClearCacheItem(cacheKey);
Updated.RaiseEvent(new SaveEventArgs <PaymentMethod>(result.Target), this);
return(Attempt <PaymentMethod> .Succeed((PaymentMethod)this.RuntimeCache.GetCacheItem(cacheKey, () => result.Target, TimeSpan.FromHours(6))));
}
var error = new BraintreeApiException(result.Errors, result.Message);
LogHelper.Error <BraintreePaymentMethodApiService>("Failed to update payment method", error);
return(Attempt <PaymentMethod> .Fail(error));
}
public void MultipleAttemptConfirm_MicroTransferVerification()
{
gateway = new BraintreeGateway
{
Environment = Environment.DEVELOPMENT,
MerchantId = "integration2_merchant_id",
PublicKey = "integration2_public_key",
PrivateKey = "integration2_private_key"
};
Result <Customer> customer = gateway.Customer.Create(new CustomerRequest());
Assert.IsTrue(customer.IsSuccess());
var request = new PaymentMethodRequest
{
CustomerId = customer.Target.Id,
PaymentMethodNonce = TestHelper.GenerateValidUsBankAccountNonce(gateway, "1000000000"),
Options = new PaymentMethodOptionsRequest
{
VerificationMerchantAccountId = MerchantAccountIDs.ANOTHER_US_BANK_MERCHANT_ACCOUNT_ID,
UsBankAccountVerificationMethod = UsBankAccountVerificationMethod.MICRO_TRANSFERS
}
};
Result <PaymentMethod> result = gateway.PaymentMethod.Create(request);
Assert.IsTrue(result.IsSuccess());
UsBankAccount usBankAccount = (UsBankAccount)result.Target;
Assert.IsNotNull(usBankAccount.Token);
UsBankAccountVerification verification = usBankAccount.Verifications[0];
Assert.AreEqual(UsBankAccountVerificationMethod.MICRO_TRANSFERS, verification.VerificationMethod);
Assert.AreEqual(UsBankAccountVerificationStatus.PENDING, verification.Status);
var confirmRequest = new UsBankAccountVerificationConfirmRequest
{
DepositAmounts = new int[] { 1, 1 }
};
for (int i = 0; i < 4; i++)
{
var r = gateway.UsBankAccountVerification.ConfirmMicroTransferAmounts(verification.Id, confirmRequest);
Assert.IsFalse(r.IsSuccess());
Assert.AreEqual(
ValidationErrorCode.US_BANK_ACCOUNT_VERIFICATION_AMOUNTS_DO_NOT_MATCH,
r.Errors.ForObject("us-bank-account-verification").OnField("base")[0].Code);
}
var confirmResult = gateway.UsBankAccountVerification.ConfirmMicroTransferAmounts(verification.Id, confirmRequest);
Assert.IsFalse(confirmResult.IsSuccess());
Assert.AreEqual(
ValidationErrorCode.US_BANK_ACCOUNT_VERIFICATION_TOO_MANY_CONFIRMATION_ATTEMPTS,
confirmResult.Errors.ForObject("us-bank-account-verification").OnField("base")[0].Code);
}
public void CreateFromPaymentMethodNonce()
{
Result <Customer> result = gateway.Customer.Create(new CustomerRequest());
Assert.IsTrue(result.IsSuccess());
string nonce = Braintree.Test.Nonce.SamsungPayDiscover;
var request = new PaymentMethodRequest
{
CustomerId = result.Target.Id,
PaymentMethodNonce = nonce,
CardholderName = "Jenny Block",
BillingAddress = new PaymentMethodAddressRequest
{
CountryName = "Chad",
}
};
Result <PaymentMethod> paymentMethodResult = gateway.PaymentMethod.Create(request);
Assert.IsTrue(paymentMethodResult.IsSuccess());
Assert.IsInstanceOf(typeof(SamsungPayCard), paymentMethodResult.Target);
SamsungPayCard samsungPayCard = (SamsungPayCard)paymentMethodResult.Target;
Assert.IsNotNull(samsungPayCard.BillingAddress);
Assert.IsNotNull(samsungPayCard.Bin);
Assert.IsNotNull(samsungPayCard.CardholderName);
Assert.IsNotNull(samsungPayCard.CardType);
Assert.IsNotNull(samsungPayCard.Commercial);
Assert.IsNotNull(samsungPayCard.CountryOfIssuance);
Assert.IsNotNull(samsungPayCard.CreatedAt);
Assert.IsNotNull(samsungPayCard.CustomerId);
Assert.IsNotNull(samsungPayCard.CustomerLocation);
Assert.IsNotNull(samsungPayCard.Debit);
Assert.IsNotNull(samsungPayCard.IsDefault);
Assert.IsNotNull(samsungPayCard.DurbinRegulated);
Assert.IsNotNull(samsungPayCard.ExpirationDate);
Assert.IsNotNull(samsungPayCard.ExpirationMonth);
Assert.IsNotNull(samsungPayCard.ExpirationYear);
Assert.IsNotNull(samsungPayCard.IsExpired);
Assert.IsNotNull(samsungPayCard.Healthcare);
Assert.IsNotNull(samsungPayCard.ImageUrl);
Assert.IsNotNull(samsungPayCard.IssuingBank);
Assert.IsNotNull(samsungPayCard.LastFour);
Assert.IsNotNull(samsungPayCard.SourceCardLastFour);
Assert.IsNotNull(samsungPayCard.MaskedNumber);
Assert.IsNotNull(samsungPayCard.Payroll);
Assert.IsNotNull(samsungPayCard.Prepaid);
Assert.IsNotNull(samsungPayCard.ProductId);
Assert.IsNotNull(samsungPayCard.Subscriptions);
Assert.IsNotNull(samsungPayCard.Token);
Assert.IsNotNull(samsungPayCard.UniqueNumberIdentifier);
Assert.IsNotNull(samsungPayCard.UpdatedAt);
}
public void SuccessfullyConfirmSettled_MicroTransferVerification()
{
gateway = new BraintreeGateway
{
Environment = Environment.DEVELOPMENT,
MerchantId = "integration2_merchant_id",
PublicKey = "integration2_public_key",
PrivateKey = "integration2_private_key"
};
Result <Customer> customer = gateway.Customer.Create(new CustomerRequest());
Assert.IsTrue(customer.IsSuccess());
var request = new PaymentMethodRequest
{
CustomerId = customer.Target.Id,
PaymentMethodNonce = TestHelper.GenerateValidUsBankAccountNonce(gateway, "1000000000"),
Options = new PaymentMethodOptionsRequest
{
VerificationMerchantAccountId = MerchantAccountIDs.ANOTHER_US_BANK_MERCHANT_ACCOUNT_ID,
UsBankAccountVerificationMethod = UsBankAccountVerificationMethod.MICRO_TRANSFERS
}
};
Result <PaymentMethod> result = gateway.PaymentMethod.Create(request);
Assert.IsTrue(result.IsSuccess());
UsBankAccount usBankAccount = (UsBankAccount)result.Target;
Assert.IsNotNull(usBankAccount.Token);
UsBankAccountVerification verification = usBankAccount.Verifications[0];
Assert.AreEqual(UsBankAccountVerificationMethod.MICRO_TRANSFERS, verification.VerificationMethod);
Assert.AreEqual(UsBankAccountVerificationStatus.PENDING, verification.Status);
var confirmRequest = new UsBankAccountVerificationConfirmRequest
{
DepositAmounts = new int[] { 17, 29 }
};
var confirmResult = gateway.UsBankAccountVerification.ConfirmMicroTransferAmounts(verification.Id, confirmRequest);
Assert.IsTrue(confirmResult.IsSuccess());
verification = (UsBankAccountVerification)confirmResult.Target;
Assert.AreEqual(UsBankAccountVerificationStatus.VERIFIED, verification.Status);
usBankAccount = (UsBankAccount)gateway.PaymentMethod.Find(verification.UsBankAccount.Token);
Assert.IsTrue(usBankAccount.IsVerified);
}
public void ToXml_IncludesDeviceData()
{
var request = new PaymentMethodRequest()
{
DeviceData = "{\"device_session_id\":\"my_dsid\", \"fraud_merchant_id\":\"my_fmid\"}"
};
Assert.IsTrue(request.ToXml().Contains("device_session_id"));
Assert.IsTrue(request.ToXml().Contains("my_dsid"));
Assert.IsTrue(request.ToXml().Contains("fraud_merchant_id"));
Assert.IsTrue(request.ToXml().Contains("my_fmid"));
}
public void ToXml_IncludesDeviceData()
{
var request = new PaymentMethodRequest()
{
DeviceData = "{\"device_session_id\":\"my_dsid\", \"fraud_merchant_id\":\"my_fmid\"}"
};
Assert.IsTrue(request.ToXml().Contains("device_session_id"));
Assert.IsTrue(request.ToXml().Contains("my_dsid"));
Assert.IsTrue(request.ToXml().Contains("fraud_merchant_id"));
Assert.IsTrue(request.ToXml().Contains("my_fmid"));
}
public void Delete_DeletesPayPalAccount()
{
var request = new PaymentMethodRequest
{
CustomerId = gateway.Customer.Create(new CustomerRequest()).Target.Id,
PaymentMethodNonce = Nonce.PayPalFuturePayment
};
Result <PaymentMethod> result = gateway.PaymentMethod.Create(request);
Assert.IsTrue(result.IsSuccess());
gateway.PaymentMethod.Delete(result.Target.Token);
}
public void Delete_DeletesCreditCard()
{
var request = new PaymentMethodRequest
{
CustomerId = gateway.Customer.Create(new CustomerRequest()).Target.Id,
PaymentMethodNonce = Nonce.Transactable
};
Result <PaymentMethod> result = gateway.PaymentMethod.Create(request);
Assert.IsTrue(result.IsSuccess());
gateway.PaymentMethod.Delete(result.Target.Token);
}
public void Sale_TransactUsBankAccountWithToken()
{
Result <Customer> result = gateway.Customer.Create(new CustomerRequest());
Assert.IsTrue(result.IsSuccess());
string nonce = TestHelper.GenerateValidUsBankAccountNonce(gateway);
var request = new PaymentMethodRequest
{
CustomerId = result.Target.Id,
PaymentMethodNonce = nonce,
Options = new PaymentMethodOptionsRequest {
VerificationMerchantAccountId = MerchantAccountIDs.US_BANK_MERCHANT_ACCOUNT_ID
}
};
Result <PaymentMethod> paymentMethodResult = gateway.PaymentMethod.Create(request);
Assert.IsTrue(paymentMethodResult.IsSuccess());
Assert.IsInstanceOf(typeof(UsBankAccount), paymentMethodResult.Target);
UsBankAccount usBankAccount = (UsBankAccount)paymentMethodResult.Target;
Assert.IsTrue(usBankAccount.IsVerified);
Assert.AreEqual(1, usBankAccount.Verifications.Count);
var transactionRequest = new TransactionRequest
{
Amount = SandboxValues.TransactionAmount.AUTHORIZE,
MerchantAccountId = MerchantAccountIDs.US_BANK_MERCHANT_ACCOUNT_ID
};
UsBankAccountGateway usBankAccountGateway = new UsBankAccountGateway(gateway);
Result <Transaction> transactionResult = usBankAccountGateway.Sale(usBankAccount.Token, transactionRequest);
Assert.IsTrue(transactionResult.IsSuccess());
Transaction transaction = transactionResult.Target;
Assert.AreEqual(TransactionStatus.SETTLEMENT_PENDING, transaction.Status);
UsBankAccountDetails usBankAccountDetails = transaction.UsBankAccountDetails;
Assert.AreEqual(usBankAccount.RoutingNumber, usBankAccountDetails.RoutingNumber);
Assert.AreEqual(usBankAccount.Last4, usBankAccountDetails.Last4);
Assert.AreEqual(usBankAccount.AccountType, usBankAccountDetails.AccountType);
Assert.AreEqual(usBankAccount.AccountHolderName, usBankAccountDetails.AccountHolderName);
AchMandate achMandate = usBankAccountDetails.AchMandate;
Assert.AreEqual(usBankAccount.AchMandate.Text, achMandate.Text);
Assert.AreEqual("DateTime", achMandate.AcceptedAt.GetType().Name);
}
public void CreateFromPaymentMethodNonce()
{
Result <Customer> result = gateway.Customer.Create(new CustomerRequest());
Assert.IsTrue(result.IsSuccess());
string nonce = Braintree.Test.Nonce.VisaCheckoutDiscover;
var request = new PaymentMethodRequest
{
CustomerId = result.Target.Id,
PaymentMethodNonce = nonce
};
Result <PaymentMethod> paymentMethodResult = gateway.PaymentMethod.Create(request);
Assert.IsTrue(paymentMethodResult.IsSuccess());
Assert.IsInstanceOf(typeof(VisaCheckoutCard), paymentMethodResult.Target);
VisaCheckoutCard visaCheckoutCard = (VisaCheckoutCard)paymentMethodResult.Target;
Assert.AreEqual("abc123", visaCheckoutCard.CallId);
Assert.IsNotNull(visaCheckoutCard.BillingAddress);
Assert.IsNotNull(visaCheckoutCard.Bin);
Assert.IsNotNull(visaCheckoutCard.CardType);
Assert.IsNotNull(visaCheckoutCard.CardholderName);
Assert.IsNotNull(visaCheckoutCard.Commercial);
Assert.IsNotNull(visaCheckoutCard.CountryOfIssuance);
Assert.IsNotNull(visaCheckoutCard.CreatedAt);
Assert.IsNotNull(visaCheckoutCard.CustomerId);
Assert.IsNotNull(visaCheckoutCard.CustomerLocation);
Assert.IsNotNull(visaCheckoutCard.Debit);
Assert.IsNotNull(visaCheckoutCard.IsDefault);
Assert.IsNotNull(visaCheckoutCard.DurbinRegulated);
Assert.IsNotNull(visaCheckoutCard.ExpirationDate);
Assert.IsNotNull(visaCheckoutCard.ExpirationMonth);
Assert.IsNotNull(visaCheckoutCard.ExpirationYear);
Assert.IsNotNull(visaCheckoutCard.IsExpired);
Assert.IsNotNull(visaCheckoutCard.Healthcare);
Assert.IsNotNull(visaCheckoutCard.ImageUrl);
Assert.IsNotNull(visaCheckoutCard.IssuingBank);
Assert.IsNotNull(visaCheckoutCard.LastFour);
Assert.IsNotNull(visaCheckoutCard.MaskedNumber);
Assert.IsNotNull(visaCheckoutCard.Payroll);
Assert.IsNotNull(visaCheckoutCard.Prepaid);
Assert.IsNotNull(visaCheckoutCard.ProductId);
Assert.IsNotNull(visaCheckoutCard.Subscriptions);
Assert.IsNotNull(visaCheckoutCard.Token);
Assert.IsNotNull(visaCheckoutCard.UniqueNumberIdentifier);
Assert.IsNotNull(visaCheckoutCard.UpdatedAt);
}
public void SearchAsync_OnMultipleValueFields()
{
Task.Run(async () =>
#endif
{
Result<Customer> customer = await gateway.Customer.CreateAsync(new CustomerRequest());
Assert.IsTrue(customer.IsSuccess());
var request1 = new PaymentMethodRequest
{
CustomerId = customer.Target.Id,
PaymentMethodNonce = TestHelper.GenerateValidUsBankAccountNonce(gateway),
Options = new PaymentMethodOptionsRequest
{
VerificationMerchantAccountId = MerchantAccountIDs.US_BANK_MERCHANT_ACCOUNT_ID,
UsBankAccountVerificationMethod = UsBankAccountVerificationMethod.NETWORK_CHECK
}
};
var request2 = new PaymentMethodRequest
{
CustomerId = customer.Target.Id,
PaymentMethodNonce = TestHelper.GenerateValidUsBankAccountNonce(gateway),
Options = new PaymentMethodOptionsRequest
{
VerificationMerchantAccountId = MerchantAccountIDs.US_BANK_MERCHANT_ACCOUNT_ID,
UsBankAccountVerificationMethod = UsBankAccountVerificationMethod.INDEPENDENT_CHECK
}
};
UsBankAccount result1 = (UsBankAccount) (await gateway.PaymentMethod.CreateAsync(request1)).Target;
UsBankAccount result2 = (UsBankAccount) (await gateway.PaymentMethod.CreateAsync(request2)).Target;
UsBankAccountVerification verification1 = gateway.UsBankAccountVerification.Find(result1.Verifications[0].Id);
UsBankAccountVerification verification2 = gateway.UsBankAccountVerification.Find(result2.Verifications[0].Id);
UsBankAccountVerificationSearchRequest searchRequest = new UsBankAccountVerificationSearchRequest().
VerificationMethod.IncludedIn(UsBankAccountVerificationMethod.INDEPENDENT_CHECK,
UsBankAccountVerificationMethod.NETWORK_CHECK).
Ids.IncludedIn(verification1.Id, verification2.Id).
Status.IncludedIn(UsBankAccountVerificationStatus.VERIFIED);
ResourceCollection<UsBankAccountVerification> collection = await gateway.UsBankAccountVerification.SearchAsync(searchRequest);
Assert.AreEqual(2, collection.MaximumCount);
}
#if net452
).GetAwaiter().GetResult();
}
public async Task <string> GetPaymentMethods(double amount)
{
PaymentMethodRequest req = new PaymentMethodRequest()
{
MerchantAccount = _configuration.MerchantAccount,
AllowedPaymentMethods = _configuration.AllowedPaymentMethods.ToArray(),
CountryCode = _configuration.CountryCode,
Amount = amount,
Channel = _configuration.Channel,
ShopperLocale = _configuration.ShopperLocale
};
HttpResponseMessage response = await _httpClient.PostAsJsonAsync("paymentMethods", req);
return(await response.Content.ReadAsStringAsync());
}
public void Find_FindsAbstractPaymentMethod()
{
var request = new PaymentMethodRequest
{
CustomerId = gateway.Customer.Create(new CustomerRequest()).Target.Id,
PaymentMethodNonce = Nonce.AbstractTransactable
};
Result <PaymentMethod> result = gateway.PaymentMethod.Create(request);
Assert.IsTrue(result.IsSuccess());
PaymentMethod found = gateway.PaymentMethod.Find(result.Target.Token);
Assert.AreEqual(result.Target.Token, found.Token);
}
public void Delete_DeletesApplePayAccount()
{
var request = new PaymentMethodRequest
{
CustomerId = gateway.Customer.Create(new CustomerRequest()).Target.Id,
PaymentMethodNonce = Nonce.ApplePayVisa
};
Result <PaymentMethod> createResult = gateway.PaymentMethod.Create(request);
Assert.IsTrue(createResult.IsSuccess());
Result <PaymentMethod> deleteResult = gateway.PaymentMethod.Delete(createResult.Target.Token);
Assert.IsTrue(deleteResult.IsSuccess());
}
public void Find_FindsPayPalAccount()
{
var request = new PaymentMethodRequest
{
CustomerId = gateway.Customer.Create(new CustomerRequest()).Target.Id,
PaymentMethodNonce = Nonce.PayPalFuturePayment
};
Result <PaymentMethod> result = gateway.PaymentMethod.Create(request);
Assert.IsTrue(result.IsSuccess());
PaymentMethod found = gateway.PaymentMethod.Find(result.Target.Token);
Assert.AreEqual(result.Target.Token, found.Token);
}
public void Vault_NoLongerSupported()
{
Result <Customer> customerResult = gateway.Customer.Create(new CustomerRequest());
Assert.IsTrue(customerResult.IsSuccess());
PaymentMethodRequest request = new PaymentMethodRequest()
{
CustomerId = customerResult.Target.Id,
PaymentMethodNonce = Nonce.Coinbase
};
var createResult = gateway.PaymentMethod.Create(request);
Assert.IsFalse(createResult.IsSuccess());
Assert.AreEqual(ValidationErrorCode.PAYMENT_METHOD_NO_LONGER_SUPPORTED, createResult.Errors.ForObject("CoinbaseAccount").OnField("Base")[0].Code);
}
public void Vault()
{
Result<Customer> customerResult = gateway.Customer.Create(new CustomerRequest());
Assert.IsTrue(customerResult.IsSuccess());
PaymentMethodRequest request = new PaymentMethodRequest()
{
CustomerId = customerResult.Target.Id,
PaymentMethodNonce = Nonce.Coinbase
};
var createResult = gateway.PaymentMethod.Create(request);
Assert.IsTrue(createResult.IsSuccess());
var findResult = gateway.PaymentMethod.Find(createResult.Target.Token);
Assert.IsTrue(findResult is CoinbaseAccount);
}
public void Find_FindsAndroidPayCard()
{
var request = new PaymentMethodRequest
{
CustomerId = gateway.Customer.Create(new CustomerRequest()).Target.Id,
PaymentMethodNonce = Nonce.AndroidPay
};
Result <PaymentMethod> result = gateway.PaymentMethod.Create(request);
Assert.IsTrue(result.IsSuccess());
PaymentMethod found = gateway.PaymentMethod.Find(result.Target.Token);
Assert.AreEqual(result.Target.Token, found.Token);
Assert.IsInstanceOf(typeof(AndroidPayCard), found);
}
public void CompliantMerchant_FailsToTransactUnverifiedToken()
{
gateway = new BraintreeGateway
{
Environment = Environment.DEVELOPMENT,
MerchantId = "integration2_merchant_id",
PublicKey = "integration2_public_key",
PrivateKey = "integration2_private_key"
};
Result <Customer> customerResult = gateway.Customer.Create(new CustomerRequest());
Assert.IsTrue(customerResult.IsSuccess());
string nonce = TestHelper.GenerateValidUsBankAccountNonce(gateway);
var request = new PaymentMethodRequest
{
CustomerId = customerResult.Target.Id,
PaymentMethodNonce = nonce,
Options = new PaymentMethodOptionsRequest {
VerificationMerchantAccountId = "another_us_bank_merchant_account"
}
};
Result <PaymentMethod> paymentMethodResult = gateway.PaymentMethod.Create(request);
Assert.IsTrue(paymentMethodResult.IsSuccess());
Assert.IsInstanceOf(typeof(UsBankAccount), paymentMethodResult.Target);
UsBankAccount usBankAccount = (UsBankAccount)paymentMethodResult.Target;
Assert.IsFalse(usBankAccount.IsVerified);
Assert.AreEqual(0, usBankAccount.Verifications.Count);
var transactionRequest = new TransactionRequest
{
Amount = SandboxValues.TransactionAmount.AUTHORIZE,
MerchantAccountId = "another_us_bank_merchant_account"
};
UsBankAccountGateway usBankAccountGateway = new UsBankAccountGateway(gateway);
Result <Transaction> transactionResult = usBankAccountGateway.Sale(usBankAccount.Token, transactionRequest);
Assert.IsFalse(transactionResult.IsSuccess());
Assert.AreEqual(
ValidationErrorCode.TRANSACTION_US_BANK_ACCOUNT_MUST_BE_VERIFIED,
transactionResult.Errors.ForObject("transaction").OnField("payment-method-token")[0].Code);
}
public void Create_CreatesAbstractPaymentMethod()
{
Result <Customer> result = gateway.Customer.Create(new CustomerRequest());
Assert.IsTrue(result.IsSuccess());
var request = new PaymentMethodRequest
{
CustomerId = result.Target.Id,
PaymentMethodNonce = Nonce.AbstractTransactable
};
Result <PaymentMethod> paymentMethodResult = gateway.PaymentMethod.Create(request);
Assert.IsTrue(paymentMethodResult.IsSuccess());
Assert.IsNotNull(paymentMethodResult.Target.Token);
Assert.IsNotNull(paymentMethodResult.Target.ImageUrl);
}
public void Create_CreatesCreditCardWithNonce()
{
String nonce = TestHelper.GenerateUnlockedNonce(gateway);
Result <Customer> result = gateway.Customer.Create(new CustomerRequest());
Assert.IsTrue(result.IsSuccess());
var request = new PaymentMethodRequest
{
CustomerId = result.Target.Id,
PaymentMethodNonce = nonce
};
Result <PaymentMethod> paymentMethodResult = gateway.PaymentMethod.Create(request);
Assert.IsTrue(paymentMethodResult.IsSuccess());
Assert.IsNotNull(paymentMethodResult.Target.Token);
Assert.IsInstanceOfType(typeof(CreditCard), paymentMethodResult.Target);
}
public void Create_CreatesCreditCardWithNonce()
{
string nonce = TestHelper.GenerateUnlockedNonce(gateway);
Result<Customer> result = gateway.Customer.Create(new CustomerRequest());
Assert.IsTrue(result.IsSuccess());
var request = new PaymentMethodRequest
{
CustomerId = result.Target.Id,
PaymentMethodNonce = nonce
};
Result<PaymentMethod> paymentMethodResult = gateway.PaymentMethod.Create(request);
Assert.IsTrue(paymentMethodResult.IsSuccess());
Assert.IsNotNull(paymentMethodResult.Target.Token);
Assert.AreEqual(result.Target.Id, paymentMethodResult.Target.CustomerId);
Assert.IsAssignableFrom(typeof(CreditCard), paymentMethodResult.Target);
}
public void Create_CreatesPayPalAccountWithFuturePaymentNonce()
{
Result<Customer> result = gateway.Customer.Create(new CustomerRequest());
Assert.IsTrue(result.IsSuccess());
string nonce = TestHelper.GenerateFuturePaymentPayPalNonce(gateway);
var request = new PaymentMethodRequest
{
CustomerId = result.Target.Id,
PaymentMethodNonce = nonce
};
Result<PaymentMethod> paymentMethodResult = gateway.PaymentMethod.Create(request);
Assert.IsTrue(paymentMethodResult.IsSuccess());
Assert.IsNotNull(paymentMethodResult.Target.Token);
Assert.IsNotNull(paymentMethodResult.Target.ImageUrl);
Assert.AreEqual(result.Target.Id, paymentMethodResult.Target.CustomerId);
Assert.IsInstanceOf(typeof(PayPalAccount), paymentMethodResult.Target);
}
public void Vault()
{
Result <Customer> customerResult = gateway.Customer.Create(new CustomerRequest());
Assert.IsTrue(customerResult.IsSuccess());
PaymentMethodRequest request = new PaymentMethodRequest()
{
CustomerId = customerResult.Target.Id,
PaymentMethodNonce = Nonce.Coinbase
};
var createResult = gateway.PaymentMethod.Create(request);
Assert.IsTrue(createResult.IsSuccess());
var findResult = gateway.PaymentMethod.Find(createResult.Target.Token);
Assert.IsTrue(findResult is CoinbaseAccount);
}
public void Create_CreatesPayPalAccountWithOneTimePaymentNonceFails()
{
Result<Customer> result = gateway.Customer.Create(new CustomerRequest());
Assert.IsTrue(result.IsSuccess());
string nonce = TestHelper.GenerateOneTimePayPalNonce(gateway);
var request = new PaymentMethodRequest
{
CustomerId = result.Target.Id,
PaymentMethodNonce = nonce
};
Result<PaymentMethod> paymentMethodResult = gateway.PaymentMethod.Create(request);
Assert.IsFalse(paymentMethodResult.IsSuccess());
Assert.AreEqual(
ValidationErrorCode.PAYPAL_ACCOUNT_CANNOT_VAULT_ONE_TIME_USE_PAYPAL_ACCOUNT,
paymentMethodResult.Errors.ForObject("paypal-account").OnField("base")[0].Code
);
}
public void Create_CreatesPayPalAccountWithFuturePaymentNonce()
{
Result <Customer> result = gateway.Customer.Create(new CustomerRequest());
Assert.IsTrue(result.IsSuccess());
String nonce = TestHelper.GenerateFuturePaymentPayPalNonce(gateway);
var request = new PaymentMethodRequest
{
CustomerId = result.Target.Id,
PaymentMethodNonce = nonce
};
Result <PaymentMethod> paymentMethodResult = gateway.PaymentMethod.Create(request);
Assert.IsTrue(paymentMethodResult.IsSuccess());
Assert.IsNotNull(paymentMethodResult.Target.Token);
Assert.IsNotNull(paymentMethodResult.Target.ImageUrl);
Assert.IsInstanceOfType(typeof(PayPalAccount), paymentMethodResult.Target);
}
public void Find_ReturnsPayPalAccountByToken()
{
Result<Customer> customerResult = gateway.Customer.Create(new CustomerRequest());
Assert.IsTrue(customerResult.IsSuccess());
var request = new PaymentMethodRequest
{
CustomerId = customerResult.Target.Id,
PaymentMethodNonce = Nonce.PayPalFuturePayment
};
Result<PaymentMethod> result = gateway.PaymentMethod.Create(request);
Assert.IsTrue(result.IsSuccess());
Assert.IsNotNull(result.Target.ImageUrl);
PayPalAccount found = gateway.PayPalAccount.Find(result.Target.Token);
Assert.IsNotNull(found);
Assert.IsNotNull(found.Email);
Assert.IsNotNull(found.ImageUrl);
Assert.IsNotNull(found.CreatedAt);
Assert.IsNotNull(found.UpdatedAt);
Assert.AreEqual(found.Email, ((PayPalAccount) result.Target).Email);
}
public void Sale_TransactUsBankAccountWithToken()
{
Result<Customer> result = gateway.Customer.Create(new CustomerRequest());
Assert.IsTrue(result.IsSuccess());
string nonce = TestHelper.GenerateValidUsBankAccountNonce(gateway);
var request = new PaymentMethodRequest
{
CustomerId = result.Target.Id,
PaymentMethodNonce = nonce
};
Result<PaymentMethod> paymentMethodResult = gateway.PaymentMethod.Create(request);
Assert.IsTrue(paymentMethodResult.IsSuccess());
Assert.IsInstanceOf(typeof(UsBankAccount), paymentMethodResult.Target);
UsBankAccount usBankAccount = (UsBankAccount) paymentMethodResult.Target;
var transactionRequest = new TransactionRequest
{
Amount = SandboxValues.TransactionAmount.AUTHORIZE,
MerchantAccountId = MerchantAccountIDs.US_BANK_MERCHANT_ACCOUNT_ID
};
UsBankAccountGateway usBankAccountGateway = new UsBankAccountGateway(gateway);
Result<Transaction> transactionResult = usBankAccountGateway.Sale(usBankAccount.Token, transactionRequest);
Assert.IsTrue(transactionResult.IsSuccess());
Transaction transaction = transactionResult.Target;
Assert.AreEqual(TransactionStatus.SETTLEMENT_PENDING, transaction.Status);
UsBankAccountDetails usBankAccountDetails = transaction.UsBankAccountDetails;
Assert.AreEqual(usBankAccount.RoutingNumber, usBankAccountDetails.RoutingNumber);
Assert.AreEqual(usBankAccount.Last4, usBankAccountDetails.Last4);
Assert.AreEqual(usBankAccount.AccountType, usBankAccountDetails.AccountType);
Assert.AreEqual(usBankAccount.AccountDescription, usBankAccountDetails.AccountDescription);
Assert.AreEqual(usBankAccount.AccountHolderName, usBankAccountDetails.AccountHolderName);
}
public void Update_UpdatesTheCoinbaseAccount()
{
var customer = gateway.Customer.Create().Target;
PaymentMethodRequest request = new PaymentMethodRequest()
{
CustomerId = customer.Id,
PaymentMethodNonce = Nonce.Coinbase
};
var coinbaseAccount = gateway.PaymentMethod.Create(request).Target;
var updateResult = gateway.PaymentMethod.Update(
coinbaseAccount.Token,
new PaymentMethodRequest
{
Options = new PaymentMethodOptionsRequest { MakeDefault = true }
});
Assert.IsTrue(updateResult.IsSuccess());
Assert.That(updateResult.Target, Is.InstanceOf(typeof(CoinbaseAccount)));
var updatedCoinbaseAccount = (CoinbaseAccount)updateResult.Target;
Assert.IsTrue(updatedCoinbaseAccount.IsDefault.Value);
}
/// <summary>
/// Updates a payment method
/// </summary>
/// <param name="token">The payment method token</param>
/// <param name="request">
/// The request.
/// </param>
/// <returns>
/// The <see cref="Attempt"/>.
/// </returns>
public Attempt<PaymentMethod> Update(string token, PaymentMethodRequest request)
{
Mandate.ParameterNotNull(request, "request");
Updating.RaiseEvent(new SaveEventArgs<PaymentMethodRequest>(request), this);
var attempt = TryGetApiResult(() => BraintreeGateway.PaymentMethod.Update(token, request));
if (!attempt.Success) return Attempt<PaymentMethod>.Fail(attempt.Exception);
var result = attempt.Result;
if (result.IsSuccess())
{
var cacheKey = MakePaymentMethodCacheKey(token);
RuntimeCache.ClearCacheItem(cacheKey);
Updated.RaiseEvent(new SaveEventArgs<PaymentMethod>(result.Target), this);
return Attempt<PaymentMethod>.Succeed((PaymentMethod)RuntimeCache.GetCacheItem(cacheKey, () => result.Target));
}
var error = new BraintreeApiException(result.Errors, result.Message);
LogHelper.Error<BraintreePaymentMethodApiService>("Failed to update payment method", error);
return Attempt<PaymentMethod>.Fail(error);
}
public void Create_CreatesAndroidPayProxyCardWithNonce()
{
Result<Customer> result = gateway.Customer.Create(new CustomerRequest());
Assert.IsTrue(result.IsSuccess());
var request = new PaymentMethodRequest
{
CustomerId = result.Target.Id,
PaymentMethodNonce = Nonce.AndroidPayDiscover
};
Result<PaymentMethod> paymentMethodResult = gateway.PaymentMethod.Create(request);
if (paymentMethodResult.IsSuccess())
{
Assert.IsNotNull(paymentMethodResult.Target.Token);
Assert.IsNotNull(paymentMethodResult.Target.ImageUrl);
Assert.IsAssignableFrom(typeof(AndroidPayCard), paymentMethodResult.Target);
AndroidPayCard androidPayCard = (AndroidPayCard)paymentMethodResult.Target;
Assert.IsNotNull(androidPayCard.IsDefault);
Assert.IsNotNull(androidPayCard.CardType);
Assert.IsNotNull(androidPayCard.VirtualCardType);
Assert.IsNotNull(androidPayCard.SourceCardType);
Assert.IsNotNull(androidPayCard.SourceDescription);
Assert.IsNotNull(androidPayCard.Last4);
Assert.IsNotNull(androidPayCard.VirtualCardLast4);
Assert.IsNotNull(androidPayCard.SourceCardLast4);
Assert.IsNotNull(androidPayCard.Bin);
Assert.IsNotNull(androidPayCard.ExpirationMonth);
Assert.IsNotNull(androidPayCard.ExpirationYear);
Assert.IsNotNull(androidPayCard.GoogleTransactionId);
Assert.IsNotNull(androidPayCard.CreatedAt);
Assert.IsNotNull(androidPayCard.UpdatedAt);
Assert.IsNotNull(androidPayCard.Subscriptions);
}
else
Assert.Inconclusive(paymentMethodResult.Message);
}
public void Find_FindsAndroidPayCard()
{
var request = new PaymentMethodRequest
{
CustomerId = gateway.Customer.Create(new CustomerRequest()).Target.Id,
PaymentMethodNonce = Nonce.AndroidPay
};
Result<PaymentMethod> result = gateway.PaymentMethod.Create(request);
if (result.IsSuccess())
{
PaymentMethod found = gateway.PaymentMethod.Find(result.Target.Token);
Assert.AreEqual(result.Target.Token, found.Token);
Assert.IsAssignableFrom(typeof(AndroidPayCard), found);
}
else
Assert.Inconclusive(result.Message);
}
public void Delete_DeletesCreditCard()
{
var request = new PaymentMethodRequest
{
CustomerId = gateway.Customer.Create(new CustomerRequest()).Target.Id,
PaymentMethodNonce = Nonce.Transactable
};
Result<PaymentMethod> createResult = gateway.PaymentMethod.Create(request);
Assert.IsTrue(createResult.IsSuccess());
Result<PaymentMethod> deleteResult = gateway.PaymentMethod.Delete(createResult.Target.Token);
Assert.IsTrue(deleteResult.IsSuccess());
}
public void Update_CanUpdateToken()
{
Result<Customer> customerResult = gateway.Customer.Create(new CustomerRequest());
Assert.IsTrue(customerResult.IsSuccess());
var request = new PaymentMethodRequest
{
CustomerId = customerResult.Target.Id,
PaymentMethodNonce = Nonce.PayPalFuturePayment
};
Result<PaymentMethod> result = gateway.PaymentMethod.Create(request);
Assert.IsTrue(result.IsSuccess());
string newToken = Guid.NewGuid().ToString();
var updateRequest = new PayPalAccountRequest
{
Token = newToken
};
var updateResult = gateway.PayPalAccount.Update(result.Target.Token, updateRequest);
Assert.IsTrue(updateResult.IsSuccess());
Assert.AreEqual(newToken, updateResult.Target.Token);
}
public void Delete_DeletesApplePayAccount()
{
var request = new PaymentMethodRequest
{
CustomerId = gateway.Customer.Create(new CustomerRequest()).Target.Id,
PaymentMethodNonce = Nonce.ApplePayVisa
};
Result<PaymentMethod> createResult = gateway.PaymentMethod.Create(request);
Assert.IsTrue(createResult.IsSuccess());
Result<PaymentMethod> deleteResult = gateway.PaymentMethod.Delete(createResult.Target.Token);
Assert.IsTrue(deleteResult.IsSuccess());
}
public void Create_CreatesCreditCardWithNonceAndDeviceData()
{
string nonce = TestHelper.GenerateUnlockedNonce(gateway);
Result<Customer> result = gateway.Customer.Create(new CustomerRequest());
Assert.IsTrue(result.IsSuccess());
var request = new PaymentMethodRequest()
{
CustomerId = result.Target.Id,
PaymentMethodNonce = nonce,
Options = new PaymentMethodOptionsRequest()
{
VerifyCard = true
},
DeviceData = "{\"device_session_id\":\"my_dsid\", \"fraud_merchant_id\":\"my_fmid\"}"
};
Result<PaymentMethod> paymentMethodResult = gateway.PaymentMethod.Create(request);
Assert.IsTrue(paymentMethodResult.IsSuccess());
Assert.IsNotNull(paymentMethodResult.Target.Token);
Assert.AreEqual(result.Target.Id, paymentMethodResult.Target.CustomerId);
}
public void Find_FindsAbstractPaymentMethod()
{
var request = new PaymentMethodRequest
{
CustomerId = gateway.Customer.Create(new CustomerRequest()).Target.Id,
PaymentMethodNonce = Nonce.AbstractTransactable
};
Result<PaymentMethod> result = gateway.PaymentMethod.Create(request);
Assert.IsTrue(result.IsSuccess());
PaymentMethod found = gateway.PaymentMethod.Find(result.Target.Token);
Assert.AreEqual(result.Target.Token, found.Token);
}
public void Update_MakeExistingPaymentMethodTheDefaultUsingDefaultPaymentMethodToken()
{
Customer customer = gateway.Customer.Create(new CustomerRequest()).Target;
var coinbaseToken = GenerateToken();
var coinbaseCreateRequest = new PaymentMethodRequest
{
CustomerId = customer.Id,
PaymentMethodNonce = Nonce.Coinbase,
Token = coinbaseToken
};
PaymentMethod coinbasePaymentMethod = gateway.PaymentMethod.Create(coinbaseCreateRequest).Target;
customer = gateway.Customer.Find(customer.Id);
Assert.AreEqual(customer.DefaultPaymentMethod.Token, coinbaseToken);
var venmoToken = GenerateToken();
var venmoCreateRequest = new PaymentMethodRequest()
{
CustomerId = customer.Id,
PaymentMethodNonce = Nonce.VenmoAccount,
Token = venmoToken
};
PaymentMethod venmoPaymentMethod = gateway.PaymentMethod.Create(venmoCreateRequest).Target;
customer = gateway.Customer.Find(customer.Id);
Assert.AreNotEqual(customer.DefaultPaymentMethod.Token, venmoToken);
Assert.AreEqual(customer.DefaultPaymentMethod.Token, coinbaseToken);
var updateRequest = new CustomerRequest
{
DefaultPaymentMethodToken = venmoToken
};
gateway.Customer.Update(customer.Id, updateRequest);
customer = gateway.Customer.Find(customer.Id);
Assert.AreEqual(customer.DefaultPaymentMethod.Token, venmoToken);
}
public void Find_FindsPayPalAccount()
{
var request = new PaymentMethodRequest
{
CustomerId = gateway.Customer.Create(new CustomerRequest()).Target.Id,
PaymentMethodNonce = Nonce.PayPalFuturePayment
};
Result<PaymentMethod> result = gateway.PaymentMethod.Create(request);
Assert.IsTrue(result.IsSuccess());
PaymentMethod found = gateway.PaymentMethod.Find(result.Target.Token);
Assert.AreEqual(result.Target.Token, found.Token);
}
public void Create_CanMakeDefaultAndSetToken()
{
Result<Customer> customerResult = gateway.Customer.Create(new CustomerRequest());
Assert.IsTrue(customerResult.IsSuccess());
var creditCardRequest = new CreditCardRequest
{
CustomerId = customerResult.Target.Id,
Number = "5105105105105100",
ExpirationDate = "05/12"
};
CreditCard creditCard = gateway.CreditCard.Create(creditCardRequest).Target;
Assert.IsTrue(creditCard.IsDefault.Value);
string nonce = TestHelper.GenerateUnlockedNonce(gateway);
Random random = new Random();
int randomNumber = random.Next(0, 10000);
var token = "token_" + randomNumber;
var request = new PaymentMethodRequest
{
CustomerId = customerResult.Target.Id,
PaymentMethodNonce = nonce,
Token = token,
Options = new PaymentMethodOptionsRequest
{
MakeDefault = true
}
};
Result<PaymentMethod> paymentMethodResult = gateway.PaymentMethod.Create(request);
Assert.IsTrue(paymentMethodResult.IsSuccess());
Assert.IsTrue(paymentMethodResult.Target.IsDefault.Value);
Assert.AreEqual(token, paymentMethodResult.Target.Token);
}
public void Create_CreatesApplePayCardWithNonce()
{
Result<Customer> result = gateway.Customer.Create(new CustomerRequest());
Assert.IsTrue(result.IsSuccess());
var request = new PaymentMethodRequest
{
CustomerId = result.Target.Id,
PaymentMethodNonce = Nonce.ApplePayAmex
};
Result<PaymentMethod> paymentMethodResult = gateway.PaymentMethod.Create(request);
Assert.IsTrue(paymentMethodResult.IsSuccess());
Assert.IsNotNull(paymentMethodResult.Target.Token);
Assert.IsNotNull(paymentMethodResult.Target.ImageUrl);
Assert.IsInstanceOf(typeof(ApplePayCard), paymentMethodResult.Target);
ApplePayCard applePayCard = (ApplePayCard) paymentMethodResult.Target;
Assert.IsNotNull(applePayCard.CardType);
Assert.IsNotNull(applePayCard.ExpirationMonth);
Assert.IsNotNull(applePayCard.ExpirationYear);
Assert.IsNotNull(applePayCard.CreatedAt);
Assert.IsNotNull(applePayCard.UpdatedAt);
Assert.IsNotNull(applePayCard.Subscriptions);
Assert.IsNotNull(applePayCard.PaymentInstrumentName);
Assert.IsNotNull(applePayCard.SourceDescription);
Assert.IsNotNull(applePayCard.IsExpired);
Assert.AreEqual(result.Target.Id, applePayCard.CustomerId);
}
public void Find_FindsAndroidPayCard()
{
var request = new PaymentMethodRequest
{
CustomerId = gateway.Customer.Create(new CustomerRequest()).Target.Id,
PaymentMethodNonce = Nonce.AndroidPay
};
Result<PaymentMethod> result = gateway.PaymentMethod.Create(request);
Assert.IsTrue(result.IsSuccess());
PaymentMethod found = gateway.PaymentMethod.Find(result.Target.Token);
Assert.AreEqual(result.Target.Token, found.Token);
Assert.IsInstanceOf(typeof(AndroidPayCard), found);
}
/// <summary>
/// Creates a <see cref="PaymentMethodRequest"/>.
/// </summary>
/// <param name="customer">
/// The customer.
/// </param>
/// <param name="paymentMethodNonce">
/// The payment method nonce.
/// </param>
/// <param name="isDefault">
/// The is default.
/// </param>
/// <returns>
/// The <see cref="PaymentMethodRequest"/>.
/// </returns>
public PaymentMethodRequest CreatePaymentMethodRequest(ICustomer customer, string paymentMethodNonce, bool isDefault = true)
{
Mandate.ParameterNotNullOrEmpty(paymentMethodNonce, "paymentMethodNonce");
var request = new PaymentMethodRequest()
{
CustomerId = customer.Key.ToString(),
PaymentMethodNonce = paymentMethodNonce
};
if (isDefault)
request.Options = new PaymentMethodOptionsRequest()
{
MakeDefault = true
};
return request;
}
public void Create_CreatesAndroidPayNetworkTokenWithNonce()
{
Result<Customer> result = gateway.Customer.Create(new CustomerRequest());
Assert.IsTrue(result.IsSuccess());
var request = new PaymentMethodRequest
{
CustomerId = result.Target.Id,
PaymentMethodNonce = Nonce.AndroidPayMasterCard
};
Result<PaymentMethod> paymentMethodResult = gateway.PaymentMethod.Create(request);
Assert.IsTrue(paymentMethodResult.IsSuccess());
Assert.IsNotNull(paymentMethodResult.Target.Token);
Assert.IsNotNull(paymentMethodResult.Target.ImageUrl);
Assert.IsInstanceOf(typeof(AndroidPayCard), paymentMethodResult.Target);
AndroidPayCard androidPayCard = (AndroidPayCard) paymentMethodResult.Target;
Assert.IsNotNull(androidPayCard.IsDefault);
Assert.IsNotNull(androidPayCard.CardType);
Assert.IsNotNull(androidPayCard.VirtualCardType);
Assert.IsNotNull(androidPayCard.SourceCardType);
Assert.IsNotNull(androidPayCard.SourceDescription);
Assert.IsNotNull(androidPayCard.Last4);
Assert.IsNotNull(androidPayCard.VirtualCardLast4);
Assert.IsNotNull(androidPayCard.SourceCardLast4);
Assert.IsNotNull(androidPayCard.Bin);
Assert.IsNotNull(androidPayCard.ExpirationMonth);
Assert.IsNotNull(androidPayCard.ExpirationYear);
Assert.IsNotNull(androidPayCard.GoogleTransactionId);
Assert.IsNotNull(androidPayCard.CreatedAt);
Assert.IsNotNull(androidPayCard.UpdatedAt);
Assert.IsNotNull(androidPayCard.Subscriptions);
}
public void Update_CanMakeDefault()
{
Result<Customer> customerResult = gateway.Customer.Create(new CustomerRequest());
Assert.IsTrue(customerResult.IsSuccess());
var creditCardRequest = new CreditCardRequest
{
CustomerId = customerResult.Target.Id,
Number = "5555555555554444",
ExpirationDate = "05/22"
};
CreditCard creditCard = gateway.CreditCard.Create(creditCardRequest).Target;
Assert.IsTrue(creditCard.IsDefault.Value);
var request = new PaymentMethodRequest
{
CustomerId = customerResult.Target.Id,
PaymentMethodNonce = Nonce.PayPalFuturePayment
};
Result<PaymentMethod> result = gateway.PaymentMethod.Create(request);
Assert.IsTrue(result.IsSuccess());
var updateRequest = new PayPalAccountRequest
{
Options = new PayPalOptionsRequest
{
MakeDefault = true
}
};
var updateResult = gateway.PayPalAccount.Update(result.Target.Token, updateRequest);
Assert.IsTrue(updateResult.IsSuccess());
Assert.IsTrue(updateResult.Target.IsDefault.Value);
}
public void Create_CreatesAmexExpressCheckoutCardWithNonce()
{
Result<Customer> result = gateway.Customer.Create(new CustomerRequest());
Assert.IsTrue(result.IsSuccess());
var request = new PaymentMethodRequest
{
CustomerId = result.Target.Id,
PaymentMethodNonce = Nonce.AmexExpressCheckout
};
Result<PaymentMethod> paymentMethodResult = gateway.PaymentMethod.Create(request);
Assert.IsTrue(paymentMethodResult.IsSuccess());
Assert.IsNotNull(paymentMethodResult.Target.Token);
Assert.IsNotNull(paymentMethodResult.Target.ImageUrl);
Assert.IsInstanceOf(typeof(AmexExpressCheckoutCard), paymentMethodResult.Target);
AmexExpressCheckoutCard amexExpressCheckoutCard = (AmexExpressCheckoutCard) paymentMethodResult.Target;
Assert.IsNotNull(amexExpressCheckoutCard.CardType);
Assert.IsNotNull(amexExpressCheckoutCard.Bin);
Assert.IsNotNull(amexExpressCheckoutCard.ExpirationMonth);
Assert.IsNotNull(amexExpressCheckoutCard.ExpirationYear);
Assert.IsNotNull(amexExpressCheckoutCard.CardMemberNumber);
Assert.IsNotNull(amexExpressCheckoutCard.CardMemberExpiryDate);
Assert.IsNotNull(amexExpressCheckoutCard.ImageUrl);
Assert.IsNotNull(amexExpressCheckoutCard.SourceDescription);
Assert.IsNotNull(amexExpressCheckoutCard.IsDefault);
Assert.IsNotNull(amexExpressCheckoutCard.CreatedAt);
Assert.IsNotNull(amexExpressCheckoutCard.UpdatedAt);
Assert.IsNotNull(amexExpressCheckoutCard.Subscriptions);
}
public void Delete_ReturnsPayPalAccountByToken()
{
Result<Customer> customerResult = gateway.Customer.Create(new CustomerRequest());
Assert.IsTrue(customerResult.IsSuccess());
var request = new PaymentMethodRequest
{
CustomerId = customerResult.Target.Id,
PaymentMethodNonce = Nonce.PayPalFuturePayment
};
Result<PaymentMethod> result = gateway.PaymentMethod.Create(request);
Assert.IsTrue(result.IsSuccess());
gateway.PayPalAccount.Delete(result.Target.Token);
}
public void Create_CreatesVenmoAccountWithNonce()
{
Result<Customer> result = gateway.Customer.Create(new CustomerRequest());
Assert.IsTrue(result.IsSuccess());
var request = new PaymentMethodRequest
{
CustomerId = result.Target.Id,
PaymentMethodNonce = Nonce.VenmoAccount
};
Result<PaymentMethod> paymentMethodResult = gateway.PaymentMethod.Create(request);
Assert.IsTrue(paymentMethodResult.IsSuccess());
VenmoAccount venmoAccount = (VenmoAccount) paymentMethodResult.Target;
Assert.IsNotNull(venmoAccount.Username);
Assert.IsNotNull(venmoAccount.VenmoUserId);
Assert.IsNotNull(venmoAccount.ImageUrl);
Assert.IsNotNull(venmoAccount.SourceDescription);
Assert.IsNotNull(venmoAccount.IsDefault);
Assert.IsNotNull(venmoAccount.CreatedAt);
Assert.IsNotNull(venmoAccount.UpdatedAt);
Assert.IsNotNull(venmoAccount.CustomerId);
Assert.IsNotNull(venmoAccount.Subscriptions);
}
public void Create_CreatesAbstractPaymentMethod()
{
Result<Customer> result = gateway.Customer.Create(new CustomerRequest());
Assert.IsTrue(result.IsSuccess());
var request = new PaymentMethodRequest
{
CustomerId = result.Target.Id,
PaymentMethodNonce = Nonce.AbstractTransactable
};
Result<PaymentMethod> paymentMethodResult = gateway.PaymentMethod.Create(request);
Assert.IsTrue(paymentMethodResult.IsSuccess());
Assert.IsNotNull(paymentMethodResult.Target.Token);
Assert.IsNotNull(paymentMethodResult.Target.ImageUrl);
}
public void Update_MakeExistingCreditCardPaymentMethodTheDefaultUsingOptions()
{
Customer customer = gateway.Customer.Create(new CustomerRequest()).Target;
var creditCardToken1 = GenerateToken();
var creditCardCreateRequest1 = new PaymentMethodRequest
{
CustomerId = customer.Id,
PaymentMethodNonce = Nonce.TransactableMasterCard,
Token = creditCardToken1
};
PaymentMethod creditCardPaymentMethod1 = gateway.PaymentMethod.Create(creditCardCreateRequest1).Target;
customer = gateway.Customer.Find(customer.Id);
Assert.AreEqual(customer.DefaultPaymentMethod.Token, creditCardToken1);
var creditCardToken2 = GenerateToken();
var creditCardCreateRequest2 = new PaymentMethodRequest()
{
CustomerId = customer.Id,
PaymentMethodNonce = Nonce.TransactableVisa,
Token = creditCardToken2
};
PaymentMethod creditCardPaymentMethod2 = gateway.PaymentMethod.Create(creditCardCreateRequest2).Target;
customer = gateway.Customer.Find(customer.Id);
Assert.AreNotEqual(customer.DefaultPaymentMethod.Token, creditCardToken2);
Assert.AreEqual(customer.DefaultPaymentMethod.Token, creditCardToken1);
var updateRequest = new CustomerRequest
{
CreditCard = new CreditCardRequest()
{
Options = new CreditCardOptionsRequest()
{
UpdateExistingToken = creditCardToken2,
MakeDefault = true
}
}
};
gateway.Customer.Update(customer.Id, updateRequest);
customer = gateway.Customer.Find(customer.Id);
Assert.AreEqual(customer.DefaultPaymentMethod.Token, creditCardToken2);
}
