fake_braintree 0.2.1 → 0.3

data/spec/fake_braintree/customer_spec.rb

@@ -1,127 +1,163 @@
 require 'spec_helper'
 
-describe "Braintree::Customer.create" do
+describe 'Braintree::Customer.create' do
   after { FakeBraintree.verify_all_cards = false }
 
-  it "successfully creates a customer" do
-    result = Braintree::Customer.create(:credit_card => { :number => TEST_CC_NUMBER,
-                                                          :expiration_date => '04/2016'})
+  it 'successfully creates a customer' do
+    result = Braintree::Customer.create(
+      :credit_card => {
+        :number => TEST_CC_NUMBER,
+        :expiration_date => '04/2016'
+      }
+    )
     result.should be_success
   end
 
-  it "associates a created credit card with the customer" do
-    result = Braintree::Customer.create(:credit_card => { :number => TEST_CC_NUMBER,
-                                                          :expiration_date => '04/2016'})
+  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_cards = Braintree::Customer.find(result.customer.id).credit_cards
     credit_cards.size.should == 1
-    credit_cards.first.expiration_date.should == "04/2016"
+    credit_cards.first.expiration_date.should == '04/2016'
   end
 
   it "successfully creates the customer's credit card" do
-    result = Braintree::Customer.create(:credit_card => { :number => TEST_CC_NUMBER,
-                                                          :expiration_date => '04/2016'})
+    result = Braintree::Customer.create(
+      :credit_card => {
+        :number => TEST_CC_NUMBER,
+        :expiration_date => '04/2016'
+      }
+    )
 
     cc_token = result.customer.credit_cards.first.token
     expect { Braintree::CreditCard.find(cc_token) }.not_to raise_error(Braintree::NotFoundError)
   end
 
-  it "can handle an empty credit card hash" 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_cards = Braintree::Customer.find(result.customer.id).credit_cards
+    credit_cards.first.should be_default
+  end
+
+  it 'can handle an empty credit card hash' do
     result = Braintree::Customer.create(:credit_card => {})
     result.should be_success
   end
 
-  it "does not overwrite a passed customer id" do
-    result = Braintree::Customer.create({ "id" => '123' })
+  it 'does not overwrite a passed customer id' do
+    result = Braintree::Customer.create({ 'id' => '123' })
 
     result.customer.id.should eq('123')
   end
 
-  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'})
+  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'
+      }
+    )
     result.should be_success
   end
 
-  it "records the billing address" 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"
+        :street_address => '1 E Main St',
+        :extended_address => 'Suite 3',
+        :locality => 'Chicago',
+        :region => 'Illinois',
+        :postal_code => '60622',
+        :country_code_alpha2 => 'US'
       }
     )
 
     billing_address = result.customer.credit_cards[0].billing_address
 
-    billing_address.street_address.should == "1 E Main St"
-    billing_address.postal_code.should == "60622"
+    billing_address.street_address.should == '1 E Main St'
+    billing_address.postal_code.should == '60622'
   end
 end
 
-describe "Braintree::Customer.create", "when passed :verify_card => true" do
-  it "accepts valid cards" 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
   end
 
-  it "rejects invalid cards" do
+  it 'rejects invalid cards' do
     create_customer_with_invalid_card(:options => { :verify_card => true }).should_not be_success
   end
 end
 
-describe "Braintree::Customer.create", "when FakeBraintree.verify_all_cards == true" do
+describe 'Braintree::Customer.create', 'when FakeBraintree.verify_all_cards == true' do
   before { FakeBraintree.verify_all_cards! }
 
-  it "accepts valid cards" do
+  it 'accepts valid cards' do
     create_customer.should be_success
   end
 
-  it "rejects invalid cards" do
+  it 'rejects invalid cards' do
     create_customer_with_invalid_card.should_not be_success
   end
 end
 
-describe "Braintree::Customer.find" do
-  it "successfully finds a customer" do
-    result = Braintree::Customer.create(:first_name => "Bob",
-                                        :last_name => "Smith")
+describe 'Braintree::Customer.find' do
+  it 'successfully finds a customer' do
+    result = Braintree::Customer.create(
+      :first_name => 'Bob',
+      :last_name => 'Smith'
+    )
 
-    Braintree::Customer.find(result.customer.id).first_name.should == "Bob"
+    Braintree::Customer.find(result.customer.id).first_name.should == 'Bob'
   end
 
-  it "raises an error for a nonexistent customer" do
-    lambda { Braintree::Customer.find("foo") }.should raise_error(Braintree::NotFoundError)
+  it 'raises an error for a nonexistent customer' do
+    lambda { Braintree::Customer.find('foo') }.should raise_error(Braintree::NotFoundError)
   end
 end
 
-describe "Braintree::Customer.update" do
-  it "successfully updates a customer" do
+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"
+    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)
+  it 'raises an error for a nonexistent customer' do
+    lambda { Braintree::Customer.update('foo', {:first_name => 'Bob'}) }.should raise_error(Braintree::NotFoundError)
   end
 
-  it "does not allow a customer to be updated to a failing credit card" do
-    bad_credit_card = "123456"
+  it 'does not allow a customer to be updated to a failing credit card' do
+    bad_credit_card = '123456'
     FakeBraintree.registry.failures[bad_credit_card] = FakeBraintree.failure_response
 
     customer = create_customer
-    result =  Braintree::Customer.update(customer.customer.id, {:credit_card => { :number => bad_credit_card }})
+    result =  Braintree::Customer.update(customer.customer.id,
+      {
+        :credit_card => {
+          :number => bad_credit_card
+        }
+      }
+    )
     result.should_not be_success
   end
 end
 
-describe "Braintree::Customer.delete" do
-  it "successfully deletes a customer" do
+describe 'Braintree::Customer.delete' do
+  it 'successfully deletes a customer' do
     customer_id = create_customer.customer.id
     result = Braintree::Customer.delete(customer_id)
 

data/spec/fake_braintree/registry_spec.rb

@@ -9,7 +9,7 @@ describe FakeBraintree::Registry do
   it { should have_hash_accessor_for(:credit_cards) }
 end
 
-describe FakeBraintree::Registry, "#clear!" do
+describe FakeBraintree::Registry, '#clear!' do
   it { should clear_hash_when_cleared(:customers) }
   it { should clear_hash_when_cleared(:subscriptions) }
   it { should clear_hash_when_cleared(:failures) }
@@ -18,15 +18,14 @@ describe FakeBraintree::Registry, "#clear!" do
   it { should clear_hash_when_cleared(:credit_cards) }
 end
 
-describe FakeBraintree::Registry, "#failure?" do
-  it "returns false if the given CC number is not marked as a failure" do
-    registry.failure?('not-a-failure').should be_false
+describe FakeBraintree::Registry, '#failure?' do
+  it 'returns false if the given CC number is not marked as a failure' do
+    FakeBraintree::Registry.new.failure?('not-a-failure').should be_false
   end
 
-  it "returns true if the given CC number is marked as a failure" do
+  it 'returns true if the given CC number is marked as a failure' do
+    registry = FakeBraintree::Registry.new
     registry.failures['abc123'] = 'whatever'
     registry.failure?('abc123').should be_true
   end
-
-  let(:registry) { subject }
 end

data/spec/fake_braintree/subscription_spec.rb

@@ -1,44 +1,50 @@
 require 'spec_helper'
 
-describe "Braintree::Subscription.create" do
+describe 'Braintree::Subscription.create' do
   let(:plan_id)                { 'plan-id-from-braintree-control-panel' }
-  let(:expiration_date)        { "04/2016" }
+  let(:expiration_date)        { '04/2016' }
 
-  it "successfully creates a subscription" do
-    Braintree::Subscription.create(:payment_method_token => cc_token,
-                                   :plan_id => 'my_plan_id').should be_success
+  it 'successfully creates a subscription' do
+    Braintree::Subscription.create(
+      :payment_method_token => cc_token,
+      :plan_id => 'my_plan_id'
+    ).should be_success
   end
 
-  it "assigns a Braintree-esque ID to the subscription" do
+  it 'assigns a Braintree-esque ID to the subscription' do
     create_subscription.subscription.id.should =~ /^[a-z0-9]{6}$/
   end
 
-  it "assigns unique IDs to each subscription" do
+  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)
-    second_result = Braintree::Subscription.create(:payment_method_token => cc_token_2,
-                                                   :plan_id => plan_id)
+    first_result = Braintree::Subscription.create(
+      :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
+    )
 
     first_result.subscription.id.should_not == second_result.subscription.id
   end
 
-  it "stores created subscriptions in FakeBraintree.registry.subscriptions" do
+  it 'stores created subscriptions in FakeBraintree.registry.subscriptions' do
     FakeBraintree.registry.subscriptions[create_subscription.subscription.id].should_not be_nil
   end
 
-  it "sets the next billing date to a string of 1.month.from_now in UTC" do
+  it 'sets the next billing date to a string of 1.month.from_now in UTC' do
     Timecop.freeze do
       create_subscription.subscription.next_billing_date.should == 1.month.from_now.strftime('%Y-%m-%d')
     end
   end
 end
 
-describe "Braintree::Subscription.find" do
-  it "can find a created subscription" do
+describe 'Braintree::Subscription.find' do
+  it 'can find a created subscription' do
     payment_method_token = cc_token
-    plan_id = "abc123"
+    plan_id = 'abc123'
     subscription_id =
       create_subscription(:payment_method_token => payment_method_token, :plan_id => plan_id).subscription.id
     subscription = Braintree::Subscription.find(subscription_id)
@@ -47,13 +53,13 @@ describe "Braintree::Subscription.find" do
     subscription.plan_id.should == plan_id
   end
 
-  it "raises a Braintree:NotFoundError when it cannot find a subscription" do
+  it 'raises a Braintree:NotFoundError when it cannot find a subscription' do
     create_subscription
     expect { Braintree::Subscription.find('abc123') }.to raise_error(Braintree::NotFoundError, /abc123/)
   end
 
-  it "returns add-ons added with the subscription" do
-    add_on_id = "def456"
+  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 = Braintree::Subscription.find(subscription_id)
     add_ons = subscription.add_ons
@@ -61,9 +67,9 @@ describe "Braintree::Subscription.find" do
     add_ons.first.id.should == add_on_id
   end
 
-  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
+  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 = Braintree::Subscription.find(subscription_id)
     discounts = subscription.discounts
     discounts.size.should == 1
@@ -71,8 +77,8 @@ describe "Braintree::Subscription.find" do
   end
 end
 
-describe "Braintree::Subscription.update" do
-  it "can update a subscription" do
+describe 'Braintree::Subscription.update' do
+  it 'can update a subscription' do
     Braintree::Subscription.update(subscription_id, :plan_id => 'a_new_plan')
     Braintree::Subscription.find(subscription_id).plan_id.should == 'a_new_plan'
   end
@@ -81,14 +87,14 @@ describe "Braintree::Subscription.update" do
   let(:subscription)    { create_subscription }
 end
 
-describe "Braintree::Subscription.cancel" do
-  it "can cancel a subscription" do
+describe 'Braintree::Subscription.cancel' do
+  it 'can cancel a subscription' do
     Braintree::Subscription.cancel(subscription_id).should be_success
     Braintree::Subscription.find(subscription_id).status.should == Braintree::Subscription::Status::Canceled
   end
 
-  it "can't cancel an unknown subscription" do
-    expect { Braintree::Subscription.cancel("totally-bogus-id") }.to raise_error(Braintree::NotFoundError)
+  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 }

data/spec/fake_braintree/transaction_spec.rb

@@ -1,55 +1,112 @@
 require 'spec_helper'
 
 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)
+  context 'Braintree::Transaction.sale' do
+    it 'successfully creates a transaction' do
+      result = Braintree::Transaction.sale(
+        :payment_method_token => cc_token,
+        :amount => 10.00
+      )
       result.should be_success
     end
 
-    context "when all cards are declined" do
+    context 'when all cards are declined' do
       before { FakeBraintree.decline_all_cards! }
 
-      it "fails" do
-        result = Braintree::Transaction.sale(:payment_method_token => cc_token, :amount => 10.00)
+      it 'fails' do
+        result = Braintree::Transaction.sale(
+          :payment_method_token => cc_token,
+          :amount => 10.00
+        )
         result.should_not be_success
       end
     end
+
+    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.transaction.status.should == 'authorized'
+      end
+    end
+
+    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
+          }
+        )
+        result.transaction.status.should == 'authorized'
+      end
+    end
+
+    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
+          }
+        )
+        result.transaction.status.should == 'authorized'
+      end
+    end
+
+    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
+          }
+        )
+        result.transaction.status.should == 'submitted_for_settlement'
+      end
+    end
   end
 end
 
 describe FakeBraintree::SinatraApp do
-  context "Braintree::Transaction.refund" do
-    it "successfully refunds a transaction" do
+  context 'Braintree::Transaction.refund' do
+    it 'successfully refunds a transaction' do
       result = Braintree::Transaction.refund(create_id('foobar'), '1')
       result.should be_success
     end
+  end
+end
 
-    context "when all cards are declined" do
-      before { FakeBraintree.decline_all_cards! }
-
-      it "fails" do
-        result = Braintree::Transaction.refund(create_id('foobar'), '1')
-        result.should_not be_success
-      end
+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
+      )
+      result = Braintree::Transaction.void(sale.transaction.id)
+      result.should be_success
+      result.transaction.status.should == Braintree::Transaction::Status::Voided
     end
   end
 end
 
 describe FakeBraintree::SinatraApp do
-  context "Braintree::Transaction.find" do
-    it "can find a created sale" do
+  context 'Braintree::Transaction.find' do
+    it 'can find a created sale' do
       id = create_transaction.id
       result = Braintree::Transaction.find(id)
       result.amount.should == amount
     end
 
-    it "can find >1 transaction" do
+    it 'can find >1 transaction' do
       Braintree::Transaction.find(create_transaction.id).should be
       Braintree::Transaction.find(create_transaction.id).should be
     end
 
-    it "raises an error when the transaction does not exist" do
+    it 'raises an error when the transaction does not exist' do
       expect { Braintree::Transaction.find('foobar') }.to raise_error(Braintree::NotFoundError)
     end