braintree 4.24.0 → 4.26.0

data/spec/integration/braintree/payment_method_nonce_spec.rb

@@ -230,6 +230,16 @@ describe Braintree::PaymentMethodNonce do
       expect(nonce.bin_data.prepaid).to eq(Braintree::CreditCard::Prepaid::Yes)
     end
 
+    it "returns bin_data with prepaid_reloadable set to Yes" do
+      result = Braintree::PaymentMethodNonce.find("fake-valid-prepaid-reloadable-nonce")
+
+      nonce = result.payment_method_nonce
+
+      expect(result).to be_success
+      expect(nonce.bin_data).not_to be_nil
+      expect(nonce.bin_data.prepaid_reloadable).to eq(Braintree::CreditCard::PrepaidReloadable::Yes)
+    end
+
     it "returns bin_data with unknown indicators" do
       result = Braintree::PaymentMethodNonce.find("fake-valid-unknown-indicators-nonce")
 
@@ -245,6 +255,7 @@ describe Braintree::PaymentMethodNonce do
       expect(nonce.bin_data.issuing_bank).to eq(Braintree::CreditCard::IssuingBank::Unknown)
       expect(nonce.bin_data.payroll).to eq(Braintree::CreditCard::Payroll::Unknown)
       expect(nonce.bin_data.prepaid).to eq(Braintree::CreditCard::Prepaid::Unknown)
+      expect(nonce.bin_data.prepaid_reloadable).to eq(Braintree::CreditCard::PrepaidReloadable::Unknown)
       expect(nonce.bin_data.product_id).to eq(Braintree::CreditCard::ProductId::Unknown)
     end
 

data/spec/integration/braintree/paypal_payment_resource_spec.rb

@@ -0,0 +1,141 @@
+require File.expand_path(File.dirname(__FILE__) + "/../spec_helper")
+require File.expand_path(File.dirname(__FILE__) + "/client_api/spec_helper")
+
+describe Braintree::PayPalPaymentResource do
+
+    describe "self.update" do
+        it "successfully updates a payment resource" do
+            nonce = nonce_for_paypal_account(
+                :intent => "order",
+                :payment_token => "fake-paypal-payment-token",
+                :payer_id => "fake-paypal-payer-id",
+              )
+
+            result = Braintree::PayPalPaymentResource.update(
+                    :amount => BigDecimal("55.00"),
+                    :amount_breakdown => {
+                        :discount => BigDecimal("15.00"),
+                        :handling =>  BigDecimal("0.00"),
+                        :insurance =>  BigDecimal("5.00"),
+                        :item_total =>  BigDecimal("45.00"),
+                        :shipping =>  BigDecimal("10.00"),
+                        :shipping_discount =>  BigDecimal("0.00"),
+                        :tax_total =>  BigDecimal("10.00"),
+                    },
+                    :currency_iso_code => "USD",
+                    :custom_field => "0437",
+                    :description => "This is a test",
+                    :line_items => [{
+                        :description => "Shoes",
+                        :image_url => "https://example.com/products/23434/pic.png",
+                        :kind => "debit",
+                        :name => "Name #1",
+                        :product_code => "23434",
+                        :quantity => "1",
+                        :total_amount =>  BigDecimal("45.00"),
+                        :unit_amount =>  BigDecimal("45.00"),
+                        :unit_tax_amount =>  BigDecimal("10.00"),
+                        :url =>  "https://example.com/products/23434",
+                    }],
+                    :order_id => "order-123456789",
+                    :payee_email => "bt_buyer_us@paypal.com",
+                    :payment_method_nonce => nonce,
+                    :shipping => {
+                        :country_name => "United States",
+                        :country_code_alpha2 => "US",
+                        :country_code_alpha3 => "USA",
+                        :country_code_numeric => "484",
+                        :extended_address => "Apt. #1",
+                        :first_name => "John",
+                        :international_phone => {
+                            :country_code => "1",
+                            :national_number => "4081111111",
+                        },
+                        :last_name => "Doe",
+                        :locality => "Chicago",
+                        :postal_code => "60618",
+                        :region => "IL",
+                        :street_address => "123 Division Street",
+                    },
+                    :shipping_options => [{
+                        :amount =>  BigDecimal("10.00"),
+                        :id => "option1",
+                        :label => "fast",
+                        :selected => true,
+                        :type =>  "SHIPPING"
+                    }],
+            )
+
+            expect(result.success?).to eq(true)
+            expect(result.payment_method_nonce).not_to be_nil
+            expect(result.payment_method_nonce.nonce).not_to be_nil
+        end
+
+        it "returns validation errors" do
+            nonce = nonce_for_paypal_account(
+                :intent => "order",
+                :payment_token => "fake-paypal-payment-token",
+                :payer_id => "fake-paypal-payer-id",
+              )
+
+              result = Braintree::PayPalPaymentResource.update(
+                :amount => BigDecimal("55.00"),
+                :amount_breakdown => {
+                    :discount => BigDecimal("15.00"),
+                    :handling =>  BigDecimal("0.00"),
+                    :insurance =>  BigDecimal("5.00"),
+                    :item_total =>  BigDecimal("45.00"),
+                    :shipping =>  BigDecimal("10.00"),
+                    :shipping_discount =>  BigDecimal("0.00"),
+                    :tax_total =>  BigDecimal("10.00"),
+                },
+                :currency_iso_code => "USD",
+                :custom_field => "0437",
+                :description => "This is a test",
+                :line_items => [{
+                    :description => "Shoes",
+                    :image_url => "https://example.com/products/23434/pic.png",
+                    :kind => "debit",
+                    :name => "Name #1",
+                    :product_code => "23434",
+                    :quantity => "1",
+                    :total_amount =>  BigDecimal("45.00"),
+                    :unit_amount =>  BigDecimal("45.00"),
+                    :unit_tax_amount =>  BigDecimal("10.00"),
+                    :url =>  "https://example.com/products/23434",
+                }],
+                :order_id => "order-123456789",
+                :payee_email => "bt_buyer_us@paypal",
+                :payment_method_nonce => nonce,
+                :shipping => {
+                    :country_name => "United States",
+                    :country_code_alpha2 => "US",
+                    :country_code_alpha3 => "USA",
+                    :country_code_numeric => "484",
+                    :extended_address => "Apt. #1",
+                    :first_name => "John",
+                    :international_phone => {
+                        :country_code => "1",
+                        :national_number => "4081111111",
+                    },
+                    :last_name => "Doe",
+                    :locality => "Chicago",
+                    :postal_code => "60618",
+                    :region => "IL",
+                    :street_address => "123 Division Street",
+                },
+                :shipping_options => [{
+                    :amount =>  BigDecimal("10.00"),
+                    :id => "option1",
+                    :label => "fast",
+                    :selected => true,
+                    :type =>  "SHIPPING"
+                }],
+            )
+
+            expect(result.success?).to eq(false)
+            errors = result.errors.for(:paypal_payment_resource)
+            expect(errors.on(:payee_email)[0].code).to eq(Braintree::ErrorCodes::PayPalPaymentResource::InvalidEmail)
+        end
+    end
+end

data/spec/integration/braintree/transaction_spec.rb

@@ -267,6 +267,19 @@ describe Braintree::Transaction do
         expect(result.transaction.credit_card_details.prepaid).to eq(Braintree::CreditCard::Prepaid::Yes)
         expect(result.transaction.payment_instrument_type).to eq(Braintree::PaymentInstrumentType::CreditCard)
       end
+
+      it "sets the prepaid_reloadable field if the card is prepaid reloadable" do
+        result = Braintree::Transaction.create(
+          :type => "sale",
+          :amount => 1_00,
+          :credit_card => {
+            :number => Braintree::Test::CreditCardNumbers::CardTypeIndicators::PrepaidReloadable,
+            :expiration_date => "05/2009"
+          },
+        )
+        expect(result.transaction.credit_card_details.prepaid_reloadable).to eq(Braintree::CreditCard::PrepaidReloadable::Yes)
+        expect(result.transaction.payment_instrument_type).to eq(Braintree::PaymentInstrumentType::CreditCard)
+      end
     end
 
     describe "sca_exemption" do
@@ -2183,6 +2196,7 @@ describe Braintree::Transaction do
         meta_checkout_card_details.last_4.should == "1881"
         meta_checkout_card_details.masked_number.should == "401288******1881"
         meta_checkout_card_details.prepaid.should == "No"
+        meta_checkout_card_details.prepaid_reloadable.should == "Unknown"
       end
 
       it "can create a transaction with a fake meta checkout token nonce" do
@@ -2213,6 +2227,7 @@ describe Braintree::Transaction do
         meta_checkout_token_details.last_4.should == "1881"
         meta_checkout_token_details.masked_number.should == "401288******1881"
         meta_checkout_token_details.prepaid.should == "No"
+        meta_checkout_token_details.prepaid_reloadable.should == "Unknown"
       end
 
       it "can create a transaction with a fake apple pay nonce" do

data/spec/unit/braintree/apple_pay_card_spec.rb

@@ -39,6 +39,7 @@ describe Braintree::ApplePayCard do
       :payment_instrument_name => nil,
       :payroll => "No",
       :prepaid => "No",
+      :prepaid_reloadable => "No",
       :product_id => "MAC",
       :source_card_last4 => "1234",
       :source_description => "blah",

data/spec/unit/braintree/credit_card_spec.rb

@@ -266,4 +266,9 @@ describe Braintree::CreditCard do
       end
     end
   end
+
+  it "initializes prepaid reloadable correctly" do
+    card = Braintree::CreditCard._new(:gateway, {:prepaid_reloadable => "No"})
+    expect(card.prepaid_reloadable).to eq("No")
+  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/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