braintree 2.10.0 → 4.26.0

data/spec/integration/braintree/customer_search_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::Transaction, "search" do
   context "advanced" do
@@ -7,11 +8,11 @@ describe Braintree::Transaction, "search" do
         search.first_name.is "thisnameisnotreal"
       end
 
-      collection.maximum_size.should == 0
+      expect(collection.maximum_size).to eq(0)
     end
 
     it "can search on text fields" do
-      cctoken = "cctoken#{rand(1_000_000)}"
+      cctoken = "cctoken_#{rand(10**10)}"
       customer = Braintree::Customer.create!(
         :first_name => "Timmy",
         :last_name => "O'Toole",
@@ -35,7 +36,7 @@ describe Braintree::Transaction, "search" do
             :postal_code => "60622",
             :country_name => "United States of America"
           }
-        }
+        },
       )
 
       customer = Braintree::Customer.find(customer.id)
@@ -68,14 +69,14 @@ describe Braintree::Transaction, "search" do
           search.send(criterion).is value
         end
 
-        collection.maximum_size.should == 1
-        collection.first.id.should == customer.id
+        expect(collection.maximum_size).to eq(1)
+        expect(collection.first.id).to eq(customer.id)
 
         collection = Braintree::Customer.search do |search|
           search.id.is customer.id
           search.send(criterion).is("invalid_attribute")
         end
-        collection.should be_empty
+        expect(collection).to be_empty
       end
 
       collection = Braintree::Customer.search do |search|
@@ -85,63 +86,110 @@ describe Braintree::Transaction, "search" do
         end
       end
 
-      collection.maximum_size.should == 1
-      collection.first.id.should == customer.id
+      expect(collection.maximum_size).to eq(1)
+      expect(collection.first.id).to eq(customer.id)
+    end
+
+    it "can find duplicate credit cards for a give payment method token " do
+      jim = Braintree::Customer.create(
+        :first_name => "Jim",
+        :credit_card => {
+          :number => Braintree::Test::CreditCardNumbers::Maestro,
+          :expiration_date => "05/2012"
+        },
+      ).customer
+
+      joe = Braintree::Customer.create(
+        :first_name => "Joe",
+        :credit_card => {
+          :number => Braintree::Test::CreditCardNumbers::Maestro,
+          :expiration_date => "05/2012"
+        },
+      ).customer
+
+      collection = Braintree::Customer.search do |search|
+        search.payment_method_token_with_duplicates.is jim.credit_cards.first.token
+      end
+
+      expect(collection).to include(jim)
+      expect(collection).to include(joe)
     end
 
     it "can search by created_at" do
       company = "Company #{rand(1_000_000)}"
       customer = Braintree::Customer.create!(
-        :company => company
+        :company => company,
       )
 
       created_at = customer.created_at
-      created_at.should be_utc
+      expect(created_at).to be_utc
 
       collection = Braintree::Customer.search do |search|
         search.company.is company
         search.created_at.between(
           created_at - 60,
-          created_at + 60
+          created_at + 60,
         )
       end
 
-      collection.maximum_size.should == 1
-      collection.first.id.should == customer.id
+      expect(collection.maximum_size).to eq(1)
+      expect(collection.first.id).to eq(customer.id)
 
       collection = Braintree::Customer.search do |search|
         search.company.is customer.company
         search.created_at >= created_at - 1
       end
 
-      collection.maximum_size.should == 1
-      collection.first.company.should == customer.company
+      expect(collection.maximum_size).to eq(1)
+      expect(collection.first.company).to eq(customer.company)
 
       collection = Braintree::Customer.search do |search|
         search.company.is customer.company
         search.created_at <= created_at + 1
       end
 
-      collection.maximum_size.should == 1
-      collection.first.company.should == customer.company
+      expect(collection.maximum_size).to eq(1)
+      expect(collection.first.company).to eq(customer.company)
 
       collection = Braintree::Customer.search do |search|
         search.company.is customer.company
         search.created_at.between(
           created_at - 300,
-          created_at - 100
+          created_at - 100,
         )
       end
 
-      collection.maximum_size.should == 0
+      expect(collection.maximum_size).to eq(0)
 
       collection = Braintree::Customer.search do |search|
         search.company.is customer.company
         search.created_at.is created_at
       end
 
-      collection.maximum_size.should == 1
-      collection.first.company.should == customer.company
+      expect(collection.maximum_size).to eq(1)
+      expect(collection.first.company).to eq(customer.company)
+    end
+  end
+
+  it "can search by paypal_account_email" do
+    paypal_token = rand(36**3).to_s(36)
+    nonce = nonce_for_paypal_account(
+      :consent_code => "PAYPAL_CONSENT_CODE",
+      :token => paypal_token,
+    )
+
+    customer_id = "UNIQUE_CUSTOMER_ID_" + rand(36**3).to_s(36)
+    customer = Braintree::Customer.create!(
+      :payment_method_nonce => nonce,
+      :id => customer_id,
+    )
+
+    collection = Braintree::Customer.search do |search|
+      search.paypal_account_email.is "jane.doe@example.com"
+      search.id.is customer_id
     end
+
+    expect(collection.maximum_size).to eq(1)
+    expect(collection.first).to eq(customer)
   end
 end

data/spec/integration/braintree/customer_session_spec.rb

@@ -0,0 +1,143 @@
+require File.expand_path(File.dirname(__FILE__) + "/../../spec_helper")
+require File.expand_path(File.dirname(__FILE__) + "/client_api/spec_helper")
+
+describe Braintree::CustomerSessionGateway do
+  let(:gateway) do
+    Braintree::Gateway.new(
+      :environment => :development,
+      :merchant_id => "pwpp_multi_account_merchant",
+      :public_key => "pwpp_multi_account_merchant_public_key",
+      :private_key => "pwpp_multi_account_merchant_private_key",
+    )
+  end
+
+  describe "create" do
+    it "can create customer session without email and phone" do
+      input = Braintree::CreateCustomerSessionInput.new(merchant_account_id: "usd_pwpp_multi_account_merchant_account")
+      result = gateway.customer_session.create_customer_session(input)
+      expect(result.success?).to eq(true)
+      expect(result.session_id).not_to be_nil
+    end
+
+    it "can can create customer session with merchant provided session id" do
+      merchant_session_id = "11EF-A1E7-A5F5EE5C-A2E5-AFD2801469FC"
+      input = Braintree::CreateCustomerSessionInput.new(
+        session_id: merchant_session_id,
+      )
+      result = gateway.customer_session.create_customer_session(input)
+      expect(result.success?).to eq(true)
+      expect(result.session_id).to eq(merchant_session_id)
+    end
+
+    it "can create customer session with API-derived session id" do
+      input = Braintree::CreateCustomerSessionInput.new({})
+      result = gateway.customer_session.create_customer_session(input)
+      expect(result.success?).to eq(true)
+      expect(result.session_id).not_to be_nil
+    end
+
+    it "cannot create duplicate customer session" do
+      existing_session_id = "11EF-34BC-2702904B-9026-C3ECF4BAC765"
+      input = Braintree::CreateCustomerSessionInput.new(
+        session_id: existing_session_id,
+      )
+      result = gateway.customer_session.create_customer_session(input)
+      expect(result.success?).to eq(false)
+      expect(result.errors.first.message).to include("Session IDs must be unique per merchant.")
+    end
+  end
+
+  describe "update" do
+    it "can update a customer session" do
+      session_id = "11EF-A1E7-A5F5EE5C-A2E5-AFD2801469FC"
+      create_input = Braintree::CreateCustomerSessionInput.new(
+        merchant_account_id: "usd_pwpp_multi_account_merchant_account",
+        session_id: session_id,
+      )
+
+      gateway.customer_session.create_customer_session(create_input)
+
+      customer = build_customer_session_input("PR5_test@example.com", "4085005005")
+
+      update_input = Braintree::UpdateCustomerSessionInput.new(
+        session_id: session_id,
+        customer: customer,
+      )
+
+      result = gateway.customer_session.update_customer_session(update_input)
+
+      expect(result.success?).to eq(true)
+      expect(result.session_id).to eq(session_id)
+
+    end
+
+    it "cannot update a non-existent customer session" do
+      session_id = "11EF-34BC-2702904B-9026-C3ECF4BAC765"
+      customer = build_customer_session_input("PR9_test@example.com", "4085005009")
+      update_input = Braintree::UpdateCustomerSessionInput.new(
+        session_id: session_id,
+        customer: customer,
+      )
+
+      result = gateway.customer_session.update_customer_session(update_input)
+
+      expect(result.success?).to eq(false)
+      expect(result.errors.first.message).to include("does not exist")
+    end
+  end
+
+  describe "customer recommendations" do
+    it "can get customer recommendations" do
+      customer = build_customer_session_input("PR5_test@example.com", "4085005005")
+      recommendations = [Braintree::Recommendations::PAYMENT_RECOMMENDATIONS]
+      customer_recommendations_input = Braintree::CustomerRecommendationsInput.new(
+        session_id: "11EF-A1E7-A5F5EE5C-A2E5-AFD2801469FC",
+        recommendations: recommendations,
+        customer: customer,
+      )
+      result = gateway.customer_session.get_customer_recommendations(customer_recommendations_input)
+
+      expect(result.success?).to eq(true)
+      payload = result.customer_recommendations
+      expect(payload.is_in_paypal_network).to eq(true)
+      payment_options = payload.recommendations.payment_options
+      expect(payment_options[0].payment_option).to eq(Braintree::RecommendedPaymentOption::PAYPAL)
+      expect(payment_options[0].recommended_priority).to equal(1)
+    end
+
+    it "cannot get customer recommendations for non-existent session" do
+      customer = build_customer_session_input("PR9_test@example.com", "4085005009")
+      recommendations = [Braintree::Recommendations::PAYMENT_RECOMMENDATIONS]
+      customer_recommendations_input = Braintree::CustomerRecommendationsInput.new(
+        session_id: "11EF-34BC-2702904B-9026-C3ECF4BAC765",
+        recommendations: recommendations,
+        customer: customer,
+      )
+      result = gateway.customer_session.get_customer_recommendations(customer_recommendations_input)
+
+      expect(result.success?).to eq(false)
+      expect(result.errors.first.message).to include("does not exist")
+    end
+  end
+
+  private
+
+  def build_customer_session(session_id = nil)
+    customer = build_customer_session_input("PR1_test@example.com", "4085005002")
+
+    input = session_id ? CreateCustomerSessionInput.new(customer: customer, session_id: session_id) : CreateCustomerSessionInput.new(customer => customer)
+    @gateway.customer_session.create_customer_session(input)
+  end
+
+  def build_customer_session_input(email, phone_number)
+    {
+      email: email,
+      device_fingerprint_id: "test",
+      phone: {country_phone_code: "1", phone_number: phone_number},
+      paypal_app_installed: true,
+      venmo_app_installed: true,
+      user_agent: "Mozilla"
+    }
+  end
+
+end