braintree 4.15.0 → 4.17.0

data/spec/integration/braintree/payment_method_us_bank_account_spec.rb

@@ -78,6 +78,78 @@ describe Braintree::PaymentMethod do
             expect(Braintree::PaymentMethod.find(us_bank_account.token)).to be_a(Braintree::UsBankAccount)
           end
         end
+
+        it "succeeds and verifies with verification_add_ons for NetworkCheck with fake nonce" do
+          customer = Braintree::Customer.create.customer
+          result = Braintree::PaymentMethod.create(
+            :payment_method_nonce => Braintree::Test::Nonce::UsBankAccount,
+            :customer_id => customer.id,
+            :options => {
+              :us_bank_account_verification_method => Braintree::UsBankAccountVerification::VerificationMethod::NetworkCheck,
+              :verification_add_ons => Braintree::UsBankAccountVerification::VerificationAddOns::CustomerVerification,
+              :verification_merchant_account_id => SpecHelper::AnotherUsBankMerchantAccountId,
+            },
+          )
+
+          expect(result).to be_success
+          us_bank_account = result.payment_method
+          expect(us_bank_account).to be_a(Braintree::UsBankAccount)
+          expect(us_bank_account.routing_number).to eq("123456789")
+          expect(us_bank_account.last_4).to eq("0000")
+          expect(us_bank_account.account_type).to eq("checking")
+          expect(us_bank_account.account_holder_name).to eq("Dan Schulman")
+          expect(us_bank_account.bank_name).to match(/Wells Fargo/)
+          expect(us_bank_account.default).to eq(true)
+          expect(us_bank_account.ach_mandate.text).to eq("example mandate text")
+          expect(us_bank_account.ach_mandate.accepted_at).to be_a Time
+
+          expect(us_bank_account.verifications.count).to eq(1)
+          expect(us_bank_account.verifications.first.status).to eq(Braintree::UsBankAccountVerification::Status::Verified)
+          expect(us_bank_account.verifications.first.verification_method).to eq(Braintree::UsBankAccountVerification::VerificationMethod::NetworkCheck)
+          expect(us_bank_account.verifications.first.id).not_to be_empty
+          expect(us_bank_account.verifications.first.verification_determined_at).to be_a Time
+          expect(us_bank_account.verifications.first.processor_response_code).to eq("1000")
+          expect(us_bank_account.verified).to eq(true)
+
+          expect(Braintree::PaymentMethod.find(us_bank_account.token)).to be_a(Braintree::UsBankAccount)
+        end
+
+        it "returns additional processor response for failed NetworkCheck" do
+          customer = Braintree::Customer.create.customer
+          invalid_nonce = generate_non_plaid_us_bank_account_nonce(account_number = "1000000005")
+          result = Braintree::PaymentMethod.create(
+            :payment_method_nonce => invalid_nonce,
+            :customer_id => customer.id,
+            :options => {
+              :us_bank_account_verification_method => Braintree::UsBankAccountVerification::VerificationMethod::NetworkCheck,
+              :verification_merchant_account_id => SpecHelper::AnotherUsBankMerchantAccountId,
+            },
+          )
+
+          expect(result).to be_success
+          us_bank_account = result.payment_method
+          expect(us_bank_account).to be_a(Braintree::UsBankAccount)
+          expect(us_bank_account.routing_number).to eq("021000021")
+          expect(us_bank_account.last_4).to eq("0005")
+          expect(us_bank_account.account_type).to eq("checking")
+          expect(us_bank_account.account_holder_name).to eq("John Doe")
+          expect(us_bank_account.bank_name).to match(/CHASE/)
+          expect(us_bank_account.default).to eq(true)
+          expect(us_bank_account.ach_mandate.text).to eq("cl mandate text")
+          expect(us_bank_account.ach_mandate.accepted_at).to be_a Time
+
+          expect(us_bank_account.verifications.count).to eq(1)
+          expect(us_bank_account.verifications.first.status).to eq(Braintree::UsBankAccountVerification::Status::ProcessorDeclined)
+          expect(us_bank_account.verifications.first.verification_method).to eq(Braintree::UsBankAccountVerification::VerificationMethod::NetworkCheck)
+          expect(us_bank_account.verifications.first.id).not_to be_empty
+          expect(us_bank_account.verifications.first.verification_determined_at).to be_a Time
+          expect(us_bank_account.verifications.first.processor_response_code).to eq("2061")
+          expect(us_bank_account.verifications.first.additional_processor_response).to eq("Invalid routing number")
+
+          expect(us_bank_account.verified).to eq(false)
+
+          expect(Braintree::PaymentMethod.find(us_bank_account.token)).to be_a(Braintree::UsBankAccount)
+        end
       end
 
       it "fails with invalid nonce" do

data/spec/integration/braintree/transaction_search_spec.rb

@@ -1494,6 +1494,33 @@ describe Braintree::Transaction, "search" do
         }.to raise_error(Braintree::UnexpectedError)
       end
     end
+
+    it "searches by payment instrument type meta checkout" do
+      meta_checkout_card_transaction = Braintree::Transaction.sale!(
+        :amount => Braintree::Test::TransactionAmounts::Authorize,
+        :options => {
+          :submit_for_settlement => true
+        },
+        :payment_method_nonce => Braintree::Test::Nonce::MetaCheckoutCard,
+      )
+
+      meta_checkout_token_transaction = Braintree::Transaction.sale!(
+        :amount => Braintree::Test::TransactionAmounts::Authorize,
+        :options => {
+          :submit_for_settlement => true
+        },
+        :payment_method_nonce => Braintree::Test::Nonce::MetaCheckoutToken,
+      )
+
+      collection = Braintree::Transaction.search do |search|
+        search.payment_instrument_type.in ["MetaCheckout"]
+      end
+
+      collection.maximum_size.should == 2
+      txn_ids = collection.map(&:id)
+      expect(txn_ids).to include(meta_checkout_card_transaction.id)
+      expect(txn_ids).to include(meta_checkout_token_transaction.id)
+    end
   end
 
   context "pagination" do

data/spec/integration/braintree/transaction_spec.rb

@@ -2,6 +2,72 @@ require File.expand_path(File.dirname(__FILE__) + "/../spec_helper")
 require File.expand_path(File.dirname(__FILE__) + "/client_api/spec_helper")
 
 describe Braintree::Transaction do
+  let(:industry_data_flight_params) do
+    {
+      :industry => {
+        :industry_type => Braintree::Transaction::IndustryType::TravelAndFlight,
+        :data => {
+          :country_code => "US",
+          :date_of_birth => "2012-12-12",
+          :passenger_first_name => "John",
+          :passenger_last_name => "Doe",
+          :passenger_middle_initial => "M",
+          :passenger_title => "Mr.",
+          :issued_date => Date.new(2018, 1, 1),
+          :travel_agency_name => "Expedia",
+          :travel_agency_code => "12345678",
+          :ticket_number => "ticket-number",
+          :issuing_carrier_code => "AA",
+          :customer_code => "customer-code",
+          :fare_amount => 70_00,
+          :fee_amount => 10_00,
+          :tax_amount => 20_00,
+          :restricted_ticket => false,
+          :legs => [
+            {
+              :conjunction_ticket => "CJ0001",
+              :exchange_ticket => "ET0001",
+              :coupon_number => "1",
+              :service_class => "Y",
+              :carrier_code => "AA",
+              :fare_basis_code => "W",
+              :flight_number => "AA100",
+              :departure_date => Date.new(2018, 1, 2),
+              :departure_airport_code => "MDW",
+              :departure_time => "08:00",
+              :arrival_airport_code => "ATX",
+              :arrival_time => "10:00",
+              :stopover_permitted => false,
+              :fare_amount => 35_00,
+              :fee_amount => 5_00,
+              :tax_amount => 10_00,
+              :endorsement_or_restrictions => "NOT REFUNDABLE"
+            },
+            {
+              :conjunction_ticket => "CJ0002",
+              :exchange_ticket => "ET0002",
+              :coupon_number => "1",
+              :service_class => "Y",
+              :carrier_code => "AA",
+              :fare_basis_code => "W",
+              :flight_number => "AA200",
+              :departure_date => Date.new(2018, 1, 3),
+              :departure_airport_code => "ATX",
+              :departure_time => "12:00",
+              :arrival_airport_code => "MDW",
+              :arrival_time => "14:00",
+              :stopover_permitted => false,
+              :fare_amount => 35_00,
+              :fee_amount => 5_00,
+              :tax_amount => 10_00,
+              :endorsement_or_restrictions => "NOT REFUNDABLE"
+            }
+          ]
+        }
+      },
+    }
+  end
+
   describe "self.clone_transaction" do
     it "creates a new transaction from the card of the transaction to clone" do
       result = Braintree::Transaction.sale(
@@ -306,8 +372,8 @@ describe Braintree::Transaction do
           check_out_date_must_follow_check_in_date = Braintree::ErrorCodes::Transaction::Industry::Lodging::CheckOutDateMustFollowCheckInDate
           room_rate_format_is_invalid = Braintree::ErrorCodes::Transaction::Industry::Lodging::RoomRateFormatIsInvalid
           invalid_additional_charge_kind = Braintree::ErrorCodes::Transaction::Industry::AdditionalCharge::KindIsInvalid
-          expect(result.errors.for(:transaction).for(:industry).map { |e| e.code }.sort).to include(*[invalid_folio, check_out_date_must_follow_check_in_date, room_rate_format_is_invalid])
-          expect(result.errors.for(:transaction).for(:industry).for(:additional_charges).for(:index_0).on(:kind).map { |e| e.code }.sort).to include(*[invalid_additional_charge_kind])
+          expect(result.errors.for(:transaction).for(:industry).map { |e| e.code }.sort).to include(invalid_folio, check_out_date_must_follow_check_in_date, room_rate_format_is_invalid)
+          expect(result.errors.for(:transaction).for(:industry).for(:additional_charges).for(:index_0).on(:kind).map { |e| e.code }.sort).to include(invalid_additional_charge_kind)
         end
       end
 
@@ -356,74 +422,18 @@ describe Braintree::Transaction do
 
       context "for travel flight" do
         it "accepts valid industry data" do
-          result = Braintree::Transaction.create(
+          params = {
             :type => "sale",
             :amount => 1_00,
             :payment_method_nonce => Braintree::Test::Nonce::PayPalOneTimePayment,
             :options => {
               :submit_for_settlement => true
             },
-            :industry => {
-              :industry_type => Braintree::Transaction::IndustryType::TravelAndFlight,
-              :data => {
-                :passenger_first_name => "John",
-                :passenger_last_name => "Doe",
-                :passenger_middle_initial => "M",
-                :passenger_title => "Mr.",
-                :issued_date => Date.new(2018, 1, 1),
-                :travel_agency_name => "Expedia",
-                :travel_agency_code => "12345678",
-                :ticket_number => "ticket-number",
-                :issuing_carrier_code => "AA",
-                :customer_code => "customer-code",
-                :fare_amount => 70_00,
-                :fee_amount => 10_00,
-                :tax_amount => 20_00,
-                :restricted_ticket => false,
-                :legs => [
-                  {
-                    :conjunction_ticket => "CJ0001",
-                    :exchange_ticket => "ET0001",
-                    :coupon_number => "1",
-                    :service_class => "Y",
-                    :carrier_code => "AA",
-                    :fare_basis_code => "W",
-                    :flight_number => "AA100",
-                    :departure_date => Date.new(2018, 1, 2),
-                    :departure_airport_code => "MDW",
-                    :departure_time => "08:00",
-                    :arrival_airport_code => "ATX",
-                    :arrival_time => "10:00",
-                    :stopover_permitted => false,
-                    :fare_amount => 35_00,
-                    :fee_amount => 5_00,
-                    :tax_amount => 10_00,
-                    :endorsement_or_restrictions => "NOT REFUNDABLE"
-                  },
-                  {
-                    :conjunction_ticket => "CJ0002",
-                    :exchange_ticket => "ET0002",
-                    :coupon_number => "1",
-                    :service_class => "Y",
-                    :carrier_code => "AA",
-                    :fare_basis_code => "W",
-                    :flight_number => "AA200",
-                    :departure_date => Date.new(2018, 1, 3),
-                    :departure_airport_code => "ATX",
-                    :departure_time => "12:00",
-                    :arrival_airport_code => "MDW",
-                    :arrival_time => "14:00",
-                    :stopover_permitted => false,
-                    :fare_amount => 35_00,
-                    :fee_amount => 5_00,
-                    :tax_amount => 10_00,
-                    :endorsement_or_restrictions => "NOT REFUNDABLE"
-                  }
-                ]
-              }
-            },
-          )
-          expect(result.success?).to be(true)
+          }
+          params.merge(industry_data_flight_params)
+
+          result = Braintree::Transaction.create(params)
+          result.success?.should be(true)
         end
 
         it "returns errors if validations on industry data fails" do
@@ -1452,8 +1462,7 @@ describe Braintree::Transaction do
 
     it "returns an error if no credit card is given" do
       params = {
-        :transaction => {
-        }
+        :transaction => {}
       }
       result = Braintree::Transaction.create(params[:transaction])
       expect(result.success?).to eq(false)
@@ -2107,6 +2116,61 @@ describe Braintree::Transaction do
         expect(result.transaction.paypal_details.debug_id).not_to be_nil
       end
 
+      it "can create a transaction with a fake meta checkout card nonce" do
+        result = Braintree::Transaction.create(
+          :type => "sale",
+          :amount => Braintree::Test::TransactionAmounts::Authorize,
+          :payment_method_nonce => Braintree::Test::Nonce::MetaCheckoutCard,
+        )
+
+        result.success?.should == true
+        result.transaction.should_not be_nil
+        meta_checkout_card_details = result.transaction.meta_checkout_card_details
+        meta_checkout_card_details.should_not be_nil
+        meta_checkout_card_details.bin.should == "401288"
+        meta_checkout_card_details.card_type.should == Braintree::CreditCard::CardType::Visa
+        meta_checkout_card_details.cardholder_name.should == "Meta Checkout Card Cardholder"
+        meta_checkout_card_details.container_id.should == "container123"
+        meta_checkout_card_details.customer_location.should == "US"
+        meta_checkout_card_details.expiration_date.should == "12/2024"
+        meta_checkout_card_details.expiration_year.should == "2024"
+        meta_checkout_card_details.expiration_month.should == "12"
+        meta_checkout_card_details.image_url.should == "https://assets.braintreegateway.com/payment_method_logo/visa.png?environment=development"
+        meta_checkout_card_details.is_network_tokenized.should == false
+        meta_checkout_card_details.last_4.should == "1881"
+        meta_checkout_card_details.masked_number.should == "401288******1881"
+        meta_checkout_card_details.prepaid.should == "No"
+      end
+
+      it "can create a transaction with a fake meta checkout token nonce" do
+        result = Braintree::Transaction.create(
+          :type => "sale",
+          :amount => Braintree::Test::TransactionAmounts::Authorize,
+          :payment_method_nonce => Braintree::Test::Nonce::MetaCheckoutToken,
+        )
+
+        result.success?.should == true
+        result.transaction.should_not be_nil
+        meta_checkout_token_details = result.transaction.meta_checkout_token_details
+
+        meta_checkout_token_details.should_not be_nil
+        meta_checkout_token_details.bin.should == "401288"
+        meta_checkout_token_details.card_type.should == Braintree::CreditCard::CardType::Visa
+        meta_checkout_token_details.cardholder_name.should == "Meta Checkout Token Cardholder"
+        meta_checkout_token_details.container_id.should == "container123"
+        meta_checkout_token_details.cryptogram.should == "AlhlvxmN2ZKuAAESNFZ4GoABFA=="
+        meta_checkout_token_details.customer_location.should == "US"
+        meta_checkout_token_details.ecommerce_indicator.should == "07"
+        meta_checkout_token_details.expiration_date.should == "12/2024"
+        meta_checkout_token_details.expiration_year.should == "2024"
+        meta_checkout_token_details.expiration_month.should == "12"
+        meta_checkout_token_details.image_url.should == "https://assets.braintreegateway.com/payment_method_logo/visa.png?environment=development"
+        meta_checkout_token_details.is_network_tokenized.should == true
+        meta_checkout_token_details.last_4.should == "1881"
+        meta_checkout_token_details.masked_number.should == "401288******1881"
+        meta_checkout_token_details.prepaid.should == "No"
+      end
+
       it "can create a transaction with a fake apple pay nonce" do
         customer = Braintree::Customer.create!
         result = Braintree::Transaction.create(
@@ -5935,6 +5999,54 @@ describe Braintree::Transaction do
       end
     end
 
+    it "succeeds when industry data is provided" do
+      transaction = Braintree::Transaction.create(
+        :type => "sale",
+        :amount => Braintree::Test::TransactionAmounts::Authorize,
+        :payment_method_nonce => Braintree::Test::Nonce::PayPalOneTimePayment,
+        :options => {
+          :submit_for_settlement => false
+        },
+      ).transaction
+
+      result = Braintree::Transaction.submit_for_settlement(transaction.id, Braintree::Test::TransactionAmounts::Authorize, industry_data_flight_params)
+      expect(result.success?).to be_truthy
+    end
+
+    it "returns errors if validations on industry data fails" do
+      transaction = Braintree::Transaction.create(
+        :type => "sale",
+        :amount => Braintree::Test::TransactionAmounts::Authorize,
+        :payment_method_nonce => Braintree::Test::Nonce::PayPalOneTimePayment,
+        :options => {
+          :submit_for_settlement => false
+        },
+      ).transaction
+
+      options = {
+        :industry => {
+          :industry_type => Braintree::Transaction::IndustryType::TravelAndFlight,
+          :data => {
+            :fare_amount => -1_23,
+            :restricted_ticket => false,
+            :legs => [
+              {
+                :fare_amount => -1_23
+              }
+            ]
+          }
+        },
+      }
+
+      result = Braintree::Transaction.submit_for_settlement(transaction.id, Braintree::Test::TransactionAmounts::Authorize, options)
+      expect(result.success?).to be_falsey
+      industry_errors = result.errors.for(:transaction).for(:industry).map { |e| e.code }.sort
+      expect(industry_errors).to eq([Braintree::ErrorCodes::Transaction::Industry::TravelFlight::FareAmountCannotBeNegative])
+
+      leg_errors = result.errors.for(:transaction).for(:industry).for(:legs).for(:index_0).map { |e| e.code }.sort
+      expect(leg_errors).to eq([Braintree::ErrorCodes::Transaction::Industry::Leg::TravelFlight::FareAmountCannotBeNegative])
+    end
+
     xit "succeeds when level 2 data is provided" do
       result = Braintree::Transaction.sale(
         :amount => Braintree::Test::TransactionAmounts::Authorize,
@@ -6371,6 +6483,20 @@ describe Braintree::Transaction do
       expect(result.success?).to eq(false)
       expect(result.errors.for(:transaction).on(:base)[0].code).to eq(Braintree::ErrorCodes::Transaction::CannotSubmitForSettlement)
     end
+
+    it "succeeds when industry data is provided" do
+      transaction = Braintree::Transaction.create(
+        :type => "sale",
+        :amount => Braintree::Test::TransactionAmounts::Authorize,
+        :payment_method_nonce => Braintree::Test::Nonce::PayPalOneTimePayment,
+        :options => {
+          :submit_for_settlement => false
+        },
+      ).transaction
+
+      result = Braintree::Transaction.submit_for_partial_settlement(transaction.id, Braintree::Test::TransactionAmounts::Authorize, industry_data_flight_params)
+      expect(result.success?).to be_truthy
+    end
   end
 
   describe "self.submit_for_partial_settlement!" do

data/spec/unit/braintree/base_module_spec.rb

@@ -8,11 +8,11 @@ describe Braintree::BaseModule do
         klass = Class.new { include Braintree::BaseModule }
         klass.return_object_or_raise(:obj) { result }
       rescue Braintree::ValidationsFailed => ex
-      end
       expect(ex).not_to eq(nil)
       expect(ex.error_result).to eq(result)
       expect(ex.inspect).to include(result.inspect)
       expect(ex.to_s).to include(result.inspect)
+      end
     end
   end
 end

data/spec/unit/braintree/credit_card_verification_gateway_spec.rb

@@ -22,30 +22,35 @@ describe Braintree::CreditCardVerificationGateway do
     it "creates a credit card verification gateway signature" do
       result = Braintree::CreditCardVerificationGateway._create_signature
       expect(result.inspect).to include("credit_card")
-      expect(result.inspect).to include("credit_card")
+      expect(result.inspect).to include("billing_address")
       expect(result.inspect).to include("cardholder_name")
       expect(result.inspect).to include("cvv")
       expect(result.inspect).to include("expiration_date")
       expect(result.inspect).to include("expiration_month")
       expect(result.inspect).to include("expiration_year")
       expect(result.inspect).to include("number")
-      expect(result.inspect).to include("billing_address")
+      expect(result.inspect).to include("external_vault")
+      expect(result.inspect).to include("previous_network_transaction_id")
+      expect(result.inspect).to include("status")
       expect(result.inspect).to include("intended_transaction_source")
       expect(result.inspect).to include("options")
+      expect(result.inspect).to include("account_type")
       expect(result.inspect).to include("amount")
       expect(result.inspect).to include("merchant_account_id")
-      expect(result.inspect).to include("account_type")
       expect(result.inspect).to include("payment_method_nonce")
+      expect(result.inspect).to include("risk_data")
+      expect(result.inspect).to include("customer_browser")
+      expect(result.inspect).to include("customer_ip")
       expect(result.inspect).to include("three_d_secure_authentication_id")
       expect(result.inspect).to include("three_d_secure_pass_thru")
-      expect(result.inspect).to include("eci_flag")
-      expect(result.inspect).to include("cavv")
-      expect(result.inspect).to include("xid")
-      expect(result.inspect).to include("three_d_secure_version")
       expect(result.inspect).to include("authentication_response")
-      expect(result.inspect).to include("directory_response")
+      expect(result.inspect).to include("cavv")
       expect(result.inspect).to include("cavv_algorithm")
+      expect(result.inspect).to include("directory_response")
       expect(result.inspect).to include("ds_transaction_id")
+      expect(result.inspect).to include("eci_flag")
+      expect(result.inspect).to include("three_d_secure_version")
+      expect(result.inspect).to include("xid")
     end
   end
 end

data/spec/unit/braintree/enriched_customer_data_spec.rb

@@ -12,6 +12,13 @@ describe Braintree::EnrichedCustomerData do
   describe "self._new" do
     it "initializes the object with the appropriate attributes set" do
 
+      address = {
+        street_address: "a-street-address",
+        extended_address: "an-extended-address",
+        locality: "a-locality",
+        region: "a-region",
+        postal_code: "a-postal-code"
+      }
       params = {
         fields_updated: ["username"],
         profile_data: {
@@ -20,6 +27,8 @@ describe Braintree::EnrichedCustomerData do
           last_name: "a-last-name",
           phone_number: "a-phone-number",
           email: "a-email",
+          billing_address: address,
+          shipping_address: address,
         },
       }
 

data/spec/unit/braintree/http_spec.rb

@@ -121,7 +121,7 @@ END
   end
 
   describe "_compose_headers" do
-    before (:each) do
+    before(:each) do
       config = Braintree::Configuration.new
       @http = Braintree::Http.new(config)
     end

data/spec/unit/braintree/meta_checkout_card_details_spec.rb

@@ -0,0 +1,60 @@
+require File.expand_path(File.dirname(__FILE__) + "/../spec_helper")
+
+describe Braintree::Transaction::MetaCheckoutCardDetails do
+    let(:attributes) do {
+
+        :bin => "abc1234",
+        :container_id => "a-container-id",
+        :card_type => "Visa",
+        :cardholder_name => "Meta Checkout Card CardHolder",
+        :commercial => "NO",
+        :country_of_issuance => "US",
+        :created_at => "2023-05-05T21:28:37Z",
+        :debit => "NO",
+        :durbin_regulated => "NO",
+        :expiration_month => "05",
+        :expiration_year => "2024",
+        :healthcare => "NO",
+        :last_4 => "1234",
+        :payroll => "NO",
+        :prepaid => "NO",
+        :token => "token1",
+        :unique_number_identifier => "abc1234",
+        :updated_at => "2023-05-05T21:28:37Z"
+    }
+    end
+
+    describe "unit tests" do
+        it "initializes with the correct attributes" do
+            card = Braintree::Transaction::MetaCheckoutCardDetails.new(attributes)
+
+            card.bin.should == "abc1234"
+            card.container_id.should == "a-container-id"
+            card.card_type.should == "Visa"
+            card.cardholder_name.should == "Meta Checkout Card CardHolder"
+            card.commercial == "NO"
+            card.country_of_issuance == "US"
+            card.created_at == "2023-05-05T21:28:37Z"
+            card.updated_at == "2023-05-05T21:28:37Z"
+            card.debit == "NO"
+            card.payroll == "NO"
+            card.prepaid == "NO"
+            card.healthcare == "NO"
+            card.token == "token1"
+            card.unique_number_identifier == "abc1234"
+            card.expiration_month.should == "05"
+            card.expiration_year.should == "2024"
+            card.last_4.should == "1234"
+        end
+
+        it "sets expiration date correctly" do
+            card = Braintree::Transaction::MetaCheckoutCardDetails.new(attributes)
+            card.expiration_date.should == "05/2024"
+        end
+
+        it "masks the card number correctly" do
+            card = Braintree::Transaction::MetaCheckoutCardDetails.new(attributes)
+            card.masked_number.should == "abc1234******1234"
+        end
+    end
+end

data/spec/unit/braintree/meta_checkout_card_spec.rb

@@ -0,0 +1,60 @@
+require File.expand_path(File.dirname(__FILE__) + "/../spec_helper")
+
+describe Braintree::MetaCheckoutCard do
+    let(:attributes) do {
+
+        :bin => "abc1234",
+        :container_id => "a-container-id",
+        :card_type => "Visa",
+        :cardholder_name => "Meta Checkout Card CardHolder",
+        :commercial => "NO",
+        :country_of_issuance => "US",
+        :created_at => "2023-05-05T21:28:37Z",
+        :debit => "NO",
+        :durbin_regulated => "NO",
+        :expiration_month => "05",
+        :expiration_year => "2024",
+        :healthcare => "NO",
+        :last_4 => "1234",
+        :payroll => "NO",
+        :prepaid => "NO",
+        :token => "token1",
+        :unique_number_identifier => "abc1234",
+        :updated_at => "2023-05-05T21:28:37Z"
+    }
+    end
+
+    describe "unit tests" do
+        it "initializes with the correct attributes" do
+            card = Braintree::MetaCheckoutCard._new(:gateway, attributes)
+
+            card.bin.should == "abc1234"
+            card.container_id.should == "a-container-id"
+            card.card_type.should == "Visa"
+            card.cardholder_name.should == "Meta Checkout Card CardHolder"
+            card.commercial == "NO"
+            card.country_of_issuance == "US"
+            card.created_at == "2023-05-05T21:28:37Z"
+            card.updated_at == "2023-05-05T21:28:37Z"
+            card.debit == "NO"
+            card.payroll == "NO"
+            card.prepaid == "NO"
+            card.healthcare == "NO"
+            card.token == "token1"
+            card.unique_number_identifier == "abc1234"
+            card.expiration_month.should == "05"
+            card.expiration_year.should == "2024"
+            card.last_4.should == "1234"
+        end
+
+        it "sets expiration date correctly" do
+            card = Braintree::MetaCheckoutCard._new(:gateway, attributes)
+            card.expiration_date.should == "05/2024"
+        end
+
+        it "masks the card number correctly" do
+            card = Braintree::MetaCheckoutCard._new(:gateway, attributes)
+            card.masked_number.should == "abc1234******1234"
+        end
+    end
+end