fake_braintree 0.4.3 → 0.5.0

data/spec/fake_braintree/customer_spec.rb

@@ -10,7 +10,7 @@ describe 'Braintree::Customer.create' do
         expiration_date: '04/2016'
       }
     )
-    result.should be_success
+    expect(result).to be_success
   end
 
   it 'associates a created credit card with the customer' do
@@ -21,8 +21,8 @@ describe 'Braintree::Customer.create' do
       }
     )
     credit_cards = Braintree::Customer.find(result.customer.id).credit_cards
-    credit_cards.size.should == 1
-    credit_cards.first.expiration_date.should == '04/2016'
+    expect(credit_cards.size).to eq 1
+    expect(credit_cards.first.expiration_date).to eq '04/2016'
   end
 
   it "successfully creates the customer's credit card" do
@@ -34,7 +34,7 @@ describe 'Braintree::Customer.create' do
     )
 
     cc_token = result.customer.credit_cards.first.token
-    expect { Braintree::CreditCard.find(cc_token) }.not_to raise_error(Braintree::NotFoundError)
+    expect { Braintree::CreditCard.find(cc_token) }.not_to raise_error
   end
 
   it "sets a default credit card for the customer" do
@@ -46,18 +46,18 @@ describe 'Braintree::Customer.create' do
     )
 
     credit_cards = Braintree::Customer.find(result.customer.id).credit_cards
-    credit_cards.first.should be_default
+    expect(credit_cards.first).to be_default
   end
 
   it 'can handle an empty credit card hash' do
     result = Braintree::Customer.create(credit_card: {})
-    result.should be_success
+    expect(result).to be_success
   end
 
   it 'does not overwrite a passed customer id' do
     result = Braintree::Customer.create({ 'id' => '123' })
 
-    result.customer.id.should eq('123')
+    expect(result.customer.id).to eq('123')
   end
 
   it 'creates a customer using an expiration month and year' do
@@ -68,7 +68,7 @@ describe 'Braintree::Customer.create' do
         expiration_year: '2016'
       }
     )
-    result.should be_success
+    expect(result).to be_success
   end
 
   it 'records the billing address' do
@@ -85,18 +85,18 @@ describe 'Braintree::Customer.create' do
 
     billing_address = result.customer.credit_cards[0].billing_address
 
-    billing_address.street_address.should == '1 E Main St'
-    billing_address.postal_code.should == '60622'
+    expect(billing_address.street_address).to eq '1 E Main St'
+    expect(billing_address.postal_code).to eq '60622'
   end
 end
 
 describe 'Braintree::Customer.create', 'when passed verify_card: true' do
   it 'accepts valid cards' do
-    create_customer(options: { verify_card: true }).should be_success
+    expect(create_customer(options: { verify_card: true })).to be_success
   end
 
   it 'rejects invalid cards' do
-    create_customer_with_invalid_card(options: { verify_card: true }).should_not be_success
+    expect(create_customer_with_invalid_card(options: { verify_card: true })).to_not be_success
   end
 end
 
@@ -104,11 +104,11 @@ describe 'Braintree::Customer.create', 'when FakeBraintree.verify_all_cards == t
   before { FakeBraintree.verify_all_cards! }
 
   it 'accepts valid cards' do
-    create_customer.should be_success
+    expect(create_customer).to be_success
   end
 
   it 'rejects invalid cards' do
-    create_customer_with_invalid_card.should_not be_success
+    expect(create_customer_with_invalid_card).to_not be_success
   end
 end
 
@@ -119,11 +119,11 @@ describe 'Braintree::Customer.find' do
       last_name: 'Smith'
     )
 
-    Braintree::Customer.find(result.customer.id).first_name.should == 'Bob'
+    expect(Braintree::Customer.find(result.customer.id).first_name).to eq 'Bob'
   end
 
   it 'raises an error for a nonexistent customer' do
-    lambda { Braintree::Customer.find('foo') }.should raise_error(Braintree::NotFoundError)
+    expect(lambda { Braintree::Customer.find('foo') }).to raise_error(Braintree::NotFoundError)
   end
 end
 
@@ -132,8 +132,8 @@ describe 'Braintree::Customer.update' do
     customer_id = create_customer.customer.id
     result = Braintree::Customer.update(customer_id, first_name: 'Jerry')
 
-    result.should be_success
-    Braintree::Customer.find(customer_id).first_name.should == 'Jerry'
+    expect(result).to be_success
+    expect(Braintree::Customer.find(customer_id).first_name).to eq 'Jerry'
   end
 
   it 'raises an error for a nonexistent customer' do
@@ -148,7 +148,7 @@ describe 'Braintree::Customer.update' do
     result =  Braintree::Customer.update(customer.customer.id,
       credit_card: { number: bad_credit_card }
     )
-    result.should_not be_success
+    expect(result).to_not be_success
   end
 end
 
@@ -157,7 +157,7 @@ describe 'Braintree::Customer.delete' do
     customer_id = create_customer.customer.id
     result = Braintree::Customer.delete(customer_id)
 
-    result.should be_success
+    expect(result).to be_success
     expect { Braintree::Customer.find(customer_id) }.to raise_error(Braintree::NotFoundError)
   end
 end

data/spec/fake_braintree/registry_spec.rb

@@ -20,12 +20,12 @@ end
 
 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
+    expect(FakeBraintree::Registry.new.failure?('not-a-failure')).to be_false
   end
 
   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
+    expect(registry.failure?('abc123')).to be_true
   end
 end

data/spec/fake_braintree/subscription_spec.rb

@@ -5,18 +5,20 @@ describe 'Braintree::Subscription.create' do
   let(:expiration_date)        { '04/2016' }
 
   it 'successfully creates a subscription' do
-    Braintree::Subscription.create(
+    subscription_result = Braintree::Subscription.create(
       payment_method_token: cc_token,
       plan_id: 'my_plan_id'
-    ).should be_success
+    )
+
+    expect(subscription_result).to be_success
   end
 
   it 'assigns a Braintree-esque ID to the subscription' do
-    create_subscription.subscription.id.should =~ /^[a-z0-9]{6}$/
+    expect(create_subscription.subscription.id).to match  /^[a-z0-9]{6}$/
   end
 
   it 'supports custom IDs' do
-    create_subscription('id' => 'custom1').subscription.id.should == 'custom1'
+    expect(create_subscription('id' => 'custom1').subscription.id).to eq 'custom1'
   end
 
   it 'assigns unique IDs to each subscription' do
@@ -31,16 +33,16 @@ describe 'Braintree::Subscription.create' do
       plan_id: plan_id
     )
 
-    first_result.subscription.id.should_not == second_result.subscription.id
+    expect(first_result.subscription.id).not_to eq second_result.subscription.id
   end
 
   it 'stores created subscriptions in FakeBraintree.registry.subscriptions' do
-    FakeBraintree.registry.subscriptions[create_subscription.subscription.id].should_not be_nil
+    expect(FakeBraintree.registry.subscriptions[create_subscription.subscription.id]).not_to be_nil
   end
 
   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')
+      expect(create_subscription.subscription.next_billing_date).to eq 1.month.from_now.strftime('%Y-%m-%d')
     end
   end
 end
@@ -54,9 +56,9 @@ describe 'Braintree::Subscription.find' do
       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
-    subscription.plan_id.should == plan_id
+    expect(subscription).to_not be_nil
+    expect(subscription.payment_method_token).to eq payment_method_token
+    expect(subscription.plan_id).to eq plan_id
   end
 
   it 'raises a Braintree:NotFoundError when it cannot find a subscription' do
@@ -69,8 +71,8 @@ describe 'Braintree::Subscription.find' do
     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
-    add_ons.first.id.should == add_on_id
+    expect(add_ons.size).to eq 1
+    expect(add_ons.first.id).to eq add_on_id
   end
 
   it 'returns discounts added with the subscription' do
@@ -78,8 +80,8 @@ describe 'Braintree::Subscription.find' do
     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
-    discounts.first.id.should == discount_id
+    expect(discounts.size).to eq 1
+    expect(discounts.first.id).to eq discount_id
   end
 end
 
@@ -88,7 +90,7 @@ describe 'Braintree::Subscription.update' do
     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'
+    expect(Braintree::Subscription.find(subscription_id).plan_id).to eq 'a_new_plan'
   end
 end
 
@@ -100,17 +102,16 @@ describe 'Braintree::Subscription.retry_charge' do
     result = Braintree::Transaction.submit_for_settlement(
       authorized_transaction.id
     )
-    result.should be_success
+    expect(result).to 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
+    expect(Braintree::Subscription.cancel(subscription_id)).to be_success
+    expect(Braintree::Subscription.find(subscription_id).status).to eq Braintree::Subscription::Status::Canceled
   end
 
   it 'cannot cancel an unknown subscription' do

data/spec/fake_braintree/transaction_spec.rb

@@ -7,8 +7,8 @@ describe FakeBraintree::SinatraApp do
         payment_method_token: cc_token,
         amount: 10.00
       )
-      result.should be_success
-      result.transaction.type.should == 'sale'
+      expect(result).to be_success
+      expect(result.transaction.type).to eq 'sale'
     end
 
     context 'when all cards are declined' do
@@ -19,14 +19,14 @@ describe FakeBraintree::SinatraApp do
           payment_method_token: cc_token,
           amount: 10.00
         )
-        result.should_not be_success
+        expect(result).to_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'
+        expect(result.transaction.status).to eq 'authorized'
       end
     end
 
@@ -39,7 +39,7 @@ describe FakeBraintree::SinatraApp do
             submit_for_settlement: false
           }
         )
-        result.transaction.status.should == 'authorized'
+        expect(result.transaction.status).to eq 'authorized'
       end
     end
 
@@ -52,7 +52,7 @@ describe FakeBraintree::SinatraApp do
             add_billing_address_to_payment_method: true
           }
         )
-        result.transaction.status.should == 'authorized'
+        expect(result.transaction.status).to eq 'authorized'
       end
     end
 
@@ -65,7 +65,7 @@ describe FakeBraintree::SinatraApp do
             submit_for_settlement: true
           }
         )
-        result.transaction.status.should == 'submitted_for_settlement'
+        expect(result.transaction.status).to eq 'submitted_for_settlement'
       end
     end
   end
@@ -75,7 +75,7 @@ describe FakeBraintree::SinatraApp do
   context 'Braintree::Transaction.refund' do
     it 'successfully refunds a transaction' do
       result = Braintree::Transaction.refund(create_id('foobar'), '1')
-      result.should be_success
+      expect(result).to be_success
     end
   end
 end
@@ -88,8 +88,8 @@ describe FakeBraintree::SinatraApp do
         amount: 10.00
       )
       result = Braintree::Transaction.void(sale.transaction.id)
-      result.should be_success
-      result.transaction.status.should == Braintree::Transaction::Status::Voided
+      expect(result).to be_success
+      expect(result.transaction.status).to eq Braintree::Transaction::Status::Voided
     end
   end
 end
@@ -99,12 +99,12 @@ describe FakeBraintree::SinatraApp do
     it 'can find a created sale' do
       id = create_transaction(10.00).id
       result = Braintree::Transaction.find(id)
-      result.amount.should == 10.00
+      expect(result.amount).to eq 10.00
     end
 
     it 'can find >1 transaction' do
-      Braintree::Transaction.find(create_transaction.id).should be
-      Braintree::Transaction.find(create_transaction.id).should be
+      expect(Braintree::Transaction.find(create_transaction.id)).to be
+      expect(Braintree::Transaction.find(create_transaction.id)).to be
     end
 
     it 'raises an error when the transaction does not exist' do
@@ -119,3 +119,20 @@ describe FakeBraintree::SinatraApp do
     end
   end
 end
+
+describe FakeBraintree::SinatraApp do
+  context "Braintree::Transaction.submit_for_settlement" do
+    it "should be able to mark transaction as completed" do
+      id = create_transaction.id
+
+      result = Braintree::Transaction.submit_for_settlement(id)
+
+      expect(result).to be_success
+      expect(Braintree::Transaction.find(id).status).to eq Braintree::Transaction::Status::SubmittedForSettlement
+    end
+
+    def create_transaction
+      Braintree::Transaction.sale(payment_method_token: cc_token, amount: 10.0).transaction
+    end
+  end
+end

data/spec/fake_braintree/transparent_redirect_spec.rb

@@ -7,12 +7,12 @@ describe FakeBraintree::SinatraApp do
 
       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}
+      expect(response.code).to eq '303'
+      expect(response['Location']).to match %r{http://example\.com/redirect_path}
       params = parse_redirect(response)
-      params[:http_status].should == '200'
-      params[:id].should_not be_nil
-      params[:kind].should_not be_nil
+      expect(params[:http_status]).to eq '200'
+      expect(params[:id]).to_not be_nil
+      expect(params[:kind]).to_not be_nil
     end
 
     it "preserves redirect_url query parameters" do
@@ -25,12 +25,12 @@ describe FakeBraintree::SinatraApp do
       )
 
       params = parse_redirect(response)
-      params[:preserve].should == 'me'
+      expect(params[:preserve]).to eq 'me'
     end
 
     it 'rejects submissions without transparent redirect data' do
       response = post_transparent_redirect_without_data
-      response.code.should == '422'
+      expect(response.code).to eq '422'
     end
   end
 
@@ -44,10 +44,10 @@ describe FakeBraintree::SinatraApp do
 
         result = Braintree::TransparentRedirect.confirm(query)
 
-        result.should be_success
+        expect(result).to be_success
 
         customer = Braintree::Customer.find(result.customer.id)
-        customer.credit_cards.first.last_4.should == '1111'
+        expect(customer.credit_cards.first.last_4).to eq '1111'
       end
     end
 
@@ -61,10 +61,10 @@ describe FakeBraintree::SinatraApp do
 
         result = Braintree::TransparentRedirect.confirm(query)
 
-        result.should be_success
+        expect(result).to be_success
 
         customer = Braintree::Customer.find(customer.id)
-        customer.credit_cards.first.last_4.should == '1111'
+        expect(customer.credit_cards.first.last_4).to eq '1111'
       end
     end
   end

data/spec/fake_braintree_spec.rb

@@ -4,12 +4,12 @@ describe FakeBraintree, '.decline_all_cards!' do
   before { FakeBraintree.decline_all_cards! }
 
   it 'declines all cards' do
-    create_sale.should_not be_success
+    expect(create_sale).not_to be_success
   end
 
   it 'stops declining cards after clear! is called' do
     FakeBraintree.clear!
-    create_sale.should be_success
+    expect(create_sale).to be_success
   end
 
   def create_sale
@@ -19,7 +19,7 @@ end
 
 describe FakeBraintree, '.log_file_path' do
   it 'is tmp/log' do
-    FakeBraintree.log_file_path.should == 'tmp/log'
+    expect(FakeBraintree.log_file_path).to eq 'tmp/log'
   end
 end
 
@@ -27,24 +27,19 @@ describe Braintree::Configuration do
   subject { Braintree::Configuration }
 
   it 'is running in the development environment' do
-    subject.environment.should == :development
+    expect(subject.environment).to eq :development
   end
 
   it 'has some fake API credentials' do
-    subject.merchant_id.should == 'xxx'
-    subject.public_key.should == 'xxx'
-    subject.private_key.should == 'xxx'
+    expect(subject.merchant_id).to eq 'xxx'
+    expect(subject.public_key).to eq 'xxx'
+    expect(subject.private_key).to eq 'xxx'
   end
 end
 
 describe FakeBraintree do
   it 'creates a log file' do
-    File.exist?(FakeBraintree.log_file_path).should == true
-  end
-
-  it 'logs to the correct path' do
-    Braintree::Configuration.logger.info('Some test')
-    File.readlines(FakeBraintree.log_file_path).last.should include "Some test"
+    expect(File.exist?(FakeBraintree.log_file_path)).to eq true
   end
 end
 
@@ -52,12 +47,15 @@ describe FakeBraintree, '.clear_log!' do
   it 'clears the log file' do
     write_to_log
     subject.clear_log!
-    File.read(FakeBraintree.log_file_path).should == ''
+    expect(File.read(FakeBraintree.log_file_path)).to eq ''
   end
 
   it 'is called by clear!' do
-    FakeBraintree.expects(:clear_log!)
+    FakeBraintree.stub(:clear_log!)
+
     FakeBraintree.clear!
+
+    expect(FakeBraintree).to have_received(:clear_log!)
   end
 
   def write_to_log
@@ -77,7 +75,7 @@ describe FakeBraintree, 'VALID_CREDIT_CARDS' do
       3530111333300000
     )
 
-    FakeBraintree::VALID_CREDIT_CARDS.sort.should == valid_credit_cards.sort
+    expect(FakeBraintree::VALID_CREDIT_CARDS.sort).to eq valid_credit_cards.sort
   end
 end
 
@@ -90,25 +88,25 @@ end
 describe FakeBraintree, '.generate_transaction' do
   it 'allows setting the subscription id' do
     transaction = FakeBraintree.generate_transaction(subscription_id: 'foobar')
-    transaction['subscription_id'].should == 'foobar'
+    expect(transaction['subscription_id']).to eq 'foobar'
   end
 
   it 'allows setting created_at' do
     time = Time.now
     transaction = FakeBraintree.generate_transaction(created_at: time)
-    transaction['created_at'].should == time
+    expect(transaction['created_at']).to eq time
   end
 
   it 'sets created_at to Time.now by default' do
     Timecop.freeze do
       transaction = FakeBraintree.generate_transaction
-      transaction['created_at'].should == Time.now
+      expect(transaction['created_at']).to eq Time.now
     end
   end
 
   it 'has the correct amount' do
     transaction = FakeBraintree.generate_transaction(amount: '20.00')
-    transaction['amount'].should == '20.00'
+    expect(transaction['amount']).to eq '20.00'
   end
 
   it 'allows no arguments' do
@@ -117,7 +115,7 @@ describe FakeBraintree, '.generate_transaction' do
 
   context 'status_history' do
     it 'returns a hash with a status_history key' do
-      FakeBraintree.generate_transaction(amount: '20').should have_key('status_history')
+      expect(FakeBraintree.generate_transaction(amount: '20')).to have_key('status_history')
     end
 
     it 'has a timestamp of Time.now' do
@@ -126,19 +124,19 @@ describe FakeBraintree, '.generate_transaction' do
           status: Braintree::Transaction::Status::Failed,
           subscription_id: 'my_subscription_id'
         )
-        transaction['status_history'].first['timestamp'].should == Time.now
+        expect(transaction['status_history'].first['timestamp']).to eq Time.now
       end
     end
 
     it 'has the desired amount' do
       transaction = FakeBraintree.generate_transaction(amount: '20.00')
-      transaction['status_history'].first['amount'].should == '20.00'
+      expect(transaction['status_history'].first['amount']).to eq '20.00'
     end
 
     it 'has the desired status' do
       status = Braintree::Transaction::Status::Failed
       transaction = FakeBraintree.generate_transaction(status: status)
-      transaction['status_history'].first['status'].should == status
+      expect(transaction['status_history'].first['status']).to eq status
     end
   end
 end