public void ParsesNodeCorrectlyWithGooglePayDetails()
{
string xml = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>" +
"<payment-method-nonce>" +
" <type>AndroidPayCard</type>" +
" <nonce>fake-android-pay-nonce</nonce>" +
" <description></description>" +
" <consumed type=\"boolean\">false</consumed>" +
" <details>" +
" <is-network-tokenized>true</is-network-tokenized>" +
" </details>" +
"</payment-method-nonce>";
XmlDocument doc = new XmlDocument();
doc.LoadXml(xml);
XmlNode newNode = doc.DocumentElement;
var node = new NodeWrapper(newNode);
var result = new ResultImpl <PaymentMethodNonce>(node, gateway);
Assert.IsNotNull(result.Target);
Assert.AreEqual("fake-android-pay-nonce", result.Target.Nonce);
Assert.AreEqual("AndroidPayCard", result.Target.Type);
Assert.IsNotNull(result.Target.Details);
Assert.IsTrue(result.Target.Details.IsNetworkTokenized);
}
public void CreateForCurrency_HandlesInvalidCurrency()
{
gateway = new BraintreeGateway(
"client_id$development$signup_client_id",
"client_secret$development$signup_client_secret"
);
ResultImpl <Merchant> merchantResult = gateway.Merchant.Create(new MerchantRequest {
Email = "*****@*****.**",
CountryCodeAlpha3 = "USA",
PaymentMethods = new string[] { "credit_card", "paypal" },
CompanyName = "Ziarog LTD"
});
Assert.IsTrue(merchantResult.IsSuccess());
gateway = new BraintreeGateway(merchantResult.Target.Credentials.AccessToken);
Result <MerchantAccount> result = gateway.MerchantAccount.CreateForCurrency(new MerchantAccountCreateForCurrencyRequest {
Currency = "badCurrency",
});
Assert.IsFalse(result.IsSuccess());
List <ValidationError> errors = result.Errors.ForObject("merchant").OnField("currency");
Assert.AreEqual(1, errors.Count);
Assert.AreEqual(ValidationErrorCode.MERCHANT_CURRENCY_IS_INVALID, errors[0].Code);
}
public async Task CreateForCurrencyAsync()
{
gateway = new BraintreeGateway(
"client_id$development$signup_client_id",
"client_secret$development$signup_client_secret"
);
ResultImpl <Merchant> merchantResult = gateway.Merchant.Create(new MerchantRequest {
Email = "*****@*****.**",
CountryCodeAlpha3 = "USA",
PaymentMethods = new string[] { "credit_card", "paypal" },
CompanyName = "Ziarog LTD"
});
Assert.IsTrue(merchantResult.IsSuccess());
gateway = new BraintreeGateway(merchantResult.Target.Credentials.AccessToken);
Result <MerchantAccount> result = await gateway.MerchantAccount.CreateForCurrencyAsync(new MerchantAccountCreateForCurrencyRequest {
Currency = "GBP",
Id = "testId",
});
Assert.IsTrue(result.IsSuccess());
Assert.AreEqual("testId", result.Target.Id);
Assert.AreEqual("GBP", result.Target.CurrencyIsoCode);
}
public void ParsesNodeCorrectlyWithDetailsMissing()
{
string xml = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>" +
"<payment-method-nonce>" +
" <type>CreditCard</type>" +
" <nonce>fake-valid-nonce</nonce>" +
" <description>ending in 22</description>" +
" <consumed type=\"boolean\">false</consumed>" +
" <three-d-secure-info nil=\"true\"/>" +
"</payment-method-nonce>";
XmlDocument doc = new XmlDocument();
doc.LoadXml(xml);
XmlNode newNode = doc.DocumentElement;
var node = new NodeWrapper(newNode);
var result = new ResultImpl <PaymentMethodNonce>(node, gateway);
Assert.IsNotNull(result.Target);
Assert.AreEqual("fake-valid-nonce", result.Target.Nonce);
Assert.AreEqual("CreditCard", result.Target.Type);
Assert.IsNull(result.Target.ThreeDSecureInfo);
Assert.IsNull(result.Target.Details);
}
public void All_ReturnsAllMerchantAccounts()
{
gateway = new BraintreeGateway(
"client_id$development$integration_client_id",
"client_secret$development$integration_client_secret"
);
var code = OAuthTestHelper.CreateGrant(gateway, "integration_merchant_id", "read_write");
ResultImpl<OAuthCredentials> accessTokenResult = gateway.OAuth.CreateTokenFromCode(new OAuthCredentialsRequest
{
Code = code,
Scope = "read_write"
});
BraintreeGateway OAuthGateway = new BraintreeGateway(accessTokenResult.Target.AccessToken);
var merchantAccountResults = OAuthGateway.MerchantAccount.All();
var merchantAccounts = new List<MerchantAccount>();
foreach (var merchantAccount in merchantAccountResults)
{
merchantAccounts.Add(merchantAccount);
}
Assert.IsTrue(merchantAccounts.Count > 20);
}
public void ParsesNodeCorrectlyWithVenmoDetails()
{
string xml = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>" +
"<payment-method-nonce>" +
" <type>VenmoAccount</type>" +
" <nonce>fake-venmo-account-nonce</nonce>" +
" <description></description>" +
" <consumed type=\"boolean\">false</consumed>" +
" <details>" +
" <last-two>99</last-two>" +
" <username>venmojoe</username>" +
" <venmo-user-id>Venmo-Joe-1</venmo-user-id>" +
" </details>" +
"</payment-method-nonce>";
XmlDocument doc = new XmlDocument();
doc.LoadXml(xml);
XmlNode newNode = doc.DocumentElement;
var node = new NodeWrapper(newNode);
var result = new ResultImpl <PaymentMethodNonce>(node, gateway);
Assert.IsNotNull(result.Target);
Assert.AreEqual("fake-venmo-account-nonce", result.Target.Nonce);
Assert.AreEqual("VenmoAccount", result.Target.Type);
Assert.IsNotNull(result.Target.Details);
Assert.AreEqual("99", result.Target.Details.LastTwo);
Assert.AreEqual("venmojoe", result.Target.Details.Username);
Assert.AreEqual("Venmo-Joe-1", result.Target.Details.VenmoUserId);
}
public void ParsesNodeCorrectlyWithCreditCardDetails()
{
string xml = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>" +
"<payment-method-nonce>" +
" <type>CreditCard</type>" +
" <nonce>fake-visa-nonce</nonce>" +
" <description></description>" +
" <consumed type=\"boolean\">false</consumed>" +
" <details>" +
" <last-two>99</last-two>" +
" <last-four>9999</last-four>" +
" <expiration-month>12</expiration-month>" +
" <expiration-year>2001</expiration-year>" +
" </details>" +
"</payment-method-nonce>";
XmlDocument doc = new XmlDocument();
doc.LoadXml(xml);
XmlNode newNode = doc.DocumentElement;
var node = new NodeWrapper(newNode);
var result = new ResultImpl <PaymentMethodNonce>(node, gateway);
Assert.IsNotNull(result.Target);
Assert.AreEqual("fake-visa-nonce", result.Target.Nonce);
Assert.AreEqual("CreditCard", result.Target.Type);
Assert.IsNotNull(result.Target.Details);
Assert.AreEqual("99", result.Target.Details.LastTwo);
Assert.AreEqual("9999", result.Target.Details.LastFour);
Assert.AreEqual("12", result.Target.Details.ExpirationMonth);
Assert.AreEqual("2001", result.Target.Details.ExpirationYear);
}
public void GetAuthorizationHeader_ReturnsAccessToken()
{
BraintreeGateway oauthGateway = new BraintreeGateway(
"client_id$development$integration_client_id",
"client_secret$development$integration_client_secret"
);
string code = OAuthTestHelper.CreateGrant(oauthGateway, "integration_merchant_id", "read_write");
ResultImpl <OAuthCredentials> accessTokenResult = oauthGateway.OAuth.CreateTokenFromCode(new OAuthCredentialsRequest
{
Code = code,
Scope = "read_write"
});
BraintreeGateway gateway = new BraintreeGateway(accessTokenResult.Target.AccessToken);
Configuration oauthConfiguration = gateway.Configuration;
BraintreeService oauthService = new BraintreeService(oauthConfiguration);
var headers = oauthService.GetAuthorizationHeader();
#if netcore
Assert.AreEqual(oauthConfiguration.AccessToken, headers);
#else
Assert.AreEqual(oauthConfiguration.AccessToken, headers.Split(' ')[1]);
#endif
}
public void VerificationIsLatestVerification()
{
string xml = "<credit-card>"
+ "<verifications>"
+ " <verification>"
+ " <created-at type=\"datetime\">2014-11-20T17:27:15Z</created-at>"
+ " <id>123</id>"
+ " </verification>"
+ " <verification>"
+ " <created-at type=\"datetime\">2014-11-20T17:27:18Z</created-at>"
+ " <id>932</id>"
+ " </verification>"
+ " <verification>"
+ " <created-at type=\"datetime\">2014-11-20T17:27:17Z</created-at>"
+ " <id>456</id>"
+ " </verification>"
+ "</verifications>"
+ "</credit-card>";
XmlDocument doc = new XmlDocument();
doc.LoadXml(xml);
XmlNode newNode = doc.DocumentElement;
var node = new NodeWrapper(newNode);
var result = new ResultImpl<CreditCard>(node, gateway);
Assert.AreEqual("932", result.Target.Verification.Id);
}
public void All_ReturnsMerchantAccountWithCorrectAttributes()
{
gateway = new BraintreeGateway(
"client_id$development$integration_client_id",
"client_secret$development$integration_client_secret"
);
ResultImpl<Merchant> result = gateway.Merchant.Create(new MerchantRequest {
Email = "*****@*****.**",
CountryCodeAlpha3 = "USA",
PaymentMethods = new string[] {"credit_card", "paypal"},
Scope = "read_write,shared_vault_transactions",
});
BraintreeGateway OAuthGateway = new BraintreeGateway(result.Target.Credentials.AccessToken);
PaginatedCollection<MerchantAccount> merchantAccountResults = OAuthGateway.MerchantAccount.All();
var merchantAccounts = new List<MerchantAccount>();
foreach (var ma in merchantAccountResults)
{
merchantAccounts.Add(ma);
}
Assert.AreEqual(1, merchantAccounts.Count);
MerchantAccount merchantAccount = merchantAccounts[0];
Assert.AreEqual("USD", merchantAccount.CurrencyIsoCode);
Assert.AreEqual(MerchantAccountStatus.ACTIVE, merchantAccount.Status);
Assert.IsTrue(merchantAccount.IsDefault);
}
public void Create_IgnoresMultiCurrencyIfOnboardingApplicationIsNotInternal()
{
ResultImpl <Merchant> result = gateway.Merchant.Create(new MerchantRequest {
Email = "*****@*****.**",
CountryCodeAlpha3 = "USA",
PaymentMethods = new string[] { "paypal" },
Currencies = new string[] { "GBP", "USD" },
PayPalAccount = new PayPalOnlyAccountRequest {
ClientId = "paypal_client_id",
ClientSecret = "paypal_client_secret"
}
});
Assert.IsTrue(result.IsSuccess());
Assert.IsFalse(string.IsNullOrEmpty(result.Target.Id));
Assert.AreEqual("*****@*****.**", result.Target.Email);
Assert.AreEqual("*****@*****.**", result.Target.CompanyName);
Assert.AreEqual("USA", result.Target.CountryCodeAlpha3);
Assert.AreEqual("US", result.Target.CountryCodeAlpha2);
Assert.AreEqual("840", result.Target.CountryCodeNumeric);
Assert.AreEqual("United States of America", result.Target.CountryName);
Assert.IsTrue(result.Target.Credentials.AccessToken.StartsWith("access_token$"));
Assert.IsTrue(result.Target.Credentials.RefreshToken.StartsWith("refresh_token$"));
Assert.IsTrue(result.Target.Credentials.ExpiresAt > DateTime.Now);
Assert.AreEqual("bearer", result.Target.Credentials.TokenType);
Assert.AreEqual(1, result.Target.MerchantAccounts.Length);
}
public void VerificationIsLatestVerification()
{
string xml = "<credit-card>"
+ "<verifications>"
+ " <verification>"
+ " <created-at type=\"datetime\">2014-11-20T17:27:15Z</created-at>"
+ " <id>123</id>"
+ " </verification>"
+ " <verification>"
+ " <created-at type=\"datetime\">2014-11-20T17:27:18Z</created-at>"
+ " <id>932</id>"
+ " </verification>"
+ " <verification>"
+ " <created-at type=\"datetime\">2014-11-20T17:27:17Z</created-at>"
+ " <id>456</id>"
+ " </verification>"
+ "</verifications>"
+ "</credit-card>";
XmlDocument doc = new XmlDocument();
doc.LoadXml(xml);
XmlNode newNode = doc.DocumentElement;
var node = new NodeWrapper(newNode);
var result = new ResultImpl <CreditCard>(node, gateway);
Assert.AreEqual("932", result.Target.Verification.Id);
}
internal static async Task <Result <TData> > GetResponse <TData>(this HttpResponseMessage responseMessage)
{
string rawResponse = await responseMessage.Content.ReadAsStringAsync();
TData response = SerializerCache.Deserializer.Deserialize <TData>(new JsonTextReader(new StringReader(rawResponse)));
Result <TData> result = new ResultImpl <TData>(responseMessage, response);
return(result);
}
public void Constructor_documentUploadCanMapFileIsTooLongResponse()
{
XmlDocument doc = new XmlDocument();
doc.LoadXml(FILE_IS_TOO_LONG_RESPONSE);
var result = new ResultImpl <DocumentUpload>(new NodeWrapper(doc.DocumentElement), gateway);
Assert.IsFalse(result.IsSuccess());
Assert.AreEqual(ValidationErrorCode.DOCUMENT_UPLOAD_FILE_IS_TOO_LONG, result.Errors.ForObject("DocumentUpload").OnField("File")[0].Code);
}
public void Create_FailsWithInvalidPaymentMethods()
{
ResultImpl <Merchant> result = gateway.Merchant.Create(new MerchantRequest {
Email = "*****@*****.**",
CountryCodeAlpha3 = "USA",
PaymentMethods = new string[] { "fake_money" }
});
Assert.IsFalse(result.IsSuccess());
Assert.AreEqual(
ValidationErrorCode.MERCHANT_PAYMENT_METHODS_ARE_INVALID,
result.Errors.ForObject("merchant").OnField("payment-methods")[0].Code
);
}
public void CreateTokenFromCode_ReturnsOAuthCredentials()
{
string code = OAuthTestHelper.CreateGrant(gateway, "integration_merchant_id", "read_write");
ResultImpl <OAuthCredentials> result = gateway.OAuth.CreateTokenFromCode(new OAuthCredentialsRequest {
Code = code,
Scope = "read_write"
});
Assert.IsTrue(result.IsSuccess());
Assert.IsNotNull(result.Target.AccessToken);
Assert.IsNotNull(result.Target.RefreshToken);
Assert.IsNotNull(result.Target.ExpiresAt);
Assert.AreEqual("bearer", result.Target.TokenType);
}
public void ParsesNodeCorrectlyWithBinData()
{
string xml = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>" +
"<payment-method-nonce>" +
" <type>CreditCard</type>" +
" <nonce>fake-valid-nonce</nonce>" +
" <description>ending in 22</description>" +
" <consumed type=\"boolean\">false</consumed>" +
" <three-d-secure-info nil=\"true\"/>" +
" <details nil=\"true\"/>" +
" <bin-data>" +
" <healthcare>Yes</healthcare>" +
" <debit>No</debit>" +
" <durbin-regulated>Unknown</durbin-regulated>" +
" <commercial>Unknown</commercial>" +
" <payroll>Unknown</payroll>" +
" <prepaid>NO</prepaid>" +
" <issuing-bank>Unknown</issuing-bank>" +
" <country-of-issuance>Something</country-of-issuance>" +
" <product-id>123</product-id>" +
" </bin-data>" +
"</payment-method-nonce>";
XmlDocument doc = new XmlDocument();
doc.LoadXml(xml);
XmlNode newNode = doc.DocumentElement;
var node = new NodeWrapper(newNode);
var result = new ResultImpl <PaymentMethodNonce>(node, gateway);
Assert.IsNotNull(result.Target);
Assert.AreEqual("fake-valid-nonce", result.Target.Nonce);
Assert.AreEqual("CreditCard", result.Target.Type);
Assert.IsNull(result.Target.ThreeDSecureInfo);
Assert.IsNull(result.Target.Details);
Assert.IsNotNull(result.Target.BinData);
Assert.AreEqual(Braintree.CreditCardCommercial.UNKNOWN, result.Target.BinData.Commercial);
Assert.AreEqual(Braintree.CreditCardDebit.NO, result.Target.BinData.Debit);
Assert.AreEqual(Braintree.CreditCardDurbinRegulated.UNKNOWN, result.Target.BinData.DurbinRegulated);
Assert.AreEqual(Braintree.CreditCardHealthcare.YES, result.Target.BinData.Healthcare);
Assert.AreEqual(Braintree.CreditCardPayroll.UNKNOWN, result.Target.BinData.Payroll);
Assert.AreEqual(Braintree.CreditCardPrepaid.NO, result.Target.BinData.Prepaid);
Assert.AreEqual("Something", result.Target.BinData.CountryOfIssuance);
Assert.AreEqual("123", result.Target.BinData.ProductId);
Assert.AreEqual("Unknown", result.Target.BinData.IssuingBank);
}
public void CreateTokenFromBadCode_ReturnsFailureCode()
{
ResultImpl <OAuthCredentials> result = gateway.OAuth.CreateTokenFromCode(new OAuthCredentialsRequest {
Code = "bad_code",
Scope = "read_write"
});
Assert.IsFalse(result.IsSuccess());
Assert.AreEqual(
ValidationErrorCode.OAUTH_INVALID_GRANT,
result.Errors.ForObject("Credentials").OnField("Code")[0].Code
);
Assert.AreEqual(
"Invalid grant: code not found",
result.Errors.ForObject("Credentials").OnField("Code")[0].Message
);
}
public void Create_MultiCurrencyMerchant()
{
gateway = new BraintreeGateway(
"client_id$development$signup_client_id",
"client_secret$development$signup_client_secret"
);
ResultImpl <Merchant> result = gateway.Merchant.Create(new MerchantRequest {
Email = "*****@*****.**",
CountryCodeAlpha3 = "USA",
PaymentMethods = new string[] { "paypal" },
CompanyName = "Ziarog LTD",
Currencies = new string[] { "GBP", "USD" },
PayPalAccount = new PayPalOnlyAccountRequest {
ClientId = "paypal_client_id",
ClientSecret = "paypal_client_secret"
}
});
Assert.IsTrue(result.IsSuccess());
Assert.IsFalse(string.IsNullOrEmpty(result.Target.Id));
Assert.AreEqual("*****@*****.**", result.Target.Email);
Assert.AreEqual("Ziarog LTD", result.Target.CompanyName);
Assert.AreEqual("USA", result.Target.CountryCodeAlpha3);
Assert.AreEqual("US", result.Target.CountryCodeAlpha2);
Assert.AreEqual("840", result.Target.CountryCodeNumeric);
Assert.AreEqual("United States of America", result.Target.CountryName);
Assert.IsTrue(result.Target.Credentials.AccessToken.StartsWith("access_token$"));
Assert.IsTrue(result.Target.Credentials.RefreshToken.StartsWith("refresh_token$"));
Assert.IsTrue(result.Target.Credentials.ExpiresAt > DateTime.Now);
Assert.AreEqual("bearer", result.Target.Credentials.TokenType);
Assert.AreEqual(2, result.Target.MerchantAccounts.Length);
var usdMerchantAccount = (from ma in result.Target.MerchantAccounts where ma.Id == "USD" select ma).ToArray()[0];
Assert.AreEqual("USD", usdMerchantAccount.CurrencyIsoCode);
Assert.IsTrue(usdMerchantAccount.IsDefault.Value);
var gbpMerchantAccount = (from ma in result.Target.MerchantAccounts where ma.Id == "GBP" select ma).ToArray()[0];
Assert.AreEqual("GBP", gbpMerchantAccount.CurrencyIsoCode);
Assert.IsFalse(gbpMerchantAccount.IsDefault.Value);
}
public void ParseThreeDSecureInfo()
{
string xml = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>" +
"<payment-method-nonce>" +
" <type>CreditCard</type>" +
" <nonce>fake-valid-nonce</nonce>" +
" <description>ending in 22</description>" +
" <consumed type=\"boolean\">false</consumed>" +
" <three-d-secure-info>" +
" <enrolled>Y</enrolled>" +
" <status>authenticate_successful</status>" +
" <liability-shifted>true</liability-shifted>" +
" <liability-shift-possible>true</liability-shift-possible>" +
" <cavv>cavv-value</cavv>" +
" <xid>xid-value</xid>" +
" <ds-transaction-id>ds-trx-id-value</ds-transaction-id>" +
" <eci-flag>06</eci-flag>" +
" <three-d-secure-version>2.0.1</three-d-secure-version>" +
" </three-d-secure-info>" +
" <details nil=\"true\"/>" +
"</payment-method-nonce>";
XmlDocument doc = new XmlDocument();
doc.LoadXml(xml);
XmlNode newNode = doc.DocumentElement;
var node = new NodeWrapper(newNode);
var result = new ResultImpl <PaymentMethodNonce>(node, gateway);
var threeDSecureInfo = result.Target.ThreeDSecureInfo;
Assert.IsNotNull(result.Target.ThreeDSecureInfo);
Assert.AreEqual("Y", threeDSecureInfo.Enrolled);
Assert.AreEqual("authenticate_successful", threeDSecureInfo.Status);
Assert.IsTrue(threeDSecureInfo.LiabilityShifted);
Assert.IsTrue(threeDSecureInfo.LiabilityShiftPossible);
Assert.AreEqual("cavv-value", threeDSecureInfo.Cavv);
Assert.AreEqual("xid-value", threeDSecureInfo.Xid);
Assert.AreEqual("ds-trx-id-value", threeDSecureInfo.DsTransactionId);
Assert.AreEqual("06", threeDSecureInfo.EciFlag);
Assert.AreEqual("2.0.1", threeDSecureInfo.ThreeDSecureVersion);
}
public void ParsesNodeCorrectlyWithoutScaIndicator()
{
string xml = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>" +
"<authentication-insight>" +
" <regulation-environment>bar</regulation-environment>" +
"</authentication-insight>";
XmlDocument doc = new XmlDocument();
doc.LoadXml(xml);
XmlNode newNode = doc.DocumentElement;
var node = new NodeWrapper(newNode);
var result = new ResultImpl <AuthenticationInsightResponse>(node, gateway);
Assert.IsNotNull(result.Target);
Assert.AreEqual(null, result.Target.ScaIndicator);
Assert.AreEqual("bar", result.Target.RegulationEnvironment);
}
public void ParsesNodeCorrectlyWithPayPalDetails()
{
string xml = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>" +
"<payment-method-nonce>" +
" <type>PayPalAccount</type>" +
" <nonce>fake-paypal-account-nonce</nonce>" +
" <description></description>" +
" <consumed type=\"boolean\">false</consumed>" +
" <details>" +
" <payer-info>" +
" <email>[email protected]</email>" +
" <first-name>first</first-name>" +
" <last-name>last</last-name>" +
" <payer-id>pay-123</payer-id>" +
" <country-code>US</country-code>" +
" </payer-info>" +
" </details>" +
"</payment-method-nonce>";
XmlDocument doc = new XmlDocument();
doc.LoadXml(xml);
XmlNode newNode = doc.DocumentElement;
var node = new NodeWrapper(newNode);
var result = new ResultImpl <PaymentMethodNonce>(node, gateway);
Assert.IsNotNull(result.Target);
Assert.AreEqual("fake-paypal-account-nonce", result.Target.Nonce);
Assert.AreEqual("PayPalAccount", result.Target.Type);
Assert.IsNotNull(result.Target.Details);
Assert.IsNotNull(result.Target.Details.PayerInfo);
Assert.AreEqual("*****@*****.**", result.Target.Details.PayerInfo.Email);
Assert.AreEqual("first", result.Target.Details.PayerInfo.FirstName);
Assert.AreEqual("last", result.Target.Details.PayerInfo.LastName);
Assert.AreEqual("pay-123", result.Target.Details.PayerInfo.PayerId);
Assert.AreEqual("US", result.Target.Details.PayerInfo.CountryCode);
}
public void Create_ReturnsMerchantAndCredentials()
{
ResultImpl <Merchant> result = gateway.Merchant.Create(new MerchantRequest {
Email = "*****@*****.**",
CountryCodeAlpha3 = "USA",
PaymentMethods = new string[] { "credit_card", "paypal" }
});
Assert.IsTrue(result.IsSuccess());
Assert.IsFalse(string.IsNullOrEmpty(result.Target.Id));
Assert.AreEqual("*****@*****.**", result.Target.Email);
Assert.AreEqual("*****@*****.**", result.Target.CompanyName);
Assert.AreEqual("USA", result.Target.CountryCodeAlpha3);
Assert.AreEqual("US", result.Target.CountryCodeAlpha2);
Assert.AreEqual("840", result.Target.CountryCodeNumeric);
Assert.AreEqual("United States of America", result.Target.CountryName);
Assert.IsTrue(result.Target.Credentials.AccessToken.StartsWith("access_token$"));
Assert.IsTrue(result.Target.Credentials.ExpiresAt > DateTime.Now);
Assert.IsTrue(string.IsNullOrEmpty(result.Target.Credentials.RefreshToken));
Assert.AreEqual("bearer", result.Target.Credentials.TokenType);
}
public void GetAuthorizationSchema_ReturnsBearerHeader()
{
BraintreeGateway oauthGateway = new BraintreeGateway(
"client_id$development$integration_client_id",
"client_secret$development$integration_client_secret"
);
string code = OAuthTestHelper.CreateGrant(oauthGateway, "integration_merchant_id", "read_write");
ResultImpl <OAuthCredentials> accessTokenResult = oauthGateway.OAuth.CreateTokenFromCode(new OAuthCredentialsRequest
{
Code = code,
Scope = "read_write"
});
BraintreeGateway gateway = new BraintreeGateway(accessTokenResult.Target.AccessToken);
Configuration oauthConfiguration = gateway.Configuration;
BraintreeService oauthService = new BraintreeService(oauthConfiguration);
string schema = oauthService.GetAuthorizationSchema();
Assert.AreEqual("Bearer", schema);
}
public void Create_DefaultsToUSDForNonUSMerchantIfOnboardingApplicationIsInternalAndCountryCurrencyNotSupported()
{
gateway = new BraintreeGateway(
"client_id$development$signup_client_id",
"client_secret$development$signup_client_secret"
);
ResultImpl <Merchant> result = gateway.Merchant.Create(new MerchantRequest {
Email = "*****@*****.**",
CountryCodeAlpha3 = "YEM",
PaymentMethods = new string[] { "paypal" },
PayPalAccount = new PayPalOnlyAccountRequest {
ClientId = "paypal_client_id",
ClientSecret = "paypal_client_secret"
}
});
Assert.IsTrue(result.IsSuccess());
Assert.IsFalse(string.IsNullOrEmpty(result.Target.Id));
Assert.AreEqual("*****@*****.**", result.Target.Email);
Assert.AreEqual("*****@*****.**", result.Target.CompanyName);
Assert.AreEqual("YEM", result.Target.CountryCodeAlpha3);
Assert.AreEqual("YE", result.Target.CountryCodeAlpha2);
Assert.AreEqual("887", result.Target.CountryCodeNumeric);
Assert.AreEqual("Yemen", result.Target.CountryName);
Assert.IsTrue(result.Target.Credentials.AccessToken.StartsWith("access_token$"));
Assert.IsTrue(result.Target.Credentials.RefreshToken.StartsWith("refresh_token$"));
Assert.IsTrue(result.Target.Credentials.ExpiresAt > DateTime.Now);
Assert.AreEqual("bearer", result.Target.Credentials.TokenType);
Assert.AreEqual(1, result.Target.MerchantAccounts.Length);
var merchantAccount = result.Target.MerchantAccounts[0];
Assert.AreEqual("USD", merchantAccount.CurrencyIsoCode);
Assert.IsTrue(merchantAccount.IsDefault.Value);
}
public void ParseAuthenticationInsights()
{
string xml = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>" +
"<payment-method-nonce>" +
" <authentication-insight>" +
" <regulation-environment>bar</regulation-environment>" +
" <sca-indicator>foo</sca-indicator>" +
" </authentication-insight>" +
"</payment-method-nonce>";
XmlDocument doc = new XmlDocument();
doc.LoadXml(xml);
XmlNode newNode = doc.DocumentElement;
var node = new NodeWrapper(newNode);
var result = new ResultImpl <PaymentMethodNonce>(node, gateway);
Assert.IsNotNull(result.Target);
Assert.AreEqual("foo", result.Target.AuthenticationInsight.ScaIndicator);
Assert.AreEqual("bar", result.Target.AuthenticationInsight.RegulationEnvironment);
}
public void Create_CreateCustomerUsingAccessToken()
{
var createRequest = new CustomerRequest()
{
FirstName = "Michael",
LastName = "Angelo",
Company = "Some Company",
Email = "*****@*****.**",
Phone = "312.555.1111",
Fax = "312.555.1112",
Website = "www.example.com",
};
BraintreeGateway oauthGateway = new BraintreeGateway(
"client_id$development$integration_client_id",
"client_secret$development$integration_client_secret"
);
string code = OAuthTestHelper.CreateGrant(oauthGateway, "integration_merchant_id", "read_write");
ResultImpl <OAuthCredentials> accessTokenResult = oauthGateway.OAuth.CreateTokenFromCode(new OAuthCredentialsRequest {
Code = code,
Scope = "read_write"
});
gateway = new BraintreeGateway(accessTokenResult.Target.AccessToken);
Customer customer = gateway.Customer.Create(createRequest).Target;
Assert.AreEqual("Michael", customer.FirstName);
Assert.AreEqual("Angelo", customer.LastName);
Assert.AreEqual("Some Company", customer.Company);
Assert.AreEqual("*****@*****.**", customer.Email);
Assert.AreEqual("312.555.1111", customer.Phone);
Assert.AreEqual("312.555.1112", customer.Fax);
Assert.AreEqual("www.example.com", customer.Website);
Assert.AreEqual(DateTime.Now.Year, customer.CreatedAt.Value.Year);
Assert.AreEqual(DateTime.Now.Year, customer.UpdatedAt.Value.Year);
}
public void RevokeAccessToken_RevokesAccessToken()
{
string code = OAuthTestHelper.CreateGrant(gateway, "integration_merchant_id", "read_write");
ResultImpl <OAuthCredentials> accessTokenResult = gateway.OAuth.CreateTokenFromCode(new OAuthCredentialsRequest {
Code = code,
Scope = "read_write"
});
string accessToken = accessTokenResult.Target.AccessToken;
ResultImpl <OAuthResult> result = gateway.OAuth.RevokeAccessToken(accessToken);
Assert.IsTrue(result.Target.Result.Value);
try {
gateway = new BraintreeGateway(
accessToken
);
gateway.Customer.Create();
Assert.Fail("Should throw AuthenticationException");
} catch (AuthenticationException) {}
}
public void Create_ReturnsErrorIfInvalidCurrencyPassed()
{
gateway = new BraintreeGateway(
"client_id$development$signup_client_id",
"client_secret$development$signup_client_secret"
);
ResultImpl <Merchant> result = gateway.Merchant.Create(new MerchantRequest {
Email = "*****@*****.**",
CountryCodeAlpha3 = "USA",
PaymentMethods = new string[] { "paypal" },
Currencies = new string[] { "GBP", "FAKE" },
PayPalAccount = new PayPalOnlyAccountRequest {
ClientId = "paypal_client_id",
ClientSecret = "paypal_client_secret"
}
});
Assert.IsFalse(result.IsSuccess());
Assert.AreEqual(
ValidationErrorCode.MERCHANT_CURRENCIES_ARE_INVALID,
result.Errors.ForObject("merchant").OnField("currencies")[0].Code
);
}
public void Create_ReturnsErrorIfValidPaymentMethodOtherThanPayPalPassedForMultiCurrency()
{
gateway = new BraintreeGateway(
"client_id$development$signup_client_id",
"client_secret$development$signup_client_secret"
);
ResultImpl <Merchant> result = gateway.Merchant.Create(new MerchantRequest {
Email = "*****@*****.**",
CountryCodeAlpha3 = "USA",
PaymentMethods = new string[] { "credit_card" },
Currencies = new string[] { "GBP", "USD" },
PayPalAccount = new PayPalOnlyAccountRequest {
ClientId = "paypal_client_id",
ClientSecret = "paypal_client_secret"
}
});
Assert.IsFalse(result.IsSuccess());
Assert.AreEqual(
ValidationErrorCode.MERCHANT_PAYMENT_METHODS_ARE_NOT_ALLOWED,
result.Errors.ForObject("merchant").OnField("payment-methods")[0].Code
);
}
