braintree 2.74.0 → 4.12.0

data/spec/integration/braintree/plan_spec.rb

@@ -1,4 +1,5 @@
 require File.expand_path(File.dirname(__FILE__) + "/../spec_helper")
+require File.expand_path(File.dirname(__FILE__) + "/client_api/spec_helper")
 
 describe Braintree::Plan do
 
@@ -48,6 +49,87 @@ describe Braintree::Plan do
     end
   end
 
+  describe "self.create" do
+    let(:attributes) do
+      {
+        :billing_day_of_month => 12,
+        :billing_frequency => 1,
+        :currency_iso_code => "USD",
+        :description => "description on create",
+        :name => "my new plan name",
+        :number_of_billing_cycles => 1,
+        :price => "9.99",
+        :trial_period => false
+      }
+
+      it "is successful with given params" do
+        result = Braintree::Plan.create(attributes)
+        expect(result.success?).to be_truthy
+        expect(result.plan.billing_day_of_month).to eq 12
+        expect(result.plan.description).to eq "description on create"
+        expect(result.plan.name).to eq "my new plan name"
+        expect(result.plan.price).to eq "9.99"
+        expect(result.plan.billing_frequency).to eq 1
+      end
+    end
+  end
+
+  describe "self.find" do
+    it "finds a plan" do
+      plan = Braintree::Plan.create(
+        :billing_day_of_month => 12,
+        :billing_frequency => 1,
+        :currency_iso_code => "USD",
+        :description => "description on create",
+        :name => "my new plan name",
+        :number_of_billing_cycles => 1,
+        :price => "9.99",
+        :trial_period => false,
+      ).plan
+
+      found_plan = Braintree::Plan.find(plan.id)
+      expect(found_plan.name).to eq plan.name
+    end
+
+    it "raises Braintree::NotFoundError if it cannot find" do
+      expect {
+        Braintree::Plan.find("noSuchPlan")
+      }.to raise_error(Braintree::NotFoundError, 'plan with id "noSuchPlan" not found')
+    end
+  end
+
+  describe "self.update!" do
+    before(:each) do
+      @plan = Braintree::Plan.create(
+        :billing_day_of_month => 12,
+        :billing_frequency => 1,
+        :currency_iso_code => "USD",
+        :description => "description on create",
+        :name => "my new plan name",
+        :number_of_billing_cycles => 1,
+        :price => "9.99",
+        :trial_period => false,
+      ).plan
+    end
+
+    it "returns the updated plan if valid" do
+      new_id = rand(36**9).to_s(36)
+      plan = Braintree::Plan.update!(@plan.id,
+                                     :name => "updated name",
+                                     :price => 99.88,
+                                    )
+
+      expect(plan.name).to eq "updated name"
+      expect(plan.price).to eq BigDecimal("99.88")
+    end
+
+    it "raises a ValidationsFailed if invalid" do
+      expect do
+        Braintree::Plan.update!(@plan.id, :number_of_billing_cycles => "number of billing cycles")
+      end.to raise_error(Braintree::ValidationsFailed)
+    end
+  end
+
   def create_plan_for_tests(attributes)
     config = Braintree::Configuration.gateway.config
     config.http.post("#{config.base_merchant_path}/plans/create_plan_for_tests", :plan => attributes)

data/spec/integration/braintree/samsung_pay_card_spec.rb

@@ -0,0 +1,144 @@
+require File.expand_path(File.dirname(__FILE__) + "/../spec_helper")
+require File.expand_path(File.dirname(__FILE__) + "/client_api/spec_helper")
+
+describe Braintree::SamsungPayCard do
+  it "can create from payment method nonce" do
+    customer = Braintree::Customer.create!
+
+    result = Braintree::PaymentMethod.create(
+      :payment_method_nonce => Braintree::Test::Nonce::SamsungPayDiscover,
+      :customer_id => customer.id,
+      :cardholder_name => "Jenny Block",
+      :billing_address => {
+          :first_name => "New First Name",
+          :last_name => "New Last Name",
+          :company => "New Company",
+          :street_address => "123 New St",
+          :extended_address => "Apt New",
+          :locality => "New City",
+          :region => "New State",
+          :postal_code => "56789",
+          :country_name => "United States of America"
+      },
+    )
+    result.should be_success
+
+    samsung_pay_card = result.payment_method
+    samsung_pay_card.should be_a(Braintree::SamsungPayCard)
+    samsung_pay_card.billing_address.should_not be_nil
+    samsung_pay_card.bin.should_not be_nil
+    samsung_pay_card.cardholder_name.should_not be_nil
+    samsung_pay_card.card_type.should_not be_nil
+    samsung_pay_card.commercial.should_not be_nil
+    samsung_pay_card.country_of_issuance.should_not be_nil
+    samsung_pay_card.created_at.should_not be_nil
+    samsung_pay_card.customer_id.should_not be_nil
+    samsung_pay_card.customer_location.should_not be_nil
+    samsung_pay_card.debit.should_not be_nil
+    samsung_pay_card.default?.should_not be_nil
+    samsung_pay_card.durbin_regulated.should_not be_nil
+    samsung_pay_card.expiration_date.should_not be_nil
+    samsung_pay_card.expiration_month.should_not be_nil
+    samsung_pay_card.expiration_year.should_not be_nil
+    samsung_pay_card.expired?.should_not be_nil
+    samsung_pay_card.healthcare.should_not be_nil
+    samsung_pay_card.image_url.should_not be_nil
+    samsung_pay_card.issuing_bank.should_not be_nil
+    samsung_pay_card.last_4.should_not be_nil
+    samsung_pay_card.payroll.should_not be_nil
+    samsung_pay_card.prepaid.should_not be_nil
+    samsung_pay_card.product_id.should_not be_nil
+    samsung_pay_card.source_card_last_4.should_not be_nil
+    samsung_pay_card.subscriptions.should_not be_nil
+    samsung_pay_card.token.should_not be_nil
+    samsung_pay_card.unique_number_identifier.should_not be_nil
+    samsung_pay_card.updated_at.should_not be_nil
+
+    customer = Braintree::Customer.find(customer.id)
+    customer.samsung_pay_cards.size.should == 1
+    customer.samsung_pay_cards.first.should == samsung_pay_card
+  end
+
+  it "returns cardholder_name and billing_address" do
+    customer = Braintree::Customer.create!
+
+    result = Braintree::PaymentMethod.create(
+      :payment_method_nonce => Braintree::Test::Nonce::SamsungPayDiscover,
+      :customer_id => customer.id,
+      :cardholder_name => "Jenny Block",
+      :billing_address => {
+          :first_name => "New First Name",
+          :last_name => "New Last Name",
+          :company => "New Company",
+          :street_address => "123 New St",
+          :extended_address => "Apt New",
+          :locality => "New City",
+          :region => "New State",
+          :postal_code => "56789",
+          :country_name => "United States of America"
+      },
+    )
+
+    result.should be_success
+    result.payment_method.cardholder_name.should == "Jenny Block"
+
+    address = result.payment_method.billing_address
+    address.first_name.should == "New First Name"
+    address.last_name.should == "New Last Name"
+    address.company.should == "New Company"
+    address.street_address.should == "123 New St"
+    address.extended_address.should == "Apt New"
+    address.locality.should == "New City"
+    address.region.should == "New State"
+    address.postal_code.should == "56789"
+  end
+
+  it "can search for transactions" do
+    transaction_create_result = Braintree::Transaction.sale(
+      :payment_method_nonce => Braintree::Test::Nonce::SamsungPayDiscover,
+      :amount => "47.00",
+    )
+    transaction_create_result.should be_success
+    transaction_id = transaction_create_result.transaction.id
+
+    search_results = Braintree::Transaction.search do |search|
+      search.id.is transaction_id
+      search.payment_instrument_type.is Braintree::PaymentInstrumentType::SamsungPayCard
+    end
+    search_results.first.id.should == transaction_id
+  end
+
+  it "can create transaction from nonce and vault" do
+    customer = Braintree::Customer.create!
+
+    result = Braintree::Transaction.sale(
+      :payment_method_nonce => Braintree::Test::Nonce::SamsungPayDiscover,
+      :customer_id => customer.id,
+      :amount => "47.00",
+      :options => {:store_in_vault => true},
+    )
+    result.should be_success
+
+    samsung_pay_card_details = result.transaction.samsung_pay_card_details
+    samsung_pay_card_details.bin.should_not be_nil
+    samsung_pay_card_details.card_type.should_not be_nil
+    samsung_pay_card_details.commercial.should_not be_nil
+    samsung_pay_card_details.country_of_issuance.should_not be_nil
+    samsung_pay_card_details.customer_location.should_not be_nil
+    samsung_pay_card_details.debit.should_not be_nil
+    samsung_pay_card_details.durbin_regulated.should_not be_nil
+    samsung_pay_card_details.expiration_date.should_not be_nil
+    samsung_pay_card_details.expiration_month.should_not be_nil
+    samsung_pay_card_details.expiration_year.should_not be_nil
+    samsung_pay_card_details.healthcare.should_not be_nil
+    samsung_pay_card_details.image_url.should_not be_nil
+    samsung_pay_card_details.issuing_bank.should_not be_nil
+    samsung_pay_card_details.last_4.should_not be_nil
+    samsung_pay_card_details.payroll.should_not be_nil
+    samsung_pay_card_details.prepaid.should_not be_nil
+    samsung_pay_card_details.product_id.should_not be_nil
+    samsung_pay_card_details.source_card_last_4.should_not be_nil
+    samsung_pay_card_details.source_card_last_4.should == "3333"
+    samsung_pay_card_details.token.should_not be_nil
+  end
+end

data/spec/integration/braintree/sepa_direct_debit_account_spec.rb

@@ -0,0 +1,196 @@
+require File.expand_path(File.dirname(__FILE__) + "/../spec_helper")
+
+describe Braintree::SepaDirectDebitAccount do
+  before do
+    Braintree::Configuration.merchant_id = "integration_merchant_id"
+    Braintree::Configuration.public_key = "integration_public_key"
+    Braintree::Configuration.private_key = "integration_private_key"
+  end
+
+  let(:customer) { Braintree::Customer.create.customer }
+  let(:nonce) { Braintree::Test::Nonce::SepaDirectDebit }
+
+  let(:token) do
+    Braintree::PaymentMethod.create(
+      payment_method_nonce: nonce,
+      customer_id: customer.id,
+    ).payment_method.token
+  end
+
+  describe "self.find" do
+    subject do
+      described_class.find(token)
+    end
+
+    context "when payment method exists" do
+      it "returns a payment method" do
+        sepa_direct_debit_account = subject
+        sepa_direct_debit_account.should be_a(Braintree::SepaDirectDebitAccount)
+        sepa_direct_debit_account.last_4.should == "1234"
+        sepa_direct_debit_account.default.should == true
+        sepa_direct_debit_account.customer_id.should == customer.id
+        sepa_direct_debit_account.global_id.should_not be_empty
+        sepa_direct_debit_account.customer_global_id.should_not be_empty
+        sepa_direct_debit_account.bank_reference_token.should == "a-fake-bank-reference-token"
+        sepa_direct_debit_account.mandate_type.should == "RECURRENT"
+        sepa_direct_debit_account.merchant_or_partner_customer_id.should == "a-fake-mp-customer-id"
+        sepa_direct_debit_account.token.should_not be_empty
+        sepa_direct_debit_account.image_url.should_not be_empty
+        sepa_direct_debit_account.created_at.should be_a Time
+        sepa_direct_debit_account.updated_at.should be_a Time
+      end
+    end
+
+    context "when payment method does not exist" do
+      let(:token) { "ABC123" }
+
+      it "raises an error" do
+        expect {
+          subject
+        }.to raise_error(Braintree::NotFoundError)
+      end
+    end
+
+    context "subscriptions" do
+      it "returns subscriptions associated with a SEPA direct debit account" do
+        customer = Braintree::Customer.create!
+
+        subscription1 = Braintree::Subscription.create(
+          :payment_method_token => token,
+          :plan_id => SpecHelper::TriallessPlan[:id],
+        ).subscription
+
+        subscription2 = Braintree::Subscription.create(
+          :payment_method_token => token,
+          :plan_id => SpecHelper::TriallessPlan[:id],
+        ).subscription
+
+        sepa_debit_account = Braintree::SepaDirectDebitAccount.find(token)
+        subscription_ids = sepa_debit_account.subscriptions.map { |h| h[:id] }.sort
+        expect(subscription_ids).to eq([subscription1.id, subscription2.id].sort)
+      end
+    end
+  end
+
+  describe "self.delete" do
+    subject do
+      described_class.delete(token)
+    end
+
+    context "when payment method exists" do
+      it "deletes a payment method" do
+        should be_success
+
+        expect {
+          described_class.find(token)
+        }.to raise_error(Braintree::NotFoundError)
+      end
+    end
+
+    context "when payment method does not exist" do
+      let(:token) { "ABC123" }
+
+      it "raises an error" do
+        expect {
+          subject
+        }.to raise_error(Braintree::NotFoundError)
+      end
+    end
+  end
+
+  describe "self.sale" do
+    let(:params) do
+      {
+        amount: 1.23,
+      }
+    end
+
+    subject do
+      described_class.sale(token, params)
+    end
+
+    context "when payment method exists" do
+      it "creates a transaction" do
+        should be_success
+
+        transaction = subject.transaction
+        transaction.amount.should eq(1.23)
+        transaction.status.should == "settling"
+        sepa_direct_debit_account_details = transaction.sepa_direct_debit_account_details
+        sepa_direct_debit_account_details.should be_a(Braintree::Transaction::SepaDirectDebitAccountDetails)
+        sepa_direct_debit_account_details.bank_reference_token.should == "a-fake-bank-reference-token"
+        sepa_direct_debit_account_details.capture_id.should_not be_empty
+        sepa_direct_debit_account_details.debug_id.should be_nil
+        sepa_direct_debit_account_details.global_id.should_not be_empty
+        sepa_direct_debit_account_details.last_4.should == "1234"
+        sepa_direct_debit_account_details.mandate_type.should == "RECURRENT"
+        sepa_direct_debit_account_details.merchant_or_partner_customer_id.should == "a-fake-mp-customer-id"
+        sepa_direct_debit_account_details.paypal_v2_order_id.should be_nil
+        sepa_direct_debit_account_details.refund_from_transaction_fee_amount.should be_nil
+        sepa_direct_debit_account_details.refund_from_transaction_fee_currency_iso_code.should be_nil
+        sepa_direct_debit_account_details.refund_id.should be_nil
+        sepa_direct_debit_account_details.settlement_type.should be_nil
+        sepa_direct_debit_account_details.token.should == token
+        sepa_direct_debit_account_details.transaction_fee_amount.should == "0.01"
+        sepa_direct_debit_account_details.transaction_fee_currency_iso_code.should == "USD"
+      end
+    end
+
+    context "when payment method does not exist" do
+      let(:token) { "ABC123" }
+
+      it "not raises an error" do
+        expect {
+          subject
+        }.to_not raise_error
+      end
+    end
+  end
+
+  describe "self.sale!" do
+    let(:params) do
+      {
+        amount: 1.23,
+      }
+    end
+
+    subject do
+      described_class.sale!(token, params)
+    end
+
+    context "when payment method exists" do
+      it "creates a transaction" do
+        transaction = subject
+        transaction.amount.should eq(1.23)
+        transaction.status.should == "settling"
+        sepa_direct_debit_account_details = transaction.sepa_direct_debit_account_details
+        sepa_direct_debit_account_details.should be_a(Braintree::Transaction::SepaDirectDebitAccountDetails)
+        sepa_direct_debit_account_details.bank_reference_token.should == "a-fake-bank-reference-token"
+        sepa_direct_debit_account_details.capture_id.should_not be_empty
+        sepa_direct_debit_account_details.debug_id.should be_nil
+        sepa_direct_debit_account_details.global_id.should_not be_empty
+        sepa_direct_debit_account_details.last_4.should == "1234"
+        sepa_direct_debit_account_details.mandate_type.should == "RECURRENT"
+        sepa_direct_debit_account_details.merchant_or_partner_customer_id.should == "a-fake-mp-customer-id"
+        sepa_direct_debit_account_details.paypal_v2_order_id.should be_nil
+        sepa_direct_debit_account_details.refund_from_transaction_fee_amount.should be_nil
+        sepa_direct_debit_account_details.refund_from_transaction_fee_currency_iso_code.should be_nil
+        sepa_direct_debit_account_details.refund_id.should be_nil
+        sepa_direct_debit_account_details.settlement_type.should be_nil
+        sepa_direct_debit_account_details.token.should == token
+        sepa_direct_debit_account_details.transaction_fee_amount.should == "0.01"
+        sepa_direct_debit_account_details.transaction_fee_currency_iso_code.should == "USD"
+      end
+    end
+
+    context "when payment method does not exist" do
+      let(:token) { "ABC123" }
+
+      it "not raises an error" do
+        expect {
+          subject
+        }.to raise_error(Braintree::ValidationsFailed)
+      end
+    end
+  end
+end

data/spec/integration/braintree/settlement_batch_summary_spec.rb

@@ -12,7 +12,7 @@ describe Braintree::SettlementBatchSummary do
     it "returns an error response if the date cannot be parsed" do
       result = Braintree::SettlementBatchSummary.generate("NOT A DATE :(")
       result.should_not be_success
-      result.errors.for(:settlement_batch_summary).on(:settlement_date).map {|e| e.code}.should include(Braintree::ErrorCodes::SettlementBatchSummary::SettlementDateIsInvalid)
+      result.errors.for(:settlement_batch_summary).on(:settlement_date).map { |e| e.code }.should include(Braintree::ErrorCodes::SettlementBatchSummary::SettlementDateIsInvalid)
     end
 
     it "returns transactions settled on a given day" do
@@ -23,14 +23,14 @@ describe Braintree::SettlementBatchSummary do
           :expiration_date => "05/2012",
           :cardholder_name => "Sergio Ramos"
         },
-        :options => { :submit_for_settlement => true }
+        :options => {:submit_for_settlement => true},
       )
       result = SpecHelper.settle_transaction transaction.id
-      settlement_date = result[:transaction][:settlement_batch_id].split('_').first
+      settlement_date = result[:transaction][:settlement_batch_id].split("_").first
       result = Braintree::SettlementBatchSummary.generate(settlement_date)
 
       result.should be_success
-      amex_records = result.settlement_batch_summary.records.select {|row| row[:card_type] == Braintree::CreditCard::CardType::AmEx }
+      amex_records = result.settlement_batch_summary.records.select { |row| row[:card_type] == Braintree::CreditCard::CardType::AmEx }
       amex_records.first[:count].to_i.should >= 1
       amex_records.first[:amount_settled].to_i.should >= Braintree::Test::TransactionAmounts::Authorize.to_i
     end
@@ -46,14 +46,14 @@ describe Braintree::SettlementBatchSummary do
         :custom_fields => {
           :store_me => "1"
         },
-        :options => { :submit_for_settlement => true }
+        :options => {:submit_for_settlement => true},
       )
       result = SpecHelper.settle_transaction transaction.id
-      settlement_date = result[:transaction][:settlement_batch_id].split('_').first
-      result = Braintree::SettlementBatchSummary.generate(settlement_date, 'store_me')
+      settlement_date = result[:transaction][:settlement_batch_id].split("_").first
+      result = Braintree::SettlementBatchSummary.generate(settlement_date, "store_me")
 
       result.should be_success
-      amex_records = result.settlement_batch_summary.records.select {|row| row[:store_me] == "1" }
+      amex_records = result.settlement_batch_summary.records.select { |row| row[:store_me] == "1" }
       amex_records.should_not be_empty
       amex_records.first[:count].to_i.should >= 1
       amex_records.first[:amount_settled].to_i.should >= Braintree::Test::TransactionAmounts::Authorize.to_i