You are here

class Braintree_SubscriptionTest in Commerce Braintree 7

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

Hierarchy

Expanded class hierarchy of Braintree_SubscriptionTest

File

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

View source
class Braintree_SubscriptionTest extends PHPUnit_Framework_TestCase {
  function testCreate_doesNotAcceptBadAttributes() {
    $this
      ->setExpectedException('InvalidArgumentException', 'invalid keys: bad');
    $result = Braintree_Subscription::create(array(
      'bad' => 'value',
    ));
  }
  function testCreate_whenSuccessful() {
    $creditCard = Braintree_SubscriptionTestHelper::createCreditCard();
    $plan = Braintree_SubscriptionTestHelper::triallessPlan();
    $result = Braintree_Subscription::create(array(
      'paymentMethodToken' => $creditCard->token,
      'planId' => $plan['id'],
    ));
    Braintree_TestHelper::assertPrintable($result);
    $this
      ->assertTrue($result->success);
    $subscription = $result->subscription;
    $this
      ->assertEquals($creditCard->token, $subscription->paymentMethodToken);
    $this
      ->assertEquals(0, $subscription->failureCount);
    $this
      ->assertEquals($plan['id'], $subscription->planId);
    $this
      ->assertEquals(Braintree_TestHelper::defaultMerchantAccountId(), $subscription->merchantAccountId);
    $this
      ->assertEquals(Braintree_Subscription::ACTIVE, $subscription->status);
    $this
      ->assertEquals('12.34', $subscription->nextBillAmount);
    $this
      ->assertEquals('12.34', $subscription->nextBillingPeriodAmount);
    $this
      ->assertEquals('0.00', $subscription->balance);
    $this
      ->assertEquals(1, $subscription->currentBillingCycle);
    $this
      ->assertType('DateTime', $subscription->firstBillingDate);
    $this
      ->assertType('DateTime', $subscription->nextBillingDate);
    $this
      ->assertType('DateTime', $subscription->billingPeriodStartDate);
    $this
      ->assertType('DateTime', $subscription->billingPeriodEndDate);
    $this
      ->assertType('DateTime', $subscription->paidThroughDate);
  }
  function testCreate_returnsTransactionWhenTransactionFails() {
    $creditCard = Braintree_SubscriptionTestHelper::createCreditCard();
    $plan = Braintree_SubscriptionTestHelper::triallessPlan();
    $result = Braintree_Subscription::create(array(
      'paymentMethodToken' => $creditCard->token,
      'planId' => $plan['id'],
      'price' => Braintree_Test_TransactionAmounts::$decline,
    ));
    Braintree_TestHelper::assertPrintable($result);
    $this
      ->assertFalse($result->success);
    $this
      ->assertEquals(Braintree_Transaction::PROCESSOR_DECLINED, $result->transaction->status);
  }
  function testCreate_canSetTheId() {
    $creditCard = Braintree_SubscriptionTestHelper::createCreditCard();
    $newId = strval(rand());
    $plan = Braintree_SubscriptionTestHelper::triallessPlan();
    $result = Braintree_Subscription::create(array(
      'paymentMethodToken' => $creditCard->token,
      'planId' => $plan['id'],
      'id' => $newId,
    ));
    $this
      ->assertTrue($result->success);
    $subscription = $result->subscription;
    $this
      ->assertEquals($newId, $subscription->id);
  }
  function testCreate_canSetTheMerchantAccountId() {
    $creditCard = Braintree_SubscriptionTestHelper::createCreditCard();
    $plan = Braintree_SubscriptionTestHelper::triallessPlan();
    $result = Braintree_Subscription::create(array(
      'paymentMethodToken' => $creditCard->token,
      'planId' => $plan['id'],
      'merchantAccountId' => Braintree_TestHelper::nonDefaultMerchantAccountId(),
    ));
    $this
      ->assertTrue($result->success);
    $subscription = $result->subscription;
    $this
      ->assertEquals(Braintree_TestHelper::nonDefaultMerchantAccountId(), $subscription->merchantAccountId);
  }
  function testCreate_trialPeriodDefaultsToPlanWithoutTrial() {
    $creditCard = Braintree_SubscriptionTestHelper::createCreditCard();
    $plan = Braintree_SubscriptionTestHelper::triallessPlan();
    $result = Braintree_Subscription::create(array(
      'paymentMethodToken' => $creditCard->token,
      'planId' => $plan['id'],
    ));
    $subscription = $result->subscription;
    $this
      ->assertFalse($subscription->trialPeriod);
    $this
      ->assertNull($subscription->trialDuration);
    $this
      ->assertNull($subscription->trialDurationUnit);
  }
  function testCreate_trialPeriondDefaultsToPlanWithTrial() {
    $creditCard = Braintree_SubscriptionTestHelper::createCreditCard();
    $plan = Braintree_SubscriptionTestHelper::trialPlan();
    $result = Braintree_Subscription::create(array(
      'paymentMethodToken' => $creditCard->token,
      'planId' => $plan['id'],
    ));
    $subscription = $result->subscription;
    $this
      ->assertTrue($subscription->trialPeriod);
    $this
      ->assertEquals(2, $subscription->trialDuration);
    $this
      ->assertEquals('day', $subscription->trialDurationUnit);
  }
  function testCreate_alterPlanTrialPeriod() {
    $creditCard = Braintree_SubscriptionTestHelper::createCreditCard();
    $plan = Braintree_SubscriptionTestHelper::trialPlan();
    $result = Braintree_Subscription::create(array(
      'paymentMethodToken' => $creditCard->token,
      'planId' => $plan['id'],
      'trialDuration' => 5,
      'trialDurationUnit' => 'month',
    ));
    $subscription = $result->subscription;
    $this
      ->assertTrue($subscription->trialPeriod);
    $this
      ->assertEquals(5, $subscription->trialDuration);
    $this
      ->assertEquals('month', $subscription->trialDurationUnit);
  }
  function testCreate_removePlanTrialPeriod() {
    $creditCard = Braintree_SubscriptionTestHelper::createCreditCard();
    $plan = Braintree_SubscriptionTestHelper::trialPlan();
    $result = Braintree_Subscription::create(array(
      'paymentMethodToken' => $creditCard->token,
      'planId' => $plan['id'],
      'trialPeriod' => false,
    ));
    $subscription = $result->subscription;
    $this
      ->assertFalse($subscription->trialPeriod);
  }
  function testCreate_createsATransactionIfNoTrialPeriod() {
    $creditCard = Braintree_SubscriptionTestHelper::createCreditCard();
    $plan = Braintree_SubscriptionTestHelper::triallessPlan();
    $result = Braintree_Subscription::create(array(
      'paymentMethodToken' => $creditCard->token,
      'planId' => $plan['id'],
    ));
    $subscription = $result->subscription;
    $this
      ->assertEquals(1, sizeof($subscription->transactions));
    $transaction = $subscription->transactions[0];
    $this
      ->assertType('Braintree_Transaction', $transaction);
    $this
      ->assertEquals($plan['price'], $transaction->amount);
    $this
      ->assertEquals(Braintree_Transaction::SALE, $transaction->type);
    $this
      ->assertEquals($subscription->id, $transaction->subscriptionId);
  }
  function testCreate_doesNotCreateTransactionIfTrialPeriod() {
    $creditCard = Braintree_SubscriptionTestHelper::createCreditCard();
    $plan = Braintree_SubscriptionTestHelper::trialPlan();
    $result = Braintree_Subscription::create(array(
      'paymentMethodToken' => $creditCard->token,
      'planId' => $plan['id'],
    ));
    $subscription = $result->subscription;
    $this
      ->assertEquals(0, sizeof($subscription->transactions));
  }
  function testCreate_returnsATransactionWithSubscriptionBillingPeriod() {
    $creditCard = Braintree_SubscriptionTestHelper::createCreditCard();
    $plan = Braintree_SubscriptionTestHelper::triallessPlan();
    $result = Braintree_Subscription::create(array(
      'paymentMethodToken' => $creditCard->token,
      'planId' => $plan['id'],
    ));
    $subscription = $result->subscription;
    $transaction = $subscription->transactions[0];
    $this
      ->assertEquals($subscription->billingPeriodStartDate, $transaction->subscriptionDetails->billingPeriodStartDate);
    $this
      ->assertEquals($subscription->billingPeriodEndDate, $transaction->subscriptionDetails->billingPeriodEndDate);
  }
  function testCreate_priceCanBeOverriden() {
    $creditCard = Braintree_SubscriptionTestHelper::createCreditCard();
    $plan = Braintree_SubscriptionTestHelper::trialPlan();
    $result = Braintree_Subscription::create(array(
      'paymentMethodToken' => $creditCard->token,
      'planId' => $plan['id'],
      'price' => '2.00',
    ));
    $subscription = $result->subscription;
    $this
      ->assertEquals('2.00', $subscription->price);
  }
  function testCreate_billingDayOfMonthIsInheritedFromPlan() {
    $creditCard = Braintree_SubscriptionTestHelper::createCreditCard();
    $plan = Braintree_SubscriptionTestHelper::billingDayOfMonthPlan();
    $result = Braintree_Subscription::create(array(
      'paymentMethodToken' => $creditCard->token,
      'planId' => $plan['id'],
    ));
    $subscription = $result->subscription;
    $this
      ->assertEquals(5, $subscription->billingDayOfMonth);
  }
  function testCreate_billingDayOfMonthCanBeOverriden() {
    $creditCard = Braintree_SubscriptionTestHelper::createCreditCard();
    $plan = Braintree_SubscriptionTestHelper::billingDayOfMonthPlan();
    $result = Braintree_Subscription::create(array(
      'paymentMethodToken' => $creditCard->token,
      'planId' => $plan['id'],
      'billingDayOfMonth' => 14,
    ));
    $subscription = $result->subscription;
    $this
      ->assertEquals(14, $subscription->billingDayOfMonth);
  }
  function testCreate_billingDayOfMonthCanBeOverridenWithStartImmediately() {
    $creditCard = Braintree_SubscriptionTestHelper::createCreditCard();
    $plan = Braintree_SubscriptionTestHelper::billingDayOfMonthPlan();
    $result = Braintree_Subscription::create(array(
      'paymentMethodToken' => $creditCard->token,
      'planId' => $plan['id'],
      'options' => array(
        'startImmediately' => true,
      ),
    ));
    $subscription = $result->subscription;
    $this
      ->assertEquals(1, sizeof($subscription->transactions));
  }
  function testCreate_firstBillingDateCanBeSet() {
    $creditCard = Braintree_SubscriptionTestHelper::createCreditCard();
    $plan = Braintree_SubscriptionTestHelper::billingDayOfMonthPlan();
    $tomorrow = new DateTime("now + 1 day");
    $tomorrow
      ->setTime(0, 0, 0);
    $result = Braintree_Subscription::create(array(
      'paymentMethodToken' => $creditCard->token,
      'planId' => $plan['id'],
      'firstBillingDate' => $tomorrow,
    ));
    $subscription = $result->subscription;
    $this
      ->assertEquals($tomorrow, $subscription->firstBillingDate);
    $this
      ->assertEquals(Braintree_Subscription::PENDING, $result->subscription->status);
  }
  function testCreate_firstBillingDateInThePast() {
    $creditCard = Braintree_SubscriptionTestHelper::createCreditCard();
    $plan = Braintree_SubscriptionTestHelper::billingDayOfMonthPlan();
    $past = new DateTime("now - 3 days");
    $past
      ->setTime(0, 0, 0);
    $result = Braintree_Subscription::create(array(
      'paymentMethodToken' => $creditCard->token,
      'planId' => $plan['id'],
      'firstBillingDate' => $past,
    ));
    $this
      ->assertFalse($result->success);
    $errors = $result->errors
      ->forKey('subscription')
      ->onAttribute('firstBillingDate');
    $this
      ->assertEquals(Braintree_Error_Codes::SUBSCRIPTION_FIRST_BILLING_DATE_CANNOT_BE_IN_THE_PAST, $errors[0]->code);
  }
  function testCreate_numberOfBillingCyclesCanBeOverridden() {
    $creditCard = Braintree_SubscriptionTestHelper::createCreditCard();
    $plan = Braintree_SubscriptionTestHelper::trialPlan();
    $result = Braintree_Subscription::create(array(
      'paymentMethodToken' => $creditCard->token,
      'planId' => $plan['id'],
    ));
    $subscription = $result->subscription;
    $this
      ->assertEquals($plan['numberOfBillingCycles'], $subscription->numberOfBillingCycles);
    $result = Braintree_Subscription::create(array(
      'numberOfBillingCycles' => '10',
      'paymentMethodToken' => $creditCard->token,
      'planId' => $plan['id'],
    ));
    $subscription = $result->subscription;
    $this
      ->assertEquals(10, $subscription->numberOfBillingCycles);
    $this
      ->assertFalse($subscription->neverExpires);
  }
  function testCreate_numberOfBillingCyclesCanBeOverriddenToNeverExpire() {
    $creditCard = Braintree_SubscriptionTestHelper::createCreditCard();
    $plan = Braintree_SubscriptionTestHelper::trialPlan();
    $result = Braintree_Subscription::create(array(
      'paymentMethodToken' => $creditCard->token,
      'planId' => $plan['id'],
    ));
    $subscription = $result->subscription;
    $this
      ->assertEquals($plan['numberOfBillingCycles'], $subscription->numberOfBillingCycles);
    $result = Braintree_Subscription::create(array(
      'neverExpires' => true,
      'paymentMethodToken' => $creditCard->token,
      'planId' => $plan['id'],
    ));
    $subscription = $result->subscription;
    $this
      ->assertNull($subscription->numberOfBillingCycles);
    $this
      ->assertTrue($subscription->neverExpires);
  }
  function testCreate_doesNotInheritAddOnsAndDiscountsWhenDoNotInheritAddOnsOrDiscountsIsSet() {
    $creditCard = Braintree_SubscriptionTestHelper::createCreditCard();
    $plan = Braintree_SubscriptionTestHelper::addOnDiscountPlan();
    $result = Braintree_Subscription::create(array(
      'paymentMethodToken' => $creditCard->token,
      'planId' => $plan['id'],
      'options' => array(
        'doNotInheritAddOnsOrDiscounts' => true,
      ),
    ));
    $subscription = $result->subscription;
    $this
      ->assertEquals(0, sizeof($subscription->addOns));
    $this
      ->assertEquals(0, sizeof($subscription->discounts));
  }
  function testCreate_inheritsAddOnsAndDiscountsFromPlanByDefault() {
    $creditCard = Braintree_SubscriptionTestHelper::createCreditCard();
    $plan = Braintree_SubscriptionTestHelper::addOnDiscountPlan();
    $result = Braintree_Subscription::create(array(
      'paymentMethodToken' => $creditCard->token,
      'planId' => $plan['id'],
    ));
    $subscription = $result->subscription;
    $this
      ->assertEquals(2, sizeof($subscription->addOns));
    $addOns = $subscription->addOns;
    Braintree_SubscriptionTestHelper::sortModificationsById($addOns);
    $this
      ->assertEquals($addOns[0]->amount, "10.00");
    $this
      ->assertEquals($addOns[0]->quantity, 1);
    $this
      ->assertEquals($addOns[0]->numberOfBillingCycles, null);
    $this
      ->assertEquals($addOns[0]->neverExpires, true);
    $this
      ->assertEquals($addOns[1]->amount, "20.00");
    $this
      ->assertEquals($addOns[1]->quantity, 1);
    $this
      ->assertEquals($addOns[1]->numberOfBillingCycles, null);
    $this
      ->assertEquals($addOns[1]->neverExpires, true);
    $this
      ->assertEquals(2, sizeof($subscription->discounts));
    $discounts = $subscription->discounts;
    Braintree_SubscriptionTestHelper::sortModificationsById($discounts);
    $this
      ->assertEquals($discounts[0]->amount, "11.00");
    $this
      ->assertEquals($discounts[0]->quantity, 1);
    $this
      ->assertEquals($discounts[0]->numberOfBillingCycles, null);
    $this
      ->assertEquals($discounts[0]->neverExpires, true);
    $this
      ->assertEquals($discounts[1]->amount, "7.00");
    $this
      ->assertEquals($discounts[1]->quantity, 1);
    $this
      ->assertEquals($discounts[1]->numberOfBillingCycles, null);
    $this
      ->assertEquals($discounts[1]->neverExpires, true);
  }
  function testCreate_allowsOverridingInheritedAddOnsAndDiscounts() {
    $creditCard = Braintree_SubscriptionTestHelper::createCreditCard();
    $plan = Braintree_SubscriptionTestHelper::addOnDiscountPlan();
    $result = Braintree_Subscription::create(array(
      'paymentMethodToken' => $creditCard->token,
      'planId' => $plan['id'],
      'addOns' => array(
        'update' => array(
          array(
            'amount' => '50.00',
            'existingId' => 'increase_10',
            'quantity' => 2,
            'numberOfBillingCycles' => 5,
          ),
          array(
            'amount' => '60.00',
            'existingId' => 'increase_20',
            'quantity' => 4,
            'numberOfBillingCycles' => 9,
          ),
        ),
      ),
      'discounts' => array(
        'update' => array(
          array(
            'amount' => '15.00',
            'existingId' => 'discount_7',
            'quantity' => 2,
            'neverExpires' => true,
          ),
        ),
      ),
    ));
    $subscription = $result->subscription;
    $this
      ->assertEquals(2, sizeof($subscription->addOns));
    $addOns = $subscription->addOns;
    Braintree_SubscriptionTestHelper::sortModificationsById($addOns);
    $this
      ->assertEquals($addOns[0]->amount, "50.00");
    $this
      ->assertEquals($addOns[0]->quantity, 2);
    $this
      ->assertEquals($addOns[0]->numberOfBillingCycles, 5);
    $this
      ->assertEquals($addOns[0]->neverExpires, false);
    $this
      ->assertEquals($addOns[1]->amount, "60.00");
    $this
      ->assertEquals($addOns[1]->quantity, 4);
    $this
      ->assertEquals($addOns[1]->numberOfBillingCycles, 9);
    $this
      ->assertEquals($addOns[1]->neverExpires, false);
    $this
      ->assertEquals(2, sizeof($subscription->discounts));
    $discounts = $subscription->discounts;
    Braintree_SubscriptionTestHelper::sortModificationsById($discounts);
    $this
      ->assertEquals($discounts[0]->amount, "11.00");
    $this
      ->assertEquals($discounts[0]->quantity, 1);
    $this
      ->assertEquals($discounts[0]->numberOfBillingCycles, null);
    $this
      ->assertEquals($discounts[0]->neverExpires, true);
    $this
      ->assertEquals($discounts[1]->amount, "15.00");
    $this
      ->assertEquals($discounts[1]->quantity, 2);
    $this
      ->assertEquals($discounts[1]->numberOfBillingCycles, null);
    $this
      ->assertEquals($discounts[1]->neverExpires, true);
  }
  function testCreate_allowsRemovalOfInheritedAddOnsAndDiscounts() {
    $creditCard = Braintree_SubscriptionTestHelper::createCreditCard();
    $plan = Braintree_SubscriptionTestHelper::addOnDiscountPlan();
    $result = Braintree_Subscription::create(array(
      'paymentMethodToken' => $creditCard->token,
      'planId' => $plan['id'],
      'addOns' => array(
        'remove' => array(
          'increase_10',
          'increase_20',
        ),
      ),
      'discounts' => array(
        'remove' => array(
          'discount_7',
        ),
      ),
    ));
    $subscription = $result->subscription;
    $this
      ->assertEquals(0, sizeof($subscription->addOns));
    $this
      ->assertEquals(1, sizeof($subscription->discounts));
    $this
      ->assertEquals($subscription->discounts[0]->amount, "11.00");
    $this
      ->assertEquals($subscription->discounts[0]->quantity, 1);
    $this
      ->assertEquals($subscription->discounts[0]->numberOfBillingCycles, null);
    $this
      ->assertEquals($subscription->discounts[0]->neverExpires, true);
  }
  function testCreate_allowsAddingNewAddOnsAndDiscounts() {
    $creditCard = Braintree_SubscriptionTestHelper::createCreditCard();
    $plan = Braintree_SubscriptionTestHelper::addOnDiscountPlan();
    $result = Braintree_Subscription::create(array(
      'paymentMethodToken' => $creditCard->token,
      'planId' => $plan['id'],
      'addOns' => array(
        'add' => array(
          array(
            'inheritedFromId' => 'increase_30',
            'amount' => '35.00',
            'neverExpires' => true,
            'quantity' => 2,
          ),
        ),
      ),
      'discounts' => array(
        'add' => array(
          array(
            'inheritedFromId' => 'discount_15',
            'amount' => '15.50',
            'numberOfBillingCycles' => 10,
            'quantity' => 3,
          ),
        ),
      ),
    ));
    $subscription = $result->subscription;
    $this
      ->assertEquals(3, sizeof($subscription->addOns));
    $addOns = $subscription->addOns;
    Braintree_SubscriptionTestHelper::sortModificationsById($addOns);
    $this
      ->assertEquals($addOns[0]->amount, "10.00");
    $this
      ->assertEquals($addOns[1]->amount, "20.00");
    $this
      ->assertEquals($addOns[2]->id, "increase_30");
    $this
      ->assertEquals($addOns[2]->amount, "35.00");
    $this
      ->assertEquals($addOns[2]->neverExpires, true);
    $this
      ->assertEquals($addOns[2]->numberOfBillingCycles, null);
    $this
      ->assertEquals($addOns[2]->quantity, 2);
    $this
      ->assertEquals(3, sizeof($subscription->discounts));
    $discounts = $subscription->discounts;
    Braintree_SubscriptionTestHelper::sortModificationsById($discounts);
    $this
      ->assertEquals($discounts[0]->amount, "11.00");
    $this
      ->assertEquals($discounts[1]->amount, "15.50");
    $this
      ->assertEquals($discounts[1]->id, "discount_15");
    $this
      ->assertEquals($discounts[1]->neverExpires, false);
    $this
      ->assertEquals($discounts[1]->numberOfBillingCycles, 10);
    $this
      ->assertEquals($discounts[1]->quantity, 3);
    $this
      ->assertEquals($discounts[2]->amount, "7.00");
  }
  function testCreate_properlyParsesValidationErrorsForArrays() {
    $creditCard = Braintree_SubscriptionTestHelper::createCreditCard();
    $plan = Braintree_SubscriptionTestHelper::addOnDiscountPlan();
    $result = Braintree_Subscription::create(array(
      'paymentMethodToken' => $creditCard->token,
      'planId' => $plan['id'],
      'addOns' => array(
        'update' => array(
          array(
            'existingId' => 'increase_10',
            'amount' => 'invalid',
          ),
          array(
            'existingId' => 'increase_20',
            'quantity' => -10,
          ),
        ),
      ),
    ));
    $this
      ->assertFalse($result->success);
    $errors = $result->errors
      ->forKey('subscription')
      ->forKey('addOns')
      ->forKey('update')
      ->forIndex(0)
      ->onAttribute('amount');
    $this
      ->assertEquals(Braintree_Error_Codes::SUBSCRIPTION_MODIFICATION_AMOUNT_IS_INVALID, $errors[0]->code);
    $errors = $result->errors
      ->forKey('subscription')
      ->forKey('addOns')
      ->forKey('update')
      ->forIndex(1)
      ->onAttribute('quantity');
    $this
      ->assertEquals(Braintree_Error_Codes::SUBSCRIPTION_MODIFICATION_QUANTITY_IS_INVALID, $errors[0]->code);
  }
  function testCreate_withDescriptor() {
    $creditCard = Braintree_SubscriptionTestHelper::createCreditCard();
    $plan = Braintree_SubscriptionTestHelper::triallessPlan();
    $result = Braintree_Subscription::create(array(
      'paymentMethodToken' => $creditCard->token,
      'planId' => $plan['id'],
      'descriptor' => array(
        'name' => '123*123456789012345678',
        'phone' => '3334445555',
      ),
    ));
    $this
      ->assertTrue($result->success);
    $subscription = $result->subscription;
    $this
      ->assertEquals('123*123456789012345678', $subscription->descriptor->name);
    $this
      ->assertEquals('3334445555', $subscription->descriptor->phone);
    $transaction = $subscription->transactions[0];
    $this
      ->assertEquals('123*123456789012345678', $transaction->descriptor->name);
    $this
      ->assertEquals('3334445555', $transaction->descriptor->phone);
  }
  function testCreate_withDescriptorValidation() {
    $result = Braintree_Subscription::create(array(
      'descriptor' => array(
        'name' => 'xxxxxx',
        'phone' => 'xxxx',
      ),
    ));
    $this
      ->assertFalse($result->success);
    $subscription = $result->subscription;
    $errors = $result->errors
      ->forKey('subscription')
      ->forKey('descriptor')
      ->onAttribute('name');
    $this
      ->assertEquals(Braintree_Error_Codes::DESCRIPTOR_NAME_FORMAT_IS_INVALID, $errors[0]->code);
    $errors = $result->errors
      ->forKey('subscription')
      ->forKey('descriptor')
      ->onAttribute('phone');
    $this
      ->assertEquals(Braintree_Error_Codes::DESCRIPTOR_PHONE_FORMAT_IS_INVALID, $errors[0]->code);
  }
  function testValidationErrors_hasValidationErrorsOnId() {
    $creditCard = Braintree_SubscriptionTestHelper::createCreditCard();
    $plan = Braintree_SubscriptionTestHelper::triallessPlan();
    $result = Braintree_Subscription::create(array(
      'paymentMethodToken' => $creditCard->token,
      'planId' => $plan['id'],
      'id' => 'invalid token',
    ));
    $this
      ->assertFalse($result->success);
    $errors = $result->errors
      ->forKey('subscription')
      ->onAttribute('id');
    $this
      ->assertEquals(Braintree_Error_Codes::SUBSCRIPTION_TOKEN_FORMAT_IS_INVALID, $errors[0]->code);
  }
  function testFind() {
    $creditCard = Braintree_SubscriptionTestHelper::createCreditCard();
    $plan = Braintree_SubscriptionTestHelper::triallessPlan();
    $result = Braintree_Subscription::create(array(
      'paymentMethodToken' => $creditCard->token,
      'planId' => $plan['id'],
    ));
    $this
      ->assertTrue($result->success);
    $subscription = Braintree_Subscription::find($result->subscription->id);
    $this
      ->assertEquals($result->subscription->id, $subscription->id);
    $this
      ->assertEquals($plan['id'], $subscription->planId);
  }
  function testFind_throwsIfNotFound() {
    $this
      ->setExpectedException('Braintree_Exception_NotFound', 'subscription with id does-not-exist not found');
    Braintree_Subscription::find('does-not-exist');
  }
  function testUpdate_whenSuccessful() {
    $subscription = Braintree_SubscriptionTestHelper::createSubscription();
    $newId = strval(rand());
    $newPlan = Braintree_SubscriptionTestHelper::trialPlan();
    $result = Braintree_Subscription::update($subscription->id, array(
      'id' => $newId,
      'price' => '999.99',
      'planId' => $newPlan['id'],
    ));
    $this
      ->assertTrue($result->success);
    $this
      ->assertEquals($newId, $result->subscription->id);
    $this
      ->assertEquals($newPlan['id'], $result->subscription->planId);
    $this
      ->assertEquals('999.99', $result->subscription->price);
  }
  function testUpdate_doesNotAcceptBadAttributes() {
    $this
      ->setExpectedException('InvalidArgumentException', 'invalid keys: bad');
    $result = Braintree_Subscription::update('id', array(
      'bad' => 'value',
    ));
  }
  function testUpdate_canUpdateNumberOfBillingCycles() {
    $plan = Braintree_SubscriptionTestHelper::triallessPlan();
    $subscription = Braintree_SubscriptionTestHelper::createSubscription();
    $this
      ->assertEquals($plan['numberOfBillingCycles'], $subscription->numberOfBillingCycles);
    $updatedSubscription = Braintree_Subscription::update($subscription->id, array(
      'numberOfBillingCycles' => 15,
    ))->subscription;
    $this
      ->assertEquals(15, $updatedSubscription->numberOfBillingCycles);
  }
  function testUpdate_canUpdateNumberOfBillingCyclesToNeverExpire() {
    $plan = Braintree_SubscriptionTestHelper::triallessPlan();
    $subscription = Braintree_SubscriptionTestHelper::createSubscription();
    $this
      ->assertEquals($plan['numberOfBillingCycles'], $subscription->numberOfBillingCycles);
    $updatedSubscription = Braintree_Subscription::update($subscription->id, array(
      'neverExpires' => true,
    ))->subscription;
    $this
      ->assertNull($updatedSubscription->numberOfBillingCycles);
  }
  function testUpdate_createsTransactionOnProration() {
    $subscription = Braintree_SubscriptionTestHelper::createSubscription();
    $result = Braintree_Subscription::update($subscription->id, array(
      'price' => $subscription->price + 1,
    ));
    $this
      ->assertTrue($result->success);
    $this
      ->assertEquals(sizeof($subscription->transactions) + 1, sizeof($result->subscription->transactions));
  }
  function testUpdate_createsProratedTransactionWhenFlagIsPassedTrue() {
    $subscription = Braintree_SubscriptionTestHelper::createSubscription();
    $result = Braintree_Subscription::update($subscription->id, array(
      'price' => $subscription->price + 1,
      'options' => array(
        'prorateCharges' => true,
      ),
    ));
    $this
      ->assertTrue($result->success);
    $this
      ->assertEquals(sizeof($subscription->transactions) + 1, sizeof($result->subscription->transactions));
  }
  function testUpdate_createsProratedTransactionWhenFlagIsPassedFalse() {
    $subscription = Braintree_SubscriptionTestHelper::createSubscription();
    $result = Braintree_Subscription::update($subscription->id, array(
      'price' => $subscription->price + 1,
      'options' => array(
        'prorateCharges' => false,
      ),
    ));
    $this
      ->assertTrue($result->success);
    $this
      ->assertEquals(sizeof($subscription->transactions), sizeof($result->subscription->transactions));
  }
  function testUpdate_DoesNotUpdateSubscriptionWhenProrationTransactionFailsAndRevertIsTrue() {
    $subscription = Braintree_SubscriptionTestHelper::createSubscription();
    $result = Braintree_Subscription::update($subscription->id, array(
      'price' => $subscription->price + 2100,
      'options' => array(
        'prorateCharges' => true,
        'revertSubscriptionOnProrationFailure' => true,
      ),
    ));
    $this
      ->assertFalse($result->success);
    $this
      ->assertEquals(sizeof($subscription->transactions) + 1, sizeof($result->subscription->transactions));
    $this
      ->assertEquals(Braintree_Transaction::PROCESSOR_DECLINED, $result->subscription->transactions[0]->status);
    $this
      ->assertEquals("0.00", $result->subscription->balance);
    $this
      ->assertEquals($subscription->price, $result->subscription->price);
  }
  function testUpdate_UpdatesSubscriptionWhenProrationTransactionFailsAndRevertIsFalse() {
    $subscription = Braintree_SubscriptionTestHelper::createSubscription();
    $result = Braintree_Subscription::update($subscription->id, array(
      'price' => $subscription->price + 2100,
      'options' => array(
        'prorateCharges' => true,
        'revertSubscriptionOnProrationFailure' => false,
      ),
    ));
    $this
      ->assertTrue($result->success);
    $this
      ->assertEquals(sizeof($subscription->transactions) + 1, sizeof($result->subscription->transactions));
    $this
      ->assertEquals(Braintree_Transaction::PROCESSOR_DECLINED, $result->subscription->transactions[0]->status);
    $this
      ->assertEquals($result->subscription->transactions[0]->amount, $result->subscription->balance);
    $this
      ->assertEquals($subscription->price + 2100, $result->subscription->price);
  }
  function testUpdate_invalidSubscriptionId() {
    $this
      ->setExpectedException('Braintree_Exception_NotFound');
    Braintree_Subscription::update('does-not-exist', array());
  }
  function testUpdate_validationErrors() {
    $subscription = Braintree_SubscriptionTestHelper::createSubscription();
    $result = Braintree_Subscription::update($subscription->id, array(
      'price' => '',
    ));
    $this
      ->assertFalse($result->success);
    $errors = $result->errors
      ->forKey('subscription')
      ->onAttribute('price');
    $this
      ->assertEquals(Braintree_Error_Codes::SUBSCRIPTION_PRICE_CANNOT_BE_BLANK, $errors[0]->code);
  }
  function testUpdate_cannotUpdateCanceledSubscription() {
    $subscription = Braintree_SubscriptionTestHelper::createSubscription();
    Braintree_Subscription::cancel($subscription->id);
    $result = Braintree_Subscription::update($subscription->id, array(
      'price' => '1.00',
    ));
    $this
      ->assertFalse($result->success);
    $errors = $result->errors
      ->forKey('subscription')
      ->onAttribute('base');
    $this
      ->assertEquals(Braintree_Error_Codes::SUBSCRIPTION_CANNOT_EDIT_CANCELED_SUBSCRIPTION, $errors[0]->code);
  }
  function testUpdate_canUpdatePaymentMethodToken() {
    $oldCreditCard = Braintree_SubscriptionTestHelper::createCreditCard();
    $plan = Braintree_SubscriptionTestHelper::triallessPlan();
    $subscription = Braintree_Subscription::create(array(
      'paymentMethodToken' => $oldCreditCard->token,
      'price' => '54.99',
      'planId' => $plan['id'],
    ))->subscription;
    $newCreditCard = Braintree_CreditCard::createNoValidate(array(
      'number' => '5105105105105100',
      'expirationDate' => '05/2010',
      'customerId' => $oldCreditCard->customerId,
    ));
    $result = Braintree_Subscription::update($subscription->id, array(
      'paymentMethodToken' => $newCreditCard->token,
    ));
    $this
      ->assertTrue($result->success);
    $this
      ->assertEquals($newCreditCard->token, $result->subscription->paymentMethodToken);
  }
  function testUpdate_canUpdateAddOnsAndDiscounts() {
    $oldCreditCard = Braintree_SubscriptionTestHelper::createCreditCard();
    $plan = Braintree_SubscriptionTestHelper::addOnDiscountPlan();
    $subscription = Braintree_Subscription::create(array(
      'paymentMethodToken' => $oldCreditCard->token,
      'price' => '54.99',
      'planId' => $plan['id'],
    ))->subscription;
    $result = Braintree_Subscription::update($subscription->id, array(
      'addOns' => array(
        'update' => array(
          array(
            'amount' => '99.99',
            'existingId' => 'increase_10',
            'quantity' => 99,
            'numberOfBillingCycles' => 99,
          ),
          array(
            'amount' => '22.22',
            'existingId' => 'increase_20',
            'quantity' => 22,
            'neverExpires' => true,
          ),
        ),
      ),
      'discounts' => array(
        'update' => array(
          array(
            'amount' => '33.33',
            'existingId' => 'discount_11',
            'quantity' => 33,
            'numberOfBillingCycles' => 33,
          ),
        ),
      ),
    ));
    $this
      ->assertTrue($result->success);
    $subscription = $result->subscription;
    $this
      ->assertEquals(2, sizeof($subscription->addOns));
    $addOns = $subscription->addOns;
    Braintree_SubscriptionTestHelper::sortModificationsById($addOns);
    $this
      ->assertEquals($addOns[0]->id, "increase_10");
    $this
      ->assertEquals($addOns[0]->amount, "99.99");
    $this
      ->assertEquals($addOns[0]->neverExpires, false);
    $this
      ->assertEquals($addOns[0]->numberOfBillingCycles, 99);
    $this
      ->assertEquals($addOns[0]->quantity, 99);
    $this
      ->assertEquals($addOns[1]->id, "increase_20");
    $this
      ->assertEquals($addOns[1]->amount, "22.22");
    $this
      ->assertEquals($addOns[1]->neverExpires, true);
    $this
      ->assertEquals($addOns[1]->numberOfBillingCycles, null);
    $this
      ->assertEquals($addOns[1]->quantity, 22);
    $this
      ->assertEquals(2, sizeof($subscription->discounts));
    $discounts = $subscription->discounts;
    Braintree_SubscriptionTestHelper::sortModificationsById($discounts);
    $this
      ->assertEquals($discounts[0]->id, "discount_11");
    $this
      ->assertEquals($discounts[0]->amount, "33.33");
    $this
      ->assertEquals($discounts[0]->neverExpires, false);
    $this
      ->assertEquals($discounts[0]->numberOfBillingCycles, 33);
    $this
      ->assertEquals($discounts[0]->quantity, 33);
  }
  function testUpdate_canAddAndRemoveAddOnsAndDiscounts() {
    $oldCreditCard = Braintree_SubscriptionTestHelper::createCreditCard();
    $plan = Braintree_SubscriptionTestHelper::addOnDiscountPlan();
    $subscription = Braintree_Subscription::create(array(
      'paymentMethodToken' => $oldCreditCard->token,
      'price' => '54.99',
      'planId' => $plan['id'],
    ))->subscription;
    $result = Braintree_Subscription::update($subscription->id, array(
      'addOns' => array(
        'add' => array(
          array(
            'amount' => '33.33',
            'inheritedFromId' => 'increase_30',
            'quantity' => 33,
            'numberOfBillingCycles' => 33,
          ),
        ),
        'remove' => array(
          'increase_10',
          'increase_20',
        ),
      ),
      'discounts' => array(
        'add' => array(
          array(
            'inheritedFromId' => 'discount_15',
          ),
        ),
        'remove' => array(
          'discount_7',
        ),
      ),
    ));
    $this
      ->assertTrue($result->success);
    $subscription = $result->subscription;
    $this
      ->assertEquals(1, sizeof($subscription->addOns));
    $addOns = $subscription->addOns;
    Braintree_SubscriptionTestHelper::sortModificationsById($addOns);
    $this
      ->assertEquals($addOns[0]->id, "increase_30");
    $this
      ->assertEquals($addOns[0]->amount, "33.33");
    $this
      ->assertEquals($addOns[0]->neverExpires, false);
    $this
      ->assertEquals($addOns[0]->numberOfBillingCycles, 33);
    $this
      ->assertEquals($addOns[0]->quantity, 33);
    $this
      ->assertEquals(2, sizeof($subscription->discounts));
    $discounts = $subscription->discounts;
    Braintree_SubscriptionTestHelper::sortModificationsById($discounts);
    $this
      ->assertEquals($discounts[0]->id, "discount_11");
    $this
      ->assertEquals($discounts[1]->id, "discount_15");
    $this
      ->assertEquals($discounts[1]->amount, "15.00");
    $this
      ->assertEquals($discounts[1]->neverExpires, true);
    $this
      ->assertNull($discounts[1]->numberOfBillingCycles);
    $this
      ->assertEquals($discounts[1]->quantity, 1);
  }
  function testUpdate_canReplaceEntireSetOfAddonsAndDiscounts() {
    $oldCreditCard = Braintree_SubscriptionTestHelper::createCreditCard();
    $plan = Braintree_SubscriptionTestHelper::addOnDiscountPlan();
    $subscription = Braintree_Subscription::create(array(
      'paymentMethodToken' => $oldCreditCard->token,
      'price' => '54.99',
      'planId' => $plan['id'],
    ))->subscription;
    $result = Braintree_Subscription::update($subscription->id, array(
      'addOns' => array(
        'add' => array(
          array(
            'inheritedFromId' => 'increase_30',
          ),
          array(
            'inheritedFromId' => 'increase_20',
          ),
        ),
      ),
      'discounts' => array(
        'add' => array(
          array(
            'inheritedFromId' => 'discount_15',
          ),
        ),
      ),
      'options' => array(
        'replaceAllAddOnsAndDiscounts' => true,
      ),
    ));
    $this
      ->assertTrue($result->success);
    $subscription = $result->subscription;
    $this
      ->assertEquals(2, sizeof($subscription->addOns));
    $addOns = $subscription->addOns;
    Braintree_SubscriptionTestHelper::sortModificationsById($addOns);
    $this
      ->assertEquals($addOns[0]->id, "increase_20");
    $this
      ->assertEquals($addOns[1]->id, "increase_30");
    $this
      ->assertEquals(1, sizeof($subscription->discounts));
    $discounts = $subscription->discounts;
    $this
      ->assertEquals($discounts[0]->id, "discount_15");
  }
  function testUpdate_withDescriptor() {
    $creditCard = Braintree_SubscriptionTestHelper::createCreditCard();
    $plan = Braintree_SubscriptionTestHelper::triallessPlan();
    $subscription = Braintree_Subscription::create(array(
      'paymentMethodToken' => $creditCard->token,
      'planId' => $plan['id'],
      'descriptor' => array(
        'name' => '123*123456789012345678',
        'phone' => '3334445555',
      ),
    ))->subscription;
    $result = Braintree_Subscription::update($subscription->id, array(
      'descriptor' => array(
        'name' => '999*9999999',
        'phone' => '8887776666',
      ),
    ));
    $updatedSubscription = $result->subscription;
    $this
      ->assertEquals('999*9999999', $updatedSubscription->descriptor->name);
    $this
      ->assertEquals('8887776666', $updatedSubscription->descriptor->phone);
  }
  function testCancel_returnsSuccessIfCanceled() {
    $subscription = Braintree_SubscriptionTestHelper::createSubscription();
    $result = Braintree_Subscription::cancel($subscription->id);
    $this
      ->assertTrue($result->success);
    $this
      ->assertEquals(Braintree_Subscription::CANCELED, $result->subscription->status);
  }
  function testCancel_throwsErrorIfRecordNotFound() {
    $this
      ->setExpectedException('Braintree_Exception_NotFound');
    Braintree_Subscription::cancel('non-existing-id');
  }
  function testCancel_returnsErrorIfCancelingCanceledSubscription() {
    $subscription = Braintree_SubscriptionTestHelper::createSubscription();
    Braintree_Subscription::cancel($subscription->id);
    $result = Braintree_Subscription::cancel($subscription->id);
    $this
      ->assertFalse($result->success);
    $errors = $result->errors
      ->forKey('subscription')
      ->onAttribute('status');
    $this
      ->assertEquals(Braintree_Error_Codes::SUBSCRIPTION_STATUS_IS_CANCELED, $errors[0]->code);
  }
  function testRetryCharge_WithoutAmount() {
    $subscription = Braintree_SubscriptionTestHelper::createSubscription();
    Braintree_Http::put('/subscriptions/' . $subscription->id . '/make_past_due');
    $result = Braintree_Subscription::retryCharge($subscription->id);
    $this
      ->assertTrue($result->success);
    $transaction = $result->transaction;
    $this
      ->assertEquals($subscription->price, $transaction->amount);
    $this
      ->assertNotNull($transaction->processorAuthorizationCode);
    $this
      ->assertEquals(Braintree_Transaction::SALE, $transaction->type);
    $this
      ->assertEquals(Braintree_Transaction::AUTHORIZED, $transaction->status);
  }
  function testRetryCharge_WithAmount() {
    $subscription = Braintree_SubscriptionTestHelper::createSubscription();
    Braintree_Http::put('/subscriptions/' . $subscription->id . '/make_past_due');
    $result = Braintree_Subscription::retryCharge($subscription->id, 1000);
    $this
      ->assertTrue($result->success);
    $transaction = $result->transaction;
    $this
      ->assertEquals(1000, $transaction->amount);
    $this
      ->assertNotNull($transaction->processorAuthorizationCode);
    $this
      ->assertEquals(Braintree_Transaction::SALE, $transaction->type);
    $this
      ->assertEquals(Braintree_Transaction::AUTHORIZED, $transaction->status);
  }

}

Members

Namesort descending Modifiers Type Description Overrides
Braintree_SubscriptionTest::testCancel_returnsErrorIfCancelingCanceledSubscription function
Braintree_SubscriptionTest::testCancel_returnsSuccessIfCanceled function
Braintree_SubscriptionTest::testCancel_throwsErrorIfRecordNotFound function
Braintree_SubscriptionTest::testCreate_allowsAddingNewAddOnsAndDiscounts function
Braintree_SubscriptionTest::testCreate_allowsOverridingInheritedAddOnsAndDiscounts function
Braintree_SubscriptionTest::testCreate_allowsRemovalOfInheritedAddOnsAndDiscounts function
Braintree_SubscriptionTest::testCreate_alterPlanTrialPeriod function
Braintree_SubscriptionTest::testCreate_billingDayOfMonthCanBeOverriden function
Braintree_SubscriptionTest::testCreate_billingDayOfMonthCanBeOverridenWithStartImmediately function
Braintree_SubscriptionTest::testCreate_billingDayOfMonthIsInheritedFromPlan function
Braintree_SubscriptionTest::testCreate_canSetTheId function
Braintree_SubscriptionTest::testCreate_canSetTheMerchantAccountId function
Braintree_SubscriptionTest::testCreate_createsATransactionIfNoTrialPeriod function
Braintree_SubscriptionTest::testCreate_doesNotAcceptBadAttributes function
Braintree_SubscriptionTest::testCreate_doesNotCreateTransactionIfTrialPeriod function
Braintree_SubscriptionTest::testCreate_doesNotInheritAddOnsAndDiscountsWhenDoNotInheritAddOnsOrDiscountsIsSet function
Braintree_SubscriptionTest::testCreate_firstBillingDateCanBeSet function
Braintree_SubscriptionTest::testCreate_firstBillingDateInThePast function
Braintree_SubscriptionTest::testCreate_inheritsAddOnsAndDiscountsFromPlanByDefault function
Braintree_SubscriptionTest::testCreate_numberOfBillingCyclesCanBeOverridden function
Braintree_SubscriptionTest::testCreate_numberOfBillingCyclesCanBeOverriddenToNeverExpire function
Braintree_SubscriptionTest::testCreate_priceCanBeOverriden function
Braintree_SubscriptionTest::testCreate_properlyParsesValidationErrorsForArrays function
Braintree_SubscriptionTest::testCreate_removePlanTrialPeriod function
Braintree_SubscriptionTest::testCreate_returnsATransactionWithSubscriptionBillingPeriod function
Braintree_SubscriptionTest::testCreate_returnsTransactionWhenTransactionFails function
Braintree_SubscriptionTest::testCreate_trialPeriodDefaultsToPlanWithoutTrial function
Braintree_SubscriptionTest::testCreate_trialPeriondDefaultsToPlanWithTrial function
Braintree_SubscriptionTest::testCreate_whenSuccessful function
Braintree_SubscriptionTest::testCreate_withDescriptor function
Braintree_SubscriptionTest::testCreate_withDescriptorValidation function
Braintree_SubscriptionTest::testFind function
Braintree_SubscriptionTest::testFind_throwsIfNotFound function
Braintree_SubscriptionTest::testRetryCharge_WithAmount function
Braintree_SubscriptionTest::testRetryCharge_WithoutAmount function
Braintree_SubscriptionTest::testUpdate_canAddAndRemoveAddOnsAndDiscounts function
Braintree_SubscriptionTest::testUpdate_cannotUpdateCanceledSubscription function
Braintree_SubscriptionTest::testUpdate_canReplaceEntireSetOfAddonsAndDiscounts function
Braintree_SubscriptionTest::testUpdate_canUpdateAddOnsAndDiscounts function
Braintree_SubscriptionTest::testUpdate_canUpdateNumberOfBillingCycles function
Braintree_SubscriptionTest::testUpdate_canUpdateNumberOfBillingCyclesToNeverExpire function
Braintree_SubscriptionTest::testUpdate_canUpdatePaymentMethodToken function
Braintree_SubscriptionTest::testUpdate_createsProratedTransactionWhenFlagIsPassedFalse function
Braintree_SubscriptionTest::testUpdate_createsProratedTransactionWhenFlagIsPassedTrue function
Braintree_SubscriptionTest::testUpdate_createsTransactionOnProration function
Braintree_SubscriptionTest::testUpdate_doesNotAcceptBadAttributes function
Braintree_SubscriptionTest::testUpdate_DoesNotUpdateSubscriptionWhenProrationTransactionFailsAndRevertIsTrue function
Braintree_SubscriptionTest::testUpdate_invalidSubscriptionId function
Braintree_SubscriptionTest::testUpdate_UpdatesSubscriptionWhenProrationTransactionFailsAndRevertIsFalse function
Braintree_SubscriptionTest::testUpdate_validationErrors function
Braintree_SubscriptionTest::testUpdate_whenSuccessful function
Braintree_SubscriptionTest::testUpdate_withDescriptor function
Braintree_SubscriptionTest::testValidationErrors_hasValidationErrorsOnId function