braintree 4.35.0 → 4.36.0

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

@@ -0,0 +1,55 @@
+require File.expand_path(File.dirname(__FILE__) + "/../../../spec_helper")
+
+describe Braintree::MonetaryAmountInput do
+  describe "#initialize" do
+    it "initializes with all attributes" do
+      attributes = {
+        value: "10.00",
+        currency_code: "USD"
+      }
+      input = Braintree::MonetaryAmountInput.new(attributes)
+
+      expect(input.value).to eq("10.00")
+      expect(input.currency_code).to eq("USD")
+    end
+  end
+
+  describe "#to_graphql_variables" do
+    it "converts to graphql variables with camelCase keys" do
+      attributes = {
+        value: "25.50",
+        currency_code: "EUR"
+      }
+      input = Braintree::MonetaryAmountInput.new(attributes)
+      expected_variables = {
+        "value" => "25.50",
+        "currencyCode" => "EUR"
+      }
+
+      expect(input.to_graphql_variables).to eq(expected_variables)
+    end
+
+    it "omits nil values" do
+      attributes = {value: "10.00"}
+      input = Braintree::MonetaryAmountInput.new(attributes)
+      expected_variables = {"value" => "10.00"}
+
+      expect(input.to_graphql_variables).to eq(expected_variables)
+    end
+  end
+
+  describe "#inspect" do
+    it "returns formatted string" do
+      attributes = {
+        value: "25.50",
+        currency_code: "EUR"
+      }
+      input = Braintree::MonetaryAmountInput.new(attributes)
+      result = input.inspect
+
+      expect(result).to include("MonetaryAmountInput")
+      expect(result).to include("value:")
+      expect(result).to include("currency_code:")
+    end
+  end
+end

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

@@ -0,0 +1,92 @@
+require File.expand_path(File.dirname(__FILE__) + "/../../../spec_helper")
+
+describe Braintree::PayerInfoInput do
+  describe "#initialize" do
+    it "initializes with all attributes" do
+      attributes = {
+        given_name: "John",
+        surname: "Doe",
+        phone_country_code: "+351",
+        phone_number: "912345678",
+        billing_address: {
+          street_address: "123 Main St",
+          locality: "Lisbon"
+        }
+      }
+      input = Braintree::PayerInfoInput.new(attributes)
+
+      expect(input.given_name).to eq("John")
+      expect(input.surname).to eq("Doe")
+      expect(input.phone_country_code).to eq("+351")
+      expect(input.phone_number).to eq("912345678")
+      expect(input.billing_address).to be_a(Braintree::BillingAddressInput)
+    end
+
+    it "handles nil billing_address" do
+      attributes = {given_name: "John", surname: "Doe"}
+      input = Braintree::PayerInfoInput.new(attributes)
+      expect(input.billing_address).to be_nil
+    end
+  end
+
+  describe "#to_graphql_variables" do
+    it "converts to graphql variables with camelCase keys" do
+      attributes = {
+        given_name: "John",
+        surname: "Doe",
+        phone_country_code: "+351",
+        phone_number: "912345678"
+      }
+      input = Braintree::PayerInfoInput.new(attributes)
+      expected_variables = {
+        "givenName" => "John",
+        "phoneCountryCode" => "+351",
+        "phoneNumber" => "912345678",
+        "surname" => "Doe"
+      }
+
+      expect(input.to_graphql_variables).to eq(expected_variables)
+    end
+
+    it "includes nested billing_address" do
+      attributes = {
+        given_name: "John",
+        surname: "Doe",
+        billing_address: {
+          street_address: "123 Main St",
+          postal_code: "1000-001"
+        }
+      }
+      input = Braintree::PayerInfoInput.new(attributes)
+      variables = input.to_graphql_variables
+
+      expect(variables["billingAddress"]).to be_a(Hash)
+      expect(variables["billingAddress"]["streetAddress"]).to eq("123 Main St")
+      expect(variables["billingAddress"]["postalCode"]).to eq("1000-001")
+    end
+
+    it "omits nil values" do
+      attributes = {given_name: "John"}
+      input = Braintree::PayerInfoInput.new(attributes)
+      expected_variables = {"givenName" => "John"}
+
+      expect(input.to_graphql_variables).to eq(expected_variables)
+    end
+  end
+
+  describe "#inspect" do
+    it "returns formatted string" do
+      attributes = {
+        given_name: "John",
+        surname: "Doe",
+        email: "john@example.com"
+      }
+      input = Braintree::PayerInfoInput.new(attributes)
+      result = input.inspect
+
+      expect(result).to include("PayerInfoInput")
+      expect(result).to include("given_name:")
+      expect(result).to include("surname:")
+    end
+  end
+end

data/spec/unit/braintree/local_payment_context_gateway_spec.rb

@@ -0,0 +1,149 @@
+require File.expand_path(File.dirname(__FILE__) + "/../../spec_helper")
+
+describe Braintree::LocalPaymentContextGateway do
+  let(:gateway) { double(:gateway) }
+  let(:graphql_client) { double(:graphql_client) }
+  let(:local_payment_gateway) { Braintree::LocalPaymentContextGateway.new(gateway, graphql_client) }
+
+  describe "#create" do
+    let(:input) do
+      {
+        amount: {value: "10.00", currency_code: "EUR"},
+        type: Braintree::LocalPaymentType::MBWAY,
+        payer_info: {
+          given_name: "John",
+          surname: "Doe"
+        }
+      }
+    end
+
+    let(:response) do
+      {
+        data: {
+          createLocalPaymentContext: {
+            paymentContext: {
+              id: "context-id-123",
+              type: "MBWAY",
+              paymentId: "payment-123",
+              approvalUrl: "https://approval.url",
+              merchantAccountId: "merchant-123",
+              orderId: "order-456",
+              createdAt: "2025-01-15T10:00:00Z",
+              transactedAt: nil,
+              approvedAt: nil,
+              amount: {
+                value: "10.00",
+                currencyCode: "EUR"
+              }
+            }
+          }
+        }
+      }
+    end
+
+    it "executes the createLocalPaymentContext mutation" do
+      create_input = Braintree::CreateLocalPaymentContextInput.new(input)
+      expect(graphql_client).to receive(:query).with(
+        Braintree::LocalPaymentContextGateway::CREATE_LOCAL_PAYMENT_CONTEXT,
+        {"input" => create_input.to_graphql_variables},
+      ).and_return(response)
+
+      expect(Braintree::GraphQLClient).to receive(:get_validation_errors)
+        .with(response).and_return(nil)
+
+      result = local_payment_gateway.create(create_input)
+      expect(result).to be_a(Braintree::SuccessfulResult)
+      expect(result.payment_context).to be_a(Braintree::LocalPaymentContext)
+      expect(result.payment_context.id).to eq("context-id-123")
+      expect(result.payment_context.approval_url).to eq("https://approval.url")
+      expect(result.payment_context.order_id).to eq("order-456")
+      expect(result.payment_context.amount.value).to eq("10.00")
+      expect(result.payment_context.amount.currency_code).to eq("EUR")
+    end
+
+    it "returns an error result if there are validation errors" do
+      create_input = Braintree::CreateLocalPaymentContextInput.new(input)
+      errors = {:errors =>
+        [ {:attribute => "", :code => "123", :message => "Invalid amount"} ]}
+
+      expect(graphql_client).to receive(:query).and_return(response)
+      expect(Braintree::GraphQLClient).to receive(:get_validation_errors)
+        .with(response).and_return(errors)
+
+      result = local_payment_gateway.create(create_input)
+      expect(result).to be_a(Braintree::ErrorResult)
+      expect(result.errors.first.message).to eq("Invalid amount")
+    end
+
+    it "raises an UnexpectedError if response is malformed" do
+      create_input = Braintree::CreateLocalPaymentContextInput.new(input)
+      bad_response = {:data => {}}
+
+      expect(graphql_client).to receive(:query).and_return(bad_response)
+      expect(Braintree::GraphQLClient).to receive(:get_validation_errors)
+        .with(bad_response).and_return(nil)
+
+      expect {
+        local_payment_gateway.create(create_input)
+      }.to raise_error(Braintree::UnexpectedError)
+    end
+  end
+
+  describe "#find" do
+    let(:find_response) do
+      {
+        data: {
+          node: {
+            id: "context-id-123",
+            legacyId: "legacy-123",
+            type: "MBWAY",
+            paymentId: "payment-123",
+            orderId: "order-456",
+            approvalUrl: "https://approval.url",
+            merchantAccountId: "merchant-123",
+            createdAt: "2025-01-15T10:00:00Z",
+            updatedAt: "2025-01-15T10:05:00Z",
+            transactedAt: nil,
+            approvedAt: nil,
+            expiredAt: nil,
+            amount: {
+              value: "10.00",
+              currencyIsoCode: "EUR"
+            }
+          }
+        }
+      }
+    end
+
+    it "finds a payment context by ID" do
+      expect(graphql_client).to receive(:query).with(
+        Braintree::LocalPaymentContextGateway::FIND_LOCAL_PAYMENT_CONTEXT,
+        {"id" => "context-id-123"},
+      ).and_return(find_response)
+
+      expect(Braintree::GraphQLClient).to receive(:get_validation_errors)
+        .with(find_response).and_return(nil)
+
+      result = local_payment_gateway.find("context-id-123")
+      expect(result).to be_a(Braintree::SuccessfulResult)
+      expect(result.payment_context).to be_a(Braintree::LocalPaymentContext)
+      expect(result.payment_context.id).to eq("context-id-123")
+      expect(result.payment_context.legacy_id).to eq("legacy-123")
+      expect(result.payment_context.type).to eq("MBWAY")
+      expect(result.payment_context.order_id).to eq("order-456")
+      expect(result.payment_context.updated_at).to eq("2025-01-15T10:05:00Z")
+    end
+
+    it "raises NotFoundError when payment context does not exist" do
+      not_found_response = {data: {node: nil}}
+
+      expect(graphql_client).to receive(:query).and_return(not_found_response)
+      expect(Braintree::GraphQLClient).to receive(:get_validation_errors)
+        .with(not_found_response).and_return(nil)
+
+      expect {
+        local_payment_gateway.find("non-existent-id")
+      }.to raise_error(Braintree::NotFoundError, "Payment context not found")
+    end
+  end
+end

data/spec/unit/braintree/local_payment_context_spec.rb

@@ -0,0 +1,141 @@
+require File.expand_path(File.dirname(__FILE__) + "/../spec_helper")
+
+describe Braintree::LocalPaymentContext do
+  describe "#initialize" do
+    it "initializes from response hash" do
+      response = {
+        response: {
+          "paymentContext" => {
+            "id" => "context-123",
+            "legacyId" => "legacy-456",
+            "type" => "MBWAY",
+            "paymentId" => "payment-789",
+            "orderId" => "order-abc",
+            "approvalUrl" => "https://example.com/approve",
+            "merchantAccountId" => "merchant-xyz",
+            "createdAt" => "2025-01-15T10:00:00Z",
+            "updatedAt" => "2025-01-15T11:00:00Z",
+            "transactedAt" => "2025-01-15T12:00:00Z",
+            "approvedAt" => "2025-01-15T11:30:00Z",
+            "expiredAt" => nil,
+            "amount" => {
+              "value" => "10.00",
+              "currencyCode" => "EUR"
+            }
+          }
+        }
+      }
+
+      context = Braintree::LocalPaymentContext._new(response)
+
+      expect(context.id).to eq("context-123")
+      expect(context.legacy_id).to eq("legacy-456")
+      expect(context.type).to eq("MBWAY")
+      expect(context.payment_id).to eq("payment-789")
+      expect(context.order_id).to eq("order-abc")
+      expect(context.approval_url).to eq("https://example.com/approve")
+      expect(context.merchant_account_id).to eq("merchant-xyz")
+      expect(context.created_at).to eq("2025-01-15T10:00:00Z")
+      expect(context.updated_at).to eq("2025-01-15T11:00:00Z")
+      expect(context.transacted_at).to eq("2025-01-15T12:00:00Z")
+      expect(context.approved_at).to eq("2025-01-15T11:30:00Z")
+      expect(context.expired_at).to be_nil
+      expect(context.amount).to be_a(Braintree::MonetaryAmount)
+      expect(context.amount.value).to eq("10.00")
+      expect(context.amount.currency_code).to eq("EUR")
+    end
+
+    it "initializes from attributes hash" do
+      attributes = {
+        id: "context-123",
+        type: "OXXO",
+        approval_url: "https://example.com/approve"
+      }
+
+      context = Braintree::LocalPaymentContext._new(attributes)
+
+      expect(context.id).to eq("context-123")
+      expect(context.type).to eq("OXXO")
+      expect(context.approval_url).to eq("https://example.com/approve")
+    end
+
+    it "handles symbol keys in amount hash" do
+      response = {
+        response: {
+          paymentContext: {
+            id: "context-123",
+            type: "MBWAY",
+            amount: {
+              value: "15.00",
+              currencyCode: "USD"
+            }
+          }
+        }
+      }
+
+      context = Braintree::LocalPaymentContext._new(response)
+
+      expect(context.amount.value).to eq("15.00")
+      expect(context.amount.currency_code).to eq("USD")
+    end
+
+    it "handles currencyIsoCode in amount hash" do
+      response = {
+        response: {
+          paymentContext: {
+            id: "context-123",
+            type: "MBWAY",
+            amount: {
+              value: "20.00",
+              currencyIsoCode: "GBP"
+            }
+          }
+        }
+      }
+
+      context = Braintree::LocalPaymentContext._new(response)
+
+      expect(context.amount.currency_code).to eq("GBP")
+    end
+
+    it "returns nil for amount when not present" do
+      response = {
+        response: {
+          paymentContext: {
+            id: "context-123",
+            type: "MBWAY"
+          }
+        }
+      }
+
+      context = Braintree::LocalPaymentContext._new(response)
+
+      expect(context.amount).to be_nil
+    end
+  end
+
+  describe "#inspect" do
+    it "returns formatted string representation" do
+      attributes = {
+        id: "context-123",
+        type: "OXXO",
+        approval_url: "https://example.com/approve"
+      }
+
+      context = Braintree::LocalPaymentContext._new(attributes)
+
+      expect(context.inspect).to include("LocalPaymentContext")
+      expect(context.inspect).to include("id:")
+      expect(context.inspect).to include("type:")
+      expect(context.inspect).to include("approval_url:")
+    end
+  end
+
+  describe "self.new" do
+    it "is protected" do
+      expect do
+        Braintree::LocalPaymentContext.new
+      end.to raise_error(NoMethodError, /protected method .new/)
+    end
+  end
+end

data/spec/unit/braintree/monetary_amount_spec.rb

@@ -0,0 +1,34 @@
+require File.expand_path(File.dirname(__FILE__) + "/../spec_helper")
+
+describe Braintree::MonetaryAmount do
+  describe "#initialize" do
+    it "initializes with value and currency_code" do
+      amount = Braintree::MonetaryAmount._new(
+        value: "10.00",
+        currency_code: "USD",
+      )
+
+      expect(amount.value).to eq("10.00")
+      expect(amount.currency_code).to eq("USD")
+    end
+  end
+
+  describe "#inspect" do
+    it "returns formatted string representation" do
+      amount = Braintree::MonetaryAmount._new(
+        value: "25.50",
+        currency_code: "EUR",
+      )
+
+      expect(amount.inspect).to eq('#<MonetaryAmount currency_code:"EUR" value:"25.50">')
+    end
+  end
+
+  describe "self.new" do
+    it "is protected" do
+      expect do
+        Braintree::MonetaryAmount.new
+      end.to raise_error(NoMethodError, /protected method .new/)
+    end
+  end
+end

data/spec/unit/braintree/three_d_secure_info_spec.rb

@@ -51,7 +51,9 @@ describe Braintree::ThreeDSecureInfo do
 
   describe "inspect" do
     it "prints the attributes" do
-      expect(three_d_secure_info.inspect).to eq(%(#<ThreeDSecureInfo acs_transaction_id: "acs_id", authentication: {:trans_status=>"authstatus", :trans_status_reason=>"authstatusreason"}, cavv: "cavvvalue", ds_transaction_id: "dstrxid", eci_flag: "06", enrolled: "Y", liability_shift_possible: true, liability_shifted: true, lookup: {:trans_status=>"lookupstatus", :trans_status_reason=>"lookupstatusreason"}, pares_status: "Y", status: "authenticate_successful", three_d_secure_authentication_id: "auth_id", three_d_secure_transaction_id: "trans_id", three_d_secure_version: "1.0.2", xid: "xidvalue">))
+      authentication_hash = {trans_status: "authstatus", trans_status_reason: "authstatusreason"}.inspect
+      lookup_hash = {trans_status: "lookupstatus", trans_status_reason: "lookupstatusreason"}.inspect
+      expect(three_d_secure_info.inspect).to eq(%(#<ThreeDSecureInfo acs_transaction_id: "acs_id", authentication: #{authentication_hash}, cavv: "cavvvalue", ds_transaction_id: "dstrxid", eci_flag: "06", enrolled: "Y", liability_shift_possible: true, liability_shifted: true, lookup: #{lookup_hash}, pares_status: "Y", status: "authenticate_successful", three_d_secure_authentication_id: "auth_id", three_d_secure_transaction_id: "trans_id", three_d_secure_version: "1.0.2", xid: "xidvalue">))
     end
   end
 

data/spec/unit/braintree/transaction/apple_pay_details_spec.rb

@@ -1,34 +1,34 @@
-require File.expand_path(File.dirname(__FILE__) + "/../spec_helper")
+require File.expand_path(File.dirname(__FILE__) + "/../../spec_helper")
 
 describe Braintree::ApplePayDetails do
   it "initializes prepaid reloadable correctly" do
-    card = Braintree::ApplePayDetails._new(:gateway, {:prepaid_reloadable => "No"})
+    card = Braintree::ApplePayDetails.new({:prepaid_reloadable => "No"})
     expect(card.prepaid_reloadable).to eq("No")
   end
 
   it "initializes business correctly" do
-    card = Braintree::ApplePayDetails._new(:gateway, {:business => "No"})
+    card = Braintree::ApplePayDetails.new({:business => "No"})
     expect(card.business).to eq("No")
   end
 
   it "initializes consumer correctly" do
-    card = Braintree::ApplePayDetails._new(:gateway, {:consumer => "No"})
+    card = Braintree::ApplePayDetails.new({:consumer => "No"})
     expect(card.consumer).to eq("No")
   end
 
   it "initializes corporate correctly" do
-    card = Braintree::ApplePayDetails._new(:gateway, {:corporate => "No"})
+    card = Braintree::ApplePayDetails.new({:corporate => "No"})
     expect(card.corporate).to eq("No")
   end
 
   it "initializes purchase correctly" do
-    card = Braintree::ApplePayDetails._new(:gateway, {:purchase => "No"})
+    card = Braintree::ApplePayDetails.new({:purchase => "No"})
     expect(card.purchase).to eq("No")
   end
 
   describe "payment_account_reference" do
     it "returns the payment account reference when present" do
-      details = Braintree::Transaction::ApplePayDetails.new(
+      details = Braintree::ApplePayDetails.new(
         :payment_account_reference => "V0010013019339005665779448477",
       )
       expect(details.payment_account_reference).to eq("V0010013019339005665779448477")

data/spec/unit/braintree/transaction/google_pay_details_spec.rb

@@ -1,34 +1,34 @@
-require File.expand_path(File.dirname(__FILE__) + "/../spec_helper")
+require File.expand_path(File.dirname(__FILE__) + "/../../spec_helper")
 
 describe Braintree::GooglePayDetails do
   it "initializes prepaid reloadable correctly" do
-    card = Braintree::GooglePayDetails._new(:gateway, {:prepaid_reloadable => "No"})
+    card = Braintree::GooglePayDetails.new({:prepaid_reloadable => "No"})
     expect(card.prepaid_reloadable).to eq("No")
   end
 
   it "initializes business correctly" do
-    card = Braintree::GooglePayDetails._new(:gateway, {:business => "No"})
+    card = Braintree::GooglePayDetails.new({:business => "No"})
     expect(card.business).to eq("No")
   end
 
   it "initializes consumer correctly" do
-    card = Braintree::GooglePayDetails._new(:gateway, {:consumer => "No"})
+    card = Braintree::GooglePayDetails.new({:consumer => "No"})
     expect(card.consumer).to eq("No")
   end
 
   it "initializes corporate correctly" do
-    card = Braintree::GooglePayDetails._new(:gateway, {:corporate => "No"})
+    card = Braintree::GooglePayDetails.new({:corporate => "No"})
     expect(card.corporate).to eq("No")
   end
 
   it "initializes purchase correctly" do
-    card = Braintree::GooglePayDetails._new(:gateway, {:purchase => "No"})
+    card = Braintree::GooglePayDetails.new({:purchase => "No"})
     expect(card.purchase).to eq("No")
   end
 
   context "payment_account_reference" do
     it "returns the payment account reference when present" do
-      details = Braintree::Transaction::GooglePayDetails.new(
+      details = Braintree::GooglePayDetails.new(
         :payment_account_reference => "V0010013019339005665779448477",
       )
       expect(details.payment_account_reference).to eq("V0010013019339005665779448477")

data/spec/unit/braintree/transaction/meta_checkout_card_details_spec.rb

@@ -1,28 +1,28 @@
-require File.expand_path(File.dirname(__FILE__) + "/../spec_helper")
+require File.expand_path(File.dirname(__FILE__) + "/../../spec_helper")
 
 describe Braintree::MetaCheckoutCardDetails do
   it "initializes prepaid reloadable correctly" do
-    card = Braintree::MetaCheckoutCardDetails._new(:gateway, {:prepaid_reloadable => "No"})
+    card = Braintree::MetaCheckoutCardDetails.new({:prepaid_reloadable => "No"})
     expect(card.prepaid_reloadable).to eq("No")
   end
 
   it "initializes business correctly" do
-    card = Braintree::MetaCheckoutCardDetails._new(:gateway, {:business => "No"})
+    card = Braintree::MetaCheckoutCardDetails.new({:business => "No"})
     expect(card.business).to eq("No")
   end
 
   it "initializes consumer correctly" do
-    card = Braintree::MetaCheckoutCardDetails._new(:gateway, {:consumer => "No"})
+    card = Braintree::MetaCheckoutCardDetails.new({:consumer => "No"})
     expect(card.consumer).to eq("No")
   end
 
   it "initializes corporate correctly" do
-    card = Braintree::MetaCheckoutCardDetails._new(:gateway, {:corporate => "No"})
+    card = Braintree::MetaCheckoutCardDetails.new({:corporate => "No"})
     expect(card.corporate).to eq("No")
   end
 
   it "initializes purchase correctly" do
-    card = Braintree::MetaCheckoutCardDetails._new(:gateway, {:purchase => "No"})
+    card = Braintree::MetaCheckoutCardDetails.new({:purchase => "No"})
     expect(card.purchase).to eq("No")
   end
 end

data/spec/unit/braintree/transaction/meta_checkout_token_details_spec.rb

@@ -1,28 +1,28 @@
-require File.expand_path(File.dirname(__FILE__) + "/../spec_helper")
+require File.expand_path(File.dirname(__FILE__) + "/../../spec_helper")
 
 describe Braintree::MetaCheckoutTokenDetails do
   it "initializes prepaid reloadable correctly" do
-    card = Braintree::MetaCheckoutTokenDetails._new(:gateway, {:prepaid_reloadable => "No"})
+    card = Braintree::MetaCheckoutTokenDetails.new({:prepaid_reloadable => "No"})
     expect(card.prepaid_reloadable).to eq("No")
   end
 
   it "initializes business correctly" do
-    card = Braintree::MetaCheckoutTokenDetails._new(:gateway, {:business => "No"})
+    card = Braintree::MetaCheckoutTokenDetails.new({:business => "No"})
     expect(card.business).to eq("No")
   end
 
   it "initializes consumer correctly" do
-    card = Braintree::MetaCheckoutTokenDetails._new(:gateway, {:consumer => "No"})
+    card = Braintree::MetaCheckoutTokenDetails.new({:consumer => "No"})
     expect(card.consumer).to eq("No")
   end
 
   it "initializes corporate correctly" do
-    card = Braintree::MetaCheckoutTokenDetails._new(:gateway, {:corporate => "No"})
+    card = Braintree::MetaCheckoutTokenDetails.new({:corporate => "No"})
     expect(card.corporate).to eq("No")
   end
 
   it "initializes purchase correctly" do
-    card = Braintree::MetaCheckoutTokenDetails._new(:gateway, {:purchase => "No"})
+    card = Braintree::MetaCheckoutTokenDetails.new({:purchase => "No"})
     expect(card.purchase).to eq("No")
   end
 end

data/spec/unit/braintree/transaction/payment_receipt_spec.rb

@@ -64,10 +64,10 @@ describe Braintree::Transaction::PaymentReceipt do
       expect(details.merchant_identification_number).to eq("merchant-id-number")
       expect(details.merchant_name).to eq("merchant-name")
       expect(details.pin_verified).to be_truthy
-      expect(details.processor_authorization_code).to be("processor-auth-code")
-      expect(details.processor_response_text).to be("processor-response-text")
-      expect(details.terminal_identification_number).to be("terminal-id")
-      expect(details.type).to be("sale")
+      expect(details.processor_authorization_code).to eq("processor-auth-code")
+      expect(details.processor_response_text).to eq("processor-response-text")
+      expect(details.terminal_identification_number).to eq("terminal-id")
+      expect(details.type).to eq("sale")
     end
   end
 end