braintree 4.14.0 → 4.18.0

data/spec/integration/braintree/merchant_spec.rb

@@ -15,22 +15,22 @@ describe Braintree::MerchantGateway do
         :payment_methods => ["credit_card", "paypal"],
       )
 
-      result.should be_success
+      expect(result).to be_success
 
       merchant = result.merchant
-      merchant.id.should_not be_nil
-      merchant.email.should == "name@email.com"
-      merchant.company_name.should == "name@email.com"
-      merchant.country_code_alpha3.should == "USA"
-      merchant.country_code_alpha2.should == "US"
-      merchant.country_code_numeric.should == "840"
-      merchant.country_name.should == "United States of America"
+      expect(merchant.id).not_to be_nil
+      expect(merchant.email).to eq("name@email.com")
+      expect(merchant.company_name).to eq("name@email.com")
+      expect(merchant.country_code_alpha3).to eq("USA")
+      expect(merchant.country_code_alpha2).to eq("US")
+      expect(merchant.country_code_numeric).to eq("840")
+      expect(merchant.country_name).to eq("United States of America")
 
       credentials = result.credentials
-      credentials.access_token.should_not be_nil
-      credentials.refresh_token.should_not be_nil
-      credentials.expires_at.should_not be_nil
-      credentials.token_type.should == "bearer"
+      expect(credentials.access_token).not_to be_nil
+      expect(credentials.refresh_token).not_to be_nil
+      expect(credentials.expires_at).not_to be_nil
+      expect(credentials.token_type).to eq("bearer")
     end
 
     it "gives an error when using invalid payment_methods" do
@@ -46,10 +46,10 @@ describe Braintree::MerchantGateway do
         :payment_methods => ["fake_money"],
       )
 
-      result.should_not be_success
+      expect(result).not_to be_success
       errors = result.errors.for(:merchant).on(:payment_methods)
 
-      errors[0].code.should == Braintree::ErrorCodes::Merchant::PaymentMethodsAreInvalid
+      expect(errors[0].code).to eq(Braintree::ErrorCodes::Merchant::PaymentMethodsAreInvalid)
     end
 
     context "credentials" do
@@ -74,7 +74,7 @@ describe Braintree::MerchantGateway do
           :payment_methods => ["credit_card", "paypal"],
         )
 
-        result.should be_success
+        expect(result).to be_success
       end
     end
 
@@ -96,30 +96,30 @@ describe Braintree::MerchantGateway do
         )
 
         merchant = result.merchant
-        merchant.id.should_not be_nil
-        merchant.email.should == "name@email.com"
-        merchant.company_name.should == "name@email.com"
-        merchant.country_code_alpha3.should == "USA"
-        merchant.country_code_alpha2.should == "US"
-        merchant.country_code_numeric.should == "840"
-        merchant.country_name.should == "United States of America"
+        expect(merchant.id).not_to be_nil
+        expect(merchant.email).to eq("name@email.com")
+        expect(merchant.company_name).to eq("name@email.com")
+        expect(merchant.country_code_alpha3).to eq("USA")
+        expect(merchant.country_code_alpha2).to eq("US")
+        expect(merchant.country_code_numeric).to eq("840")
+        expect(merchant.country_name).to eq("United States of America")
 
         credentials = result.credentials
-        credentials.access_token.should_not be_nil
-        credentials.refresh_token.should_not be_nil
-        credentials.expires_at.should_not be_nil
-        credentials.token_type.should == "bearer"
+        expect(credentials.access_token).not_to be_nil
+        expect(credentials.refresh_token).not_to be_nil
+        expect(credentials.expires_at).not_to be_nil
+        expect(credentials.token_type).to eq("bearer")
 
         merchant_accounts = merchant.merchant_accounts
-        merchant_accounts.count.should == 2
+        expect(merchant_accounts.count).to eq(2)
 
         merchant_account = merchant_accounts.detect { |ma| ma.id == "USD" }
-        merchant_account.default.should == true
-        merchant_account.currency_iso_code.should == "USD"
+        expect(merchant_account.default).to eq(true)
+        expect(merchant_account.currency_iso_code).to eq("USD")
 
         merchant_account = merchant_accounts.detect { |ma| ma.id == "GBP" }
-        merchant_account.default.should == false
-        merchant_account.currency_iso_code.should == "GBP"
+        expect(merchant_account.default).to eq(false)
+        expect(merchant_account.currency_iso_code).to eq("GBP")
       end
 
       it "creates an EU multi currency merchant for paypal and credit_card" do
@@ -131,30 +131,30 @@ describe Braintree::MerchantGateway do
         )
 
         merchant = result.merchant
-        merchant.id.should_not be_nil
-        merchant.email.should == "name@email.com"
-        merchant.company_name.should == "name@email.com"
-        merchant.country_code_alpha3.should == "GBR"
-        merchant.country_code_alpha2.should == "GB"
-        merchant.country_code_numeric.should == "826"
-        merchant.country_name.should == "United Kingdom"
+        expect(merchant.id).not_to be_nil
+        expect(merchant.email).to eq("name@email.com")
+        expect(merchant.company_name).to eq("name@email.com")
+        expect(merchant.country_code_alpha3).to eq("GBR")
+        expect(merchant.country_code_alpha2).to eq("GB")
+        expect(merchant.country_code_numeric).to eq("826")
+        expect(merchant.country_name).to eq("United Kingdom")
 
         credentials = result.credentials
-        credentials.access_token.should_not be_nil
-        credentials.refresh_token.should_not be_nil
-        credentials.expires_at.should_not be_nil
-        credentials.token_type.should == "bearer"
+        expect(credentials.access_token).not_to be_nil
+        expect(credentials.refresh_token).not_to be_nil
+        expect(credentials.expires_at).not_to be_nil
+        expect(credentials.token_type).to eq("bearer")
 
         merchant_accounts = merchant.merchant_accounts
-        merchant_accounts.count.should == 2
+        expect(merchant_accounts.count).to eq(2)
 
         merchant_account = merchant_accounts.detect { |ma| ma.id == "GBP" }
-        merchant_account.default.should == true
-        merchant_account.currency_iso_code.should == "GBP"
+        expect(merchant_account.default).to eq(true)
+        expect(merchant_account.currency_iso_code).to eq("GBP")
 
         merchant_account = merchant_accounts.detect { |ma| ma.id == "USD" }
-        merchant_account.default.should == false
-        merchant_account.currency_iso_code.should == "USD"
+        expect(merchant_account.default).to eq(false)
+        expect(merchant_account.currency_iso_code).to eq("USD")
       end
 
 
@@ -170,33 +170,33 @@ describe Braintree::MerchantGateway do
           },
         )
 
-        result.should be_success
+        expect(result).to be_success
 
         merchant = result.merchant
-        merchant.id.should_not be_nil
-        merchant.email.should == "name@email.com"
-        merchant.company_name.should == "name@email.com"
-        merchant.country_code_alpha3.should == "USA"
-        merchant.country_code_alpha2.should == "US"
-        merchant.country_code_numeric.should == "840"
-        merchant.country_name.should == "United States of America"
+        expect(merchant.id).not_to be_nil
+        expect(merchant.email).to eq("name@email.com")
+        expect(merchant.company_name).to eq("name@email.com")
+        expect(merchant.country_code_alpha3).to eq("USA")
+        expect(merchant.country_code_alpha2).to eq("US")
+        expect(merchant.country_code_numeric).to eq("840")
+        expect(merchant.country_name).to eq("United States of America")
 
         credentials = result.credentials
-        credentials.access_token.should_not be_nil
-        credentials.refresh_token.should_not be_nil
-        credentials.expires_at.should_not be_nil
-        credentials.token_type.should == "bearer"
+        expect(credentials.access_token).not_to be_nil
+        expect(credentials.refresh_token).not_to be_nil
+        expect(credentials.expires_at).not_to be_nil
+        expect(credentials.token_type).to eq("bearer")
 
         merchant_accounts = merchant.merchant_accounts
-        merchant_accounts.count.should == 2
+        expect(merchant_accounts.count).to eq(2)
 
         merchant_account = merchant_accounts.detect { |ma| ma.id == "USD" }
-        merchant_account.default.should == true
-        merchant_account.currency_iso_code.should == "USD"
+        expect(merchant_account.default).to eq(true)
+        expect(merchant_account.currency_iso_code).to eq("USD")
 
         merchant_account = merchant_accounts.detect { |ma| ma.id == "GBP" }
-        merchant_account.default.should == false
-        merchant_account.currency_iso_code.should == "GBP"
+        expect(merchant_account.default).to eq(false)
+        expect(merchant_account.currency_iso_code).to eq("GBP")
       end
 
       it "allows creation of non-US merchant if onboarding application is internal" do
@@ -210,29 +210,29 @@ describe Braintree::MerchantGateway do
           },
         )
 
-        result.should be_success
+        expect(result).to be_success
 
         merchant = result.merchant
-        merchant.id.should_not be_nil
-        merchant.email.should == "name@email.com"
-        merchant.company_name.should == "name@email.com"
-        merchant.country_code_alpha3.should == "JPN"
-        merchant.country_code_alpha2.should == "JP"
-        merchant.country_code_numeric.should == "392"
-        merchant.country_name.should == "Japan"
+        expect(merchant.id).not_to be_nil
+        expect(merchant.email).to eq("name@email.com")
+        expect(merchant.company_name).to eq("name@email.com")
+        expect(merchant.country_code_alpha3).to eq("JPN")
+        expect(merchant.country_code_alpha2).to eq("JP")
+        expect(merchant.country_code_numeric).to eq("392")
+        expect(merchant.country_name).to eq("Japan")
 
         credentials = result.credentials
-        credentials.access_token.should_not be_nil
-        credentials.refresh_token.should_not be_nil
-        credentials.expires_at.should_not be_nil
-        credentials.token_type.should == "bearer"
+        expect(credentials.access_token).not_to be_nil
+        expect(credentials.refresh_token).not_to be_nil
+        expect(credentials.expires_at).not_to be_nil
+        expect(credentials.token_type).to eq("bearer")
 
         merchant_accounts = merchant.merchant_accounts
-        merchant_accounts.count.should == 1
+        expect(merchant_accounts.count).to eq(1)
 
         merchant_account = merchant_accounts.detect { |ma| ma.id == "JPY" }
-        merchant_account.default.should == true
-        merchant_account.currency_iso_code.should == "JPY"
+        expect(merchant_account.default).to eq(true)
+        expect(merchant_account.currency_iso_code).to eq("JPY")
       end
 
       it "defaults to USD for non-US merchant if onboarding application is internal and country currency not supported" do
@@ -246,29 +246,29 @@ describe Braintree::MerchantGateway do
           },
         )
 
-        result.should be_success
+        expect(result).to be_success
 
         merchant = result.merchant
-        merchant.id.should_not be_nil
-        merchant.email.should == "name@email.com"
-        merchant.company_name.should == "name@email.com"
-        merchant.country_code_alpha3.should == "YEM"
-        merchant.country_code_alpha2.should == "YE"
-        merchant.country_code_numeric.should == "887"
-        merchant.country_name.should == "Yemen"
+        expect(merchant.id).not_to be_nil
+        expect(merchant.email).to eq("name@email.com")
+        expect(merchant.company_name).to eq("name@email.com")
+        expect(merchant.country_code_alpha3).to eq("YEM")
+        expect(merchant.country_code_alpha2).to eq("YE")
+        expect(merchant.country_code_numeric).to eq("887")
+        expect(merchant.country_name).to eq("Yemen")
 
         credentials = result.credentials
-        credentials.access_token.should_not be_nil
-        credentials.refresh_token.should_not be_nil
-        credentials.expires_at.should_not be_nil
-        credentials.token_type.should == "bearer"
+        expect(credentials.access_token).not_to be_nil
+        expect(credentials.refresh_token).not_to be_nil
+        expect(credentials.expires_at).not_to be_nil
+        expect(credentials.token_type).to eq("bearer")
 
         merchant_accounts = merchant.merchant_accounts
-        merchant_accounts.count.should == 1
+        expect(merchant_accounts.count).to eq(1)
 
         merchant_account = merchant_accounts.detect { |ma| ma.id == "USD" }
-        merchant_account.default.should == true
-        merchant_account.currency_iso_code.should == "USD"
+        expect(merchant_account.default).to eq(true)
+        expect(merchant_account.currency_iso_code).to eq("USD")
       end
 
       it "returns error if invalid currency is passed" do
@@ -283,10 +283,10 @@ describe Braintree::MerchantGateway do
           },
         )
 
-        result.should_not be_success
+        expect(result).not_to be_success
         errors = result.errors.for(:merchant).on(:currencies)
 
-        errors[0].code.should == Braintree::ErrorCodes::Merchant::CurrenciesAreInvalid
+        expect(errors[0].code).to eq(Braintree::ErrorCodes::Merchant::CurrenciesAreInvalid)
       end
     end
   end
@@ -304,16 +304,16 @@ describe Braintree::MerchantGateway do
 
       it "succeeds" do
         result = Braintree::Merchant.provision_raw_apple_pay
-        result.should be_success
-        result.supported_networks.should == ["visa", "mastercard", "amex", "discover", "maestro", "elo"]
+        expect(result).to be_success
+        expect(result.supported_networks).to eq(["visa", "mastercard", "amex", "discover", "maestro", "elo"])
       end
 
       it "is repeatable" do
         result = Braintree::Merchant.provision_raw_apple_pay
-        result.should be_success
+        expect(result).to be_success
         result = Braintree::Merchant.provision_raw_apple_pay
-        result.should be_success
-        result.supported_networks.should == ["visa", "mastercard", "amex", "discover", "maestro", "elo"]
+        expect(result).to be_success
+        expect(result.supported_networks).to eq(["visa", "mastercard", "amex", "discover", "maestro", "elo"])
       end
     end
 
@@ -326,8 +326,8 @@ describe Braintree::MerchantGateway do
 
       it "returns a validation error" do
         result = Braintree::Merchant.provision_raw_apple_pay
-        result.should_not be_success
-        result.errors.for(:apple_pay).first.code.should == Braintree::ErrorCodes::ApplePay::ApplePayCardsAreNotAccepted
+        expect(result).not_to be_success
+        expect(result.errors.for(:apple_pay).first.code).to eq(Braintree::ErrorCodes::ApplePay::ApplePayCardsAreNotAccepted)
       end
     end
 

data/spec/integration/braintree/oauth_spec.rb

@@ -21,12 +21,12 @@ describe "OAuth" do
         :scope => "read_write",
       )
 
-      result.should be_success
+      expect(result).to be_success
       credentials = result.credentials
-      credentials.access_token.should_not be_nil
-      credentials.refresh_token.should_not be_nil
-      credentials.expires_at.should_not be_nil
-      credentials.token_type.should == "bearer"
+      expect(credentials.access_token).not_to be_nil
+      expect(credentials.refresh_token).not_to be_nil
+      expect(credentials.expires_at).not_to be_nil
+      expect(credentials.token_type).to eq("bearer")
     end
 
     it "returns validation errors for bad params" do
@@ -35,9 +35,9 @@ describe "OAuth" do
         :scope => "read_write",
       )
 
-      result.should_not be_success
-      errors = result.errors.for(:credentials).on(:code)[0].code.should == Braintree::ErrorCodes::OAuth::InvalidGrant
-      result.message.should =~ /Invalid grant: code not found/
+      expect(result).not_to be_success
+      errors = expect(result.errors.for(:credentials).on(:code)[0].code).to eq(Braintree::ErrorCodes::OAuth::InvalidGrant)
+      expect(result.message).to match(/Invalid grant: code not found/)
     end
 
     it "raises with a helpful error if client_id and client_secret are not set" do
@@ -71,12 +71,12 @@ describe "OAuth" do
         :scope => "read_write",
       )
 
-      result.should be_success
+      expect(result).to be_success
       credentials = result.credentials
-      credentials.access_token.should_not be_nil
-      credentials.refresh_token.should_not be_nil
-      credentials.expires_at.should_not be_nil
-      credentials.token_type.should == "bearer"
+      expect(credentials.access_token).not_to be_nil
+      expect(credentials.refresh_token).not_to be_nil
+      expect(credentials.expires_at).not_to be_nil
+      expect(credentials.token_type).to eq("bearer")
     end
   end
 
@@ -92,7 +92,7 @@ describe "OAuth" do
       ).credentials.access_token
 
       result = @gateway.oauth.revoke_access_token(access_token)
-      result.should be_success
+      expect(result).to be_success
 
       gateway = Braintree::Gateway.new(
         :access_token => access_token,
@@ -150,49 +150,49 @@ describe "OAuth" do
       )
 
       uri = URI.parse(url)
-      uri.host.should == Braintree::Configuration.instantiate.server
-      uri.path.should == "/oauth/connect"
+      expect(uri.host).to eq(Braintree::Configuration.instantiate.server)
+      expect(uri.path).to eq("/oauth/connect")
 
       query = CGI.parse(uri.query)
-      query["merchant_id"].should == ["integration_merchant_id"]
-      query["client_id"].should == ["client_id$#{Braintree::Configuration.environment}$integration_client_id"]
-      query["redirect_uri"].should == ["http://bar.example.com"]
-      query["scope"].should == ["read_write"]
-      query["state"].should == ["baz_state"]
-      query["landing_page"].should == ["signup"]
-      query["login_only"].should == ["false"]
-
-      query["user[country]"].should == ["USA"]
-      query["business[name]"].should == ["14 Ladders"]
-
-      query["user[email]"].should == ["foo@example.com"]
-      query["user[first_name]"].should == ["Bob"]
-      query["user[last_name]"].should == ["Jones"]
-      query["user[phone]"].should == ["555-555-5555"]
-      query["user[dob_year]"].should == ["1970"]
-      query["user[dob_month]"].should == ["01"]
-      query["user[dob_day]"].should == ["01"]
-      query["user[street_address]"].should == ["222 W Merchandise Mart"]
-      query["user[locality]"].should == ["Chicago"]
-      query["user[region]"].should == ["IL"]
-      query["user[postal_code]"].should == ["60606"]
-
-      query["business[name]"].should == ["14 Ladders"]
-      query["business[registered_as]"].should == ["14.0 Ladders"]
-      query["business[industry]"].should == ["Ladders"]
-      query["business[description]"].should == ["We sell the best ladders"]
-      query["business[street_address]"].should == ["111 N Canal"]
-      query["business[locality]"].should == ["Chicago"]
-      query["business[region]"].should == ["IL"]
-      query["business[postal_code]"].should == ["60606"]
-      query["business[country]"].should == ["USA"]
-      query["business[annual_volume_amount]"].should == ["1000000"]
-      query["business[average_transaction_amount]"].should == ["100"]
-      query["business[maximum_transaction_amount]"].should == ["10000"]
-      query["business[ship_physical_goods]"].should == ["true"]
-      query["business[fulfillment_completed_in]"].should == ["7"]
-      query["business[currency]"].should == ["USD"]
-      query["business[website]"].should == ["http://example.com"]
+      expect(query["merchant_id"]).to eq(["integration_merchant_id"])
+      expect(query["client_id"]).to eq(["client_id$#{Braintree::Configuration.environment}$integration_client_id"])
+      expect(query["redirect_uri"]).to eq(["http://bar.example.com"])
+      expect(query["scope"]).to eq(["read_write"])
+      expect(query["state"]).to eq(["baz_state"])
+      expect(query["landing_page"]).to eq(["signup"])
+      expect(query["login_only"]).to eq(["false"])
+
+      expect(query["user[country]"]).to eq(["USA"])
+      expect(query["business[name]"]).to eq(["14 Ladders"])
+
+      expect(query["user[email]"]).to eq(["foo@example.com"])
+      expect(query["user[first_name]"]).to eq(["Bob"])
+      expect(query["user[last_name]"]).to eq(["Jones"])
+      expect(query["user[phone]"]).to eq(["555-555-5555"])
+      expect(query["user[dob_year]"]).to eq(["1970"])
+      expect(query["user[dob_month]"]).to eq(["01"])
+      expect(query["user[dob_day]"]).to eq(["01"])
+      expect(query["user[street_address]"]).to eq(["222 W Merchandise Mart"])
+      expect(query["user[locality]"]).to eq(["Chicago"])
+      expect(query["user[region]"]).to eq(["IL"])
+      expect(query["user[postal_code]"]).to eq(["60606"])
+
+      expect(query["business[name]"]).to eq(["14 Ladders"])
+      expect(query["business[registered_as]"]).to eq(["14.0 Ladders"])
+      expect(query["business[industry]"]).to eq(["Ladders"])
+      expect(query["business[description]"]).to eq(["We sell the best ladders"])
+      expect(query["business[street_address]"]).to eq(["111 N Canal"])
+      expect(query["business[locality]"]).to eq(["Chicago"])
+      expect(query["business[region]"]).to eq(["IL"])
+      expect(query["business[postal_code]"]).to eq(["60606"])
+      expect(query["business[country]"]).to eq(["USA"])
+      expect(query["business[annual_volume_amount]"]).to eq(["1000000"])
+      expect(query["business[average_transaction_amount]"]).to eq(["100"])
+      expect(query["business[maximum_transaction_amount]"]).to eq(["10000"])
+      expect(query["business[ship_physical_goods]"]).to eq(["true"])
+      expect(query["business[fulfillment_completed_in]"]).to eq(["7"])
+      expect(query["business[currency]"]).to eq(["USD"])
+      expect(query["business[website]"]).to eq(["http://example.com"])
     end
 
     it "builds the query string with multiple payment_methods" do
@@ -205,13 +205,13 @@ describe "OAuth" do
       )
 
       uri = URI.parse(url)
-      uri.host.should == Braintree::Configuration.instantiate.server
-      uri.path.should == "/oauth/connect"
+      expect(uri.host).to eq(Braintree::Configuration.instantiate.server)
+      expect(uri.path).to eq("/oauth/connect")
 
       query = CGI.parse(CGI.unescape(uri.query))
-      query["payment_methods[]"].length.should == 2
-      query["payment_methods[]"].should include("paypal")
-      query["payment_methods[]"].should include("credit_card")
+      expect(query["payment_methods[]"].length).to eq(2)
+      expect(query["payment_methods[]"]).to include("paypal")
+      expect(query["payment_methods[]"]).to include("credit_card")
     end
 
     it "doesn't mutate the options" do
@@ -219,7 +219,7 @@ describe "OAuth" do
 
       @gateway.oauth.connect_url(params)
 
-      params.should == {:payment_methods => ["credit_card"]}
+      expect(params).to eq({:payment_methods => ["credit_card"]})
     end
   end
 end

data/spec/integration/braintree/package_tracking_spec.rb

@@ -0,0 +1,111 @@
+require File.expand_path(File.dirname(__FILE__) + "/../spec_helper")
+
+describe Braintree::Transaction do
+    describe "self.package_tracking" do
+        it "returns validation error message from gateway api" do
+            # Create Transaction
+          result = Braintree::Transaction.sale(
+            :amount => "100",
+            :options => {
+              :submit_for_settlement => true
+            },
+            :paypal_account => {
+              :payer_id => "fake-payer-id",
+              :payment_id => "fake-payment-id",
+            },
+          )
+
+          expect(result.success?).to eq(true)
+
+          # Carrier name is required
+          invalidResult = Braintree::Transaction.package_tracking(result.transaction.id, {tracking_number: "tracking_number_1"})
+          expect(invalidResult.message).to eq("Carrier name is required.")
+
+           # Tracking number is required
+           invalidResult = Braintree::Transaction.package_tracking(result.transaction.id, {carrier: "UPS"})
+           expect(invalidResult.message).to eq("Tracking number is required.")
+        end
+
+        it "successfully calls gateway API and adds package tracking information" do
+
+          # Create Transaction
+          result = Braintree::Transaction.sale(
+            :amount => "100",
+            :options => {
+              :submit_for_settlement => true
+            },
+            :paypal_account => {
+              :payer_id => "fake-payer-id",
+              :payment_id => "fake-payment-id",
+            },
+          )
+
+          expect(result.success?).to eq(true)
+
+          # Create First Package with 2 products
+          firstPackageResult = Braintree::Transaction.package_tracking(
+            result.transaction.id,
+            {
+              carrier: "UPS",
+              notify_payer: true,
+              tracking_number: "tracking_number_1",
+              line_items: [
+                {
+                  product_code: "ABC 01",
+                  name: "Best Product Ever",
+                  quantity: "1",
+                  description: "Best Description Ever",
+                  upc_code: "51234567890",
+                  upc_type: "UPC-A",
+                  image_url: "https://example.com/image.png",
+                },
+                {
+                  product_code: "ABC 02",
+                  name: "Best Product Ever",
+                  quantity: "1",
+                  description: "Best Description Ever",
+                  upc_code: "51234567891",
+                  upc_type: "UPC-A",
+                  image_url: "https://example.com/image.png",
+                },
+              ],
+            },
+          )
+
+          # First package is shipped by the merchant
+          expect(firstPackageResult.success?).to eq(true)
+          expect(firstPackageResult.transaction.packages[0].id).not_to be_nil
+          expect(firstPackageResult.transaction.packages[0].carrier).to eq("UPS")
+          expect(firstPackageResult.transaction.packages[0].tracking_number).to eq("tracking_number_1")
+
+
+          # Create second package with 1 product
+          secondPackageResult = Braintree::Transaction.package_tracking(
+            result.transaction.id,
+            {
+              carrier: "FEDEX",
+              notify_payer: true,
+              tracking_number: "tracking_number_2",
+              line_items: [
+                {
+                  product_code: "ABC 03",
+                  name: "Best Product Ever",
+                  quantity: "1",
+                  description: "Best Description Ever",
+                },
+              ]
+            },
+          )
+
+          # Second package is shipped by the merchant
+          expect(secondPackageResult.success?).to eq(true)
+          expect(secondPackageResult.transaction.packages[1].id).not_to be_nil
+          expect(secondPackageResult.transaction.packages[1].carrier).to eq("FEDEX")
+          expect(secondPackageResult.transaction.packages[1].tracking_number).to eq("tracking_number_2")
+
+          # Find transaction gives both packages
+          findTransaction = Braintree::Transaction.find(result.transaction.id)
+          expect(findTransaction.packages.length).to eq(2)
+        end
+    end
+end