braintree 2.10.0 → 4.26.0

data/spec/unit/braintree/errors_spec.rb

@@ -4,26 +4,26 @@ describe Braintree::Errors do
   describe "for" do
     it "accesses errors for the given scope" do
       errors = Braintree::Errors.new(
-        :level1 => {:errors => [{:code => "code1", :attribute => "attr", :message => "message"}]}
+        :level1 => {:errors => [{:code => "code1", :attribute => "attr", :message => "message"}]},
       )
-      errors.for(:level1).size.should == 1
-      errors.for(:level1)[0].code.should == "code1"
+      expect(errors.for(:level1).size).to eq(1)
+      expect(errors.for(:level1)[0].code).to eq("code1")
     end
 
     it "returns nil if there are no errors at the given scope" do
       errors = Braintree::Errors.new(
-        :level1 => {:errors => [{:code => "code1", :attribute => "attr", :message => "message"}]}
+        :level1 => {:errors => [{:code => "code1", :attribute => "attr", :message => "message"}]},
       )
-      errors.for(:no_errors_here).should == nil
+      expect(errors.for(:no_errors_here)).to eq(nil)
     end
   end
 
   describe "inspect" do
     it "is better than the default inspect" do
       errors = Braintree::Errors.new(
-        :level1 => {:errors => [{:code => "code1", :attribute => "attr", :message => "message"}]}
+        :level1 => {:errors => [{:code => "code1", :attribute => "attr", :message => "message"}]},
       )
-      errors.inspect.should == "#<Braintree::Errors level1:[(code1) message]>"
+      expect(errors.inspect).to eq("#<Braintree::Errors level1:[(code1) message]>")
     end
 
     it "shows errors 2 levels deep" do
@@ -33,9 +33,9 @@ describe Braintree::Errors do
           :level2 => {
             :errors => [{:code => "code2", :attribute => "attr2", :message => "message2"}],
           }
-        }
+        },
       )
-      errors.inspect.should == "#<Braintree::Errors level1:[(code1) message], level1/level2:[(code2) message2]>"
+      expect(errors.inspect).to eq("#<Braintree::Errors level1:[(code1) message], level1/level2:[(code2) message2]>")
     end
 
     it "shows errors 3 levels deep" do
@@ -48,9 +48,9 @@ describe Braintree::Errors do
               :errors => [{:code => "code3", :attribute => "attr3", :message => "message3"}],
             }
           }
-        }
+        },
       )
-      errors.inspect.should == "#<Braintree::Errors level1:[(code1) message], level1/level2:[(code2) message2], level1/level2/level3:[(code3) message3]>"
+      expect(errors.inspect).to eq("#<Braintree::Errors level1:[(code1) message], level1/level2:[(code2) message2], level1/level2/level3:[(code3) message3]>")
     end
   end
 
@@ -65,18 +65,18 @@ describe Braintree::Errors do
               {:code => "3", :attribute => "attr3", :message => "message3"}
             ],
           }
-        }
+        },
       )
-      errors.map { |e| e.code }.sort.should == %w[1 2 3]
+      expect(errors.map { |e| e.code }.sort).to eq(%w[1 2 3])
     end
   end
 
   describe "size" do
     it "returns the number of validation errors at the first level if only has one level" do
       errors = Braintree::Errors.new(
-        :level1 => {:errors => [{:code => "1", :attribute => "attr", :message => "message"}]}
+        :level1 => {:errors => [{:code => "1", :attribute => "attr", :message => "message"}]},
       )
-      errors.size.should == 1
+      expect(errors.size).to eq(1)
     end
 
     it "returns the total number of validation errors in the hierarchy" do
@@ -89,9 +89,9 @@ describe Braintree::Errors do
               {:code => "3", :attribute => "attr3", :message => "message3"}
             ],
           }
-        }
+        },
       )
-      errors.size.should == 3
+      expect(errors.size).to eq(3)
     end
   end
 end

data/spec/unit/braintree/exchange_rate_quote_input_spec.rb

@@ -0,0 +1,42 @@
+require File.expand_path(File.dirname(__FILE__) + "/../spec_helper")
+
+describe Braintree::ExchangeRateQuoteInput do
+  let(:exchange_rate_quote_input) do
+    {
+      base_currency: "USD",
+      quote_currency: "EUR",
+      base_amount: "10.00",
+      markup: "2.00"
+    }
+  end
+
+  describe "#initialize" do
+    it "initialize and sets the input keys to attrs variable" do
+      quote_input = described_class.new(exchange_rate_quote_input)
+
+      expect(quote_input.attrs).to include(:base_currency)
+      expect(quote_input.attrs).to include(:quote_currency)
+      expect(quote_input.attrs).to include(:base_amount)
+      expect(quote_input.attrs).to include(:markup)
+      expect(quote_input.attrs.length).to eq(4)
+    end
+  end
+
+  describe "inspect" do
+    it "includes the base_currency first" do
+      output = described_class.new(base_currency: "USD").inspect
+
+      expect(output).to include("#<Braintree::ExchangeRateQuoteInput base_currency:\"USD\">")
+    end
+
+    it "includes all quote input attributes" do
+      quote_input = described_class.new(exchange_rate_quote_input)
+      output = quote_input.inspect
+
+      expect(output).to include("base_currency:\"USD\"")
+      expect(output).to include("quote_currency:\"EUR\"")
+      expect(output).to include("base_amount:\"10.00\"")
+      expect(output).to include("markup:\"2.00\"")
+    end
+  end
+end

data/spec/unit/braintree/exchange_rate_quote_request_spec.rb

@@ -0,0 +1,82 @@
+require File.expand_path(File.dirname(__FILE__) + "/../spec_helper")
+
+describe Braintree::ExchangeRateQuoteRequest do
+  describe "#initialize" do
+    it "creates and validates the exchange rate quote request" do
+      req = Braintree::ExchangeRateQuoteRequest.new(
+          :quotes => [
+            {
+              :base_currency => "USD",
+              :quote_currency => "EUR",
+              :base_amount => "10.00",
+              :markup => "2.00"
+            },
+            {
+              :base_currency => "EUR",
+              :quote_currency => "GBP",
+              :base_amount => "20.00",
+              :markup => "4.00"
+            }
+          ],
+      )
+
+      expect(req.quotes[0].base_currency).to eq("USD")
+      expect(req.quotes[0].quote_currency).to eq("EUR")
+      expect(req.quotes[0].base_amount).to eq("10.00")
+      expect(req.quotes[0].markup).to eq("2.00")
+
+      expect(req.quotes[1].base_currency).to eq("EUR")
+      expect(req.quotes[1].quote_currency).to eq("GBP")
+      expect(req.quotes[1].base_amount).to eq("20.00")
+      expect(req.quotes[1].markup).to eq("4.00")
+    end
+
+    it "creates and validates the exchange rate quote request without amount and markup" do
+      req = Braintree::ExchangeRateQuoteRequest.new(
+          :quotes => [
+            {
+              :base_currency => "USD",
+              :quote_currency => "EUR",
+            },
+            {
+              :base_currency => "EUR",
+              :quote_currency => "GBP",
+            }
+          ],
+      )
+
+      expect(req.quotes[0].base_currency).to eq("USD")
+      expect(req.quotes[0].quote_currency).to eq("EUR")
+      expect(req.quotes[0].base_amount).to be_nil
+      expect(req.quotes[0].markup).to be_nil
+
+      expect(req.quotes[1].base_currency).to eq("EUR")
+      expect(req.quotes[1].quote_currency).to eq("GBP")
+      expect(req.quotes[1].base_amount).to be_nil
+      expect(req.quotes[1].markup).to be_nil
+    end
+
+  end
+
+  describe "inspect" do
+    it "prints the attributes" do
+      exchange_rate_req = Braintree::ExchangeRateQuoteRequest.new(
+          :quotes => [
+            {
+              :base_currency => "USD",
+              :quote_currency => "EUR",
+              :base_amount => "10.00",
+              :markup => "2.00"
+            },
+            {
+              :base_currency => "EUR",
+              :quote_currency => "GBP",
+              :base_amount => "20.00",
+              :markup => "4.00"
+            }
+          ],
+      )
+      expect(exchange_rate_req.inspect).to eq(%(#<Braintree::ExchangeRateQuoteRequest quotes:[#<Braintree::ExchangeRateQuoteInput base_currency:"USD" quote_currency:"EUR" base_amount:"10.00" markup:"2.00">, #<Braintree::ExchangeRateQuoteInput base_currency:"EUR" quote_currency:"GBP" base_amount:"20.00" markup:"4.00">]>))
+    end
+  end
+end

data/spec/unit/braintree/exchange_rate_quote_response_spec.rb

@@ -0,0 +1,52 @@
+require File.expand_path(File.dirname(__FILE__) + "/../spec_helper")
+
+describe Braintree::ExchangeRateQuoteResponse do
+  describe "#initialize" do
+    it "creates and validated the exchange rate quote payload" do
+      quote_payload = Braintree::ExchangeRateQuoteResponse.new(
+        quotes: [
+          {
+            :base_amount => "10.00",
+            :quote_amount => "9.03",
+            :exchange_rate => "0.90"
+          },
+          {
+            :base_amount => "20.00",
+            :quote_amount => "18.06",
+            :exchange_rate => "0.90"
+          }
+        ],
+      )
+
+      quote_1 = quote_payload.quotes[0]
+      quote_2 = quote_payload.quotes[1]
+
+      expect(quote_1.base_amount).to eq("10.00")
+      expect(quote_1.quote_amount).to eq("9.03")
+      expect(quote_1.exchange_rate).to eq("0.90")
+
+      expect(quote_2.base_amount).to eq("20.00")
+      expect(quote_2.quote_amount).to eq("18.06")
+      expect(quote_1.exchange_rate).to eq("0.90")
+    end
+  end
+
+  describe "inspect" do
+    it "prints the attributes" do
+      exchange_rate_quote_payload = Braintree::ExchangeRateQuoteResponse.new(
+        quotes: [
+          {
+            :base_amount => "10.00",
+            :quote_amount => "9.03"
+          },
+          {
+            :base_amount => "20.00",
+            :quote_amount => "18.06"
+          }
+        ],
+      )
+
+      expect(exchange_rate_quote_payload.inspect).to eq(%(#<Braintree::ExchangeRateQuoteResponse quotes:[#<Braintree::ExchangeRateQuote base_amount:"10.00" quote_amount:"9.03">, #<Braintree::ExchangeRateQuote base_amount:"20.00" quote_amount:"18.06">]>))
+    end
+  end
+end

data/spec/unit/braintree/exchange_rate_quote_spec.rb

@@ -0,0 +1,42 @@
+require File.expand_path(File.dirname(__FILE__) + "/../spec_helper")
+
+describe Braintree::ExchangeRateQuote do
+  let(:rate_quote) do
+    {
+      id: "1234",
+      base_amount: "10.00",
+      exchange_rate: "74",
+      quote_amount: "740"
+    }
+  end
+
+  describe "#initialize" do
+    it "initialize and sets the input keys to attrs variable" do
+      quote = described_class.new(rate_quote)
+
+      expect(quote.attrs).to include(:id)
+      expect(quote.attrs).to include(:base_amount)
+      expect(quote.attrs).to include(:exchange_rate)
+      expect(quote.attrs).to include(:quote_amount)
+      expect(quote.attrs.length).to eq(4)
+    end
+  end
+
+  describe "inspect" do
+    it "includes the id first" do
+      output = described_class.new(id: "1234").inspect
+
+      expect(output).to include("#<Braintree::ExchangeRateQuote id:\"1234\">")
+    end
+
+    it "includes all quote attributes" do
+      quote = described_class.new(rate_quote)
+      output = quote.inspect
+
+      expect(output).to include("id:\"1234\"")
+      expect(output).to include("base_amount:\"10.00\"")
+      expect(output).to include("exchange_rate:\"74\"")
+      expect(output).to include("quote_amount:\"740\"")
+    end
+  end
+end

data/spec/unit/braintree/exchange_rate_spec.rb

@@ -0,0 +1,23 @@
+require File.expand_path(File.dirname(__FILE__) + "/../spec_helper")
+
+describe ::Braintree::ExchangeRate do
+  let(:rate_quote) do
+    {
+      id: "1234",
+      base_amount: "10.00",
+      exchange_rate: "74",
+      quote_amount: "740"
+    }
+  end
+
+  describe "#initialize" do
+    it "initialize and sets the attributes" do
+      exchange_rate = described_class.new(:gateway, rate_quote).inspect
+
+      expect(exchange_rate).to include("@id=\"1234\"")
+      expect(exchange_rate).to include("@base_amount=\"10.00\"")
+      expect(exchange_rate).to include("@exchange_rate=\"74\"")
+      expect(exchange_rate).to include("@quote_amount=\"740\"")
+    end
+  end
+end

data/spec/unit/braintree/google_pay_card_spec.rb

@@ -0,0 +1,8 @@
+require File.expand_path(File.dirname(__FILE__) + "/../spec_helper")
+
+describe Braintree::GooglePayCard do
+  it "initializes prepaid reloadable correctly" do
+    card = Braintree::GooglePayCard._new(:gateway, {:prepaid_reloadable => "No"})
+    expect(card.prepaid_reloadable).to eq("No")
+  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