You are here

class Braintree_CustomerTest in Commerce Braintree 7

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

Hierarchy

Expanded class hierarchy of Braintree_CustomerTest

File

braintree_php/tests/integration/CustomerTest.php, line 4

View source
class Braintree_CustomerTest extends PHPUnit_Framework_TestCase {
  function testAll_smokeTest() {
    $all = Braintree_Customer::all();
    $this
      ->assertTrue($all
      ->maximumCount() > 0);
  }
  function testAllWithManyResults() {
    $collection = Braintree_Customer::all();
    $this
      ->assertTrue($collection
      ->maximumCount() > 1);
    $arr = array();
    foreach ($collection as $customer) {
      array_push($arr, $customer->id);
    }
    $unique_customer_ids = array_unique(array_values($arr));
    $this
      ->assertEquals($collection
      ->maximumCount(), count($unique_customer_ids));
  }
  function testCreate() {
    $result = 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',
    ));
    $this
      ->assertEquals(true, $result->success);
    $customer = $result->customer;
    $this
      ->assertEquals('Mike', $customer->firstName);
    $this
      ->assertEquals('Jones', $customer->lastName);
    $this
      ->assertEquals('Jones Co.', $customer->company);
    $this
      ->assertEquals('mike.jones@example.com', $customer->email);
    $this
      ->assertEquals('419.555.1234', $customer->phone);
    $this
      ->assertEquals('419.555.1235', $customer->fax);
    $this
      ->assertEquals('http://example.com', $customer->website);
    $this
      ->assertNotNull($customer->merchantId);
  }
  function testCreate_withUnicode() {
    $result = Braintree_Customer::create(array(
      'firstName' => "Здравствуйте",
      'lastName' => 'Jones',
      'company' => 'Jones Co.',
      'email' => 'mike.jones@example.com',
      'phone' => '419.555.1234',
      'fax' => '419.555.1235',
      'website' => 'http://example.com',
    ));
    $this
      ->assertEquals(true, $result->success);
    $customer = $result->customer;
    $this
      ->assertEquals("Здравствуйте", $customer->firstName);
    $this
      ->assertEquals('Jones', $customer->lastName);
    $this
      ->assertEquals('Jones Co.', $customer->company);
    $this
      ->assertEquals('mike.jones@example.com', $customer->email);
    $this
      ->assertEquals('419.555.1234', $customer->phone);
    $this
      ->assertEquals('419.555.1235', $customer->fax);
    $this
      ->assertEquals('http://example.com', $customer->website);
    $this
      ->assertNotNull($customer->merchantId);
  }
  function testCreate_withCountry() {
    $result = Braintree_Customer::create(array(
      'firstName' => 'Bat',
      'lastName' => 'Manderson',
      'creditCard' => array(
        'number' => '5105105105105100',
        'expirationDate' => '05/12',
        'billingAddress' => array(
          'countryName' => 'Gabon',
          'countryCodeAlpha2' => 'GA',
          'countryCodeAlpha3' => 'GAB',
          'countryCodeNumeric' => '266',
        ),
      ),
    ));
    $this
      ->assertEquals(true, $result->success);
    $customer = $result->customer;
    $this
      ->assertEquals('Gabon', $customer->creditCards[0]->billingAddress->countryName);
    $this
      ->assertEquals('GA', $customer->creditCards[0]->billingAddress->countryCodeAlpha2);
    $this
      ->assertEquals('GAB', $customer->creditCards[0]->billingAddress->countryCodeAlpha3);
    $this
      ->assertEquals('266', $customer->creditCards[0]->billingAddress->countryCodeNumeric);
    $this
      ->assertEquals(1, preg_match('/\\A\\w{32}\\z/', $customer->creditCards[0]->uniqueNumberIdentifier));
  }
  function testCreate_blankCustomer() {
    $result = Braintree_Customer::create();
    $this
      ->assertEquals(true, $result->success);
    $this
      ->assertNotNull($result->customer->id);
    $result = Braintree_Customer::create(array());
    $this
      ->assertEquals(true, $result->success);
    $this
      ->assertNotNull($result->customer->id);
  }
  function testCreate_withSpecialChars() {
    $result = Braintree_Customer::create(array(
      'firstName' => '<>&"\'',
    ));
    $this
      ->assertEquals(true, $result->success);
    $this
      ->assertEquals('<>&"\'', $result->customer->firstName);
  }
  function testCreate_withCustomFields() {
    $result = Braintree_Customer::create(array(
      'firstName' => 'Mike',
      'customFields' => array(
        'store_me' => 'some custom value',
      ),
    ));
    $this
      ->assertEquals(true, $result->success);
    $customFields = $result->customer->customFields;
    $this
      ->assertEquals('some custom value', $customFields['store_me']);
  }
  function testCreate_withCreditCard() {
    $result = 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',
      'creditCard' => array(
        'number' => '5105105105105100',
        'expirationDate' => '05/12',
        'cvv' => '123',
        'cardholderName' => 'Mike Jones',
      ),
    ));
    $this
      ->assertEquals(true, $result->success);
    $customer = $result->customer;
    $this
      ->assertEquals('Mike', $customer->firstName);
    $this
      ->assertEquals('Jones', $customer->lastName);
    $this
      ->assertEquals('Jones Co.', $customer->company);
    $this
      ->assertEquals('mike.jones@example.com', $customer->email);
    $this
      ->assertEquals('419.555.1234', $customer->phone);
    $this
      ->assertEquals('419.555.1235', $customer->fax);
    $this
      ->assertEquals('http://example.com', $customer->website);
    $creditCard = $customer->creditCards[0];
    $this
      ->assertEquals('510510', $creditCard->bin);
    $this
      ->assertEquals('5100', $creditCard->last4);
    $this
      ->assertEquals('Mike Jones', $creditCard->cardholderName);
    $this
      ->assertEquals('05/2012', $creditCard->expirationDate);
    $this
      ->assertEquals('05', $creditCard->expirationMonth);
    $this
      ->assertEquals('2012', $creditCard->expirationYear);
  }
  function testCreate_withDuplicateCardCheck() {
    $customer = Braintree_Customer::createNoValidate();
    $attributes = 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',
      'creditCard' => array(
        'number' => '5105105105105100',
        'expirationDate' => '05/12',
        'cvv' => '123',
        'cardholderName' => 'Mike Jones',
        'options' => array(
          'failOnDuplicatePaymentMethod' => true,
        ),
      ),
    );
    Braintree_Customer::create($attributes);
    $result = Braintree_Customer::create($attributes);
    $this
      ->assertFalse($result->success);
    $errors = $result->errors
      ->forKey('customer')
      ->forKey('creditCard')
      ->onAttribute('number');
    $this
      ->assertEquals(Braintree_Error_Codes::CREDIT_CARD_DUPLICATE_CARD_EXISTS, $errors[0]->code);
    $this
      ->assertEquals(1, preg_match('/Duplicate card exists in the vault\\./', $result->message));
  }
  function testCreate_withCreditCardAndSpecificVerificationMerchantAccount() {
    $result = 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',
      'creditCard' => array(
        'number' => '5105105105105100',
        'expirationDate' => '05/12',
        'cvv' => '123',
        'cardholderName' => 'Mike Jones',
        'options' => array(
          'verificationMerchantAccountId' => Braintree_TestHelper::nonDefaultMerchantAccountId(),
          'verifyCard' => true,
        ),
      ),
    ));
    Braintree_TestHelper::assertPrintable($result);
    $this
      ->assertFalse($result->success);
    $this
      ->assertEquals(Braintree_Result_CreditCardVerification::PROCESSOR_DECLINED, $result->creditCardVerification->status);
    $this
      ->assertEquals('2000', $result->creditCardVerification->processorResponseCode);
    $this
      ->assertEquals('Do Not Honor', $result->creditCardVerification->processorResponseText);
    $this
      ->assertEquals('M', $result->creditCardVerification->cvvResponseCode);
    $this
      ->assertEquals(null, $result->creditCardVerification->avsErrorResponseCode);
    $this
      ->assertEquals('I', $result->creditCardVerification->avsPostalCodeResponseCode);
    $this
      ->assertEquals('I', $result->creditCardVerification->avsStreetAddressResponseCode);
  }
  function testCreate_withCreditCardAndBillingAddress() {
    $result = 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',
      'creditCard' => array(
        'number' => '5105105105105100',
        'expirationDate' => '05/12',
        'cvv' => '123',
        'cardholderName' => 'Mike Jones',
        'billingAddress' => array(
          'firstName' => 'Drew',
          'lastName' => 'Smith',
          'company' => 'Smith Co.',
          'streetAddress' => '1 E Main St',
          'extendedAddress' => 'Suite 101',
          'locality' => 'Chicago',
          'region' => 'IL',
          'postalCode' => '60622',
          'countryName' => 'United States of America',
        ),
      ),
    ));
    Braintree_TestHelper::assertPrintable($result);
    $this
      ->assertEquals(true, $result->success);
    $customer = $result->customer;
    $this
      ->assertEquals('Mike', $customer->firstName);
    $this
      ->assertEquals('Jones', $customer->lastName);
    $this
      ->assertEquals('Jones Co.', $customer->company);
    $this
      ->assertEquals('mike.jones@example.com', $customer->email);
    $this
      ->assertEquals('419.555.1234', $customer->phone);
    $this
      ->assertEquals('419.555.1235', $customer->fax);
    $this
      ->assertEquals('http://example.com', $customer->website);
    $creditCard = $customer->creditCards[0];
    $this
      ->assertEquals('510510', $creditCard->bin);
    $this
      ->assertEquals('5100', $creditCard->last4);
    $this
      ->assertEquals('Mike Jones', $creditCard->cardholderName);
    $this
      ->assertEquals('05/2012', $creditCard->expirationDate);
    $this
      ->assertEquals('05', $creditCard->expirationMonth);
    $this
      ->assertEquals('2012', $creditCard->expirationYear);
    $address = $customer->addresses[0];
    $this
      ->assertEquals($address, $creditCard->billingAddress);
    $this
      ->assertEquals('Drew', $address->firstName);
    $this
      ->assertEquals('Smith', $address->lastName);
    $this
      ->assertEquals('Smith Co.', $address->company);
    $this
      ->assertEquals('1 E Main St', $address->streetAddress);
    $this
      ->assertEquals('Suite 101', $address->extendedAddress);
    $this
      ->assertEquals('Chicago', $address->locality);
    $this
      ->assertEquals('IL', $address->region);
    $this
      ->assertEquals('60622', $address->postalCode);
    $this
      ->assertEquals('United States of America', $address->countryName);
  }
  function testCreate_withValidationErrors() {
    $result = Braintree_Customer::create(array(
      'email' => 'invalid',
      'creditCard' => array(
        'number' => 'invalid',
        'billingAddress' => array(
          'streetAddress' => str_repeat('x', 256),
        ),
      ),
    ));
    Braintree_TestHelper::assertPrintable($result);
    $this
      ->assertEquals(false, $result->success);
    $errors = $result->errors
      ->forKey('customer')
      ->onAttribute('email');
    $this
      ->assertEquals(Braintree_Error_Codes::CUSTOMER_EMAIL_IS_INVALID, $errors[0]->code);
    $errors = $result->errors
      ->forKey('customer')
      ->forKey('creditCard')
      ->onAttribute('number');
    $this
      ->assertEquals(Braintree_Error_Codes::CREDIT_CARD_NUMBER_INVALID_LENGTH, $errors[0]->code);
    $errors = $result->errors
      ->forKey('customer')
      ->forKey('creditCard')
      ->forKey('billingAddress')
      ->onAttribute('streetAddress');
    $this
      ->assertEquals(Braintree_Error_Codes::ADDRESS_STREET_ADDRESS_IS_TOO_LONG, $errors[0]->code);
  }
  function testCreate_countryValidations_inconsistency() {
    $result = Braintree_Customer::create(array(
      'creditCard' => array(
        'billingAddress' => array(
          'countryName' => 'Georgia',
          'countryCodeAlpha2' => 'TF',
        ),
      ),
    ));
    $this
      ->assertEquals(false, $result->success);
    $errors = $result->errors
      ->forKey('customer')
      ->forKey('creditCard')
      ->forKey('billingAddress')
      ->onAttribute('base');
    $this
      ->assertEquals(Braintree_Error_Codes::ADDRESS_INCONSISTENT_COUNTRY, $errors[0]->code);
  }
  function testCreateNoValidate_returnsCustomer() {
    $customer = Braintree_Customer::createNoValidate(array(
      'firstName' => 'Paul',
      'lastName' => 'Martin',
    ));
    $this
      ->assertEquals('Paul', $customer->firstName);
    $this
      ->assertEquals('Martin', $customer->lastName);
  }
  function testCreateNoValidate_throwsIfInvalid() {
    $this
      ->setExpectedException('Braintree_Exception_ValidationsFailed');
    $customer = Braintree_Customer::createNoValidate(array(
      'email' => 'invalid',
    ));
  }
  function testDelete_deletesTheCustomer() {
    $result = Braintree_Customer::create(array());
    $this
      ->assertEquals(true, $result->success);
    Braintree_Customer::find($result->customer->id);
    Braintree_Customer::delete($result->customer->id);
    $this
      ->setExpectedException('Braintree_Exception_NotFound');
    Braintree_Customer::find($result->customer->id);
  }
  function testFind() {
    $result = 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',
    ));
    $this
      ->assertEquals(true, $result->success);
    $customer = Braintree_Customer::find($result->customer->id);
    $this
      ->assertEquals('Mike', $customer->firstName);
    $this
      ->assertEquals('Jones', $customer->lastName);
    $this
      ->assertEquals('Jones Co.', $customer->company);
    $this
      ->assertEquals('mike.jones@example.com', $customer->email);
    $this
      ->assertEquals('419.555.1234', $customer->phone);
    $this
      ->assertEquals('419.555.1235', $customer->fax);
    $this
      ->assertEquals('http://example.com', $customer->website);
  }
  function testFind_throwsExceptionIfNotFound() {
    $this
      ->setExpectedException('Braintree_Exception_NotFound');
    Braintree_Customer::find("does-not-exist");
  }
  function testUpdate() {
    $result = Braintree_Customer::create(array(
      'firstName' => 'Old First',
      'lastName' => 'Old Last',
      'company' => 'Old Company',
      'email' => 'old.email@example.com',
      'phone' => 'old phone',
      'fax' => 'old fax',
      'website' => 'http://old.example.com',
    ));
    $this
      ->assertEquals(true, $result->success);
    $customer = $result->customer;
    $updateResult = Braintree_Customer::update($customer->id, array(
      'firstName' => 'New First',
      'lastName' => 'New Last',
      'company' => 'New Company',
      'email' => 'new.email@example.com',
      'phone' => 'new phone',
      'fax' => 'new fax',
      'website' => 'http://new.example.com',
    ));
    $this
      ->assertEquals(true, $updateResult->success);
    $this
      ->assertEquals('New First', $updateResult->customer->firstName);
    $this
      ->assertEquals('New Last', $updateResult->customer->lastName);
    $this
      ->assertEquals('New Company', $updateResult->customer->company);
    $this
      ->assertEquals('new.email@example.com', $updateResult->customer->email);
    $this
      ->assertEquals('new phone', $updateResult->customer->phone);
    $this
      ->assertEquals('new fax', $updateResult->customer->fax);
    $this
      ->assertEquals('http://new.example.com', $updateResult->customer->website);
  }
  function testUpdate_withCountry() {
    $customer = Braintree_Customer::create(array(
      'firstName' => 'Bat',
      'lastName' => 'Manderson',
      'creditCard' => array(
        'number' => '5105105105105100',
        'expirationDate' => '05/12',
        'billingAddress' => array(
          'countryName' => 'United States of America',
          'countryCodeAlpha2' => 'US',
          'countryCodeAlpha3' => 'USA',
          'countryCodeNumeric' => '840',
        ),
      ),
    ))->customer;
    $result = Braintree_Customer::update($customer->id, array(
      'firstName' => 'Bat',
      'lastName' => 'Manderson',
      'creditCard' => array(
        'options' => array(
          'updateExistingToken' => $customer->creditCards[0]->token,
        ),
        'billingAddress' => array(
          'countryName' => 'Gabon',
          'countryCodeAlpha2' => 'GA',
          'countryCodeAlpha3' => 'GAB',
          'countryCodeNumeric' => '266',
          'options' => array(
            'updateExisting' => true,
          ),
        ),
      ),
    ));
    $this
      ->assertEquals(true, $result->success);
    $updatedCustomer = $result->customer;
    $this
      ->assertEquals('Gabon', $updatedCustomer->creditCards[0]->billingAddress->countryName);
    $this
      ->assertEquals('GA', $updatedCustomer->creditCards[0]->billingAddress->countryCodeAlpha2);
    $this
      ->assertEquals('GAB', $updatedCustomer->creditCards[0]->billingAddress->countryCodeAlpha3);
    $this
      ->assertEquals('266', $updatedCustomer->creditCards[0]->billingAddress->countryCodeNumeric);
  }
  function testUpdate_withUpdatingExistingCreditCard() {
    $create_result = Braintree_Customer::create(array(
      'firstName' => 'Old First',
      'lastName' => 'Old Last',
      'website' => 'http://old.example.com',
      'creditCard' => array(
        'number' => '5105105105105100',
        'expirationDate' => '05/12',
        'cardholderName' => 'Old Cardholder',
      ),
    ));
    $this
      ->assertEquals(true, $create_result->success);
    $customer = $create_result->customer;
    $creditCard = $customer->creditCards[0];
    $result = Braintree_Customer::update($customer->id, array(
      'firstName' => 'New First',
      'lastName' => 'New Last',
      'creditCard' => array(
        'number' => '4111111111111111',
        'expirationDate' => '11/14',
        'cardholderName' => 'New Cardholder',
        'options' => array(
          'updateExistingToken' => $creditCard->token,
        ),
      ),
    ));
    $this
      ->assertEquals(true, $result->success);
    $this
      ->assertEquals('New First', $result->customer->firstName);
    $this
      ->assertEquals('New Last', $result->customer->lastName);
    $this
      ->assertEquals(1, sizeof($result->customer->creditCards));
    $creditCard = $result->customer->creditCards[0];
    $this
      ->assertEquals('411111', $creditCard->bin);
    $this
      ->assertEquals('11/2014', $creditCard->expirationDate);
    $this
      ->assertEquals('New Cardholder', $creditCard->cardholderName);
  }
  function testUpdate_forBillingAddressAndExistingCreditCardAndCustomerDetailsTogether() {
    $create_result = Braintree_Customer::create(array(
      'firstName' => 'Old First',
      'lastName' => 'Old Last',
      'creditCard' => array(
        'number' => '5105105105105100',
        'expirationDate' => '05/12',
        'cvv' => '123',
        'cardholderName' => 'Old Cardholder',
        'billingAddress' => array(
          'firstName' => 'Drew',
          'lastName' => 'Smith',
        ),
      ),
    ));
    $this
      ->assertEquals(true, $create_result->success);
    $customer = $create_result->customer;
    $creditCard = $customer->creditCards[0];
    $result = Braintree_Customer::update($customer->id, array(
      'firstName' => 'New Customer First',
      'lastName' => 'New Customer Last',
      'creditCard' => array(
        'number' => '4111111111111111',
        'expirationDate' => '11/14',
        'options' => array(
          'updateExistingToken' => $creditCard->token,
        ),
        'billingAddress' => array(
          'firstName' => 'New Billing First',
          'lastName' => 'New Billing Last',
          'options' => array(
            'updateExisting' => true,
          ),
        ),
      ),
    ));
    $this
      ->assertEquals(true, $result->success);
    $this
      ->assertEquals('New Customer First', $result->customer->firstName);
    $this
      ->assertEquals('New Customer Last', $result->customer->lastName);
    $this
      ->assertEquals(1, sizeof($result->customer->creditCards));
    $this
      ->assertEquals(1, sizeof($result->customer->addresses));
    $creditCard = $result->customer->creditCards[0];
    $this
      ->assertEquals('411111', $creditCard->bin);
    $this
      ->assertEquals('11/2014', $creditCard->expirationDate);
    $billingAddress = $creditCard->billingAddress;
    $this
      ->assertEquals('New Billing First', $billingAddress->firstName);
    $this
      ->assertEquals('New Billing Last', $billingAddress->lastName);
  }
  function testUpdate_withNewCreditCardAndExistingBillingAddress() {
    $customer = Braintree_Customer::create()->customer;
    $address = Braintree_Address::create(array(
      'customerId' => $customer->id,
      'firstName' => 'Dan',
    ))->address;
    $result = Braintree_Customer::update($customer->id, array(
      'creditCard' => array(
        'number' => '4111111111111111',
        'expirationDate' => '11/14',
        'billingAddressId' => $address->id,
      ),
    ));
    $billingAddress = $result->customer->creditCards[0]->billingAddress;
    $this
      ->assertEquals($address->id, $billingAddress->id);
    $this
      ->assertEquals('Dan', $billingAddress->firstName);
  }
  function testUpdateNoValidate() {
    $result = Braintree_Customer::create(array(
      'firstName' => 'Old First',
      'lastName' => 'Old Last',
      'company' => 'Old Company',
      'email' => 'old.email@example.com',
      'phone' => 'old phone',
      'fax' => 'old fax',
      'website' => 'http://old.example.com',
    ));
    $this
      ->assertEquals(true, $result->success);
    $customer = $result->customer;
    $updated = Braintree_Customer::updateNoValidate($customer->id, array(
      'firstName' => 'New First',
      'lastName' => 'New Last',
      'company' => 'New Company',
      'email' => 'new.email@example.com',
      'phone' => 'new phone',
      'fax' => 'new fax',
      'website' => 'http://new.example.com',
    ));
    $this
      ->assertEquals('New First', $updated->firstName);
    $this
      ->assertEquals('New Last', $updated->lastName);
    $this
      ->assertEquals('New Company', $updated->company);
    $this
      ->assertEquals('new.email@example.com', $updated->email);
    $this
      ->assertEquals('new phone', $updated->phone);
    $this
      ->assertEquals('new fax', $updated->fax);
    $this
      ->assertEquals('http://new.example.com', $updated->website);
  }
  function testCreateFromTransparentRedirect() {
    Braintree_TestHelper::suppressDeprecationWarnings();
    $queryString = $this
      ->createCustomerViaTr(array(
      'customer' => array(
        'first_name' => 'Joe',
        'last_name' => 'Martin',
        'credit_card' => array(
          'number' => '5105105105105100',
          'expiration_date' => '05/12',
        ),
      ),
    ), array());
    $result = Braintree_Customer::createFromTransparentRedirect($queryString);
    $this
      ->assertTrue($result->success);
    $this
      ->assertEquals('Joe', $result->customer->firstName);
    $this
      ->assertEquals('Martin', $result->customer->lastName);
    $creditCard = $result->customer->creditCards[0];
    $this
      ->assertEquals('510510', $creditCard->bin);
    $this
      ->assertEquals('5100', $creditCard->last4);
    $this
      ->assertEquals('05/2012', $creditCard->expirationDate);
  }
  function testCreateFromTransparentRedirect_withParamsInTrData() {
    Braintree_TestHelper::suppressDeprecationWarnings();
    $queryString = $this
      ->createCustomerViaTr(array(), array(
      'customer' => array(
        'firstName' => 'Joe',
        'lastName' => 'Martin',
        'creditCard' => array(
          'number' => '5105105105105100',
          'expirationDate' => '05/12',
        ),
      ),
    ));
    $result = Braintree_Customer::createFromTransparentRedirect($queryString);
    $this
      ->assertTrue($result->success);
    $this
      ->assertEquals('Joe', $result->customer->firstName);
    $this
      ->assertEquals('Martin', $result->customer->lastName);
    $creditCard = $result->customer->creditCards[0];
    $this
      ->assertEquals('510510', $creditCard->bin);
    $this
      ->assertEquals('5100', $creditCard->last4);
    $this
      ->assertEquals('05/2012', $creditCard->expirationDate);
  }
  function testCreateFromTransparentRedirect_withValidationErrors() {
    Braintree_TestHelper::suppressDeprecationWarnings();
    $queryString = $this
      ->createCustomerViaTr(array(
      'customer' => array(
        'first_name' => str_repeat('x', 256),
        'credit_card' => array(
          'number' => 'invalid',
          'expiration_date' => '',
        ),
      ),
    ), array());
    $result = Braintree_Customer::createFromTransparentRedirect($queryString);
    $this
      ->assertFalse($result->success);
    $errors = $result->errors
      ->forKey('customer')
      ->onAttribute('firstName');
    $this
      ->assertEquals(Braintree_Error_Codes::CUSTOMER_FIRST_NAME_IS_TOO_LONG, $errors[0]->code);
    $errors = $result->errors
      ->forKey('customer')
      ->forKey('creditCard')
      ->onAttribute('number');
    $this
      ->assertEquals(Braintree_Error_Codes::CREDIT_CARD_NUMBER_INVALID_LENGTH, $errors[0]->code);
    $errors = $result->errors
      ->forKey('customer')
      ->forKey('creditCard')
      ->onAttribute('expirationDate');
    $this
      ->assertEquals(Braintree_Error_Codes::CREDIT_CARD_EXPIRATION_DATE_IS_REQUIRED, $errors[0]->code);
  }
  function testCreateWithInvalidUTF8Bytes() {
    $result = Braintree_Customer::create(array(
      'firstName' => "",
    ));
    $this
      ->assertEquals(true, $result->success);
    $customer = $result->customer;
    $this
      ->assertEquals("Josè Maria", $customer->firstName);
  }
  function testCreateWithValidUTF8Bytes() {
    $result = Braintree_Customer::create(array(
      'firstName' => "José",
    ));
    $this
      ->assertEquals(true, $result->success);
    $customer = $result->customer;
    $this
      ->assertEquals("José", $customer->firstName);
  }
  function testUpdateFromTransparentRedirect() {
    Braintree_TestHelper::suppressDeprecationWarnings();
    $customer = Braintree_Customer::createNoValidate();
    $queryString = $this
      ->updateCustomerViaTr(array(
      'customer' => array(
        'first_name' => 'Joe',
        'last_name' => 'Martin',
        'email' => 'joe.martin@example.com',
      ),
    ), array(
      'customerId' => $customer->id,
    ));
    $result = Braintree_Customer::updateFromTransparentRedirect($queryString);
    $this
      ->assertTrue($result->success);
    $this
      ->assertEquals('Joe', $result->customer->firstName);
    $this
      ->assertEquals('Martin', $result->customer->lastName);
    $this
      ->assertEquals('joe.martin@example.com', $result->customer->email);
  }
  function testUpdateFromTransparentRedirect_withParamsInTrData() {
    Braintree_TestHelper::suppressDeprecationWarnings();
    $customer = Braintree_Customer::createNoValidate();
    $queryString = $this
      ->updateCustomerViaTr(array(), array(
      'customerId' => $customer->id,
      'customer' => array(
        'firstName' => 'Joe',
        'lastName' => 'Martin',
        'email' => 'joe.martin@example.com',
      ),
    ));
    $result = Braintree_Customer::updateFromTransparentRedirect($queryString);
    $this
      ->assertTrue($result->success);
    $this
      ->assertEquals('Joe', $result->customer->firstName);
    $this
      ->assertEquals('Martin', $result->customer->lastName);
    $this
      ->assertEquals('joe.martin@example.com', $result->customer->email);
  }
  function testUpdateFromTransparentRedirect_withValidationErrors() {
    Braintree_TestHelper::suppressDeprecationWarnings();
    $customer = Braintree_Customer::createNoValidate();
    $queryString = $this
      ->updateCustomerViaTr(array(
      'customer' => array(
        'first_name' => str_repeat('x', 256),
      ),
    ), array(
      'customerId' => $customer->id,
    ));
    $result = Braintree_Customer::updateFromTransparentRedirect($queryString);
    $this
      ->assertFalse($result->success);
    $errors = $result->errors
      ->forKey('customer')
      ->onAttribute('firstName');
    $this
      ->assertEquals(Braintree_Error_Codes::CUSTOMER_FIRST_NAME_IS_TOO_LONG, $errors[0]->code);
  }
  function testUpdateFromTransparentRedirect_withUpdateExisting() {
    Braintree_TestHelper::suppressDeprecationWarnings();
    $customer = Braintree_Customer::create(array(
      'firstName' => 'Mike',
      'lastName' => 'Jones',
      'creditCard' => array(
        'number' => '5105105105105100',
        'expirationDate' => '05/12',
        'cardholderName' => 'Mike Jones',
        'billingAddress' => array(
          'firstName' => 'Drew',
          'lastName' => 'Smith',
        ),
      ),
    ))->customer;
    $queryString = $this
      ->updateCustomerViaTr(array(), array(
      'customerId' => $customer->id,
      'customer' => array(
        'firstName' => 'New First',
        'lastName' => 'New Last',
        'creditCard' => array(
          'number' => '4111111111111111',
          'expirationDate' => '05/13',
          'cardholderName' => 'New Cardholder',
          'options' => array(
            'updateExistingToken' => $customer->creditCards[0]->token,
          ),
          'billingAddress' => array(
            'firstName' => 'New First Billing',
            'lastName' => 'New Last Billing',
            'options' => array(
              'updateExisting' => true,
            ),
          ),
        ),
      ),
    ));
    $result = Braintree_Customer::updateFromTransparentRedirect($queryString);
    $this
      ->assertTrue($result->success);
    $this
      ->assertEquals(true, $result->success);
    $customer = $result->customer;
    $this
      ->assertEquals('New First', $customer->firstName);
    $this
      ->assertEquals('New Last', $customer->lastName);
    $this
      ->assertEquals(1, sizeof($result->customer->creditCards));
    $creditCard = $customer->creditCards[0];
    $this
      ->assertEquals('411111', $creditCard->bin);
    $this
      ->assertEquals('1111', $creditCard->last4);
    $this
      ->assertEquals('New Cardholder', $creditCard->cardholderName);
    $this
      ->assertEquals('05/2013', $creditCard->expirationDate);
    $this
      ->assertEquals(1, sizeof($result->customer->addresses));
    $address = $customer->addresses[0];
    $this
      ->assertEquals($address, $creditCard->billingAddress);
    $this
      ->assertEquals('New First Billing', $address->firstName);
    $this
      ->assertEquals('New Last Billing', $address->lastName);
  }
  function testSale_createsASaleUsingGivenToken() {
    $customer = Braintree_Customer::createNoValidate(array(
      'creditCard' => array(
        'number' => '5105105105105100',
        'expirationDate' => '05/12',
      ),
    ));
    $creditCard = $customer->creditCards[0];
    $result = Braintree_Customer::sale($customer->id, array(
      'amount' => '100.00',
    ));
    $this
      ->assertTrue($result->success);
    $this
      ->assertEquals('100.00', $result->transaction->amount);
    $this
      ->assertEquals($customer->id, $result->transaction->customerDetails->id);
    $this
      ->assertEquals($creditCard->token, $result->transaction->creditCardDetails->token);
  }
  function testSaleNoValidate_createsASaleUsingGivenToken() {
    $customer = Braintree_Customer::createNoValidate(array(
      'creditCard' => array(
        'number' => '5105105105105100',
        'expirationDate' => '05/12',
      ),
    ));
    $creditCard = $customer->creditCards[0];
    $transaction = Braintree_Customer::saleNoValidate($customer->id, array(
      'amount' => '100.00',
    ));
    $this
      ->assertEquals('100.00', $transaction->amount);
    $this
      ->assertEquals($customer->id, $transaction->customerDetails->id);
    $this
      ->assertEquals($creditCard->token, $transaction->creditCardDetails->token);
  }
  function testSaleNoValidate_throwsIfInvalid() {
    $customer = Braintree_Customer::createNoValidate(array(
      'creditCard' => array(
        'number' => '5105105105105100',
        'expirationDate' => '05/12',
      ),
    ));
    $creditCard = $customer->creditCards[0];
    $this
      ->setExpectedException('Braintree_Exception_ValidationsFailed');
    Braintree_Customer::saleNoValidate($customer->id, array(
      'amount' => 'invalid',
    ));
  }
  function testCredit_createsACreditUsingGivenCustomerId() {
    $customer = Braintree_Customer::createNoValidate(array(
      'creditCard' => array(
        'number' => '5105105105105100',
        'expirationDate' => '05/12',
      ),
    ));
    $creditCard = $customer->creditCards[0];
    $result = Braintree_Customer::credit($customer->id, array(
      'amount' => '100.00',
    ));
    $this
      ->assertTrue($result->success);
    $this
      ->assertEquals('100.00', $result->transaction->amount);
    $this
      ->assertEquals(Braintree_Transaction::CREDIT, $result->transaction->type);
    $this
      ->assertEquals($customer->id, $result->transaction->customerDetails->id);
    $this
      ->assertEquals($creditCard->token, $result->transaction->creditCardDetails->token);
  }
  function testCreditNoValidate_createsACreditUsingGivenId() {
    $customer = Braintree_Customer::createNoValidate(array(
      'creditCard' => array(
        'number' => '5105105105105100',
        'expirationDate' => '05/12',
      ),
    ));
    $creditCard = $customer->creditCards[0];
    $transaction = Braintree_Customer::creditNoValidate($customer->id, array(
      'amount' => '100.00',
    ));
    $this
      ->assertEquals('100.00', $transaction->amount);
    $this
      ->assertEquals(Braintree_Transaction::CREDIT, $transaction->type);
    $this
      ->assertEquals($customer->id, $transaction->customerDetails->id);
    $this
      ->assertEquals($creditCard->token, $transaction->creditCardDetails->token);
  }
  function testCreditNoValidate_throwsIfInvalid() {
    $customer = Braintree_Customer::createNoValidate(array(
      'creditCard' => array(
        'number' => '5105105105105100',
        'expirationDate' => '05/12',
      ),
    ));
    $creditCard = $customer->creditCards[0];
    $this
      ->setExpectedException('Braintree_Exception_ValidationsFailed');
    Braintree_Customer::creditNoValidate($customer->id, array(
      'amount' => 'invalid',
    ));
  }
  function createCustomerViaTr($regularParams, $trParams) {
    Braintree_TestHelper::suppressDeprecationWarnings();
    $trData = Braintree_TransparentRedirect::createCustomerData(array_merge($trParams, array(
      "redirectUrl" => "http://www.example.com",
    )));
    return Braintree_TestHelper::submitTrRequest(Braintree_Customer::createCustomerUrl(), $regularParams, $trData);
  }
  function updateCustomerViaTr($regularParams, $trParams) {
    Braintree_TestHelper::suppressDeprecationWarnings();
    $trData = Braintree_TransparentRedirect::updateCustomerData(array_merge($trParams, array(
      "redirectUrl" => "http://www.example.com",
    )));
    return Braintree_TestHelper::submitTrRequest(Braintree_Customer::updateCustomerUrl(), $regularParams, $trData);
  }

}

Members

Namesort descending Modifiers Type Description Overrides
Braintree_CustomerTest::createCustomerViaTr function
Braintree_CustomerTest::testAllWithManyResults function
Braintree_CustomerTest::testAll_smokeTest function
Braintree_CustomerTest::testCreate function
Braintree_CustomerTest::testCreateFromTransparentRedirect function
Braintree_CustomerTest::testCreateFromTransparentRedirect_withParamsInTrData function
Braintree_CustomerTest::testCreateFromTransparentRedirect_withValidationErrors function
Braintree_CustomerTest::testCreateNoValidate_returnsCustomer function
Braintree_CustomerTest::testCreateNoValidate_throwsIfInvalid function
Braintree_CustomerTest::testCreateWithInvalidUTF8Bytes function
Braintree_CustomerTest::testCreateWithValidUTF8Bytes function
Braintree_CustomerTest::testCreate_blankCustomer function
Braintree_CustomerTest::testCreate_countryValidations_inconsistency function
Braintree_CustomerTest::testCreate_withCountry function
Braintree_CustomerTest::testCreate_withCreditCard function
Braintree_CustomerTest::testCreate_withCreditCardAndBillingAddress function
Braintree_CustomerTest::testCreate_withCreditCardAndSpecificVerificationMerchantAccount function
Braintree_CustomerTest::testCreate_withCustomFields function
Braintree_CustomerTest::testCreate_withDuplicateCardCheck function
Braintree_CustomerTest::testCreate_withSpecialChars function
Braintree_CustomerTest::testCreate_withUnicode function
Braintree_CustomerTest::testCreate_withValidationErrors function
Braintree_CustomerTest::testCreditNoValidate_createsACreditUsingGivenId function
Braintree_CustomerTest::testCreditNoValidate_throwsIfInvalid function
Braintree_CustomerTest::testCredit_createsACreditUsingGivenCustomerId function
Braintree_CustomerTest::testDelete_deletesTheCustomer function
Braintree_CustomerTest::testFind function
Braintree_CustomerTest::testFind_throwsExceptionIfNotFound function
Braintree_CustomerTest::testSaleNoValidate_createsASaleUsingGivenToken function
Braintree_CustomerTest::testSaleNoValidate_throwsIfInvalid function
Braintree_CustomerTest::testSale_createsASaleUsingGivenToken function
Braintree_CustomerTest::testUpdate function
Braintree_CustomerTest::testUpdateFromTransparentRedirect function
Braintree_CustomerTest::testUpdateFromTransparentRedirect_withParamsInTrData function
Braintree_CustomerTest::testUpdateFromTransparentRedirect_withUpdateExisting function
Braintree_CustomerTest::testUpdateFromTransparentRedirect_withValidationErrors function
Braintree_CustomerTest::testUpdateNoValidate function
Braintree_CustomerTest::testUpdate_forBillingAddressAndExistingCreditCardAndCustomerDetailsTogether function
Braintree_CustomerTest::testUpdate_withCountry function
Braintree_CustomerTest::testUpdate_withNewCreditCardAndExistingBillingAddress function
Braintree_CustomerTest::testUpdate_withUpdatingExistingCreditCard function
Braintree_CustomerTest::updateCustomerViaTr function