braintree 4.15.0 → 4.18.0

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,63 @@ 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"
+        next_year = Date.today().next_year().year.to_s
+        meta_checkout_card_details.expiration_date.should == "12/".concat(next_year)
+        meta_checkout_card_details.expiration_year.should == next_year
+        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"
+        next_year = Date.today().next_year().year.to_s
+        meta_checkout_token_details.expiration_date.should == "12/".concat(next_year)
+        meta_checkout_token_details.expiration_year.should == next_year
+        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(
@@ -2684,7 +2750,7 @@ describe Braintree::Transaction do
             },
             :three_d_secure_authentication_id => three_d_secure_authentication_id,
             :three_d_secure_pass_thru => {
-              :eci_flag => "02",
+              :eci_flag => "05",
               :cavv => "some_cavv",
               :xid => "some_xid",
               :three_d_secure_version => "1.0.2",
@@ -2771,7 +2837,7 @@ describe Braintree::Transaction do
             :expiration_date => "12/12",
           },
           :three_d_secure_pass_thru => {
-            :eci_flag => "02",
+            :eci_flag => "05",
             :cavv => "some_cavv",
             :xid => "some_xid",
             :three_d_secure_version => "1.0.2",
@@ -2796,7 +2862,7 @@ describe Braintree::Transaction do
             :expiration_date => "12/12",
           },
           :three_d_secure_pass_thru => {
-            :eci_flag => "02",
+            :eci_flag => "05",
             :cavv => "some_cavv",
             :xid => "some_xid",
             :three_d_secure_version => "1.0.2",
@@ -2883,7 +2949,7 @@ describe Braintree::Transaction do
             :expiration_date => "12/12",
           },
           :three_d_secure_pass_thru => {
-            :eci_flag => "02",
+            :eci_flag => "05",
             :cavv => "some_cavv",
             :xid => "some_xid",
             :three_d_secure_version => "invalid",
@@ -2907,7 +2973,7 @@ describe Braintree::Transaction do
             :expiration_date => "12/12",
           },
           :three_d_secure_pass_thru => {
-            :eci_flag => "02",
+            :eci_flag => "05",
             :cavv => "some_cavv",
             :xid => "some_xid",
             :three_d_secure_version => "1.0.2",
@@ -2931,7 +2997,7 @@ describe Braintree::Transaction do
             :expiration_date => "12/12",
           },
           :three_d_secure_pass_thru => {
-            :eci_flag => "02",
+            :eci_flag => "05",
             :cavv => "some_cavv",
             :xid => "some_xid",
             :three_d_secure_version => "1.0.2",
@@ -2955,7 +3021,7 @@ describe Braintree::Transaction do
             :expiration_date => "12/12",
           },
           :three_d_secure_pass_thru => {
-            :eci_flag => "02",
+            :eci_flag => "05",
             :cavv => "some_cavv",
             :xid => "some_xid",
             :three_d_secure_version => "1.0.2",
@@ -4541,6 +4607,84 @@ describe Braintree::Transaction do
         expect(result.success?).to eq(false)
         expect(result.errors.for(:transaction).on(:line_items)[0].code).to eq(Braintree::ErrorCodes::Transaction::TooManyLineItems)
       end
+
+      context "UPC code and type" do
+        let(:line_item) do
+          {
+            :quantity => "1",
+            :name => "Name #1",
+            :description => "Description #1",
+            :kind => "debit",
+            :unit_amount => "45.12",
+            :unit_tax_amount => "1.23",
+            :unit_of_measure => "gallon",
+            :discount_amount => "1.02",
+            :tax_amount => "4.50",
+            :total_amount => "45.15",
+            :product_code => "23434",
+            :commodity_code => "9SAASSD8724",
+            :url => "https://example.com/products/23434",
+            :upc_code => "042100005264",
+            :upc_type => "UPC-A",
+            :image_url => "https://google.com/image.png",
+          }
+        end
+
+        it "accepts valid values" do
+          result = Braintree::Transaction.create(
+            :type => "sale",
+            :amount => "45.15",
+            :payment_method_nonce => Braintree::Test::Nonce::Transactable,
+            :line_items => [line_item],
+          )
+          expect(result.success?).to eq(true)
+          expect(result.transaction.line_items.length).to eq(1)
+          line_item = result.transaction.line_items[0]
+          expect(line_item.upc_code).to eq("042100005264")
+          expect(line_item.upc_type).to eq("UPC-A")
+        end
+
+        it "returns validation errors for invalid UPC code and type too long" do
+          line_item[:upc_code] = "THISCODELONGERTHAN17CHARS"
+          line_item[:upc_type] = "USB-C"
+          result = Braintree::Transaction.create(
+            :type => "sale",
+            :amount => "45.15",
+            :payment_method_nonce => Braintree::Test::Nonce::Transactable,
+            :line_items => [line_item],
+          )
+
+          expect(result.success?).to eq(false)
+          expect(result.errors.for(:transaction).for(:line_items).for(:index_0).on(:upc_code)[0].code).to eq(Braintree::ErrorCodes::TransactionLineItem::UPCCodeIsTooLong)
+          expect(result.errors.for(:transaction).for(:line_items).for(:index_0).on(:upc_type)[0].code).to eq(Braintree::ErrorCodes::TransactionLineItem::UPCTypeIsInvalid)
+        end
+
+        it "returns UPC code missing error when code is not present" do
+          line_item.delete(:upc_code)
+          result = Braintree::Transaction.create(
+            :type => "sale",
+            :amount => "45.15",
+            :payment_method_nonce => Braintree::Test::Nonce::Transactable,
+            :line_items => [line_item],
+          )
+
+          expect(result.success?).to eq(false)
+          expect(result.errors.for(:transaction).for(:line_items).for(:index_0).on(:upc_code)[0].code).to eq(Braintree::ErrorCodes::TransactionLineItem::UPCCodeIsMissing)
+        end
+
+        it "returns UPC type missing error when type is not present" do
+          line_item.delete(:upc_type)
+          result = Braintree::Transaction.create(
+            :type => "sale",
+            :amount => "45.15",
+            :payment_method_nonce => Braintree::Test::Nonce::Transactable,
+            :line_items => [line_item],
+          )
+
+          expect(result.success?).to eq(false)
+          expect(result.errors.for(:transaction).for(:line_items).for(:index_0).on(:upc_type)[0].code).to eq(Braintree::ErrorCodes::TransactionLineItem::UPCTypeIsMissing)
+        end
+      end
     end
 
     context "level 3 summary data" do
@@ -5756,7 +5900,7 @@ describe Braintree::Transaction do
     end
 
     context "Pinless debit transaction" do
-      xit "succesfully submits for settlement" do
+      it "succesfully submits for settlement" do
         result = Braintree::Transaction.sale(
           :amount => Braintree::Test::TransactionAmounts::Authorize,
           :merchant_account_id => SpecHelper::PinlessDebitMerchantAccountId,
@@ -5767,10 +5911,28 @@ describe Braintree::Transaction do
           },
         )
         expect(result.success?).to be_truthy
-        expect(result.transaction.status).to eq(Braintree::Transaction::Status::SubmittedForSettlement)
         expect(result.transaction.debit_network).not_to be_nil
       end
     end
+
+    context "Process debit as credit" do
+      it "succesfully completed pinless eligible transaction in signature" do
+        result = Braintree::Transaction.sale(
+          :amount => Braintree::Test::TransactionAmounts::Authorize,
+          :merchant_account_id => SpecHelper::PinlessDebitMerchantAccountId,
+          :currency_iso_code => "USD",
+          :payment_method_nonce => Braintree::Test::Nonce::TransactablePinlessDebitVisa,
+          :options => {
+            :submit_for_settlement => true,
+            :credit_card => {
+              :process_debit_as_credit => true
+            }
+          },
+        )
+        expect(result.success?).to be_truthy
+        expect(result.transaction.debit_network).to be_nil
+      end
+    end
   end
 
   describe "self.sale!" do
@@ -5935,6 +6097,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 +6581,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
@@ -7613,20 +7837,6 @@ describe Braintree::Transaction do
         expect(adjustment_transaction.errors.for(:authorization_adjustment).on(:base).first.code).to eq(Braintree::ErrorCodes::Transaction::NoNetAmountToPerformAuthAdjustment)
       end
 
-      it "returns failure, when transaction status is not authorized" do
-        additional_params = {:options => {:submit_for_settlement => true}}
-        initial_transaction = Braintree::Transaction.sale(first_data_master_transaction_params.merge(additional_params))
-        expect(initial_transaction.success?).to eq(true)
-
-        adjustment_transaction = Braintree::Transaction.adjust_authorization(
-          initial_transaction.transaction.id, "85.50"
-        )
-
-        expect(adjustment_transaction.success?).to eq(false)
-        expect(adjustment_transaction.transaction.amount).to eq(BigDecimal("75.50"))
-        expect(adjustment_transaction.errors.for(:transaction).on(:base).first.code).to eq(Braintree::ErrorCodes::Transaction::TransactionMustBeInStateAuthorized)
-      end
-
       it "returns failure, when transaction authorization type final or undefined" do
         additional_params = {:transaction_source => "recurring"}
         initial_transaction = Braintree::Transaction.sale(first_data_master_transaction_params.merge(additional_params))

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