braintree 2.36.0 → 2.37.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: c48ff6229db7ba353e35139264ee163912aad603
+  data.tar.gz: 923b9b3a830e9ea040579593e4f21e27b3161efa
+SHA512:
+  metadata.gz: d0e8171010de2bff30836124bfcf8421afa7e3093d5f19e1550a7cb45497d83be5e5f88483cf9cb6611c2aaa69d53645edfd6a1204c331c050b3a33232fdc3d0
+  data.tar.gz: 6da4afeea421900cc0c429e9410fa14cd164e60711bd3b81bfad62b9bc9e6f7498d19de7a74a012404031f9ce3c15a0e57e63c16a66c2f6e3fa37ba9c548246d

data/lib/braintree.rb

@@ -62,6 +62,7 @@ require "braintree/paypal_account"
 require "braintree/paypal_account_gateway"
 require "braintree/plan"
 require "braintree/plan_gateway"
+require "braintree/risk_data"
 require "braintree/settlement_batch_summary"
 require "braintree/settlement_batch_summary_gateway"
 require "braintree/resource_collection"

data/lib/braintree/credit_card.rb

@@ -38,7 +38,7 @@ module Braintree
     attr_reader :billing_address, :bin, :card_type, :cardholder_name, :commercial, :country_of_issuance,
       :created_at, :customer_id, :debit, :durbin_regulated, :expiration_month, :expiration_year, :healthcare,
       :issuing_bank, :last_4, :payroll, :prepaid, :subscriptions, :token, :unique_number_identifier, :updated_at,
-      :image_url
+      :image_url, :verification
 
     # See http://www.braintreepayments.com/docs/ruby/credit_cards/create
     def self.create(attributes)
@@ -139,6 +139,12 @@ module Braintree
       set_instance_variables_from_hash(attributes)
       @billing_address = attributes[:billing_address] ? Address._new(@gateway, attributes[:billing_address]) : nil
       @subscriptions = (@subscriptions || []).map { |subscription_hash| Subscription._new(@gateway, subscription_hash) }
+      @verification = _most_recent_verification(attributes)
+    end
+
+    def _most_recent_verification(attributes)
+      verification = (attributes[:verifications] || []).sort_by{ |verification| verification[:created_at] }.reverse.first
+      CreditCardVerification._new(verification) if verification
     end
 
     # Deprecated. Use Braintree::CreditCard.credit

data/lib/braintree/credit_card_gateway.rb

@@ -84,7 +84,7 @@ module Braintree
 
     def self._signature(type) # :nodoc:
       billing_address_params = AddressGateway._shared_signature
-      options = [:make_default, :verification_merchant_account_id, :verify_card, :venmo_sdk_session]
+      options = [:make_default, :verification_merchant_account_id, :verify_card, :verification_amount, :venmo_sdk_session]
       signature = [
         :billing_address_id, :cardholder_name, :cvv, :device_session_id, :expiration_date,
         :expiration_month, :expiration_year, :number, :token, :venmo_sdk_payment_method_code,

data/lib/braintree/credit_card_verification.rb

@@ -12,10 +12,11 @@ module Braintree
 
     attr_reader :avs_error_response_code, :avs_postal_code_response_code, :avs_street_address_response_code,
       :cvv_response_code, :merchant_account_id, :processor_response_code, :processor_response_text, :status,
-      :id, :gateway_rejection_reason, :credit_card, :billing, :created_at
+      :id, :gateway_rejection_reason, :credit_card, :billing, :created_at, :risk_data
 
     def initialize(attributes) # :nodoc:
       set_instance_variables_from_hash(attributes)
+      @risk_data = RiskData.new(attributes[:risk_data]) if attributes[:risk_data]
     end
 
     def inspect # :nodoc:

data/lib/braintree/customer.rb

@@ -4,7 +4,7 @@ module Braintree
     include BaseModule
 
     attr_reader :addresses, :company, :created_at, :credit_cards, :email, :fax, :first_name, :id, :last_name,
-      :phone, :updated_at, :website, :custom_fields, :paypal_accounts
+      :phone, :updated_at, :website, :custom_fields, :paypal_accounts, :apple_pay_cards
 
     # See http://www.braintreepayments.com/docs/ruby/customers/search
     def self.all
@@ -108,6 +108,7 @@ module Braintree
       set_instance_variables_from_hash(attributes)
       @credit_cards = (@credit_cards || []).map { |pm| CreditCard._new gateway, pm }
       @paypal_accounts = (@paypal_accounts || []).map { |pm| PayPalAccount._new gateway, pm }
+      @apple_pay_cards = (@apple_pay_cards || []).map { |pm| ApplePayCard._new gateway, pm }
       @addresses = (@addresses || []).map { |addr| Address._new gateway, addr }
       @custom_fields = attributes[:custom_fields].is_a?(Hash) ? attributes[:custom_fields] : {}
     end
@@ -142,7 +143,7 @@ module Braintree
 
     # Returns the customer's payment methods
     def payment_methods
-      @credit_cards.dup + @paypal_accounts.dup
+      @credit_cards.dup + @paypal_accounts.dup + @apple_pay_cards.dup
     end
 
     def inspect # :nodoc:

data/lib/braintree/error_codes.rb

@@ -293,6 +293,25 @@ module Braintree
         SubmitForSettlementIsRequiredForCloning = "91544"
         VaultIsDisabled = "91525"
       end
+
+      module Industry
+        module Lodging
+          EmptyData = "93402"
+          FolioNumberIsInvalid = "93403"
+          CheckInDateIsInvalid = "93404"
+          CheckOutDateIsInvalid = "93405"
+          CheckOutDateMustFollowCheckInDate = "93406"
+        end
+
+        module TravelCruise
+          EmptyData = "93408"
+          UnknownDataField = "93409"
+          TravelPackageIsInvalid = "93410"
+          DepartureDateIsInvalid = "93411"
+          LodgingCheckInDateIsInvalid = "93412"
+          LodgingCheckOutDateIsInvalid = "93413"
+        end
+      end
     end
 
     module MerchantAccount

data/lib/braintree/payment_method_gateway.rb

@@ -42,6 +42,8 @@ module Braintree
         PayPalAccount._new(@gateway, response[:paypal_account])
       elsif response.has_key?(:sepa_bank_account)
         SEPABankAccount._new(@gateway, response[:sepa_bank_account])
+      elsif response.has_key?(:apple_pay_card)
+        ApplePayCard._new(@gateway, response[:apple_pay_card])
       else
         UnknownPaymentMethod._new(@gateway, response)
       end

data/lib/braintree/risk_data.rb

@@ -0,0 +1,19 @@
+module Braintree
+  class RiskData # :nodoc:
+    include BaseModule
+
+    attr_reader :id, :decision
+
+    def initialize(attributes)
+      set_instance_variables_from_hash attributes unless attributes.nil?
+    end
+
+    def inspect
+      attr_order = [:id, :decision]
+      formatted_attrs = attr_order.map do |attr|
+        "#{attr}: #{send(attr).inspect}"
+      end
+      "#<RiskData #{formatted_attrs.join(", ")}>"
+    end
+  end
+end

data/lib/braintree/test/nonce.rb

@@ -8,6 +8,7 @@ module Braintree
       ApplePayVisa = "fake-apple-pay-visa-nonce"
       ApplePayMasterCard = "fake-apple-pay-mastercard-nonce"
       ApplePayAmEx = "fake-apple-pay-amex-nonce"
+      AbstractTransactable = "fake-abstract-transactable-nonce"
     end
   end
 end

data/lib/braintree/transaction.rb

@@ -55,6 +55,7 @@ module Braintree
 
     module IndustryType
       Lodging = "lodging"
+      TravelAndCruise = "travel_cruise"
 
       All = constants.map { |c| const_get(c) }
     end
@@ -111,6 +112,7 @@ module Braintree
     attr_reader :updated_at
     attr_reader :add_ons, :discounts
     attr_reader :payment_instrument_type
+    attr_reader :risk_data
 
     # See http://www.braintreepayments.com/docs/ruby/transactions/create
     def self.create(attributes)
@@ -249,6 +251,7 @@ module Braintree
       add_ons.map! { |attrs| AddOn._new(attrs) } if add_ons
       discounts.map! { |attrs| Discount._new(attrs) } if discounts
       @payment_instrument_type = attributes[:payment_instrument_type]
+      @risk_data = RiskData.new(attributes[:risk_data]) if attributes[:risk_data]
     end
 
     # True if <tt>other</tt> is a Braintree::Transaction with the same id.

data/lib/braintree/transaction_gateway.rb

@@ -131,7 +131,7 @@ module Braintree
         {:custom_fields => :_any_key_},
         {:descriptor => [:name, :phone, :url]},
         {:paypal_account => [:email, :token, :paypal_data, :payee_email]},
-        {:industry => [:industry_type, {:data => [:folio_number, :check_in_date, :check_out_date]}]}
+        {:industry => [:industry_type, {:data => [:folio_number, :check_in_date, :check_out_date, :travel_package, :lodging_check_in_date, :lodging_check_out_date, :departure_date, :lodging_name, :room_rate]}]}
       ]
     end
 

data/lib/braintree/version.rb

@@ -1,7 +1,7 @@
 module Braintree
   module Version
     Major = 2
-    Minor = 36
+    Minor = 37
     Tiny = 0
 
     String = "#{Major}.#{Minor}.#{Tiny}"

data/lib/braintree/webhook_testing_gateway.rb

@@ -9,7 +9,7 @@ module Braintree
       payload = Base64.encode64(_sample_xml(kind, id))
       signature_string = "#{@config.public_key}|#{Braintree::Digest.hexdigest(@config.private_key, payload)}"
 
-      return signature_string, payload
+      return {:bt_signature => signature_string, :bt_payload => payload}
     end
 
     def _sample_xml(kind, data)

data/spec/httpsd.pid

@@ -1 +1 @@
-28120
+22683

data/spec/integration/braintree/credit_card_spec.rb

@@ -119,6 +119,21 @@ describe Braintree::CreditCard do
       result.credit_card_verification.avs_street_address_response_code.should == "I"
     end
 
+    it "returns risk data on verification on credit_card create" do
+      customer = Braintree::Customer.create!
+      credit_card = Braintree::CreditCard.create!(
+        :cardholder_name => "Original Holder",
+        :customer_id => customer.id,
+        :cvv => "123",
+        :number => Braintree::Test::CreditCardNumbers::Visa,
+        :expiration_date => "05/2020",
+        :options => {:verify_card => true}
+      )
+      verification = credit_card.verification
+      verification.risk_data.should respond_to(:id)
+      verification.risk_data.should respond_to(:decision)
+    end
+
     it "exposes the gateway rejection reason on verification" do
       old_merchant = Braintree::Configuration.merchant_id
       old_public_key = Braintree::Configuration.public_key
@@ -146,6 +161,24 @@ describe Braintree::CreditCard do
       end
     end
 
+    it "verifies the credit card if options[verify_card]=true" do
+      customer = Braintree::Customer.create!
+      result = Braintree::CreditCard.create(
+        :customer_id => customer.id,
+        :number => Braintree::Test::CreditCardNumbers::FailsSandboxVerification::Visa,
+        :expiration_date => "05/2009",
+        :options => {:verify_card => true, :verification_amount => "1.01"}
+      )
+      result.success?.should == false
+      result.credit_card_verification.status.should == Braintree::Transaction::Status::ProcessorDeclined
+      result.credit_card_verification.processor_response_code.should == "2000"
+      result.credit_card_verification.processor_response_text.should == "Do Not Honor"
+      result.credit_card_verification.cvv_response_code.should == "I"
+      result.credit_card_verification.avs_error_response_code.should == nil
+      result.credit_card_verification.avs_postal_code_response_code.should == "I"
+      result.credit_card_verification.avs_street_address_response_code.should == "I"
+    end
+
     it "allows user to specify merchant account for verification" do
       customer = Braintree::Customer.create!
       result = Braintree::CreditCard.create(
@@ -1193,33 +1226,6 @@ describe Braintree::CreditCard do
       end.to raise_error(Braintree::NotFoundError)
     end
 
-    it "does not find the payment method for a locked nonce" do
-      raw_client_token = Braintree::ClientToken.generate
-      client_token = decode_client_token(raw_client_token)
-      client = ClientApiHttp.new(Braintree::Configuration.instantiate,
-        :authorization_fingerprint => client_token["authorizationFingerprint"],
-        :shared_customer_identifier => "fake_identifier",
-        :shared_customer_identifier_type => "testing"
-      )
-
-      client.add_payment_method(
-        :credit_card => {
-          :number => "4111111111111111",
-          :expiration_month => "11",
-          :expiration_year => "2099",
-        },
-        :share => true
-      )
-
-      response = client.get_payment_methods
-      body = JSON.parse(response.body)
-      nonce = body["paymentMethods"].first["nonce"]
-
-      expect do
-        Braintree::CreditCard.from_nonce(nonce)
-      end.to raise_error(Braintree::NotFoundError, /locked/)
-    end
-
     it "does not find the payment method for a consumednonce" do
       customer = Braintree::Customer.create!
       nonce = nonce_for_new_payment_method(

data/spec/integration/braintree/customer_spec.rb

@@ -403,6 +403,20 @@ describe Braintree::Customer do
         result.customer.credit_cards.first.last_4.should == "1111"
       end
     end
+
+    it "can create a customer with an apple pay payment method" do
+      result = Braintree::Customer.create(:payment_method_nonce => Braintree::Test::Nonce::ApplePayVisa)
+
+      result.success?.should == true
+      result.customer.payment_methods.should_not be_empty
+      result.customer.payment_methods.first.token.should_not be_nil
+    end
+
+    it "can create a customer with an unknown payment method" do
+      result = Braintree::Customer.create(:payment_method_nonce => Braintree::Test::Nonce::AbstractTransactable)
+
+      result.success?.should == true
+    end
   end
 
   describe "self.create!" do
@@ -730,6 +744,20 @@ describe Braintree::Customer do
       found_customer.credit_cards.first.subscriptions.first.price.should == BigDecimal.new("1.00")
     end
 
+    it "returns associated ApplePayCards" do
+      result = Braintree::Customer.create(
+        :payment_method_nonce => Braintree::Test::Nonce::ApplePayAmEx
+      )
+      result.success?.should == true
+
+      found_customer = Braintree::Customer.find(result.customer.id)
+      found_customer.apple_pay_cards.should_not be_nil
+      apple_pay_card = found_customer.apple_pay_cards.first
+      apple_pay_card.should be_a Braintree::ApplePayCard
+      apple_pay_card.token.should_not be_nil
+      apple_pay_card.expiration_year.should_not be_nil
+    end
+
     it "works for a blank customer" do
       created_customer = Braintree::Customer.create!
       found_customer = Braintree::Customer.find(created_customer.id)

data/spec/integration/braintree/payment_method_spec.rb

@@ -487,6 +487,24 @@ describe Braintree::PaymentMethod do
         result.payment_method.image_url.should_not be_nil
       end
     end
+
+    context "Unknown payment methods" do
+      it "creates an unknown payment method from a nonce" do
+        customer = Braintree::Customer.create.customer
+        token = SecureRandom.hex(16)
+        result = Braintree::PaymentMethod.create(
+          :payment_method_nonce => Braintree::Test::Nonce::AbstractTransactable,
+          :customer_id => customer.id,
+          :token => token
+        )
+
+        result.should be_success
+        payment_method = result.payment_method
+        payment_method.should_not be_nil
+        payment_method.token.should == token
+        payment_method.should be_a Braintree::UnknownPaymentMethod
+      end
+    end
   end
 
   describe "self.find" do
@@ -550,6 +568,48 @@ describe Braintree::PaymentMethod do
       end
     end
 
+    context "apple pay cards" do
+      it "finds the payment method with the given token" do
+        customer = Braintree::Customer.create!
+        payment_method_token = "PAYMENT_METHOD_TOKEN_#{rand(36**3).to_s(36)}"
+        result = Braintree::PaymentMethod.create(
+          :payment_method_nonce => Braintree::Test::Nonce::ApplePayAmEx,
+          :customer_id => customer.id,
+          :token => payment_method_token
+        )
+        result.should be_success
+
+        apple_pay_card = Braintree::PaymentMethod.find(payment_method_token)
+        apple_pay_card.should be_a(Braintree::ApplePayCard)
+        apple_pay_card.should_not be_nil
+        apple_pay_card.token.should == payment_method_token
+        apple_pay_card.card_type.should == Braintree::ApplePayCard::CardType::AmEx
+        apple_pay_card.default.should == true
+        apple_pay_card.image_url.should =~ /apple_pay/
+        apple_pay_card.expiration_month.to_i.should > 0
+        apple_pay_card.expiration_year.to_i.should > 0
+      end
+    end
+
+    context "unknown payment methods" do
+      it "finds the payment method with the given token" do
+        customer = Braintree::Customer.create!
+        payment_method_token = "FUTURE_PAYMENT_#{rand(36**3).to_s(36)}"
+        result = Braintree::PaymentMethod.create(
+          :payment_method_nonce => Braintree::Test::Nonce::AbstractTransactable,
+          :customer_id => customer.id,
+          :token => payment_method_token
+        )
+        result.should be_success
+
+        payment_method = Braintree::PaymentMethod.find(payment_method_token)
+        payment_method.should_not be_nil
+        payment_method.token.should == payment_method_token
+        payment_method.image_url.should_not be_nil
+        payment_method.should be_a Braintree::UnknownPaymentMethod
+      end
+    end
+
     it "raises a NotFoundError exception if payment method cannot be found" do
       expect do
         Braintree::PaymentMethod.find("invalid-token")

data/spec/integration/braintree/transaction_spec.rb

@@ -122,190 +122,126 @@ describe Braintree::Transaction do
   end
 
   describe "self.create" do
-    describe "card type indicators" do
-      it "sets the prepaid field if the card is prepaid" do
-        result = Braintree::Transaction.create(
-          :type => "sale",
-          :amount => 1_00,
-          :credit_card => {
-            :number => Braintree::Test::CreditCardNumbers::CardTypeIndicators::Prepaid,
-            :expiration_date => "05/2009"
-          }
-        )
-        result.transaction.credit_card_details.prepaid.should == Braintree::CreditCard::Prepaid::Yes
-        result.transaction.payment_instrument_type.should == Braintree::PaymentInstrumentType::CreditCard
-      end
-    end
-
-    describe "industry data" do
-      it "accepts valid industry data" do
+    describe "risk data" do
+      it "returns decision and id" do
         result = Braintree::Transaction.create(
           :type => "sale",
           :amount => 1_00,
           :credit_card => {
             :number => Braintree::Test::CreditCardNumbers::CardTypeIndicators::Prepaid,
             :expiration_date => "05/2009"
-          },
-          :industry => {
-            :industry_type => Braintree::Transaction::IndustryType::Lodging,
-            :data => {
-              :folio_number => "ABCDEFG",
-              :check_in_date => "2014-06-01",
-              :check_out_date => "2014-06-30"
-            }
-          }
-        )
-        result.success?.should be_true
-      end
-
-      it "returns errors if validations on industry data fails" do
-        result = Braintree::Transaction.create(
-          :type => "sale",
-          :amount => 1_00,
-          :credit_card => {
-            :number => Braintree::Test::CreditCardNumbers::CardTypeIndicators::Prepaid,
-            :expiration_date => "05/2009"
-          },
-          :industry => {
-            :industry_type => Braintree::Transaction::IndustryType::Lodging,
-            :data => {
-              :folio_number => "foo bar",
-              :check_in_date => "2014-06-30",
-              :check_out_date => "2014-06-01"
-            }
           }
         )
-        result.success?.should be_false
-        result.errors.for(:transaction).for(:industry).map { |e| e.code }.sort.should == ["93403", "93406"]
+        result.transaction.risk_data.should be_a(Braintree::RiskData)
+        result.transaction.risk_data.should respond_to(:id)
+        result.transaction.risk_data.should respond_to(:decision)
       end
     end
 
-    describe "industry data" do
-      it "accepts valid industry data" do
-        result = Braintree::Transaction.create(
-          :type => "sale",
-          :amount => 1_00,
-          :credit_card => {
-            :number => Braintree::Test::CreditCardNumbers::CardTypeIndicators::Prepaid,
-            :expiration_date => "05/2009"
-          },
-          :industry => {
-            :industry_type => Braintree::Transaction::IndustryType::Lodging,
-            :data => {
-              :folio_number => "ABCDEFG",
-              :check_in_date => "2014-06-01",
-              :check_out_date => "2014-06-30"
-            }
-          }
-        )
-        result.success?.should be_true
-      end
-
-      it "returns errors if validations on industry data fails" do
+    describe "card type indicators" do
+      it "sets the prepaid field if the card is prepaid" do
         result = Braintree::Transaction.create(
           :type => "sale",
           :amount => 1_00,
           :credit_card => {
             :number => Braintree::Test::CreditCardNumbers::CardTypeIndicators::Prepaid,
             :expiration_date => "05/2009"
-          },
-          :industry => {
-            :industry_type => Braintree::Transaction::IndustryType::Lodging,
-            :data => {
-              :folio_number => "foo bar",
-              :check_in_date => "2014-06-30",
-              :check_out_date => "2014-06-01"
-            }
           }
         )
-        result.success?.should be_false
-        result.errors.for(:transaction).for(:industry).map { |e| e.code }.sort.should == ["93403", "93406"]
+        result.transaction.credit_card_details.prepaid.should == Braintree::CreditCard::Prepaid::Yes
+        result.transaction.payment_instrument_type.should == Braintree::PaymentInstrumentType::CreditCard
       end
     end
 
     describe "industry data" do
-      it "accepts valid industry data" do
-        result = Braintree::Transaction.create(
-          :type => "sale",
-          :amount => 1_00,
-          :credit_card => {
-            :number => Braintree::Test::CreditCardNumbers::CardTypeIndicators::Prepaid,
-            :expiration_date => "05/2009"
-          },
-          :industry => {
-            :industry_type => Braintree::Transaction::IndustryType::Lodging,
-            :data => {
-              :folio_number => "ABCDEFG",
-              :check_in_date => "2014-06-01",
-              :check_out_date => "2014-06-30"
+      context "for lodging" do
+        it "accepts valid industry data" do
+          result = Braintree::Transaction.create(
+            :type => "sale",
+            :amount => 1_00,
+            :credit_card => {
+              :number => Braintree::Test::CreditCardNumbers::CardTypeIndicators::Prepaid,
+              :expiration_date => "05/2009"
+            },
+            :industry => {
+              :industry_type => Braintree::Transaction::IndustryType::Lodging,
+              :data => {
+                :folio_number => "ABCDEFG",
+                :check_in_date => "2014-06-01",
+                :check_out_date => "2014-06-30",
+                :room_rate => "239.00",
+              }
             }
-          }
-        )
-        result.success?.should be_true
-      end
+          )
+          result.success?.should be_true
+        end
 
-      it "returns errors if validations on industry data fails" do
-        result = Braintree::Transaction.create(
-          :type => "sale",
-          :amount => 1_00,
-          :credit_card => {
-            :number => Braintree::Test::CreditCardNumbers::CardTypeIndicators::Prepaid,
-            :expiration_date => "05/2009"
-          },
-          :industry => {
-            :industry_type => Braintree::Transaction::IndustryType::Lodging,
-            :data => {
-              :folio_number => "foo bar",
-              :check_in_date => "2014-06-30",
-              :check_out_date => "2014-06-01"
+        it "returns errors if validations on industry lodging data fails" do
+          result = Braintree::Transaction.create(
+            :type => "sale",
+            :amount => 1_00,
+            :credit_card => {
+              :number => Braintree::Test::CreditCardNumbers::CardTypeIndicators::Prepaid,
+              :expiration_date => "05/2009"
+            },
+            :industry => {
+              :industry_type => Braintree::Transaction::IndustryType::Lodging,
+              :data => {
+                :folio_number => "foo bar",
+                :check_in_date => "2014-06-30",
+                :check_out_date => "2014-06-01",
+                :room_rate => "asdfasdf",
+              }
             }
-          }
-        )
-        result.success?.should be_false
-        result.errors.for(:transaction).for(:industry).map { |e| e.code }.sort.should == ["93403", "93406"]
+          )
+          result.success?.should be_false
+          invalid_folio = Braintree::ErrorCodes::Transaction::Industry::Lodging::FolioNumberIsInvalid
+          check_out_date_must_follow_check_in_date = Braintree::ErrorCodes::Transaction::Industry::Lodging::CheckOutDateMustFollowCheckInDate
+          result.errors.for(:transaction).for(:industry).map { |e| e.code }.sort.should == [invalid_folio, check_out_date_must_follow_check_in_date]
+        end
       end
-    end
 
-    describe "industry data" do
-      it "accepts valid industry data" do
-        result = Braintree::Transaction.create(
-          :type => "sale",
-          :amount => 1_00,
-          :credit_card => {
-            :number => Braintree::Test::CreditCardNumbers::CardTypeIndicators::Prepaid,
-            :expiration_date => "05/2009"
-          },
-          :industry => {
-            :industry_type => Braintree::Transaction::IndustryType::Lodging,
-            :data => {
-              :folio_number => "ABCDEFG",
-              :check_in_date => "2014-06-01",
-              :check_out_date => "2014-06-30"
+      context "for travel cruise" do
+        it "accepts valid industry data" do
+          result = Braintree::Transaction.create(
+            :type => "sale",
+            :amount => 1_00,
+            :credit_card => {
+              :number => Braintree::Test::CreditCardNumbers::CardTypeIndicators::Prepaid,
+              :expiration_date => "05/2009"
+            },
+            :industry => {
+              :industry_type => Braintree::Transaction::IndustryType::TravelAndCruise,
+              :data => {
+                :travel_package => "flight",
+                :departure_date => "2014-07-01",
+                :lodging_check_in_date => "2014-07-07",
+                :lodging_check_out_date => "2014-07-07",
+                :lodging_name => "Royal Caribbean",
+              }
             }
-          }
-        )
-        result.success?.should be_true
-      end
+          )
+          result.success?.should be_true
+        end
 
-      it "returns errors if validations on industry data fails" do
-        result = Braintree::Transaction.create(
-          :type => "sale",
-          :amount => 1_00,
-          :credit_card => {
-            :number => Braintree::Test::CreditCardNumbers::CardTypeIndicators::Prepaid,
-            :expiration_date => "05/2009"
-          },
-          :industry => {
-            :industry_type => Braintree::Transaction::IndustryType::Lodging,
-            :data => {
-              :folio_number => "foo bar",
-              :check_in_date => "2014-06-30",
-              :check_out_date => "2014-06-01"
+        it "returns errors if validations on industry data fails" do
+          result = Braintree::Transaction.create(
+            :type => "sale",
+            :amount => 1_00,
+            :credit_card => {
+              :number => Braintree::Test::CreditCardNumbers::CardTypeIndicators::Prepaid,
+              :expiration_date => "05/2009"
+            },
+            :industry => {
+              :industry_type => Braintree::Transaction::IndustryType::TravelAndCruise,
+              :data => {
+                :lodging_name => "Royal Caribbean"
+              }
             }
-          }
-        )
-        result.success?.should be_false
-        result.errors.for(:transaction).for(:industry).map { |e| e.code }.sort.should == ["93403", "93406"]
+          )
+          result.success?.should be_false
+          result.errors.for(:transaction).for(:industry).map { |e| e.code }.sort.should == [Braintree::ErrorCodes::Transaction::Industry::TravelCruise::TravelPackageIsInvalid]
+        end
       end
     end
 
@@ -1321,7 +1257,7 @@ describe Braintree::Transaction do
         result = Braintree::Transaction.create(
           :type => "sale",
           :amount => Braintree::Test::TransactionAmounts::Authorize,
-          :payment_method_nonce => "fake-apple-pay-visa-nonce"
+          :payment_method_nonce => Braintree::Test::Nonce::ApplePayVisa
         )
         result.success?.should == true
         result.transaction.should_not be_nil
@@ -1333,6 +1269,17 @@ describe Braintree::Transaction do
         apple_pay_details.cardholder_name.should_not be_nil
       end
 
+      it "can create a transaction with an unknown nonce" do
+        customer = Braintree::Customer.create!
+        result = Braintree::Transaction.create(
+          :type => "sale",
+          :amount => Braintree::Test::TransactionAmounts::Authorize,
+          :payment_method_nonce => Braintree::Test::Nonce::AbstractTransactable
+        )
+        result.success?.should == true
+        result.transaction.should_not be_nil
+      end
+
       it "can create a transaction with a payee email" do
         customer = Braintree::Customer.create!
         nonce = nonce_for_new_payment_method(