braintree 2.104.0 → 4.9.0

data/spec/unit/braintree/transaction_search_spec.rb

@@ -1,19 +1,19 @@
 require File.expand_path(File.dirname(__FILE__) + "/../spec_helper")
 
 describe Braintree::TransactionSearch do
-	it "overrides previous 'is' with new 'is' for the same field" do
-		search = Braintree::TransactionSearch.new
-		search.billing_company.is "one"
-		search.billing_company.is "two"
-		search.to_hash.should == {:billing_company => {:is => "two"}}
-	end
+  it "overrides previous 'is' with new 'is' for the same field" do
+    search = Braintree::TransactionSearch.new
+    search.billing_company.is "one"
+    search.billing_company.is "two"
+    search.to_hash.should == {:billing_company => {:is => "two"}}
+  end
 
-	it "overrides previous 'in' with new 'in' for the same field" do
-		search = Braintree::TransactionSearch.new
-		search.status.in Braintree::Transaction::Status::Authorized
-		search.status.in Braintree::Transaction::Status::SubmittedForSettlement
-		search.to_hash.should == {:status => [Braintree::Transaction::Status::SubmittedForSettlement]}
-	end
+  it "overrides previous 'in' with new 'in' for the same field" do
+    search = Braintree::TransactionSearch.new
+    search.status.in Braintree::Transaction::Status::Authorized
+    search.status.in Braintree::Transaction::Status::SubmittedForSettlement
+    search.to_hash.should == {:status => [Braintree::Transaction::Status::SubmittedForSettlement]}
+  end
 
   it "raises if the operator 'is' is left off" do
     search = Braintree::TransactionSearch.new

data/spec/unit/braintree/transaction_spec.rb

@@ -17,45 +17,38 @@ describe Braintree::Transaction do
     end
   end
 
-  describe "self.create_from_transparent_redirect" do
-    it "raises an exception if the query string is forged" do
-      expect do
-        Braintree::Transaction.create_from_transparent_redirect("http_status=200&forged=query_string")
-      end.to raise_error(Braintree::ForgedQueryString)
-    end
-  end
-
   describe "self.find" do
     it "raises error if passed empty string" do
       expect do
         Braintree::Transaction.find("")
-      end.to raise_error(ArgumentError)
+      end.to raise_error(ArgumentError, "id can not be empty")
     end
 
     it "raises error if passed empty string wth space" do
       expect do
         Braintree::Transaction.find(" ")
-      end.to raise_error(ArgumentError)
+      end.to raise_error(ArgumentError, "id can not be empty")
     end
 
     it "raises error if passed nil" do
       expect do
         Braintree::Transaction.find(nil)
-      end.to raise_error(ArgumentError)
+      end.to raise_error(ArgumentError, "id can not be empty")
     end
   end
 
-  describe "self.create_transaction_url" do
-    it "returns the url" do
-      config = Braintree::Configuration.instantiate
-      Braintree::Transaction.create_transaction_url.should == "http#{config.ssl? ? 's' : ''}://#{config.server}:#{config.port}/merchants/integration_merchant_id/transactions/all/create_via_transparent_redirect_request"
+  describe "self.submit_for_settlement" do
+    it "raises an ArgumentError if transaction_id is an invalid format" do
+      expect do
+        Braintree::Transaction.submit_for_settlement("invalid-transaction-id")
+      end.to raise_error(ArgumentError, "transaction_id is invalid")
     end
   end
 
-  describe "self.submit_for_settlement" do
+  describe "self.adjust_authorization" do
     it "raises an ArgumentError if transaction_id is an invalid format" do
       expect do
-        Braintree::Transaction.submit_for_settlement("invalid-transaction-id")
+        Braintree::Transaction.adjust_authorization("invalid-transaction-id", "10.00")
       end.to raise_error(ArgumentError, "transaction_id is invalid")
     end
   end
@@ -81,7 +74,7 @@ describe Braintree::Transaction do
           :website => "lednerllc.com",
           :phone => "1-999-652-4189 x56883",
           :fax => "012-161-8055"
-        }
+        },
       )
       transaction.customer_details.id.should == "123"
       transaction.customer_details.first_name.should == "Adam"
@@ -103,10 +96,10 @@ describe Braintree::Transaction do
           :settlement_currency_exchange_rate => "1",
           :funds_held => false,
           :success => true
-        }
+        },
       )
       disbursement = transaction.disbursement_details
-      disbursement.disbursement_date.should == "2013-04-03"
+      disbursement.disbursement_date.should == Date.parse("2013-04-03")
       disbursement.settlement_amount.should == "120.00"
       disbursement.settlement_currency_iso_code.should == "USD"
       disbursement.settlement_currency_exchange_rate.should == "1"
@@ -134,7 +127,7 @@ describe Braintree::Transaction do
           :product_id => "Unknown",
           :country_of_issuance => "Narnia",
           :issuing_bank => "Mr Tumnus"
-        }
+        },
       )
       transaction.credit_card_details.token.should == "mzg2"
       transaction.credit_card_details.bin.should == "411111"
@@ -162,7 +155,7 @@ describe Braintree::Transaction do
           :liability_shifted => true,
           :liability_shift_possible => true,
           :status => "authenticate_successful",
-        }
+        },
       )
 
       transaction.three_d_secure_info.enrolled.should == "Y"
@@ -171,33 +164,14 @@ describe Braintree::Transaction do
       transaction.three_d_secure_info.liability_shift_possible.should == true
     end
 
-    it "sets up ideal_payment_details" do
-      transaction = Braintree::Transaction._new(
-        :gateway,
-        :ideal_payment => {
-          :ideal_payment_id => "idealpayment_abc_123",
-          :ideal_transaction_id => "1150000008857321",
-          :masked_iban => "12************7890",
-          :bic => "RABONL2U",
-          :image_url => "http://www.example.com/ideal.png"
-        }
-      )
-
-      transaction.ideal_payment_details.ideal_payment_id.should == "idealpayment_abc_123"
-      transaction.ideal_payment_details.ideal_transaction_id.should == "1150000008857321"
-      transaction.ideal_payment_details.masked_iban.should == "12************7890"
-      transaction.ideal_payment_details.bic.should == "RABONL2U"
-      transaction.ideal_payment_details.image_url.should == "http://www.example.com/ideal.png"
-    end
-
     it "sets up history attributes in status_history" do
       time = Time.utc(2010,1,14)
       transaction = Braintree::Transaction._new(
         :gateway,
         :status_history => [
-          { :timestamp => time, :amount => "12.00", :transaction_source => "API",
-            :user => "larry", :status => Braintree::Transaction::Status::Authorized },
-          { :timestamp => Time.utc(2010,1,15), :amount => "12.00", :transaction_source => "API",
+          {:timestamp => time, :amount => "12.00", :transaction_source => "API",
+            :user => "larry", :status => Braintree::Transaction::Status::Authorized},
+          {:timestamp => Time.utc(2010,1,15), :amount => "12.00", :transaction_source => "API",
             :user => "curly", :status => "scheduled_for_settlement"}
         ])
       transaction.status_history.size.should == 2
@@ -214,8 +188,8 @@ describe Braintree::Transaction do
       transaction = Braintree::Transaction._new(
         :gateway,
         :authorization_adjustments => [
-          { :timestamp => timestamp, :processor_response_code => "1000", :processor_response_text => "Approved", :amount => "12.00", :success => true },
-          { :timestamp => timestamp, :processor_response_code => "3000", :processor_response_text => "Processor Network Unavailable - Try Again", :amount => "12.34", :success => false },
+          {:timestamp => timestamp, :processor_response_code => "1000", :processor_response_text => "Approved", :amount => "12.00", :success => true},
+          {:timestamp => timestamp, :processor_response_code => "3000", :processor_response_text => "Processor Network Unavailable - Try Again", :amount => "12.34", :success => false},
         ])
       transaction.authorization_adjustments.size.should == 2
       transaction.authorization_adjustments[0].amount.should == "12.00"
@@ -233,7 +207,7 @@ describe Braintree::Transaction do
     it "handles receiving custom as an empty string" do
       transaction = Braintree::Transaction._new(
         :gateway,
-        :custom => "\n    "
+        :custom => "\n    ",
       )
     end
 
@@ -251,7 +225,7 @@ describe Braintree::Transaction do
     it "handles nil risk_data" do
       transaction = Braintree::Transaction._new(
         :gateway,
-        :risk_data => nil
+        :risk_data => nil,
       )
       transaction.risk_data.should be_nil
     end
@@ -259,11 +233,19 @@ describe Braintree::Transaction do
     it "accepts network_transaction_id" do
       transaction = Braintree::Transaction._new(
         :gateway,
-        :network_transaction_id => "123456789012345"
+        :network_transaction_id => "123456789012345",
       )
       transaction.network_transaction_id.should == "123456789012345"
     end
 
+    it "accepts ach_return_code" do
+      transaction = Braintree::Transaction._new(
+        :gateway,
+        :ach_return_code => "R01",
+      )
+      expect(transaction.ach_return_code).to eq("R01")
+    end
+
     it "accepts network_response code and network_response_text" do
       transaction = Braintree::Transaction._new(
         :gateway,
@@ -341,8 +323,8 @@ describe Braintree::Transaction do
   end
 
   describe "sale" do
-    let(:mock_response) { {:transaction => {}}}
-    let(:http_stub) { double('http_stub').as_null_object }
+    let(:mock_response) { {:transaction => {}} }
+    let(:http_stub) { double("http_stub").as_null_object }
 
     RSpec::Matchers.define :skip_advanced_fraud_check_value_is do |value|
         match { |params| params[:transaction][:options][:skip_advanced_fraud_checking] == value }
@@ -360,7 +342,7 @@ describe Braintree::Transaction do
         },
         :options => {
           :skip_advanced_fraud_checking => true
-        }
+        },
       )
     end
 
@@ -376,7 +358,7 @@ describe Braintree::Transaction do
         },
         :options => {
           :skip_advanced_fraud_checking => false
-        }
+        },
       )
     end
 
@@ -392,7 +374,7 @@ describe Braintree::Transaction do
         },
         :options => {
           :submit_for_settlement => false
-        }
+        },
       )
     end
   end

data/spec/unit/braintree/util_spec.rb

@@ -11,12 +11,12 @@ describe Braintree::Util do
     end
 
     it "symbolizes nested keys" do
-      hash = {"a" => {"b" => {"c" => "d" }}}
+      hash = {"a" => {"b" => {"c" => "d"}}}
       Braintree::Util.symbolize_keys(hash).should == {:a => {:b => {:c => "d"}}}
     end
 
     it "symbolizes nested keys in arrays" do
-      hash = {"a" => ["b" => {"c" => "d" }]}
+      hash = {"a" => ["b" => {"c" => "d"}]}
       Braintree::Util.symbolize_keys(hash).should == {:a => [:b => {:c => "d"}]}
     end
   end
@@ -44,7 +44,7 @@ describe Braintree::Util do
             :nested_allowed => "ok",
             :nested_allowed2 => "also ok",
             :nested_invalid => "bad"
-          }
+          },
         )
       end.to raise_error(ArgumentError, "invalid keys: nested[nested_invalid], top_level_invalid")
     end
@@ -57,7 +57,7 @@ describe Braintree::Util do
           :custom_fields => {
             :custom_allowed => "ok",
             :custom_allowed2 => "also ok",
-          }
+          },
         )
       end.to_not raise_error
     end
@@ -70,7 +70,7 @@ describe Braintree::Util do
             :custom_fields => {
               :bad_nesting => "very bad"
             }
-          }
+          },
         )
       end.to raise_error(ArgumentError, "invalid keys: allowed[custom_fields][bad_nesting]")
     end
@@ -89,7 +89,7 @@ describe Braintree::Util do
               :super_deep_allowed => "yep",
               :real_deep_invalid => "nope"
             }
-          }
+          },
         )
       end.to raise_error(ArgumentError, "invalid keys: nested[deeply_allowed][real_deep_invalid], nested[nested_invalid], top_level_invalid")
     end
@@ -101,7 +101,7 @@ describe Braintree::Util do
           :add_ons => {
             :update => [{:amount => 10}],
             :add => [{:amount => 5}]
-          }
+          },
         )
       end.to_not raise_error
     end
@@ -113,7 +113,7 @@ describe Braintree::Util do
           :add_ons => {
             :update => [{:foo => 10}],
             :add => [{:bar => 5}]
-          }
+          },
         )
       end.to raise_error(ArgumentError, /invalid keys: add_ons\[add\]\[bar\], add_ons\[update\]\[foo\]/)
     end
@@ -127,7 +127,7 @@ describe Braintree::Util do
         :custom_fields => {
           :custom_allowed => "ok",
           :custom_allowed2 => "also ok",
-        }
+        },
       )
       expect(response).to eq(true)
     end
@@ -147,7 +147,7 @@ describe Braintree::Util do
         :add_ons => {
           :update => [{:foo => 10}],
           :add => [{:bar => 5}]
-        }
+        },
       )
       expect(response).to eq(false)
     end
@@ -165,12 +165,28 @@ describe Braintree::Util do
             :super_deep_allowed => "yep",
             :real_deep_invalid => "nope"
           }
-        }
+        },
       )
       expect(response).to eq(false)
     end
   end
 
+  describe "self.replace_key" do
+    it "replaces the target key with the replacement key" do
+      Braintree::Util.replace_key(
+        {:a => {:b => "some value"}},
+        :b,
+        :c).should == {:a => {:c => "some value"}}
+    end
+
+    it "returns hash with all of the original keys if the target key does not exist" do
+      Braintree::Util.replace_key(
+        {:some_key => "some value"},
+        :not_found,
+        :new_key).should == {:some_key => "some value"}
+    end
+  end
+
   describe "self._flatten_hash_keys" do
     it "flattens hash keys" do
       Braintree::Util._flatten_hash_keys(:nested => {
@@ -184,13 +200,13 @@ describe Braintree::Util do
   describe "self._flatten_valid_keys" do
     it "flattens hash keys" do
       Braintree::Util._flatten_valid_keys(
-        [:top_level, {:nested => [:nested_allowed, :nested_allowed2]}]
+        [:top_level, {:nested => [:nested_allowed, :nested_allowed2]}],
       ).should == ["nested[nested_allowed2]", "nested[nested_allowed]", "top_level"]
     end
 
     it "allows wildcards with the :_any_key_ symbol" do
       Braintree::Util._flatten_valid_keys(
-        [:top_level, {:nested => :_any_key_}]
+        [:top_level, {:nested => :_any_key_}],
       ).should == ["nested[_any_key_]", "top_level"]
     end
   end
@@ -220,11 +236,11 @@ describe Braintree::Util do
       result.should == []
     end
 
-		it "raises an UnexpectedError if nil data is provided" do
-			expect do
-				Braintree::Util.extract_attribute_as_array(nil, :abc)
-			end.to raise_error(Braintree::UnexpectedError, /Unprocessable entity due to an invalid request/)
-		end
+    it "raises an UnexpectedError if nil data is provided" do
+      expect do
+        Braintree::Util.extract_attribute_as_array(nil, :abc)
+      end.to raise_error(Braintree::UnexpectedError, /Unprocessable entity due to an invalid request/)
+    end
   end
 
   describe "self.hash_to_query_string" do
@@ -259,7 +275,7 @@ describe Braintree::Util do
       "UNSUPPORTED_CLIENT" => Braintree::UpgradeRequiredError,
       "RESOURCE_LIMIT" => Braintree::TooManyRequestsError,
       "INTERNAL" => Braintree::ServerError,
-      "SERVICE_AVAILABILITY" => Braintree::DownForMaintenanceError,
+      "SERVICE_AVAILABILITY" => Braintree::ServiceUnavailableError,
     }
 
     errors.each do |graphQLError, exception|
@@ -321,6 +337,18 @@ describe Braintree::Util do
       end.to raise_error(Braintree::AuthorizationError)
     end
 
+    it "raises a NotFoundError if resource is not found" do
+      expect do
+        Braintree::Util.raise_exception_for_status_code(404)
+      end.to raise_error(Braintree::NotFoundError)
+    end
+
+    it "raises a RequestTimeoutError if the request times out" do
+      expect do
+        Braintree::Util.raise_exception_for_status_code(408)
+      end.to raise_error(Braintree::RequestTimeoutError)
+    end
+
     it "raises an UpgradeRequired if the client library is EOL'd" do
       expect do
         Braintree::Util.raise_exception_for_status_code(426)
@@ -339,10 +367,16 @@ describe Braintree::Util do
       end.to raise_error(Braintree::ServerError)
     end
 
-    it "raises a DownForMaintenanceError if the server is down for maintenance" do
+    it "raises a ServiceUnavailableError if the server is unavailable" do
       expect do
         Braintree::Util.raise_exception_for_status_code(503)
-      end.to raise_error(Braintree::DownForMaintenanceError)
+      end.to raise_error(Braintree::ServiceUnavailableError)
+    end
+
+    it "raises a GatewayTimeoutError if the gateway times out" do
+      expect do
+        Braintree::Util.raise_exception_for_status_code(504)
+      end.to raise_error(Braintree::GatewayTimeoutError)
     end
 
     it "raises an UnexpectedError if some other code is returned" do

data/spec/unit/braintree/validation_error_collection_spec.rb

@@ -5,7 +5,7 @@ describe Braintree::ValidationErrorCollection do
   context "blue response" do
     describe "initialize" do
       it "builds an error object given an array of hashes" do
-        hash = {:errors => [{ :attribute => "some model attribute", :code => 1, :message => "bad juju" }]}
+        hash = {:errors => [{:attribute => "some model attribute", :code => 1, :message => "bad juju"}]}
         collection = Braintree::ValidationErrorCollection.new(hash)
         error = collection[0]
         error.attribute.should == "some model attribute"
@@ -17,9 +17,9 @@ describe Braintree::ValidationErrorCollection do
     describe "for" do
       it "provides access to nested errors" do
         hash = {
-          :errors => [{ :attribute => "some model attribute", :code => 1, :message => "bad juju" }],
+          :errors => [{:attribute => "some model attribute", :code => 1, :message => "bad juju"}],
           :nested => {
-            :errors => [{ :attribute => "number", :code => 2, :message => "badder juju"}]
+            :errors => [{:attribute => "number", :code => 2, :message => "badder juju"}]
           }
         }
         errors = Braintree::ValidationErrorCollection.new(hash)
@@ -45,7 +45,7 @@ describe Braintree::ValidationErrorCollection do
           ],
           :level1 => {
             :errors => [{:attribute => "name", :code => "code2", :message => "message2"}]
-          }
+          },
         )
         errors.inspect.should == "#<Braintree::ValidationErrorCollection errors:[(code1) message1], level1:[(code2) message2]>"
       end
@@ -60,7 +60,7 @@ describe Braintree::ValidationErrorCollection do
             :level2 => {
               :errors => [{:attribute => "name", :code => "code3", :message => "message3"}],
             }
-          }
+          },
         )
         errors.inspect.should == "#<Braintree::ValidationErrorCollection errors:[(code1) message1], level1:[(code2) message2], level1/level2:[(code3) message3]>"
       end
@@ -74,12 +74,12 @@ describe Braintree::ValidationErrorCollection do
           {:attribute => "not name", :code => 3, :message => "is invalid"}
         ])
         errors.on("name").size.should == 2
-        errors.on("name").map{ |e| e.code }.should == [1, 2]
+        errors.on("name").map { |e| e.code }.should == [1, 2]
       end
 
       it "has indifferent access" do
         errors = Braintree::ValidationErrorCollection.new(:errors => [
-          { :attribute => "name", :code => 3, :message => "is too long" },
+          {:attribute => "name", :code => 3, :message => "is too long"},
         ])
         errors.on(:name).size.should == 1
         errors.on(:name)[0].code.should == 3
@@ -99,10 +99,10 @@ describe Braintree::ValidationErrorCollection do
 
       it "returns the size of nested errors as well" do
         errors = Braintree::ValidationErrorCollection.new(
-          :errors => [{ :attribute => "some model attribute", :code => 1, :message => "bad juju" }],
+          :errors => [{:attribute => "some model attribute", :code => 1, :message => "bad juju"}],
           :nested => {
-            :errors => [{ :attribute => "number", :code => 2, :message => "badder juju"}]
-          }
+            :errors => [{:attribute => "number", :code => 2, :message => "badder juju"}]
+          },
         )
         errors.deep_size.should == 2
       end
@@ -110,17 +110,17 @@ describe Braintree::ValidationErrorCollection do
       it "returns the size of multiple nestings of errors" do
         errors = Braintree::ValidationErrorCollection.new(
           :errors => [
-            { :attribute => "one", :code => 1, :message => "bad juju" },
-            { :attribute => "two", :code => 1, :message => "bad juju" }],
+            {:attribute => "one", :code => 1, :message => "bad juju"},
+            {:attribute => "two", :code => 1, :message => "bad juju"}],
           :nested => {
-            :errors => [{ :attribute => "three", :code => 2, :message => "badder juju"}],
+            :errors => [{:attribute => "three", :code => 2, :message => "badder juju"}],
             :nested_again => {
-              :errors => [{ :attribute => "four", :code => 2, :message => "badder juju"}]
+              :errors => [{:attribute => "four", :code => 2, :message => "badder juju"}]
             }
           },
           :same_level => {
-            :errors => [{ :attribute => "five", :code => 2, :message => "badder juju"}],
-          }
+            :errors => [{:attribute => "five", :code => 2, :message => "badder juju"}],
+          },
         )
         errors.deep_size.should == 5
       end
@@ -130,17 +130,17 @@ describe Braintree::ValidationErrorCollection do
       it "returns errors from all levels" do
         errors = Braintree::ValidationErrorCollection.new(
           :errors => [
-            { :attribute => "one", :code => 1, :message => "bad juju" },
-            { :attribute => "two", :code => 2, :message => "bad juju" }],
+            {:attribute => "one", :code => 1, :message => "bad juju"},
+            {:attribute => "two", :code => 2, :message => "bad juju"}],
           :nested => {
-            :errors => [{ :attribute => "three", :code => 3, :message => "badder juju"}],
+            :errors => [{:attribute => "three", :code => 3, :message => "badder juju"}],
             :nested_again => {
-              :errors => [{ :attribute => "four", :code => 4, :message => "badder juju"}]
+              :errors => [{:attribute => "four", :code => 4, :message => "badder juju"}]
             }
           },
           :same_level => {
-            :errors => [{ :attribute => "five", :code => 5, :message => "badder juju"}],
-          }
+            :errors => [{:attribute => "five", :code => 5, :message => "badder juju"}],
+          },
         )
         errors.deep_errors.map { |e| e.code }.sort.should == [1, 2, 3, 4, 5]
       end
@@ -150,27 +150,27 @@ describe Braintree::ValidationErrorCollection do
       it "returns errors on one level" do
         errors = Braintree::ValidationErrorCollection.new(
           :errors => [
-            { :attribute => "one", :code => 1, :message => "bad juju" },
-            { :attribute => "two", :code => 2, :message => "bad juju" }],
+            {:attribute => "one", :code => 1, :message => "bad juju"},
+            {:attribute => "two", :code => 2, :message => "bad juju"}],
           :nested => {
-            :errors => [{ :attribute => "three", :code => 3, :message => "badder juju"}],
+            :errors => [{:attribute => "three", :code => 3, :message => "badder juju"}],
             :nested_again => {
-              :errors => [{ :attribute => "four", :code => 4, :message => "badder juju"}]
+              :errors => [{:attribute => "four", :code => 4, :message => "badder juju"}]
             }
-          }
+          },
         )
-        errors.shallow_errors.map {|e| e.code}.should == [1, 2]
-        errors.for(:nested).shallow_errors.map {|e| e.code}.should == [3]
+        errors.shallow_errors.map { |e| e.code }.should == [1, 2]
+        errors.for(:nested).shallow_errors.map { |e| e.code }.should == [3]
       end
 
       it "returns an clone of the real array" do
         errors = Braintree::ValidationErrorCollection.new(
           :errors => [
-            { :attribute => "one", :code => 1, :message => "bad juju" },
-            { :attribute => "two", :code => 2, :message => "bad juju" }]
+            {:attribute => "one", :code => 1, :message => "bad juju"},
+            {:attribute => "two", :code => 2, :message => "bad juju"}],
         )
         errors.shallow_errors.pop
-        errors.shallow_errors.map {|e| e.code}.should == [1, 2]
+        errors.shallow_errors.map { |e| e.code }.should == [1, 2]
       end
     end
   end
@@ -368,10 +368,10 @@ describe Braintree::ValidationErrorCollection do
           }
         }
         errors = Braintree::ValidationErrorCollection.new(hash)
-        errors.shallow_errors.map {|e| e.code}.should == [1]
-        errors.for(:nested).shallow_errors.map {|e| e.code}.should == [2,3]
-        errors.for(:nested).for(:deeply_nested).shallow_errors.map {|e| e.code}.should == [4]
-        errors.for(:nested_again).shallow_errors.map {|e| e.code}.should == [5]
+        errors.shallow_errors.map { |e| e.code }.should == [1]
+        errors.for(:nested).shallow_errors.map { |e| e.code }.should == [2,3]
+        errors.for(:nested).for(:deeply_nested).shallow_errors.map { |e| e.code }.should == [4]
+        errors.for(:nested_again).shallow_errors.map { |e| e.code }.should == [5]
       end
     end
   end

data/spec/unit/braintree/venmo_profile_data_spec.rb

@@ -0,0 +1,32 @@
+require File.expand_path(File.dirname(__FILE__) + "/../spec_helper")
+
+describe Braintree::VenmoProfileData do
+  describe "self.new" do
+    it "is protected" do
+      expect do
+        Braintree::VenmoProfileData.new
+      end.to raise_error(NoMethodError, /protected method .new/)
+    end
+  end
+
+  describe "self._new" do
+    it "initializes the object with the appropriate attributes set" do
+
+      params = {
+        username: "a-username",
+        first_name: "a-first-name",
+        last_name: "a-last-name",
+        phone_number: "12312312343",
+        email: "a-email",
+      }
+
+      payment_method_customer_data_updated = Braintree::VenmoProfileData._new(params)
+
+      payment_method_customer_data_updated.username.should eq("a-username")
+      payment_method_customer_data_updated.first_name.should eq("a-first-name")
+      payment_method_customer_data_updated.last_name.should eq("a-last-name")
+      payment_method_customer_data_updated.phone_number.should eq("12312312343")
+      payment_method_customer_data_updated.email.should eq("a-email")
+    end
+  end
+end