fake_braintree 0.4 → 0.4.1

data/spec/fake_braintree/customer_spec.rb

@@ -5,9 +5,9 @@ describe 'Braintree::Customer.create' do
 
   it 'successfully creates a customer' do
     result = Braintree::Customer.create(
-      :credit_card => {
-        :number => TEST_CC_NUMBER,
-        :expiration_date => '04/2016'
+      credit_card: {
+        number: TEST_CC_NUMBER,
+        expiration_date: '04/2016'
       }
     )
     result.should be_success
@@ -15,9 +15,9 @@ describe 'Braintree::Customer.create' do
 
   it 'associates a created credit card with the customer' do
     result = Braintree::Customer.create(
-      :credit_card => {
-        :number => TEST_CC_NUMBER,
-        :expiration_date => '04/2016'
+      credit_card: {
+        number: TEST_CC_NUMBER,
+        expiration_date: '04/2016'
       }
     )
     credit_cards = Braintree::Customer.find(result.customer.id).credit_cards
@@ -27,9 +27,9 @@ describe 'Braintree::Customer.create' do
 
   it "successfully creates the customer's credit card" do
     result = Braintree::Customer.create(
-      :credit_card => {
-        :number => TEST_CC_NUMBER,
-        :expiration_date => '04/2016'
+      credit_card: {
+        number: TEST_CC_NUMBER,
+        expiration_date: '04/2016'
       }
     )
 
@@ -39,9 +39,9 @@ describe 'Braintree::Customer.create' do
 
   it "sets a default credit card for the customer" do
     result = Braintree::Customer.create(
-      :credit_card => {
-        :number => TEST_CC_NUMBER,
-        :expiration_date => '04/2016'
+      credit_card: {
+        number: TEST_CC_NUMBER,
+        expiration_date: '04/2016'
       }
     )
 
@@ -50,7 +50,7 @@ describe 'Braintree::Customer.create' do
   end
 
   it 'can handle an empty credit card hash' do
-    result = Braintree::Customer.create(:credit_card => {})
+    result = Braintree::Customer.create(credit_card: {})
     result.should be_success
   end
 
@@ -62,10 +62,10 @@ describe 'Braintree::Customer.create' do
 
   it 'creates a customer using an expiration month and year' do
     result = Braintree::Customer.create(
-      :credit_card => {
-        :number => TEST_CC_NUMBER,
-        :expiration_month => '04',
-        :expiration_year => '2016'
+      credit_card: {
+        number: TEST_CC_NUMBER,
+        expiration_month: '04',
+        expiration_year: '2016'
       }
     )
     result.should be_success
@@ -73,13 +73,13 @@ describe 'Braintree::Customer.create' do
 
   it 'records the billing address' do
     result = create_customer(
-      :billing_address => {
-        :street_address => '1 E Main St',
-        :extended_address => 'Suite 3',
-        :locality => 'Chicago',
-        :region => 'Illinois',
-        :postal_code => '60622',
-        :country_code_alpha2 => 'US'
+      billing_address: {
+        street_address: '1 E Main St',
+        extended_address: 'Suite 3',
+        locality: 'Chicago',
+        region: 'Illinois',
+        postal_code: '60622',
+        country_code_alpha2: 'US'
       }
     )
 
@@ -90,13 +90,13 @@ describe 'Braintree::Customer.create' do
   end
 end
 
-describe 'Braintree::Customer.create', 'when passed :verify_card => true' do
+describe 'Braintree::Customer.create', 'when passed verify_card: true' do
   it 'accepts valid cards' do
-    create_customer(:options => { :verify_card => true }).should be_success
+    create_customer(options: { verify_card: true }).should be_success
   end
 
   it 'rejects invalid cards' do
-    create_customer_with_invalid_card(:options => { :verify_card => true }).should_not be_success
+    create_customer_with_invalid_card(options: { verify_card: true }).should_not be_success
   end
 end
 
@@ -115,8 +115,8 @@ end
 describe 'Braintree::Customer.find' do
   it 'successfully finds a customer' do
     result = Braintree::Customer.create(
-      :first_name => 'Bob',
-      :last_name => 'Smith'
+      first_name: 'Bob',
+      last_name: 'Smith'
     )
 
     Braintree::Customer.find(result.customer.id).first_name.should == 'Bob'
@@ -130,14 +130,14 @@ end
 describe 'Braintree::Customer.update' do
   it 'successfully updates a customer' do
     customer_id = create_customer.customer.id
-    result = Braintree::Customer.update(customer_id, :first_name => 'Jerry')
+    result = Braintree::Customer.update(customer_id, first_name: 'Jerry')
 
     result.should be_success
     Braintree::Customer.find(customer_id).first_name.should == 'Jerry'
   end
 
   it 'raises an error for a nonexistent customer' do
-    lambda { Braintree::Customer.update('foo', {:first_name => 'Bob'}) }.should raise_error(Braintree::NotFoundError)
+    expect { Braintree::Customer.update('foo', {first_name: 'Bob'}) }.to raise_error(Braintree::NotFoundError)
   end
 
   it 'does not allow a customer to be updated to a failing credit card' do
@@ -146,11 +146,7 @@ describe 'Braintree::Customer.update' do
 
     customer = create_customer
     result =  Braintree::Customer.update(customer.customer.id,
-      {
-        :credit_card => {
-          :number => bad_credit_card
-        }
-      }
+      credit_card: { number: bad_credit_card }
     )
     result.should_not be_success
   end

data/spec/fake_braintree/subscription_spec.rb

@@ -6,8 +6,8 @@ describe 'Braintree::Subscription.create' do
 
   it 'successfully creates a subscription' do
     Braintree::Subscription.create(
-      :payment_method_token => cc_token,
-      :plan_id => 'my_plan_id'
+      payment_method_token: cc_token,
+      plan_id: 'my_plan_id'
     ).should be_success
   end
 
@@ -15,16 +15,20 @@ describe 'Braintree::Subscription.create' do
     create_subscription.subscription.id.should =~ /^[a-z0-9]{6}$/
   end
 
+  it 'supports custom IDs' do
+    create_subscription('id' => 'custom1').subscription.id.should == 'custom1'
+  end
+
   it 'assigns unique IDs to each subscription' do
     cc_token_1 = cc_token
     cc_token_2 = braintree_credit_card_token(TEST_CC_NUMBER.sub('1', '5'), expiration_date)
     first_result = Braintree::Subscription.create(
-      :payment_method_token => cc_token_1,
-      :plan_id => plan_id
+      payment_method_token: cc_token_1,
+      plan_id: plan_id
     )
     second_result = Braintree::Subscription.create(
-      :payment_method_token => cc_token_2,
-      :plan_id => plan_id
+      payment_method_token: cc_token_2,
+      plan_id: plan_id
     )
 
     first_result.subscription.id.should_not == second_result.subscription.id
@@ -45,8 +49,10 @@ describe 'Braintree::Subscription.find' do
   it 'can find a created subscription' do
     payment_method_token = cc_token
     plan_id = 'abc123'
-    subscription_id =
-      create_subscription(:payment_method_token => payment_method_token, :plan_id => plan_id).subscription.id
+    subscription_id = create_subscription(
+      payment_method_token: payment_method_token,
+      plan_id: plan_id
+    ).subscription.id
     subscription = Braintree::Subscription.find(subscription_id)
     subscription.should_not be_nil
     subscription.payment_method_token.should == payment_method_token
@@ -60,7 +66,7 @@ describe 'Braintree::Subscription.find' do
 
   it 'returns add-ons added with the subscription' do
     add_on_id = 'def456'
-    subscription_id = create_subscription(:add_ons => { :add => [{ :inherited_from_id => add_on_id }] }).subscription.id
+    subscription_id = create_subscription(add_ons: { add: [{ inherited_from_id: add_on_id }] }).subscription.id
     subscription = Braintree::Subscription.find(subscription_id)
     add_ons = subscription.add_ons
     add_ons.size.should == 1
@@ -69,7 +75,7 @@ describe 'Braintree::Subscription.find' do
 
   it 'returns discounts added with the subscription' do
     discount_id = 'def456'
-    subscription_id = create_subscription(:discounts => { :add => [{ :inherited_from_id => discount_id, :amount => BigDecimal.new('15.00') }]}).subscription.id
+    subscription_id = create_subscription(discounts: { add: [{ inherited_from_id: discount_id, amount: BigDecimal.new('15.00') }]}).subscription.id
     subscription = Braintree::Subscription.find(subscription_id)
     discounts = subscription.discounts
     discounts.size.should == 1
@@ -79,16 +85,30 @@ end
 
 describe 'Braintree::Subscription.update' do
   it 'can update a subscription' do
-    Braintree::Subscription.update(subscription_id, :plan_id => 'a_new_plan')
+    subscription_id = create_subscription.subscription.id
+
+    Braintree::Subscription.update(subscription_id, plan_id: 'a_new_plan')
     Braintree::Subscription.find(subscription_id).plan_id.should == 'a_new_plan'
   end
+end
+
+describe 'Braintree::Subscription.retry_charge' do
+  it 'can submit for settlement' do
+    subscription_id = create_subscription.subscription.id
 
-  let(:subscription_id) { subscription.subscription.id }
-  let(:subscription)    { create_subscription }
+    authorized_transaction = Braintree::Subscription.retry_charge(subscription_id, 42.0).transaction
+    result = Braintree::Transaction.submit_for_settlement(
+      authorized_transaction.id
+    )
+    result.should be_success
+  end
 end
 
+
 describe 'Braintree::Subscription.cancel' do
   it 'can cancel a subscription' do
+    subscription_id = create_subscription.subscription.id
+
     Braintree::Subscription.cancel(subscription_id).should be_success
     Braintree::Subscription.find(subscription_id).status.should == Braintree::Subscription::Status::Canceled
   end
@@ -96,7 +116,4 @@ describe 'Braintree::Subscription.cancel' do
   it 'cannot cancel an unknown subscription' do
     expect { Braintree::Subscription.cancel('totally-bogus-id') }.to raise_error(Braintree::NotFoundError)
   end
-
-  let(:subscription_id) { subscription.subscription.id }
-  let(:subscription)    { create_subscription }
 end

data/spec/fake_braintree/transaction_spec.rb

@@ -4,8 +4,8 @@ describe FakeBraintree::SinatraApp do
   context 'Braintree::Transaction.sale' do
     it 'successfully creates a transaction' do
       result = Braintree::Transaction.sale(
-        :payment_method_token => cc_token,
-        :amount => 10.00
+        payment_method_token: cc_token,
+        amount: 10.00
       )
       result.should be_success
       result.transaction.type.should == 'sale'
@@ -16,8 +16,8 @@ describe FakeBraintree::SinatraApp do
 
       it 'fails' do
         result = Braintree::Transaction.sale(
-          :payment_method_token => cc_token,
-          :amount => 10.00
+          payment_method_token: cc_token,
+          amount: 10.00
         )
         result.should_not be_success
       end
@@ -25,7 +25,7 @@ describe FakeBraintree::SinatraApp do
 
     context "when the options hash is nil" do
       it "returns a transaction with a status of authorized" do
-        result = Braintree::Transaction.sale(:payment_method_token => cc_token, :amount => 10.00)
+        result = Braintree::Transaction.sale(payment_method_token: cc_token, amount: 10.00)
         result.transaction.status.should == 'authorized'
       end
     end
@@ -33,10 +33,10 @@ describe FakeBraintree::SinatraApp do
     context "when submit_for_settlement is not true" do
       it "returns a transaction with a status of authorized" do
         result = Braintree::Transaction.sale(
-          :payment_method_token => cc_token,
-          :amount => 10.00,
-          :options => {
-            :submit_for_settlement => false
+          payment_method_token: cc_token,
+          amount: 10.00,
+          options: {
+            submit_for_settlement: false
           }
         )
         result.transaction.status.should == 'authorized'
@@ -46,10 +46,10 @@ describe FakeBraintree::SinatraApp do
     context "when submit_for_settlement does not exist" do
       it "returns a transaction with a status of authorized" do
         result = Braintree::Transaction.sale(
-          :payment_method_token => cc_token,
-          :amount => 10.00,
-          :options => {
-            :add_billing_address_to_payment_method => true
+          payment_method_token: cc_token,
+          amount: 10.00,
+          options: {
+            add_billing_address_to_payment_method: true
           }
         )
         result.transaction.status.should == 'authorized'
@@ -59,10 +59,10 @@ describe FakeBraintree::SinatraApp do
     context "when submit_for_settlement is true" do
       it "returns a transaction with a status of submitted_for_settlement" do
         result = Braintree::Transaction.sale(
-          :payment_method_token => cc_token,
-          :amount => 10.00,
-          :options => {
-            :submit_for_settlement => true
+          payment_method_token: cc_token,
+          amount: 10.00,
+          options: {
+            submit_for_settlement: true
           }
         )
         result.transaction.status.should == 'submitted_for_settlement'
@@ -84,8 +84,8 @@ describe FakeBraintree::SinatraApp do
   context 'Braintree::Transaction.void' do
     it 'successfully voids a transaction' do
       sale = Braintree::Transaction.sale(
-        :payment_method_token => cc_token,
-        :amount => 10.00
+        payment_method_token: cc_token,
+        amount: 10.00
       )
       result = Braintree::Transaction.void(sale.transaction.id)
       result.should be_success
@@ -97,9 +97,9 @@ end
 describe FakeBraintree::SinatraApp do
   context 'Braintree::Transaction.find' do
     it 'can find a created sale' do
-      id = create_transaction.id
+      id = create_transaction(10.00).id
       result = Braintree::Transaction.find(id)
-      result.amount.should == amount
+      result.amount.should == 10.00
     end
 
     it 'can find >1 transaction' do
@@ -111,10 +111,11 @@ describe FakeBraintree::SinatraApp do
       expect { Braintree::Transaction.find('foobar') }.to raise_error(Braintree::NotFoundError)
     end
 
-    def create_transaction
-      Braintree::Transaction.sale(:payment_method_token => cc_token, :amount => amount).transaction
+    def create_transaction(amount = 10.00)
+      Braintree::Transaction.sale(
+        payment_method_token: cc_token,
+        amount: amount
+      ).transaction
     end
-
-    let(:amount) { 10.00 }
   end
 end

data/spec/fake_braintree/transparent_redirect_spec.rb

@@ -5,7 +5,7 @@ describe FakeBraintree::SinatraApp do
     it 'returns a URL that will redirect with a token for the specified request' do
       redirect_url = 'http://example.com/redirect_path'
 
-      response = post_transparent_redirect(:create_customer_data, :redirect_url => redirect_url, :customer => build_customer_hash)
+      response = post_transparent_redirect(:create_customer_data, redirect_url: redirect_url, customer: build_customer_hash)
 
       response.code.should == '303'
       response['Location'].should =~ %r{http://example\.com/redirect_path}
@@ -20,8 +20,8 @@ describe FakeBraintree::SinatraApp do
 
       response = post_transparent_redirect(
         :create_customer_data,
-        :redirect_url => redirect_url,
-        :customer => build_customer_hash
+        redirect_url: redirect_url,
+        customer: build_customer_hash
       )
 
       params = parse_redirect(response)
@@ -38,8 +38,8 @@ describe FakeBraintree::SinatraApp do
     describe 'Creating customers' do
       it 'confirms and runs the specified request' do
         number = '4111111111111111'
-        customer_hash = build_customer_hash(:credit_card => { :number => number })
-        response = post_transparent_redirect(:create_customer_data, :customer => customer_hash)
+        customer_hash = build_customer_hash(credit_card: { number: number })
+        response = post_transparent_redirect(:create_customer_data, customer: customer_hash)
         query = parse_query(response)
 
         result = Braintree::TransparentRedirect.confirm(query)
@@ -55,8 +55,8 @@ describe FakeBraintree::SinatraApp do
       it 'confirms and runs the specified request' do
         customer = create_customer.customer
         number = '4111111111111337'
-        credit_card_hash = build_credit_card_hash({ :number => number, :customer_id => customer.id})
-        response = post_transparent_redirect(:create_credit_card_data, :credit_card => credit_card_hash)
+        credit_card_hash = build_credit_card_hash({ number: number, customer_id: customer.id})
+        response = post_transparent_redirect(:create_credit_card_data, credit_card: credit_card_hash)
         query = parse_query(response)
 
         result = Braintree::TransparentRedirect.confirm(query)
@@ -71,25 +71,25 @@ describe FakeBraintree::SinatraApp do
 
   def build_customer_hash(options = {})
     {
-      :credit_card => {
-        :number => '4111111111111111',
-        :expiration_date => '4/2015',
-        :cardholder_name => 'Susie Spender'
+      credit_card: {
+        number: '4111111111111111',
+        expiration_date: '4/2015',
+        cardholder_name: 'Susie Spender'
       }.update(options[:credit_card] || {})
     }
   end
 
   def build_credit_card_hash(options = {})
     {
-        :number => '4111111111111111',
-        :expiration_date => '4/2015',
-        :cardholder_name => 'Susie Spender',
-        :cvv => '123',
-        :billing_address => {
-          :street_address => '123 Sesame Street',
-          :locality => 'San Francisco',
-          :region => 'CA',
-          :postal_code => '94110'
+        number: '4111111111111111',
+        expiration_date: '4/2015',
+        cardholder_name: 'Susie Spender',
+        cvv: '123',
+        billing_address: {
+          street_address: '123 Sesame Street',
+          locality: 'San Francisco',
+          region: 'CA',
+          postal_code: '94110'
         }
     }.update(options || {})
   end
@@ -97,7 +97,7 @@ describe FakeBraintree::SinatraApp do
   def post_transparent_redirect(type, data)
     params = data.dup
     redirect_url = params.delete(:redirect_url) || 'http://example.com/redirect_path'
-    params[:tr_data] = Braintree::TransparentRedirect.send(type, {:redirect_url => redirect_url}.merge(params))
+    params[:tr_data] = Braintree::TransparentRedirect.send(type, {redirect_url: redirect_url}.merge(params))
     post_transparent_redirect_params(params)
   end