You are here

class Braintree_TransactionTest in Commerce Braintree 7

Same name in this branch
  1. 7 braintree_php/tests/unit/TransactionTest.php \Braintree_TransactionTest
  2. 7 braintree_php/tests/integration/TransactionTest.php \Braintree_TransactionTest

Hierarchy

Expanded class hierarchy of Braintree_TransactionTest

File

braintree_php/tests/integration/TransactionTest.php, line 5

View source
class Braintree_TransactionTest extends PHPUnit_Framework_TestCase {
  function testCloneTransaction() {
    $result = Braintree_Transaction::sale(array(
      'amount' => '100.00',
      'orderId' => '123',
      'creditCard' => array(
        'number' => '5105105105105100',
        'expirationDate' => '05/2011',
      ),
      'customer' => array(
        'firstName' => 'Dan',
      ),
      'billing' => array(
        'firstName' => 'Carl',
      ),
      'shipping' => array(
        'firstName' => 'Andrew',
      ),
    ));
    $this
      ->assertTrue($result->success);
    $transaction = $result->transaction;
    $cloneResult = Braintree_Transaction::cloneTransaction($transaction->id, array(
      'amount' => '123.45',
      'options' => array(
        'submitForSettlement' => false,
      ),
    ));
    Braintree_TestHelper::assertPrintable($cloneResult);
    $this
      ->assertTrue($cloneResult->success);
    $cloneTransaction = $cloneResult->transaction;
    $this
      ->assertEquals('Dan', $cloneTransaction->customerDetails->firstName);
    $this
      ->assertEquals('Carl', $cloneTransaction->billingDetails->firstName);
    $this
      ->assertEquals('Andrew', $cloneTransaction->shippingDetails->firstName);
    $this
      ->assertEquals('510510******5100', $cloneTransaction->creditCardDetails->maskedNumber);
    $this
      ->assertEquals('authorized', $cloneTransaction->status);
  }
  function testCloneTransactionAndSubmitForSettlement() {
    $result = Braintree_Transaction::sale(array(
      'amount' => '100.00',
      'creditCard' => array(
        'number' => '5105105105105100',
        'expirationDate' => '05/2011',
      ),
    ));
    $this
      ->assertTrue($result->success);
    $transaction = $result->transaction;
    $cloneResult = Braintree_Transaction::cloneTransaction($transaction->id, array(
      'amount' => '123.45',
      'options' => array(
        'submitForSettlement' => true,
      ),
    ));
    $cloneTransaction = $cloneResult->transaction;
    $this
      ->assertEquals('submitted_for_settlement', $cloneTransaction->status);
  }
  function testCloneWithValidations() {
    $result = Braintree_Transaction::credit(array(
      'amount' => '100.00',
      'creditCard' => array(
        'number' => '5105105105105100',
        'expirationDate' => '05/2011',
      ),
    ));
    $this
      ->assertTrue($result->success);
    $transaction = $result->transaction;
    $cloneResult = Braintree_Transaction::cloneTransaction($transaction->id, array(
      'amount' => '123.45',
    ));
    $this
      ->assertFalse($cloneResult->success);
    $baseErrors = $cloneResult->errors
      ->forKey('transaction')
      ->onAttribute('base');
    $this
      ->assertEquals(Braintree_Error_Codes::TRANSACTION_CANNOT_CLONE_CREDIT, $baseErrors[0]->code);
  }
  function testSale() {
    $result = Braintree_Transaction::sale(array(
      'amount' => '100.00',
      'creditCard' => array(
        'cardholderName' => 'The Cardholder',
        'number' => '5105105105105100',
        'expirationDate' => '05/12',
      ),
    ));
    $this
      ->assertTrue($result->success);
    $transaction = $result->transaction;
    $this
      ->assertEquals(Braintree_Transaction::AUTHORIZED, $transaction->status);
    $this
      ->assertEquals(Braintree_Transaction::SALE, $transaction->type);
    $this
      ->assertEquals('100.00', $transaction->amount);
    $this
      ->assertNotNull($transaction->processorAuthorizationCode);
    $this
      ->assertEquals('510510', $transaction->creditCardDetails->bin);
    $this
      ->assertEquals('5100', $transaction->creditCardDetails->last4);
    $this
      ->assertEquals('The Cardholder', $transaction->creditCardDetails->cardholderName);
  }
  function testRecurring() {
    $result = Braintree_Transaction::sale(array(
      'amount' => '100.00',
      'recurring' => true,
      'creditCard' => array(
        'cardholderName' => 'The Cardholder',
        'number' => '5105105105105100',
        'expirationDate' => '05/12',
      ),
    ));
    $this
      ->assertTrue($result->success);
    $transaction = $result->transaction;
    $this
      ->assertEquals(true, $transaction->recurring);
  }
  function testSale_withLevel2Attributes() {
    $result = Braintree_Transaction::sale(array(
      'amount' => '100.00',
      'creditCard' => array(
        'cardholderName' => 'The Cardholder',
        'expirationDate' => '05/2011',
        'number' => '5105105105105100',
      ),
      'taxExempt' => true,
      'taxAmount' => '10.00',
      'purchaseOrderNumber' => '12345',
    ));
    $this
      ->assertTrue($result->success);
    $transaction = $result->transaction;
    $this
      ->assertTrue($transaction->taxExempt);
    $this
      ->assertEquals('10.00', $transaction->taxAmount);
    $this
      ->assertEquals('12345', $transaction->purchaseOrderNumber);
  }
  function testSale_withInvalidTaxAmountAttribute() {
    $result = Braintree_Transaction::sale(array(
      'amount' => '100.00',
      'creditCard' => array(
        'cardholderName' => 'The Cardholder',
        'expirationDate' => '05/2011',
        'number' => '5105105105105100',
      ),
      'taxAmount' => 'abc',
    ));
    $this
      ->assertFalse($result->success);
    $taxAmountErrors = $result->errors
      ->forKey('transaction')
      ->onAttribute('taxAmount');
    $this
      ->assertEquals(Braintree_Error_Codes::TRANSACTION_TAX_AMOUNT_FORMAT_IS_INVALID, $taxAmountErrors[0]->code);
  }
  function testSale_withTooLongPurchaseOrderAttribute() {
    $result = Braintree_Transaction::sale(array(
      'amount' => '100.00',
      'creditCard' => array(
        'cardholderName' => 'The Cardholder',
        'expirationDate' => '05/2011',
        'number' => '5105105105105100',
      ),
      'purchaseOrderNumber' => 'aaaaaaaaaaaaaaaaaa',
    ));
    $this
      ->assertFalse($result->success);
    $purchaseOrderNumberErrors = $result->errors
      ->forKey('transaction')
      ->onAttribute('purchaseOrderNumber');
    $this
      ->assertEquals(Braintree_Error_Codes::TRANSACTION_PURCHASE_ORDER_NUMBER_IS_TOO_LONG, $purchaseOrderNumberErrors[0]->code);
  }
  function testSale_withInvalidPurchaseOrderNumber() {
    $result = Braintree_Transaction::sale(array(
      'amount' => '100.00',
      'creditCard' => array(
        'cardholderName' => 'The Cardholder',
        'expirationDate' => '05/2011',
        'number' => '5105105105105100',
      ),
      'purchaseOrderNumber' => "",
    ));
    $this
      ->assertFalse($result->success);
    $purchaseOrderNumberErrors = $result->errors
      ->forKey('transaction')
      ->onAttribute('purchaseOrderNumber');
    $this
      ->assertEquals(Braintree_Error_Codes::TRANSACTION_PURCHASE_ORDER_NUMBER_IS_INVALID, $purchaseOrderNumberErrors[0]->code);
  }
  function testSale_withAllAttributes() {
    $result = Braintree_Transaction::sale(array(
      'amount' => '100.00',
      'orderId' => '123',
      'creditCard' => array(
        'cardholderName' => 'The Cardholder',
        'number' => '5105105105105100',
        'expirationDate' => '05/2011',
        'cvv' => '123',
      ),
      'customer' => array(
        'firstName' => 'Dan',
        'lastName' => 'Smith',
        'company' => 'Braintree Payment Solutions',
        'email' => 'dan@example.com',
        'phone' => '419-555-1234',
        'fax' => '419-555-1235',
        'website' => 'http://braintreepayments.com',
      ),
      'billing' => array(
        'firstName' => 'Carl',
        'lastName' => 'Jones',
        'company' => 'Braintree',
        'streetAddress' => '123 E Main St',
        'extendedAddress' => 'Suite 403',
        'locality' => 'Chicago',
        'region' => 'IL',
        'postalCode' => '60622',
        'countryName' => 'United States of America',
        'countryCodeAlpha2' => 'US',
        'countryCodeAlpha3' => 'USA',
        'countryCodeNumeric' => '840',
      ),
      'shipping' => array(
        'firstName' => 'Andrew',
        'lastName' => 'Mason',
        'company' => 'Braintree',
        'streetAddress' => '456 W Main St',
        'extendedAddress' => 'Apt 2F',
        'locality' => 'Bartlett',
        'region' => 'IL',
        'postalCode' => '60103',
        'countryName' => 'United States of America',
        'countryCodeAlpha2' => 'US',
        'countryCodeAlpha3' => 'USA',
        'countryCodeNumeric' => '840',
      ),
    ));
    Braintree_TestHelper::assertPrintable($result);
    $this
      ->assertTrue($result->success);
    $transaction = $result->transaction;
    $this
      ->assertNotNull($transaction->id);
    $this
      ->assertNotNull($transaction->createdAt);
    $this
      ->assertNotNull($transaction->updatedAt);
    $this
      ->assertNull($transaction->refundId);
    $this
      ->assertEquals(Braintree_TestHelper::defaultMerchantAccountId(), $transaction->merchantAccountId);
    $this
      ->assertEquals(Braintree_Transaction::AUTHORIZED, $transaction->status);
    $this
      ->assertEquals(Braintree_Transaction::SALE, $transaction->type);
    $this
      ->assertEquals('100.00', $transaction->amount);
    $this
      ->assertEquals('USD', $transaction->currencyIsoCode);
    $this
      ->assertEquals('123', $transaction->orderId);
    $this
      ->assertEquals('MasterCard', $transaction->creditCardDetails->cardType);
    $this
      ->assertEquals('1000', $transaction->processorResponseCode);
    $this
      ->assertEquals('Approved', $transaction->processorResponseText);
    $this
      ->assertFalse($transaction->taxExempt);
    $this
      ->assertEquals('M', $transaction->avsPostalCodeResponseCode);
    $this
      ->assertEquals('M', $transaction->avsStreetAddressResponseCode);
    $this
      ->assertEquals('M', $transaction->cvvResponseCode);
    $this
      ->assertEquals('Dan', $transaction->customerDetails->firstName);
    $this
      ->assertEquals('Smith', $transaction->customerDetails->lastName);
    $this
      ->assertEquals('Braintree Payment Solutions', $transaction->customerDetails->company);
    $this
      ->assertEquals('dan@example.com', $transaction->customerDetails->email);
    $this
      ->assertEquals('419-555-1234', $transaction->customerDetails->phone);
    $this
      ->assertEquals('419-555-1235', $transaction->customerDetails->fax);
    $this
      ->assertEquals('http://braintreepayments.com', $transaction->customerDetails->website);
    $this
      ->assertEquals('Carl', $transaction->billingDetails->firstName);
    $this
      ->assertEquals('Jones', $transaction->billingDetails->lastName);
    $this
      ->assertEquals('Braintree', $transaction->billingDetails->company);
    $this
      ->assertEquals('123 E Main St', $transaction->billingDetails->streetAddress);
    $this
      ->assertEquals('Suite 403', $transaction->billingDetails->extendedAddress);
    $this
      ->assertEquals('Chicago', $transaction->billingDetails->locality);
    $this
      ->assertEquals('IL', $transaction->billingDetails->region);
    $this
      ->assertEquals('60622', $transaction->billingDetails->postalCode);
    $this
      ->assertEquals('United States of America', $transaction->billingDetails->countryName);
    $this
      ->assertEquals('US', $transaction->billingDetails->countryCodeAlpha2);
    $this
      ->assertEquals('USA', $transaction->billingDetails->countryCodeAlpha3);
    $this
      ->assertEquals('840', $transaction->billingDetails->countryCodeNumeric);
    $this
      ->assertEquals('Andrew', $transaction->shippingDetails->firstName);
    $this
      ->assertEquals('Mason', $transaction->shippingDetails->lastName);
    $this
      ->assertEquals('Braintree', $transaction->shippingDetails->company);
    $this
      ->assertEquals('456 W Main St', $transaction->shippingDetails->streetAddress);
    $this
      ->assertEquals('Apt 2F', $transaction->shippingDetails->extendedAddress);
    $this
      ->assertEquals('Bartlett', $transaction->shippingDetails->locality);
    $this
      ->assertEquals('IL', $transaction->shippingDetails->region);
    $this
      ->assertEquals('60103', $transaction->shippingDetails->postalCode);
    $this
      ->assertEquals('United States of America', $transaction->shippingDetails->countryName);
    $this
      ->assertEquals('US', $transaction->shippingDetails->countryCodeAlpha2);
    $this
      ->assertEquals('USA', $transaction->shippingDetails->countryCodeAlpha3);
    $this
      ->assertEquals('840', $transaction->shippingDetails->countryCodeNumeric);
    $this
      ->assertNotNull($transaction->processorAuthorizationCode);
    $this
      ->assertEquals('510510', $transaction->creditCardDetails->bin);
    $this
      ->assertEquals('5100', $transaction->creditCardDetails->last4);
    $this
      ->assertEquals('510510******5100', $transaction->creditCardDetails->maskedNumber);
    $this
      ->assertEquals('The Cardholder', $transaction->creditCardDetails->cardholderName);
    $this
      ->assertEquals('05', $transaction->creditCardDetails->expirationMonth);
    $this
      ->assertEquals('2011', $transaction->creditCardDetails->expirationYear);
  }
  function testSale_withCustomFields() {
    $result = Braintree_Transaction::sale(array(
      'amount' => '100.00',
      'creditCard' => array(
        'number' => '5105105105105100',
        'expirationDate' => '05/12',
      ),
      'customFields' => array(
        'store_me' => 'custom value',
      ),
    ));
    $this
      ->assertTrue($result->success);
    $transaction = $result->transaction;
    $customFields = $transaction->customFields;
    $this
      ->assertEquals('custom value', $customFields['store_me']);
  }
  function testSale_withExpirationMonthAndYear() {
    $result = Braintree_Transaction::sale(array(
      'amount' => '100.00',
      'creditCard' => array(
        'number' => '5105105105105100',
        'expirationMonth' => '5',
        'expirationYear' => '2012',
      ),
    ));
    $this
      ->assertTrue($result->success);
    $transaction = $result->transaction;
    $this
      ->assertEquals('05', $transaction->creditCardDetails->expirationMonth);
    $this
      ->assertEquals('2012', $transaction->creditCardDetails->expirationYear);
  }
  function testSale_underscoresAllCustomFields() {
    $result = Braintree_Transaction::sale(array(
      'amount' => '100.00',
      'creditCard' => array(
        'number' => '5105105105105100',
        'expirationDate' => '05/12',
      ),
      'customFields' => array(
        'storeMe' => 'custom value',
      ),
    ));
    $this
      ->assertTrue($result->success);
    $transaction = $result->transaction;
    $customFields = $transaction->customFields;
    $this
      ->assertEquals('custom value', $customFields['store_me']);
  }
  function testSale_withInvalidCustomField() {
    $result = Braintree_Transaction::sale(array(
      'amount' => '100.00',
      'creditCard' => array(
        'number' => '5105105105105100',
        'expirationDate' => '05/12',
      ),
      'customFields' => array(
        'invalidKey' => 'custom value',
      ),
    ));
    $this
      ->assertFalse($result->success);
    $errors = $result->errors
      ->forKey('transaction')
      ->onAttribute('customFields');
    $this
      ->assertEquals(Braintree_Error_Codes::TRANSACTION_CUSTOM_FIELD_IS_INVALID, $errors[0]->code);
    $this
      ->assertEquals('Custom field is invalid: invalidKey.', $errors[0]->message);
  }
  function testSale_withMerchantAccountId() {
    $result = Braintree_Transaction::sale(array(
      'amount' => '100.00',
      'merchantAccountId' => Braintree_TestHelper::nonDefaultMerchantAccountId(),
      'creditCard' => array(
        'number' => '5105105105105100',
        'expirationDate' => '05/12',
      ),
    ));
    $this
      ->assertTrue($result->success);
    $transaction = $result->transaction;
    $this
      ->assertEquals(Braintree_TestHelper::nonDefaultMerchantAccountId(), $transaction->merchantAccountId);
  }
  function testSale_withoutMerchantAccountIdFallsBackToDefault() {
    $result = Braintree_Transaction::sale(array(
      'amount' => '100.00',
      'creditCard' => array(
        'number' => '5105105105105100',
        'expirationDate' => '05/12',
      ),
    ));
    $this
      ->assertTrue($result->success);
    $transaction = $result->transaction;
    $this
      ->assertEquals(Braintree_TestHelper::defaultMerchantAccountId(), $transaction->merchantAccountId);
  }
  function testSale_withShippingAddressId() {
    $customer = Braintree_Customer::create(array(
      'firstName' => 'Mike',
      'creditCard' => array(
        'cardholderName' => 'The Cardholder',
        'number' => Braintree_Test_CreditCardNumbers::$visa,
        'expirationDate' => '05/12',
      ),
    ))->customer;
    $address = Braintree_Address::create(array(
      'customerId' => $customer->id,
      'streetAddress' => '123 Fake St.',
    ))->address;
    $result = Braintree_Transaction::sale(array(
      'amount' => '100.00',
      'customerId' => $customer->id,
      'shippingAddressId' => $address->id,
    ));
    $this
      ->assertTrue($result->success);
    $transaction = $result->transaction;
    $this
      ->assertEquals('123 Fake St.', $transaction->shippingDetails->streetAddress);
    $this
      ->assertEquals($address->id, $transaction->shippingDetails->id);
  }
  function testSaleNoValidate() {
    $transaction = Braintree_Transaction::saleNoValidate(array(
      'amount' => '100.00',
      'creditCard' => array(
        'number' => '5105105105105100',
        'expirationDate' => '05/12',
      ),
    ));
    $this
      ->assertEquals(Braintree_Transaction::AUTHORIZED, $transaction->status);
    $this
      ->assertEquals(Braintree_Transaction::SALE, $transaction->type);
    $this
      ->assertEquals('100.00', $transaction->amount);
    $this
      ->assertEquals('510510', $transaction->creditCardDetails->bin);
    $this
      ->assertEquals('5100', $transaction->creditCardDetails->last4);
  }
  function testSale_withProcessorDecline() {
    $result = Braintree_Transaction::sale(array(
      'amount' => Braintree_Test_TransactionAmounts::$decline,
      'creditCard' => array(
        'number' => '5105105105105100',
        'expirationDate' => '05/12',
      ),
    ));
    $this
      ->assertFalse($result->success);
    $this
      ->assertEquals(Braintree_Transaction::PROCESSOR_DECLINED, $result->transaction->status);
    $this
      ->assertEquals(2000, $result->transaction->processorResponseCode);
    $this
      ->assertEquals("Do Not Honor", $result->transaction->processorResponseText);
  }
  function testSale_withExistingCustomer() {
    $customer = Braintree_Customer::create(array(
      'firstName' => 'Mike',
      'lastName' => 'Jones',
      'company' => 'Jones Co.',
      'email' => 'mike.jones@example.com',
      'phone' => '419.555.1234',
      'fax' => '419.555.1235',
      'website' => 'http://example.com',
    ))->customer;
    $transaction = Braintree_Transaction::sale(array(
      'amount' => '100.00',
      'customerId' => $customer->id,
      'creditCard' => array(
        'cardholderName' => 'The Cardholder',
        'number' => Braintree_Test_CreditCardNumbers::$visa,
        'expirationDate' => '05/12',
      ),
    ))->transaction;
    $this
      ->assertEquals($transaction->creditCardDetails->maskedNumber, '401288******1881');
    $this
      ->assertNull($transaction
      ->vaultCreditCard());
  }
  function testSale_andStoreShippingAddressInVault() {
    $customer = Braintree_Customer::create(array(
      'firstName' => 'Mike',
      'lastName' => 'Jones',
      'company' => 'Jones Co.',
      'email' => 'mike.jones@example.com',
      'phone' => '419.555.1234',
      'fax' => '419.555.1235',
      'website' => 'http://example.com',
    ))->customer;
    $transaction = Braintree_Transaction::sale(array(
      'amount' => '100.00',
      'customerId' => $customer->id,
      'creditCard' => array(
        'cardholderName' => 'The Cardholder',
        'number' => Braintree_Test_CreditCardNumbers::$visa,
        'expirationDate' => '05/12',
      ),
      'shipping' => array(
        'firstName' => 'Darren',
        'lastName' => 'Stevens',
      ),
      'options' => array(
        'storeInVault' => true,
        'storeShippingAddressInVault' => true,
      ),
    ))->transaction;
    $customer = Braintree_Customer::find($customer->id);
    $this
      ->assertEquals('Darren', $customer->addresses[0]->firstName);
    $this
      ->assertEquals('Stevens', $customer->addresses[0]->lastName);
  }
  function testSale_withExistingCustomer_storeInVault() {
    $customer = Braintree_Customer::create(array(
      'firstName' => 'Mike',
      'lastName' => 'Jones',
      'company' => 'Jones Co.',
      'email' => 'mike.jones@example.com',
      'phone' => '419.555.1234',
      'fax' => '419.555.1235',
      'website' => 'http://example.com',
    ))->customer;
    $transaction = Braintree_Transaction::sale(array(
      'amount' => '100.00',
      'customerId' => $customer->id,
      'creditCard' => array(
        'cardholderName' => 'The Cardholder',
        'number' => Braintree_Test_CreditCardNumbers::$visa,
        'expirationDate' => '05/12',
      ),
      'options' => array(
        'storeInVault' => true,
      ),
    ))->transaction;
    $this
      ->assertEquals($transaction->creditCardDetails->maskedNumber, '401288******1881');
    $this
      ->assertEquals($transaction
      ->vaultCreditCard()->maskedNumber, '401288******1881');
  }
  function testCredit() {
    $result = Braintree_Transaction::credit(array(
      'amount' => '100.00',
      'creditCard' => array(
        'number' => '5105105105105100',
        'expirationDate' => '05/12',
      ),
    ));
    $this
      ->assertTrue($result->success);
    $transaction = $result->transaction;
    $this
      ->assertEquals(Braintree_Transaction::SUBMITTED_FOR_SETTLEMENT, $transaction->status);
    $this
      ->assertEquals(Braintree_Transaction::CREDIT, $transaction->type);
    $this
      ->assertEquals('100.00', $transaction->amount);
    $this
      ->assertEquals('510510', $transaction->creditCardDetails->bin);
    $this
      ->assertEquals('5100', $transaction->creditCardDetails->last4);
  }
  function testCreditNoValidate() {
    $transaction = Braintree_Transaction::creditNoValidate(array(
      'amount' => '100.00',
      'creditCard' => array(
        'number' => '5105105105105100',
        'expirationDate' => '05/12',
      ),
    ));
    $this
      ->assertEquals(Braintree_Transaction::CREDIT, $transaction->type);
    $this
      ->assertEquals(Braintree_Transaction::SUBMITTED_FOR_SETTLEMENT, $transaction->status);
    $this
      ->assertEquals('100.00', $transaction->amount);
    $this
      ->assertEquals('510510', $transaction->creditCardDetails->bin);
    $this
      ->assertEquals('5100', $transaction->creditCardDetails->last4);
  }
  function testCredit_withMerchantAccountId() {
    $result = Braintree_Transaction::credit(array(
      'amount' => '100.00',
      'merchantAccountId' => Braintree_TestHelper::nonDefaultMerchantAccountId(),
      'creditCard' => array(
        'number' => '5105105105105100',
        'expirationDate' => '05/12',
      ),
    ));
    $this
      ->assertTrue($result->success);
    $transaction = $result->transaction;
    $this
      ->assertEquals(Braintree_TestHelper::nonDefaultMerchantAccountId(), $transaction->merchantAccountId);
  }
  function testCredit_withoutMerchantAccountIdFallsBackToDefault() {
    $result = Braintree_Transaction::credit(array(
      'amount' => '100.00',
      'creditCard' => array(
        'number' => '5105105105105100',
        'expirationDate' => '05/12',
      ),
    ));
    $this
      ->assertTrue($result->success);
    $transaction = $result->transaction;
    $this
      ->assertEquals(Braintree_TestHelper::defaultMerchantAccountId(), $transaction->merchantAccountId);
  }
  function testSubmitForSettlement_nullAmount() {
    $transaction = Braintree_Transaction::saleNoValidate(array(
      'amount' => '100.00',
      'creditCard' => array(
        'number' => '5105105105105100',
        'expirationDate' => '05/12',
      ),
    ));
    $this
      ->assertEquals(Braintree_Transaction::AUTHORIZED, $transaction->status);
    $submitResult = Braintree_Transaction::submitForSettlement($transaction->id);
    $this
      ->assertEquals(true, $submitResult->success);
    $this
      ->assertEquals(Braintree_Transaction::SUBMITTED_FOR_SETTLEMENT, $submitResult->transaction->status);
    $this
      ->assertEquals('100.00', $submitResult->transaction->amount);
  }
  function testSubmitForSettlement_withAmount() {
    $transaction = Braintree_Transaction::saleNoValidate(array(
      'amount' => '100.00',
      'creditCard' => array(
        'number' => '5105105105105100',
        'expirationDate' => '05/12',
      ),
    ));
    $this
      ->assertEquals(Braintree_Transaction::AUTHORIZED, $transaction->status);
    $submitResult = Braintree_Transaction::submitForSettlement($transaction->id, '50.00');
    $this
      ->assertEquals(true, $submitResult->success);
    $this
      ->assertEquals(Braintree_Transaction::SUBMITTED_FOR_SETTLEMENT, $submitResult->transaction->status);
    $this
      ->assertEquals('50.00', $submitResult->transaction->amount);
  }
  function testSubmitForSettlementNoValidate_whenValidWithoutAmount() {
    $transaction = Braintree_Transaction::saleNoValidate(array(
      'amount' => '100.00',
      'creditCard' => array(
        'number' => '5105105105105100',
        'expirationDate' => '05/12',
      ),
    ));
    $this
      ->assertEquals(Braintree_Transaction::AUTHORIZED, $transaction->status);
    $submittedTransaction = Braintree_Transaction::submitForSettlementNoValidate($transaction->id);
    $this
      ->assertEquals(Braintree_Transaction::SUBMITTED_FOR_SETTLEMENT, $submittedTransaction->status);
    $this
      ->assertEquals('100.00', $submittedTransaction->amount);
  }
  function testSubmitForSettlementNoValidate_whenValidWithAmount() {
    $transaction = Braintree_Transaction::saleNoValidate(array(
      'amount' => '100.00',
      'creditCard' => array(
        'number' => '5105105105105100',
        'expirationDate' => '05/12',
      ),
    ));
    $this
      ->assertEquals(Braintree_Transaction::AUTHORIZED, $transaction->status);
    $submittedTransaction = Braintree_Transaction::submitForSettlementNoValidate($transaction->id, '99.00');
    $this
      ->assertEquals(Braintree_Transaction::SUBMITTED_FOR_SETTLEMENT, $submittedTransaction->status);
    $this
      ->assertEquals('99.00', $submittedTransaction->amount);
  }
  function testSubmitForSettlementNoValidate_whenInvalid() {
    $transaction = Braintree_Transaction::saleNoValidate(array(
      'amount' => '100.00',
      'creditCard' => array(
        'number' => '5105105105105100',
        'expirationDate' => '05/12',
      ),
    ));
    $this
      ->assertEquals(Braintree_Transaction::AUTHORIZED, $transaction->status);
    $this
      ->setExpectedException('Braintree_Exception_ValidationsFailed');
    $submittedTransaction = Braintree_Transaction::submitForSettlementNoValidate($transaction->id, '101.00');
  }
  function testVoid() {
    $transaction = Braintree_Transaction::saleNoValidate(array(
      'amount' => '100.00',
      'creditCard' => array(
        'number' => '5105105105105100',
        'expirationDate' => '05/12',
      ),
    ));
    $this
      ->assertEquals(Braintree_Transaction::AUTHORIZED, $transaction->status);
    $voidResult = Braintree_Transaction::void($transaction->id);
    $this
      ->assertEquals(true, $voidResult->success);
    $this
      ->assertEquals(Braintree_Transaction::VOIDED, $voidResult->transaction->status);
  }
  function test_countryValidationError_inconsistency() {
    $result = Braintree_Transaction::sale(array(
      'amount' => '100.00',
      'creditCard' => array(
        'number' => '5105105105105100',
        'expirationDate' => '05/12',
      ),
      'billing' => array(
        'countryCodeAlpha2' => 'AS',
        'countryCodeAlpha3' => 'USA',
      ),
    ));
    $this
      ->assertFalse($result->success);
    $errors = $result->errors
      ->forKey('transaction')
      ->forKey('billing')
      ->onAttribute('base');
    $this
      ->assertEquals(Braintree_Error_Codes::ADDRESS_INCONSISTENT_COUNTRY, $errors[0]->code);
  }
  function test_countryValidationError_incorrectAlpha2() {
    $result = Braintree_Transaction::sale(array(
      'amount' => '100.00',
      'creditCard' => array(
        'number' => '5105105105105100',
        'expirationDate' => '05/12',
      ),
      'billing' => array(
        'countryCodeAlpha2' => 'ZZ',
      ),
    ));
    $this
      ->assertFalse($result->success);
    $errors = $result->errors
      ->forKey('transaction')
      ->forKey('billing')
      ->onAttribute('countryCodeAlpha2');
    $this
      ->assertEquals(Braintree_Error_Codes::ADDRESS_COUNTRY_CODE_ALPHA2_IS_NOT_ACCEPTED, $errors[0]->code);
  }
  function test_countryValidationError_incorrectAlpha3() {
    $result = Braintree_Transaction::sale(array(
      'amount' => '100.00',
      'creditCard' => array(
        'number' => '5105105105105100',
        'expirationDate' => '05/12',
      ),
      'billing' => array(
        'countryCodeAlpha3' => 'ZZZ',
      ),
    ));
    $this
      ->assertFalse($result->success);
    $errors = $result->errors
      ->forKey('transaction')
      ->forKey('billing')
      ->onAttribute('countryCodeAlpha3');
    $this
      ->assertEquals(Braintree_Error_Codes::ADDRESS_COUNTRY_CODE_ALPHA3_IS_NOT_ACCEPTED, $errors[0]->code);
  }
  function test_countryValidationError_incorrectNumericCode() {
    $result = Braintree_Transaction::sale(array(
      'amount' => '100.00',
      'creditCard' => array(
        'number' => '5105105105105100',
        'expirationDate' => '05/12',
      ),
      'billing' => array(
        'countryCodeNumeric' => '000',
      ),
    ));
    $this
      ->assertFalse($result->success);
    $errors = $result->errors
      ->forKey('transaction')
      ->forKey('billing')
      ->onAttribute('countryCodeNumeric');
    $this
      ->assertEquals(Braintree_Error_Codes::ADDRESS_COUNTRY_CODE_NUMERIC_IS_NOT_ACCEPTED, $errors[0]->code);
  }
  function testVoid_withValidationError() {
    $transaction = Braintree_Transaction::saleNoValidate(array(
      'amount' => '100.00',
      'creditCard' => array(
        'number' => '5105105105105100',
        'expirationDate' => '05/12',
      ),
    ));
    $this
      ->assertEquals(Braintree_Transaction::AUTHORIZED, $transaction->status);
    $voided = Braintree_Transaction::voidNoValidate($transaction->id);
    $this
      ->assertEquals(Braintree_Transaction::VOIDED, $voided->status);
    $result = Braintree_Transaction::void($transaction->id);
    $this
      ->assertEquals(false, $result->success);
    $errors = $result->errors
      ->forKey('transaction')
      ->onAttribute('base');
    $this
      ->assertEquals(Braintree_Error_Codes::TRANSACTION_CANNOT_BE_VOIDED, $errors[0]->code);
  }
  function testVoidNoValidate() {
    $transaction = Braintree_Transaction::saleNoValidate(array(
      'amount' => '100.00',
      'creditCard' => array(
        'number' => '5105105105105100',
        'expirationDate' => '05/12',
      ),
    ));
    $this
      ->assertEquals(Braintree_Transaction::AUTHORIZED, $transaction->status);
    $voided = Braintree_Transaction::voidNoValidate($transaction->id);
    $this
      ->assertEquals(Braintree_Transaction::VOIDED, $voided->status);
  }
  function testVoidNoValidate_throwsIfNotInvalid() {
    $transaction = Braintree_Transaction::saleNoValidate(array(
      'amount' => '100.00',
      'creditCard' => array(
        'number' => '5105105105105100',
        'expirationDate' => '05/12',
      ),
    ));
    $this
      ->assertEquals(Braintree_Transaction::AUTHORIZED, $transaction->status);
    $voided = Braintree_Transaction::voidNoValidate($transaction->id);
    $this
      ->assertEquals(Braintree_Transaction::VOIDED, $voided->status);
    $this
      ->setExpectedException('Braintree_Exception_ValidationsFailed');
    $voided = Braintree_Transaction::voidNoValidate($transaction->id);
  }
  function testFind() {
    $result = Braintree_Transaction::sale(array(
      'amount' => '100.00',
      'creditCard' => array(
        'number' => '5105105105105100',
        'expirationDate' => '05/12',
      ),
    ));
    $transaction = Braintree_Transaction::find($result->transaction->id);
    $this
      ->assertEquals(Braintree_Transaction::AUTHORIZED, $transaction->status);
    $this
      ->assertEquals(Braintree_Transaction::SALE, $transaction->type);
    $this
      ->assertEquals('100.00', $transaction->amount);
    $this
      ->assertEquals('510510', $transaction->creditCardDetails->bin);
    $this
      ->assertEquals('5100', $transaction->creditCardDetails->last4);
  }
  function testSale_storeInVault() {
    $transaction = Braintree_Transaction::saleNoValidate(array(
      'amount' => '100.00',
      'creditCard' => array(
        'cardholderName' => 'Card Holder',
        'number' => '5105105105105100',
        'expirationDate' => '05/12',
      ),
      'customer' => array(
        'firstName' => 'Dan',
        'lastName' => 'Smith',
        'company' => 'Braintree Payment Solutions',
        'email' => 'dan@example.com',
        'phone' => '419-555-1234',
        'fax' => '419-555-1235',
        'website' => 'http://getbraintree.com',
      ),
      'options' => array(
        'storeInVault' => true,
      ),
    ));
    $this
      ->assertNotNull($transaction->creditCardDetails->token);
    $creditCard = $transaction
      ->vaultCreditCard();
    $this
      ->assertEquals('510510', $creditCard->bin);
    $this
      ->assertEquals('5100', $creditCard->last4);
    $this
      ->assertEquals('05/2012', $creditCard->expirationDate);
    $this
      ->assertEquals('Card Holder', $creditCard->cardholderName);
    $customer = $transaction
      ->vaultCustomer();
    $this
      ->assertEquals('Dan', $customer->firstName);
    $this
      ->assertEquals('Smith', $customer->lastName);
    $this
      ->assertEquals('Braintree Payment Solutions', $customer->company);
    $this
      ->assertEquals('dan@example.com', $customer->email);
    $this
      ->assertEquals('419-555-1234', $customer->phone);
    $this
      ->assertEquals('419-555-1235', $customer->fax);
    $this
      ->assertEquals('http://getbraintree.com', $customer->website);
  }
  function testSale_storeInVaultOnSuccessWithSuccessfulTransaction() {
    $transaction = Braintree_Transaction::saleNoValidate(array(
      'amount' => '100.00',
      'creditCard' => array(
        'cardholderName' => 'Card Holder',
        'number' => '5105105105105100',
        'expirationDate' => '05/12',
      ),
      'customer' => array(
        'firstName' => 'Dan',
        'lastName' => 'Smith',
        'company' => 'Braintree Payment Solutions',
        'email' => 'dan@example.com',
        'phone' => '419-555-1234',
        'fax' => '419-555-1235',
        'website' => 'http://getbraintree.com',
      ),
      'options' => array(
        'storeInVaultOnSuccess' => true,
      ),
    ));
    $this
      ->assertNotNull($transaction->creditCardDetails->token);
    $creditCard = $transaction
      ->vaultCreditCard();
    $this
      ->assertEquals('510510', $creditCard->bin);
    $this
      ->assertEquals('5100', $creditCard->last4);
    $this
      ->assertEquals('05/2012', $creditCard->expirationDate);
    $this
      ->assertEquals('Card Holder', $creditCard->cardholderName);
    $customer = $transaction
      ->vaultCustomer();
    $this
      ->assertEquals('Dan', $customer->firstName);
    $this
      ->assertEquals('Smith', $customer->lastName);
    $this
      ->assertEquals('Braintree Payment Solutions', $customer->company);
    $this
      ->assertEquals('dan@example.com', $customer->email);
    $this
      ->assertEquals('419-555-1234', $customer->phone);
    $this
      ->assertEquals('419-555-1235', $customer->fax);
    $this
      ->assertEquals('http://getbraintree.com', $customer->website);
  }
  function testSale_storeInVaultOnSuccessWithFailedTransaction() {
    $result = Braintree_Transaction::sale(array(
      'amount' => Braintree_Test_TransactionAmounts::$decline,
      'creditCard' => array(
        'cardholderName' => 'Card Holder',
        'number' => '5105105105105100',
        'expirationDate' => '05/12',
      ),
      'customer' => array(
        'firstName' => 'Dan',
        'lastName' => 'Smith',
        'company' => 'Braintree Payment Solutions',
        'email' => 'dan@example.com',
        'phone' => '419-555-1234',
        'fax' => '419-555-1235',
        'website' => 'http://getbraintree.com',
      ),
      'options' => array(
        'storeInVaultOnSuccess' => true,
      ),
    ));
    $transaction = $result->transaction;
    $this
      ->assertNull($transaction->creditCardDetails->token);
    $this
      ->assertNull($transaction
      ->vaultCreditCard());
    $this
      ->assertNull($transaction->customerDetails->id);
    $this
      ->assertNull($transaction
      ->vaultCustomer());
  }
  function testSale_withDescriptor() {
    $result = Braintree_Transaction::sale(array(
      'amount' => '100.00',
      'creditCard' => array(
        'number' => '5105105105105100',
        'expirationDate' => '05/12',
      ),
      'descriptor' => array(
        'name' => '123*123456789012345678',
        'phone' => '3334445555',
      ),
    ));
    $this
      ->assertTrue($result->success);
    $transaction = $result->transaction;
    $this
      ->assertEquals('123*123456789012345678', $transaction->descriptor->name);
    $this
      ->assertEquals('3334445555', $transaction->descriptor->phone);
  }
  function testSale_withDescriptorValidation() {
    $result = Braintree_Transaction::sale(array(
      'amount' => '100.00',
      'creditCard' => array(
        'number' => '5105105105105100',
        'expirationDate' => '05/12',
      ),
      'descriptor' => array(
        'name' => 'badcompanyname12*badproduct12',
        'phone' => '%bad4445555',
      ),
    ));
    $this
      ->assertFalse($result->success);
    $transaction = $result->transaction;
    $errors = $result->errors
      ->forKey('transaction')
      ->forKey('descriptor')
      ->onAttribute('name');
    $this
      ->assertEquals(Braintree_Error_Codes::DESCRIPTOR_NAME_FORMAT_IS_INVALID, $errors[0]->code);
    $errors = $result->errors
      ->forKey('transaction')
      ->forKey('descriptor')
      ->onAttribute('phone');
    $this
      ->assertEquals(Braintree_Error_Codes::DESCRIPTOR_PHONE_FORMAT_IS_INVALID, $errors[0]->code);
  }
  function testCreateFromTransparentRedirect() {
    Braintree_TestHelper::suppressDeprecationWarnings();
    $queryString = $this
      ->createTransactionViaTr(array(
      'transaction' => array(
        'customer' => array(
          'first_name' => 'First',
        ),
        'credit_card' => array(
          'number' => '5105105105105100',
          'expiration_date' => '05/12',
        ),
      ),
    ), array(
      'transaction' => array(
        'type' => Braintree_Transaction::SALE,
        'amount' => '100.00',
      ),
    ));
    $result = Braintree_Transaction::createFromTransparentRedirect($queryString);
    Braintree_TestHelper::assertPrintable($result);
    $this
      ->assertTrue($result->success);
    $this
      ->assertEquals('100.00', $result->transaction->amount);
    $this
      ->assertEquals(Braintree_Transaction::SALE, $result->transaction->type);
    $this
      ->assertEquals(Braintree_Transaction::AUTHORIZED, $result->transaction->status);
    $creditCard = $result->transaction->creditCardDetails;
    $this
      ->assertEquals('510510', $creditCard->bin);
    $this
      ->assertEquals('5100', $creditCard->last4);
    $this
      ->assertEquals('US', $creditCard->customerLocation);
    $this
      ->assertEquals('MasterCard', $creditCard->cardType);
    $this
      ->assertEquals('05/2012', $creditCard->expirationDate);
    $this
      ->assertEquals('510510******5100', $creditCard->maskedNumber);
    $customer = $result->transaction->customerDetails;
    $this
      ->assertequals('First', $customer->firstName);
  }
  function testCreateFromTransparentRedirectWithInvalidParams() {
    Braintree_TestHelper::suppressDeprecationWarnings();
    $queryString = $this
      ->createTransactionViaTr(array(
      'transaction' => array(
        'bad_key' => 'bad_value',
        'customer' => array(
          'first_name' => 'First',
        ),
        'credit_card' => array(
          'number' => '5105105105105100',
          'expiration_date' => '05/12',
        ),
      ),
    ), array(
      'transaction' => array(
        'type' => Braintree_Transaction::SALE,
        'amount' => '100.00',
      ),
    ));
    try {
      $result = Braintree_Transaction::createFromTransparentRedirect($queryString);
      $this
        ->fail();
    } catch (Braintree_Exception_Authorization $e) {
      $this
        ->assertEquals("Invalid params: transaction[bad_key]", $e
        ->getMessage());
    }
  }
  function testCreateFromTransparentRedirect_withParamsInTrData() {
    Braintree_TestHelper::suppressDeprecationWarnings();
    $queryString = $this
      ->createTransactionViaTr(array(), array(
      'transaction' => array(
        'type' => Braintree_Transaction::SALE,
        'amount' => '100.00',
        'customer' => array(
          'firstName' => 'First',
        ),
        'creditCard' => array(
          'number' => '5105105105105100',
          'expirationDate' => '05/12',
        ),
      ),
    ));
    $result = Braintree_Transaction::createFromTransparentRedirect($queryString);
    $this
      ->assertTrue($result->success);
    $this
      ->assertEquals('100.00', $result->transaction->amount);
    $this
      ->assertEquals(Braintree_Transaction::SALE, $result->transaction->type);
    $this
      ->assertEquals(Braintree_Transaction::AUTHORIZED, $result->transaction->status);
    $creditCard = $result->transaction->creditCardDetails;
    $this
      ->assertEquals('510510', $creditCard->bin);
    $this
      ->assertEquals('5100', $creditCard->last4);
    $this
      ->assertEquals('US', $creditCard->customerLocation);
    $this
      ->assertEquals('MasterCard', $creditCard->cardType);
    $this
      ->assertEquals('05/2012', $creditCard->expirationDate);
    $this
      ->assertEquals('510510******5100', $creditCard->maskedNumber);
    $customer = $result->transaction->customerDetails;
    $this
      ->assertequals('First', $customer->firstName);
  }
  function testCreateFromTransparentRedirect_withValidationErrors() {
    Braintree_TestHelper::suppressDeprecationWarnings();
    $queryString = $this
      ->createTransactionViaTr(array(
      'transaction' => array(
        'customer' => array(
          'first_name' => str_repeat('x', 256),
        ),
        'credit_card' => array(
          'number' => 'invalid',
          'expiration_date' => '',
        ),
      ),
    ), array(
      'transaction' => array(
        'type' => Braintree_Transaction::SALE,
      ),
    ));
    $result = Braintree_Transaction::createFromTransparentRedirect($queryString);
    $this
      ->assertFalse($result->success);
    $errors = $result->errors
      ->forKey('transaction')
      ->forKey('customer')
      ->onAttribute('firstName');
    $this
      ->assertEquals(Braintree_Error_Codes::CUSTOMER_FIRST_NAME_IS_TOO_LONG, $errors[0]->code);
    $errors = $result->errors
      ->forKey('transaction')
      ->forKey('creditCard')
      ->onAttribute('number');
    $this
      ->assertTrue(count($errors) > 0);
    $errors = $result->errors
      ->forKey('transaction')
      ->forKey('creditCard')
      ->onAttribute('expirationDate');
    $this
      ->assertEquals(Braintree_Error_Codes::CREDIT_CARD_EXPIRATION_DATE_IS_REQUIRED, $errors[0]->code);
  }
  function testRefund() {
    $transaction = $this
      ->createTransactionToRefund();
    $result = Braintree_Transaction::refund($transaction->id);
    $this
      ->assertTrue($result->success);
    $refund = $result->transaction;
    $this
      ->assertEquals(Braintree_Transaction::CREDIT, $refund->type);
    $this
      ->assertEquals($transaction->id, $refund->refundedTransactionId);
    $this
      ->assertEquals($refund->id, Braintree_Transaction::find($transaction->id)->refundId);
  }
  function testRefundWithPartialAmount() {
    $transaction = $this
      ->createTransactionToRefund();
    $result = Braintree_Transaction::refund($transaction->id, '50.00');
    $this
      ->assertTrue($result->success);
    $this
      ->assertEquals(Braintree_Transaction::CREDIT, $result->transaction->type);
    $this
      ->assertEquals("50.00", $result->transaction->amount);
  }
  function testMultipleRefundsWithPartialAmounts() {
    $transaction = $this
      ->createTransactionToRefund();
    $transaction1 = Braintree_Transaction::refund($transaction->id, '50.00')->transaction;
    $this
      ->assertEquals(Braintree_Transaction::CREDIT, $transaction1->type);
    $this
      ->assertEquals("50.00", $transaction1->amount);
    $transaction2 = Braintree_Transaction::refund($transaction->id, '50.00')->transaction;
    $this
      ->assertEquals(Braintree_Transaction::CREDIT, $transaction2->type);
    $this
      ->assertEquals("50.00", $transaction2->amount);
    $transaction = Braintree_Transaction::find($transaction->id);
    $expectedRefundIds = array(
      $transaction1->id,
      $transaction2->id,
    );
    $refundIds = $transaction->refundIds;
    sort($expectedRefundIds);
    sort($refundIds);
    $this
      ->assertEquals($expectedRefundIds, $refundIds);
  }
  function testRefundWithUnsuccessfulPartialAmount() {
    $transaction = $this
      ->createTransactionToRefund();
    $result = Braintree_Transaction::refund($transaction->id, '150.00');
    $this
      ->assertFalse($result->success);
    $errors = $result->errors
      ->forKey('transaction')
      ->onAttribute('amount');
    $this
      ->assertEquals(Braintree_Error_Codes::TRANSACTION_REFUND_AMOUNT_IS_TOO_LARGE, $errors[0]->code);
  }
  function testGatewayRejectionOnAvs() {
    $old_merchant_id = Braintree_Configuration::merchantId();
    $old_public_key = Braintree_Configuration::publicKey();
    $old_private_key = Braintree_Configuration::privateKey();
    Braintree_Configuration::merchantId('processing_rules_merchant_id');
    Braintree_Configuration::publicKey('processing_rules_public_key');
    Braintree_Configuration::privateKey('processing_rules_private_key');
    $result = Braintree_Transaction::sale(array(
      'amount' => '100.00',
      'billing' => array(
        'streetAddress' => '200 2nd Street',
      ),
      'creditCard' => array(
        'number' => '5105105105105100',
        'expirationDate' => '05/12',
      ),
    ));
    Braintree_Configuration::merchantId($old_merchant_id);
    Braintree_Configuration::publicKey($old_public_key);
    Braintree_Configuration::privateKey($old_private_key);
    $this
      ->assertFalse($result->success);
    Braintree_TestHelper::assertPrintable($result);
    $transaction = $result->transaction;
    $this
      ->assertEquals(Braintree_Transaction::AVS, $transaction->gatewayRejectionReason);
  }
  function testGatewayRejectionOnAvsAndCvv() {
    $old_merchant_id = Braintree_Configuration::merchantId();
    $old_public_key = Braintree_Configuration::publicKey();
    $old_private_key = Braintree_Configuration::privateKey();
    Braintree_Configuration::merchantId('processing_rules_merchant_id');
    Braintree_Configuration::publicKey('processing_rules_public_key');
    Braintree_Configuration::privateKey('processing_rules_private_key');
    $result = Braintree_Transaction::sale(array(
      'amount' => '100.00',
      'billing' => array(
        'postalCode' => '20000',
      ),
      'creditCard' => array(
        'number' => '5105105105105100',
        'expirationDate' => '05/12',
        'cvv' => '200',
      ),
    ));
    Braintree_Configuration::merchantId($old_merchant_id);
    Braintree_Configuration::publicKey($old_public_key);
    Braintree_Configuration::privateKey($old_private_key);
    $this
      ->assertFalse($result->success);
    $transaction = $result->transaction;
    $this
      ->assertEquals(Braintree_Transaction::AVS_AND_CVV, $transaction->gatewayRejectionReason);
  }
  function testGatewayRejectionOnCvv() {
    $old_merchant_id = Braintree_Configuration::merchantId();
    $old_public_key = Braintree_Configuration::publicKey();
    $old_private_key = Braintree_Configuration::privateKey();
    Braintree_Configuration::merchantId('processing_rules_merchant_id');
    Braintree_Configuration::publicKey('processing_rules_public_key');
    Braintree_Configuration::privateKey('processing_rules_private_key');
    $result = Braintree_Transaction::sale(array(
      'amount' => '100.00',
      'creditCard' => array(
        'number' => '5105105105105100',
        'expirationDate' => '05/12',
        'cvv' => '200',
      ),
    ));
    Braintree_Configuration::merchantId($old_merchant_id);
    Braintree_Configuration::publicKey($old_public_key);
    Braintree_Configuration::privateKey($old_private_key);
    $this
      ->assertFalse($result->success);
    $transaction = $result->transaction;
    $this
      ->assertEquals(Braintree_Transaction::CVV, $transaction->gatewayRejectionReason);
  }
  function testSnapshotPlanIdAddOnsAndDiscountsFromSubscription() {
    $creditCard = Braintree_SubscriptionTestHelper::createCreditCard();
    $plan = Braintree_SubscriptionTestHelper::triallessPlan();
    $result = Braintree_Subscription::create(array(
      'paymentMethodToken' => $creditCard->token,
      'planId' => $plan['id'],
      'addOns' => array(
        'add' => array(
          array(
            'amount' => '11.00',
            'inheritedFromId' => 'increase_10',
            'quantity' => 2,
            'numberOfBillingCycles' => 5,
          ),
          array(
            'amount' => '21.00',
            'inheritedFromId' => 'increase_20',
            'quantity' => 3,
            'numberOfBillingCycles' => 6,
          ),
        ),
      ),
      'discounts' => array(
        'add' => array(
          array(
            'amount' => '7.50',
            'inheritedFromId' => 'discount_7',
            'quantity' => 2,
            'neverExpires' => true,
          ),
        ),
      ),
    ));
    $transaction = $result->subscription->transactions[0];
    $this
      ->assertEquals($transaction->planId, $plan['id']);
    $addOns = $transaction->addOns;
    Braintree_SubscriptionTestHelper::sortModificationsById($addOns);
    $this
      ->assertEquals($addOns[0]->amount, "11.00");
    $this
      ->assertEquals($addOns[0]->id, "increase_10");
    $this
      ->assertEquals($addOns[0]->quantity, 2);
    $this
      ->assertEquals($addOns[0]->numberOfBillingCycles, 5);
    $this
      ->assertFalse($addOns[0]->neverExpires);
    $this
      ->assertEquals($addOns[1]->amount, "21.00");
    $this
      ->assertEquals($addOns[1]->id, "increase_20");
    $this
      ->assertEquals($addOns[1]->quantity, 3);
    $this
      ->assertEquals($addOns[1]->numberOfBillingCycles, 6);
    $this
      ->assertFalse($addOns[1]->neverExpires);
    $discounts = $transaction->discounts;
    $this
      ->assertEquals($discounts[0]->amount, "7.50");
    $this
      ->assertEquals($discounts[0]->id, "discount_7");
    $this
      ->assertEquals($discounts[0]->quantity, 2);
    $this
      ->assertEquals($discounts[0]->numberOfBillingCycles, null);
    $this
      ->assertTrue($discounts[0]->neverExpires);
  }
  function createTransactionViaTr($regularParams, $trParams) {
    Braintree_TestHelper::suppressDeprecationWarnings();
    $trData = Braintree_TransparentRedirect::transactionData(array_merge($trParams, array(
      "redirectUrl" => "http://www.example.com",
    )));
    return Braintree_TestHelper::submitTrRequest(Braintree_Transaction::createTransactionUrl(), $regularParams, $trData);
  }
  function createTransactionToRefund() {
    $transaction = Braintree_Transaction::saleNoValidate(array(
      'amount' => '100.00',
      'creditCard' => array(
        'number' => '5105105105105100',
        'expirationDate' => '05/12',
      ),
      'options' => array(
        'submitForSettlement' => true,
      ),
    ));
    Braintree_TestHelper::settle($transaction->id);
    return $transaction;
  }

}

Members

Namesort descending Modifiers Type Description Overrides
Braintree_TransactionTest::createTransactionToRefund function
Braintree_TransactionTest::createTransactionViaTr function
Braintree_TransactionTest::testCloneTransaction function
Braintree_TransactionTest::testCloneTransactionAndSubmitForSettlement function
Braintree_TransactionTest::testCloneWithValidations function
Braintree_TransactionTest::testCreateFromTransparentRedirect function
Braintree_TransactionTest::testCreateFromTransparentRedirectWithInvalidParams function
Braintree_TransactionTest::testCreateFromTransparentRedirect_withParamsInTrData function
Braintree_TransactionTest::testCreateFromTransparentRedirect_withValidationErrors function
Braintree_TransactionTest::testCredit function
Braintree_TransactionTest::testCreditNoValidate function
Braintree_TransactionTest::testCredit_withMerchantAccountId function
Braintree_TransactionTest::testCredit_withoutMerchantAccountIdFallsBackToDefault function
Braintree_TransactionTest::testFind function
Braintree_TransactionTest::testGatewayRejectionOnAvs function
Braintree_TransactionTest::testGatewayRejectionOnAvsAndCvv function
Braintree_TransactionTest::testGatewayRejectionOnCvv function
Braintree_TransactionTest::testMultipleRefundsWithPartialAmounts function
Braintree_TransactionTest::testRecurring function
Braintree_TransactionTest::testRefund function
Braintree_TransactionTest::testRefundWithPartialAmount function
Braintree_TransactionTest::testRefundWithUnsuccessfulPartialAmount function
Braintree_TransactionTest::testSale function
Braintree_TransactionTest::testSaleNoValidate function
Braintree_TransactionTest::testSale_andStoreShippingAddressInVault function
Braintree_TransactionTest::testSale_storeInVault function
Braintree_TransactionTest::testSale_storeInVaultOnSuccessWithFailedTransaction function
Braintree_TransactionTest::testSale_storeInVaultOnSuccessWithSuccessfulTransaction function
Braintree_TransactionTest::testSale_underscoresAllCustomFields function
Braintree_TransactionTest::testSale_withAllAttributes function
Braintree_TransactionTest::testSale_withCustomFields function
Braintree_TransactionTest::testSale_withDescriptor function
Braintree_TransactionTest::testSale_withDescriptorValidation function
Braintree_TransactionTest::testSale_withExistingCustomer function
Braintree_TransactionTest::testSale_withExistingCustomer_storeInVault function
Braintree_TransactionTest::testSale_withExpirationMonthAndYear function
Braintree_TransactionTest::testSale_withInvalidCustomField function
Braintree_TransactionTest::testSale_withInvalidPurchaseOrderNumber function
Braintree_TransactionTest::testSale_withInvalidTaxAmountAttribute function
Braintree_TransactionTest::testSale_withLevel2Attributes function
Braintree_TransactionTest::testSale_withMerchantAccountId function
Braintree_TransactionTest::testSale_withoutMerchantAccountIdFallsBackToDefault function
Braintree_TransactionTest::testSale_withProcessorDecline function
Braintree_TransactionTest::testSale_withShippingAddressId function
Braintree_TransactionTest::testSale_withTooLongPurchaseOrderAttribute function
Braintree_TransactionTest::testSnapshotPlanIdAddOnsAndDiscountsFromSubscription function
Braintree_TransactionTest::testSubmitForSettlementNoValidate_whenInvalid function
Braintree_TransactionTest::testSubmitForSettlementNoValidate_whenValidWithAmount function
Braintree_TransactionTest::testSubmitForSettlementNoValidate_whenValidWithoutAmount function
Braintree_TransactionTest::testSubmitForSettlement_nullAmount function
Braintree_TransactionTest::testSubmitForSettlement_withAmount function
Braintree_TransactionTest::testVoid function
Braintree_TransactionTest::testVoidNoValidate function
Braintree_TransactionTest::testVoidNoValidate_throwsIfNotInvalid function
Braintree_TransactionTest::testVoid_withValidationError function
Braintree_TransactionTest::test_countryValidationError_inconsistency function
Braintree_TransactionTest::test_countryValidationError_incorrectAlpha2 function
Braintree_TransactionTest::test_countryValidationError_incorrectAlpha3 function
Braintree_TransactionTest::test_countryValidationError_incorrectNumericCode function