braintree 4.24.0 → 4.25.0

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

data/spec/unit/braintree/customer_session_gateway_spec.rb

@@ -0,0 +1,120 @@
+require File.expand_path(File.dirname(__FILE__) + "/../spec_helper")
+
+describe Braintree::CustomerSessionGateway do
+  let(:gateway) { double(:gateway) }
+  let(:graphql_client) { double(:graphql_client) }
+  let(:customer_session_gateway) { Braintree::CustomerSessionGateway.new(gateway, graphql_client) }
+
+  describe "#create_customer_session" do
+    let(:input) do
+      {
+       :merchant_account_id => "merchant-account-id",
+      }
+    end
+
+    let(:response) do
+        {
+          data: {
+            createCustomerSession: {
+                sessionId: "session-id"
+            }
+          }
+        }
+    end
+
+
+    it "executes the createCustomerSession mutation" do
+      create_input = Braintree::CreateCustomerSessionInput.new(input)
+      expect(graphql_client).to receive(:query).with(Braintree::CustomerSessionGateway::CREATE_CUSTOMER_SESSION,
+      {
+        "input" => create_input.to_graphql_variables
+      }).and_return(response)
+
+      expect(Braintree::GraphQLClient).to receive(:get_validation_errors).with(response).and_return(nil)
+      result = customer_session_gateway.create_customer_session(create_input)
+      expect(result).to be_a(Braintree::SuccessfulResult)
+      expect(result.session_id).to eq("session-id")
+    end
+
+    it "returns an error result if there are validation errors" do
+      create_input = Braintree::CreateCustomerSessionInput.new(input)
+      errors = {:errors =>
+        [ {:attribute => "", :code => "123", :message => "error"} ]
+      }
+      expect(graphql_client).to receive(:query).and_return(response)
+      expect(Braintree::GraphQLClient).to receive(:get_validation_errors).with(response).and_return(errors)
+      result = customer_session_gateway.create_customer_session(create_input)
+      expect(result).to be_a(Braintree::ErrorResult)
+      expect(result.errors.first.message).to eq("error")
+    end
+
+    it "raises an UnexpectedError if there is a problem parsing the response" do
+      create_input = Braintree::CreateCustomerSessionInput.new(input)
+      badResonse =  {:data => {}}
+      expect(graphql_client).to receive(:query).and_return(badResonse)
+      expect(Braintree::GraphQLClient).to receive(:get_validation_errors).with(badResonse).and_return(nil)
+      expect { customer_session_gateway.create_customer_session(create_input) }.to raise_error(Braintree::UnexpectedError)
+    end
+  end
+
+
+  describe "#update_customer_session" do
+      let(:input) do
+        {
+          :merchant_account_id => "merchant-account-id", :session_id => "session-id"
+        }
+      end
+      let(:response) do
+        {
+          data: {
+            updateCustomerSession: {
+                sessionId: "session-id"
+            }
+          }
+        }
+      end
+
+      it "executes the updateCustomerSession mutation" do
+        update_input = Braintree::UpdateCustomerSessionInput.new(input)
+        expect(graphql_client).to receive(:query).with(Braintree::CustomerSessionGateway::UPDATE_CUSTOMER_SESSION,
+        {
+          "input" => update_input.to_graphql_variables
+        }).and_return(response)
+        expect(Braintree::GraphQLClient).to receive(:get_validation_errors).with(response).and_return(nil)
+        result = customer_session_gateway.update_customer_session(update_input)
+        expect(result).to be_a(Braintree::SuccessfulResult)
+        expect(result.session_id).to eq("session-id")
+      end
+  end
+
+  describe "#get_customer_recommendations" do
+    let(:customer_recommendations_input) { double(:customer_recommendations_input, to_graphql_variables: {"sessionId" => "session_id", recommendations: ["PAYMENT_RECOMMENDATIONS"]}) }
+    let(:response) do
+      {
+        data: {
+          customerRecommendations: {
+              isInPayPalNetwork: true,
+              recommendations: {
+                paymentOptions: [
+                  {paymentOption: "PAYPAL", recommendedPriority: 1}
+                ]
+              }
+          }
+        }
+      }
+    end
+
+    it "fetches customer recommendations" do
+      expected_variables = {"input" => {"sessionId" => "session_id", recommendations: ["PAYMENT_RECOMMENDATIONS"]}}
+      expect(graphql_client).to receive(:query).with(Braintree::CustomerSessionGateway::GET_CUSTOMER_RECOMMENDATIONS, expected_variables).and_return(response)
+      expect(Braintree::GraphQLClient).to receive(:get_validation_errors).with(response).and_return(nil)
+
+      result = customer_session_gateway.get_customer_recommendations(customer_recommendations_input)
+      expect(result).to be_a(Braintree::SuccessfulResult)
+      expect(result.customer_recommendations.is_in_paypal_network).to eq(true)
+      expect(result.customer_recommendations.recommendations.payment_options[0].payment_option).to eq("PAYPAL")
+      expect(result.customer_recommendations.recommendations.payment_options[0].recommended_priority).to eq(1)
+    end
+  end
+
+end

data/spec/unit/braintree/graphql/create_customer_session_input_spec.rb

@@ -0,0 +1,81 @@
+require File.expand_path(File.dirname(__FILE__) + "/../../spec_helper")
+
+
+describe Braintree::CreateCustomerSessionInput do
+  let(:input_data) do
+  {
+    merchant_account_id: "merchant-account-id",
+    session_id: "session-id",
+    customer: {
+      email: "test@example.com" ,
+    },
+    domain: "example.com"
+  }
+  end
+
+  describe "#initialize" do
+    it "initializes with attributes" do
+      input = Braintree::CreateCustomerSessionInput.new(input_data)
+
+      expect(input.attrs).to eq(input_data.keys)
+      expect(input.merchant_account_id).to eq("merchant-account-id")
+      expect(input.session_id).to eq("session-id")
+      expect(input.customer).to be_a(Braintree::CustomerSessionInput)
+      expect(input.customer.email).to eq("test@example.com")
+      expect(input.domain).to eq("example.com")
+    end
+
+    it "handles nil customer" do
+      attributes = {merchant_account_id: "merchant-account-id"}
+      input = Braintree::CreateCustomerSessionInput.new(attributes)
+      expect(input.customer).to be_nil
+    end
+  end
+
+
+  describe "#inspect" do
+      it "returns a string representation of the object" do
+        input = Braintree::CreateCustomerSessionInput.new(input_data)
+        expected_string = "#<Braintree::CreateCustomerSessionInput merchant_account_id:\"merchant-account-id\" session_id:\"session-id\" customer:#<Braintree::CustomerSessionInput email:\"test@example.com\"> domain:\"example.com\">"
+        expect(input.inspect).to eq(expected_string)
+
+      end
+
+      it "handles nil values" do
+        attributes = {
+          merchant_account_id: "merchant-account-id",
+          session_id: nil,
+          customer: nil
+        }
+        input = Braintree::CreateCustomerSessionInput.new(attributes)
+        expected_string = "#<Braintree::CreateCustomerSessionInput merchant_account_id:\"merchant-account-id\" session_id:nil customer:nil>"
+
+        expect(input.inspect).to eq(expected_string)
+      end
+
+  end
+
+  describe "#to_graphql_variables" do
+    it "converts the input to graphql variables" do
+      input = Braintree::CreateCustomerSessionInput.new(input_data)
+      expected_variables = {
+        "merchantAccountId" => "merchant-account-id",
+        "sessionId" => "session-id",
+        "domain" => "example.com",
+        "customer" => {"email" => "test@example.com"}
+      }
+
+      expect(input.to_graphql_variables).to eq(expected_variables)
+
+
+    end
+
+    it "handles nil values" do
+        attributes = {merchant_account_id: "merchant-account-id"}
+        input = Braintree::CreateCustomerSessionInput.new(attributes)
+        expected_variables = {"merchantAccountId" => "merchant-account-id"}
+
+        expect(input.to_graphql_variables).to eq(expected_variables)
+    end
+  end
+end

data/spec/unit/braintree/graphql/customer_recommendations_input_spec.rb

@@ -0,0 +1,110 @@
+require File.expand_path(File.dirname(__FILE__) + "/../../spec_helper")
+
+
+describe Braintree::CustomerRecommendationsInput do
+  let(:input_data) do
+  {
+    merchant_account_id: "merchant-account-id",
+    session_id: "session-id",
+    recommendations: ["PAYMENT_RECOMMENDATIONS"],
+    customer: {email: "test@example.com"}
+  }
+  end
+  describe "#initialize" do
+    it "initializes with attributes" do
+      input = Braintree::CustomerRecommendationsInput.new(input_data)
+
+      expect(input.attrs).to eq(input_data.keys)
+      expect(input.merchant_account_id).to eq("merchant-account-id")
+      expect(input.session_id).to eq("session-id")
+      expect(input.customer).to be_a(Braintree::CustomerSessionInput)
+      expect(input.recommendations[0]).to eq("PAYMENT_RECOMMENDATIONS")
+    end
+
+    it "disallows nil session id" do
+      attributes = {
+        merchant_account_id: "merchant-account-id",
+        recommendations: ["PAYMENT_RECOMMENDATIONS"],
+      }
+      expect do
+        Braintree::CustomerRecommendationsInput.new(attributes)
+      end.to raise_error(ArgumentError, "Expected hash to contain a :session_id")
+    end
+
+    it "disallows nil recommendations" do
+      attributes = {
+        merchant_account_id: "merchant-account-id",
+        session_id: "session-id",
+      }
+      expect do
+        Braintree::CustomerRecommendationsInput.new(attributes)
+      end.to raise_error(ArgumentError, "Expected hash to contain a :recommendations")
+    end
+
+    it "handles nil customer" do
+      attributes = {
+        merchant_account_id: "merchant-account-id",
+        session_id: "session-id",
+        recommendations: ["PAYMENT_RECOMMENDATIONS"],
+      }
+      input = Braintree::CustomerRecommendationsInput.new(attributes)
+
+      expect(input.customer).to be_nil
+    end
+  end
+
+
+  describe "#inspect" do
+      it "returns a string representation of the object" do
+        input = Braintree::CustomerRecommendationsInput.new(input_data)
+        expected_string = "#<Braintree::CustomerRecommendationsInput merchant_account_id:\"merchant-account-id\" session_id:\"session-id\" recommendations:[\"PAYMENT_RECOMMENDATIONS\"] customer:#<Braintree::CustomerSessionInput email:\"test@example.com\">>"
+        expect(input.inspect).to eq(expected_string)
+
+      end
+
+      it "handles nil values" do
+        attributes = {
+          merchant_account_id: "merchant-account-id",
+          session_id: "session-id",
+          recommendations: ["PAYMENT_RECOMMENDATIONS"],
+        }
+        input = Braintree::CustomerRecommendationsInput.new(attributes)
+        expected_string = "#<Braintree::CustomerRecommendationsInput merchant_account_id:\"merchant-account-id\" session_id:\"session-id\" recommendations:[\"PAYMENT_RECOMMENDATIONS\"]>"
+
+        expect(input.inspect).to eq(expected_string)
+      end
+
+  end
+
+  describe "#to_graphql_variables" do
+    it "converts the input to graphql variables" do
+      input = Braintree::CustomerRecommendationsInput.new(input_data)
+      expected_variables = {
+        "merchantAccountId" => "merchant-account-id",
+        "sessionId" => "session-id",
+        "customer" => {"email" => "test@example.com"},
+        "recommendations" => ["PAYMENT_RECOMMENDATIONS"],
+      }
+
+      expect(input.to_graphql_variables).to eq(expected_variables)
+    end
+
+    it "handles nil values" do
+      attributes = {
+        merchant_account_id: "merchant-account-id",
+        session_id: "session-id",
+        recommendations: ["PAYMENT_RECOMMENDATIONS"],
+      }
+      input = Braintree::CustomerRecommendationsInput.new(attributes)
+
+      expected_variables = {
+        "merchantAccountId" => "merchant-account-id",
+        "sessionId" => "session-id",
+        "recommendations" => ["PAYMENT_RECOMMENDATIONS"],
+      }
+
+      expect(input.to_graphql_variables).to eq(expected_variables)
+    end
+  end
+
+end

data/spec/unit/braintree/graphql/customer_session_input_spec.rb

@@ -0,0 +1,81 @@
+require File.expand_path(File.dirname(__FILE__) + "/../../spec_helper")
+
+
+describe Braintree::CustomerSessionInput do
+  let(:input_data) do
+  {
+    email: "test@example.com" ,
+    phone: {
+      country_phone_code: "1",
+      phone_number: "555-123-4567",
+      extension_number: "123",
+    },
+    user_agent: "Mozilla"
+  }
+  end
+
+  describe "#initialize" do
+    it "initializes with attributes" do
+      input = Braintree::CustomerSessionInput.new(input_data)
+
+      expect(input.attrs).to eq(input_data.keys)
+      expect(input.email).to eq("test@example.com")
+      expect(input.phone.country_phone_code).to eq("1")
+      expect(input.phone.phone_number).to eq("555-123-4567")
+      expect(input.phone.extension_number).to eq("123")
+      expect(input.user_agent).to eq("Mozilla")
+    end
+
+    it "handles nil email" do
+      attributes = {}
+      input = Braintree::CustomerSessionInput.new(attributes)
+      expect(input.email).to be_nil
+    end
+  end
+
+
+  describe "#inspect" do
+      it "returns a string representation of the object" do
+        input = Braintree::CustomerSessionInput.new(input_data)
+        expected_string = "#<Braintree::CustomerSessionInput email:\"test@example.com\" phone:#<Braintree::PhoneInput country_phone_code:\"1\" phone_number:\"555-123-4567\" extension_number:\"123\"> user_agent:\"Mozilla\">"
+        expect(input.inspect).to eq(expected_string)
+
+      end
+
+      it "handles nil values" do
+        attributes = {}
+        input = Braintree::CustomerSessionInput.new(attributes)
+        expected_string = "#<Braintree::CustomerSessionInput >"
+
+        expect(input.inspect).to eq(expected_string)
+      end
+
+  end
+
+  describe "#to_graphql_variables" do
+    it "converts the input to graphql variables" do
+      input = Braintree::CustomerSessionInput.new(input_data)
+      expected_variables = {
+        "email" => "test@example.com",
+        "phone" => {
+          "countryPhoneCode" => "1",
+          "phoneNumber" => "555-123-4567",
+          "extensionNumber" => "123"
+        },
+        "userAgent" => "Mozilla"
+      }
+
+      expect(input.to_graphql_variables).to eq(expected_variables)
+
+
+    end
+
+    it "handles nil values" do
+        attributes = {}
+        input = Braintree::CustomerSessionInput.new(attributes)
+        expected_variables = {}
+
+        expect(input.to_graphql_variables).to eq(expected_variables)
+    end
+  end
+end

data/spec/unit/braintree/graphql/phone_input_spec.rb

@@ -0,0 +1,51 @@
+require File.expand_path(File.dirname(__FILE__) + "/../../spec_helper")
+
+
+describe Braintree::PhoneInput do
+    let(:phone_input_data) do
+    {
+        country_phone_code: "1",
+        phone_number: "555-123-4567",
+        extension_number: "123"
+    }
+    end
+
+    let(:partial_phone_input_data) do
+    {
+        country_phone_code: "1",
+        phone_number: "555-123-4567"
+    }
+    end
+
+
+    describe "#initialize" do
+      it "initialize and sets the input keys to attrs variable" do
+        phone_input = described_class.new(phone_input_data)
+
+        expect(phone_input.attrs).to include(:country_phone_code)
+        expect(phone_input.attrs).to include(:phone_number)
+        expect(phone_input.attrs).to include(:extension_number)
+        expect(phone_input.attrs.length).to eq(3)
+      end
+    end
+
+    describe "inspect" do
+      it "includes all phone input attributes" do
+        phone_input = described_class.new(phone_input_data)
+        output = phone_input.inspect
+
+        expect(output).to include("country_phone_code:\"1\"")
+        expect(output).to include("phone_number:\"555-123-4567\"")
+        expect(output).to include("extension_number:\"123\"")
+      end
+
+      it "includes only specified phone input attributes" do
+        phone_input = described_class.new(partial_phone_input_data)
+        output = phone_input.inspect
+
+        expect(output).to include("country_phone_code:\"1\"")
+        expect(output).to include("phone_number:\"555-123-4567\"")
+        expect(output).not_to include("extension_number")
+      end
+    end
+end

data/spec/unit/braintree/graphql/update_customer_session_input_spec.rb

@@ -0,0 +1,93 @@
+require File.expand_path(File.dirname(__FILE__) + "/../../spec_helper")
+
+
+describe Braintree::UpdateCustomerSessionInput do
+  let(:input_data) do
+  {
+    merchant_account_id: "merchant-account-id",
+    session_id: "session-id",
+    customer: {email: "test@example.com"}
+  }
+  end
+  describe "#initialize" do
+    it "initializes with attributes" do
+      input = Braintree::UpdateCustomerSessionInput.new(input_data)
+
+      expect(input.attrs).to eq(input_data.keys)
+      expect(input.merchant_account_id).to eq("merchant-account-id")
+      expect(input.session_id).to eq("session-id")
+      expect(input.customer).to be_a(Braintree::CustomerSessionInput)
+      expect(input.customer.email).to eq("test@example.com")
+    end
+
+    it "disallows nil session id" do
+      attributes = {
+        merchant_account_id: "merchant-account-id",
+      }
+      expect do
+        Braintree::UpdateCustomerSessionInput.new(attributes)
+      end.to raise_error(ArgumentError, "Expected hash to contain a :session_id")
+    end
+
+    it "handles nil customer" do
+      attributes = {
+        merchant_account_id: "merchant-account-id",
+        session_id: "session-id",
+      }
+      input = Braintree::UpdateCustomerSessionInput.new(attributes)
+
+      expect(input.customer).to be_nil
+    end
+  end
+
+
+  describe "#inspect" do
+      it "returns a string representation of the object" do
+        input = Braintree::UpdateCustomerSessionInput.new(input_data)
+        expected_string = "#<Braintree::UpdateCustomerSessionInput merchant_account_id:\"merchant-account-id\" session_id:\"session-id\" customer:#<Braintree::CustomerSessionInput email:\"test@example.com\">>"
+        expect(input.inspect).to eq(expected_string)
+
+      end
+
+      it "handles nil values" do
+        attributes = {
+          merchant_account_id: "merchant-account-id",
+          session_id: "session-id",
+        }
+        input = Braintree::UpdateCustomerSessionInput.new(attributes)
+        expected_string = "#<Braintree::UpdateCustomerSessionInput merchant_account_id:\"merchant-account-id\" session_id:\"session-id\">"
+
+        expect(input.inspect).to eq(expected_string)
+      end
+
+  end
+
+  describe "#to_graphql_variables" do
+    it "converts the input to graphql variables" do
+      input = Braintree::UpdateCustomerSessionInput.new(input_data)
+      expected_variables = {
+        "merchantAccountId" => "merchant-account-id",
+        "sessionId" => "session-id",
+        "customer" => {"email" => "test@example.com"},
+      }
+
+      expect(input.to_graphql_variables).to eq(expected_variables)
+    end
+
+    it "handles nil values" do
+      attributes = {
+        merchant_account_id: "merchant-account-id",
+        session_id: "session-id",
+      }
+      input = Braintree::UpdateCustomerSessionInput.new(attributes)
+
+      expected_variables = {
+        "merchantAccountId" => "merchant-account-id",
+        "sessionId" => "session-id",
+      }
+
+      expect(input.to_graphql_variables).to eq(expected_variables)
+    end
+  end
+
+end