braintree 1.0.0

data/lib/braintree/xml/libxml.rb

@@ -0,0 +1,69 @@
+# Portions of this code were copied and modified from Ruby on Rails, released
+# under the MIT license, copyright (c) 2005-2009 David Heinemeier Hansson
+module Braintree
+  module Xml
+    module Libxml # :nodoc:
+      LIB_XML_LIMIT = 30000000
+
+      def self.parse(xml_string)
+        old_keep_blanks_setting = ::LibXML::XML.default_keep_blanks
+        ::LibXML::XML.default_keep_blanks = false
+        root_node = LibXML::XML::Parser.string(xml_string.strip).parse.root
+        _node_to_hash(root_node)
+      ensure
+        ::LibXML::XML.default_keep_blanks = old_keep_blanks_setting
+      end
+      
+      def self._node_to_hash(node, hash = {})
+        if node.text?
+          raise ::LibXML::XML::Error if node.content.length >= LIB_XML_LIMIT
+          hash[CONTENT_ROOT] = node.content
+        else
+          sub_hash = _build_sub_hash(hash, node.name)
+          _attributes_to_hash(node, sub_hash)
+          if _array?(node)
+            _children_array_to_hash(node, sub_hash)
+          else
+            _children_to_hash(node, sub_hash)
+          end
+        end
+        hash
+      end
+
+      def self._build_sub_hash(hash, name)
+        sub_hash = {}
+        if hash[name]
+          if !hash[name].kind_of? Array
+            hash[name] = [hash[name]]
+          end
+          hash[name] << sub_hash
+        else
+          hash[name] = sub_hash
+        end
+        sub_hash
+      end
+
+      def self._children_to_hash(node, hash={})
+        node.each { |child| _node_to_hash(child, hash) }
+        _attributes_to_hash(node, hash)
+        hash
+      end
+
+      def self._attributes_to_hash(node, hash={})
+        node.each_attr { |attr| hash[attr.name] = attr.value }
+        hash
+      end
+
+      def self._children_array_to_hash(node, hash={})
+        hash[node.child.name] = node.map do |child|
+          _children_to_hash(child, {})
+        end
+        hash
+      end
+
+      def self._array?(node)
+        node.child? && node.child.next? && node.child.name == node.child.next.name
+      end
+    end
+  end
+end

data/lib/braintree/xml/parser.rb

@@ -0,0 +1,93 @@
+# Portions of this code were copied and modified from Ruby on Rails, released
+# under the MIT license, copyright (c) 2005-2009 David Heinemeier Hansson
+module Braintree
+  module Xml
+    CONTENT_ROOT = '__content__'
+
+    module Parser # :nodoc:
+      XML_PARSING = {
+        "datetime" => Proc.new { |time| ::Time.parse(time).utc },
+        "integer"  => Proc.new { |integer| integer.to_i },
+        "boolean"  => Proc.new { |boolean| %w(1 true).include?(boolean.strip) },
+      }
+
+      def self.hash_from_xml(xml)
+        standardized_hash_structure = ::Braintree::Xml::Libxml.parse(xml)
+        with_underscores_in_keys = _unrename_keys(standardized_hash_structure)
+        typecasted_xml = _typecast_xml_value(with_underscores_in_keys)
+        Util.symbolize_keys(typecasted_xml)
+      end
+
+      def self._typecast_xml_value(value)
+        case value.class.to_s
+          when 'Hash'
+            if value['type'] == 'array'
+              child_key, entries = value.detect { |k,v| k != 'type' }   # child_key is throwaway
+              if entries.nil? || (c = value[CONTENT_ROOT] && c.blank?)
+                []
+              else
+                case entries.class.to_s   # something weird with classes not matching here.  maybe singleton methods breaking is_a?
+                when "Array"
+                  entries.collect { |v| _typecast_xml_value(v) }
+                when "Hash"
+                  [_typecast_xml_value(entries)]
+                else
+                  raise "can't typecast #{entries.inspect}"
+                end
+              end
+            elsif value.has_key?(CONTENT_ROOT)
+              content = value[CONTENT_ROOT]
+              if parser = XML_PARSING[value["type"]]
+                XML_PARSING[value["type"]].call(content)
+              else
+                content
+              end
+            elsif value['type'] == 'string' && value['nil'] != 'true'
+              ""
+            elsif value == {}
+              ""
+            elsif value.nil? || value['nil'] == 'true'
+              nil
+            # If the type is the only element which makes it then 
+            # this still makes the value nil, except if type is
+            # a XML node(where type['value'] is a Hash)
+            elsif value['type'] && value.size == 1 && !value['type'].is_a?(::Hash)
+              raise "is this needed?"
+              nil
+            else
+              xml_value = value.inject({}) do |h,(k,v)|
+                h[k] = _typecast_xml_value(v)
+                h
+              end
+              xml_value
+            end
+          when 'Array'
+            value.map! { |i| _typecast_xml_value(i) }
+            case value.length
+              when 0 then nil
+              when 1 then value.first
+              else value
+            end
+          when 'String'
+            value
+          else
+            raise "can't typecast #{value.class.name} - #{value.inspect}"
+        end
+      end
+
+      def self._unrename_keys(params)
+        case params.class.to_s
+          when "Hash"
+            params.inject({}) do |h,(k,v)|
+              h[k.to_s.tr("-", "_")] = _unrename_keys(v)
+              h
+            end
+          when "Array"
+            params.map { |v| _unrename_keys(v) }
+          else
+            params
+        end
+      end
+    end
+  end
+end

data/lib/ssl/securetrust_ca.crt

@@ -0,0 +1,44 @@
+-----BEGIN CERTIFICATE-----
+MIIDuDCCAqCgAwIBAgIQDPCOXAgWpa1Cf/DrJxhZ0DANBgkqhkiG9w0BAQUFADBI
+MQswCQYDVQQGEwJVUzEgMB4GA1UEChMXU2VjdXJlVHJ1c3QgQ29ycG9yYXRpb24x
+FzAVBgNVBAMTDlNlY3VyZVRydXN0IENBMB4XDTA2MTEwNzE5MzExOFoXDTI5MTIz
+MTE5NDA1NVowSDELMAkGA1UEBhMCVVMxIDAeBgNVBAoTF1NlY3VyZVRydXN0IENv
+cnBvcmF0aW9uMRcwFQYDVQQDEw5TZWN1cmVUcnVzdCBDQTCCASIwDQYJKoZIhvcN
+AQEBBQADggEPADCCAQoCggEBAKukgeWVzfX2FI7CT8rU4niVWJxB4Q2ZQCQXOZEz
+Zum+4YOvYlyJ0fwkW2Gz4BERQRwdbvC4u/jep4G6pkjGnx29vo6pQT64lO0pGtSO
+0gMdA+9tDWccV9cGrcrI9f4Or2YlSASWC12juhbDCE/RRvgUXPLIXgGZbf2IzIao
+wW8xQmxSPmjL8xk037uHGFaAJsTQ3MBv396gwpEWoGQRS0S8Hvbn+mPeZqx2pHGj
+7DaUaHp3pLHnDi+BeuK1cobvomuL8A/b01k/unK8RCSc43Oz969XL0Imnal0ugBS
+8kvNU3xHCzaFDmapCJcWNFfBZveA4+1wVMeT4C4oFVmHursCAwEAAaOBnTCBmjAT
+BgkrBgEEAYI3FAIEBh4EAEMAQTALBgNVHQ8EBAMCAYYwDwYDVR0TAQH/BAUwAwEB
+/zAdBgNVHQ4EFgQUQjK2FvoE/f5dS3rD/fdMQB1aQ68wNAYDVR0fBC0wKzApoCeg
+JYYjaHR0cDovL2NybC5zZWN1cmV0cnVzdC5jb20vU1RDQS5jcmwwEAYJKwYBBAGC
+NxUBBAMCAQAwDQYJKoZIhvcNAQEFBQADggEBADDtT0rhWDpSclu1pqNlGKa7UTt3
+6Z3q059c4EVlew3KW+JwULKUBRSuSceNQQcSc5R+DCMh/bwQf2AQWnL1mA6s7Ll/
+3XpvXdMc9P+IBWlCqQVxyLesJugutIxq/3HcuLHfmbx8IVQr5Fiiu1cprp6poxkm
+D5kuCLDv/WnPmRoJjeOnnyvJNjR7JLN4TJUXpAYmHrZkUjZfYGfZnMUFdAvnZyPS
+CPyI6a6Lf+Ew9Dd+/cYy2i2eRDAwbO4H3tI0/NL/QPZL9GZGBlSm8jIKYyYwa5vR
+3ItHuuG51WLQoqD0ZwV4KWMabwTW+MZMo5qxN7SN5ShLHZ4swrhovO0C7jE=
+-----END CERTIFICATE-----
+-----BEGIN CERTIFICATE-----
+MIIDvDCCAqSgAwIBAgIQB1YipOjUiolN9BPI8PjqpTANBgkqhkiG9w0BAQUFADBK
+MQswCQYDVQQGEwJVUzEgMB4GA1UEChMXU2VjdXJlVHJ1c3QgQ29ycG9yYXRpb24x
+GTAXBgNVBAMTEFNlY3VyZSBHbG9iYWwgQ0EwHhcNMDYxMTA3MTk0MjI4WhcNMjkx
+MjMxMTk1MjA2WjBKMQswCQYDVQQGEwJVUzEgMB4GA1UEChMXU2VjdXJlVHJ1c3Qg
+Q29ycG9yYXRpb24xGTAXBgNVBAMTEFNlY3VyZSBHbG9iYWwgQ0EwggEiMA0GCSqG
+SIb3DQEBAQUAA4IBDwAwggEKAoIBAQCvNS7YrGxVaQZx5RNoJLNP2MwhR/jxYDiJ
+iQPpvepeRlMJ3Fz1Wuj3RSoC6zFh1ykzTM7HfAo3fg+6MpjhHZevj8fcyTiW89sa
+/FHtaMbQbqR8JNGuQsiWUGMu4P51/pinX0kuleM5M2SOHqRfkNJnPLLZ/kG5VacJ
+jnIFHovdRIWCQtBJwB1g8NEXLJXr9qXBkqPFwqcIYA1gBBCWeZ4WNOaptvolRTnI
+HmX5k/Wq8VLcmZg9pYYaDDUz+kulBAYVHDGA76oYa8J719rO+TMg1fW9ajMtgQT7
+sFzUnKPiXB3jqUJ1XnvUd+85VLrJChgbEplJL4hL/VBi0XPnj3pDAgMBAAGjgZ0w
+gZowEwYJKwYBBAGCNxQCBAYeBABDAEEwCwYDVR0PBAQDAgGGMA8GA1UdEwEB/wQF
+MAMBAf8wHQYDVR0OBBYEFK9EBMJBfkiD2045AuzshHrmzsmkMDQGA1UdHwQtMCsw
+KaAnoCWGI2h0dHA6Ly9jcmwuc2VjdXJldHJ1c3QuY29tL1NHQ0EuY3JsMBAGCSsG
+AQQBgjcVAQQDAgEAMA0GCSqGSIb3DQEBBQUAA4IBAQBjGghAfaReUw132HquHw0L
+URYD7xh8yOOvaliTFGCRsoTciE6+OYo68+aCiV0BN7OrJKQVDpI1WkpEXk5X+nXO
+H0jOZvQ8QCaSmGwb7iRGDBezUqXbpZGRzzfTb+cnCDpOGR86p1hcF895P4vkp9Mm
+I50mD1hp/Ed+stCNi5O/KU9DaXR2Z0vPB4zmAve14bRDtUstFJ/53CYNv6ZHdAbY
+iNE6KTCEztI5gGIbqMdXSbxqVVFnFUq+NQfk1XWYN3kwFNspnWzFacxHVaIw98xc
+f8LDmBxrThaA63p4ZUWiABqvDA1VZDRIuJK58bRQKfJPIx/abKwfROHdI3hRW8cW
+-----END CERTIFICATE-----

data/lib/ssl/valicert_ca.crt

@@ -0,0 +1,18 @@
+-----BEGIN CERTIFICATE-----
+MIIC5zCCAlACAQEwDQYJKoZIhvcNAQEFBQAwgbsxJDAiBgNVBAcTG1ZhbGlDZXJ0
+IFZhbGlkYXRpb24gTmV0d29yazEXMBUGA1UEChMOVmFsaUNlcnQsIEluYy4xNTAz
+BgNVBAsTLFZhbGlDZXJ0IENsYXNzIDIgUG9saWN5IFZhbGlkYXRpb24gQXV0aG9y
+aXR5MSEwHwYDVQQDExhodHRwOi8vd3d3LnZhbGljZXJ0LmNvbS8xIDAeBgkqhkiG
+9w0BCQEWEWluZm9AdmFsaWNlcnQuY29tMB4XDTk5MDYyNjAwMTk1NFoXDTE5MDYy
+NjAwMTk1NFowgbsxJDAiBgNVBAcTG1ZhbGlDZXJ0IFZhbGlkYXRpb24gTmV0d29y
+azEXMBUGA1UEChMOVmFsaUNlcnQsIEluYy4xNTAzBgNVBAsTLFZhbGlDZXJ0IENs
+YXNzIDIgUG9saWN5IFZhbGlkYXRpb24gQXV0aG9yaXR5MSEwHwYDVQQDExhodHRw
+Oi8vd3d3LnZhbGljZXJ0LmNvbS8xIDAeBgkqhkiG9w0BCQEWEWluZm9AdmFsaWNl
+cnQuY29tMIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQDOOnHK5avIWZJV16vY
+dA757tn2VUdZZUcOBVXc65g2PFxTXdMwzzjsvUGJ7SVCCSRrCl6zfN1SLUzm1NZ9
+WlmpZdRJEy0kTRxQb7XBhVQ7/nHk01xC+YDgkRoKWzk2Z/M/VXwbP7RfZHM047QS
+v4dk+NoS/zcnwbNDu+97bi5p9wIDAQABMA0GCSqGSIb3DQEBBQUAA4GBADt/UG9v
+UJSZSWI4OB9L+KXIPqeCgfYrx+jFzug6EILLGACOTb2oWH+heQC1u+mNr0HZDzTu
+IYEZoDJJKPTEjlbVUjP9UNV+mWwD5MlM/Mtsq2azSiGM5bUMMj4QssxsodyamEwC
+W/POuZ6lcg5Ktz885hZo+L7tdEy8W9ViH0Pd
+-----END CERTIFICATE-----

data/spec/integration/braintree/address_spec.rb

@@ -0,0 +1,352 @@
+require File.dirname(__FILE__) + "/../spec_helper"
+
+describe Braintree::Address do
+  describe "self.create" do
+    it "returns a successful result if valid" do
+      customer = Braintree::Customer.create!(:last_name => "Wilson")
+      result = Braintree::Address.create(
+        :customer_id => customer.id,
+        :first_name => "Ben",
+        :last_name => "Moore",
+        :company => "Moore Co.",
+        :street_address => "1811 E Main St",
+        :extended_address => "Suite 200",
+        :locality => "Chicago",
+        :region => "Illinois",
+        :postal_code => "60622",
+        :country_name => "United States of America"
+      )
+      result.success?.should == true
+      result.address.customer_id.should == customer.id
+      result.address.first_name.should == "Ben"
+      result.address.last_name.should == "Moore"
+      result.address.company.should == "Moore Co."
+      result.address.street_address.should == "1811 E Main St"
+      result.address.extended_address.should == "Suite 200"
+      result.address.locality.should == "Chicago"
+      result.address.region.should == "Illinois"
+      result.address.postal_code.should == "60622"
+      result.address.country_name.should == "United States of America"
+    end
+    
+    it "returns an error response if invalid" do
+      customer = Braintree::Customer.create!(:last_name => "Wilson")
+      result = Braintree::Address.create(
+        :customer_id => customer.id,
+        :country_name => "United States of Invalid"
+      )
+      result.success?.should == false
+      result.errors.for(:address).on(:country_name)[0].message.should == "Country name is not an accepted country."
+    end
+
+    it "allows -, _, A-Z, a-z, and 0-9 in customer_id without raising an ArgumentError" do
+      expect do
+        Braintree::Address.create(:customer_id => "hyphen-")
+      end.to raise_error(Braintree::NotFoundError)
+      expect do
+        Braintree::Address.create(:customer_id => "underscore_")
+      end.to raise_error(Braintree::NotFoundError)
+      expect do
+        Braintree::Address.create(:customer_id => "CAPS")
+      end.to raise_error(Braintree::NotFoundError)
+    end
+  end
+
+  describe "self.create!" do
+    it "returns the address if valid" do
+      customer = Braintree::Customer.create!(:last_name => "Miller")
+      address = Braintree::Address.create!(
+        :customer_id => customer.id,
+        :street_address => "1812 E Main St",
+        :extended_address => "Suite 201",
+        :locality => "Bartlett",
+        :region => "IL",
+        :postal_code => "60623",
+        :country_name => "United States of America"
+      )
+      address.customer_id.should == customer.id
+      address.street_address.should == "1812 E Main St"
+      address.extended_address.should == "Suite 201"
+      address.locality.should == "Bartlett"
+      address.region.should == "IL"
+      address.postal_code.should == "60623"
+      address.country_name.should == "United States of America"
+    end
+    
+    it "raises a ValidationsFailed if invalid" do
+      customer = Braintree::Customer.create!(:last_name => "Wilson")
+      expect do
+        Braintree::Address.create!(
+          :customer_id => customer.id,
+          :country_name => "United States of Invalid"
+        )
+      end.to raise_error(Braintree::ValidationsFailed)
+    end
+  end
+  
+  describe "self.delete" do
+    it "deletes the address given a customer id and an address id" do
+      customer = Braintree::Customer.create!(:last_name => "Wilson")
+      address = Braintree::Address.create!(:customer_id => customer.id, :street_address => "123 E Main St")
+      Braintree::Address.delete(customer.id, address.id).success?.should == true
+      expect do
+        Braintree::Address.find(customer.id, address.id)
+      end.to raise_error(Braintree::NotFoundError)
+    end
+
+    it "deletes the address given a customer and an address id" do
+      customer = Braintree::Customer.create!(:last_name => "Wilson")
+      address = Braintree::Address.create!(:customer_id => customer.id, :street_address => "123 E Main St")
+      Braintree::Address.delete(customer, address.id).success?.should == true
+      expect do
+        Braintree::Address.find(customer.id, address.id)
+      end.to raise_error(Braintree::NotFoundError)
+    end
+  end
+  
+  describe "self.find" do
+    it "finds the address given a customer and an address id" do
+      customer = Braintree::Customer.create!(:last_name => "Wilson")
+      address = Braintree::Address.create!(:customer_id => customer.id, :street_address => "123 E Main St")
+      Braintree::Address.find(customer, address.id).should == address
+    end
+
+    it "finds the address given a customer id and an address id" do
+      customer = Braintree::Customer.create!(:last_name => "Wilson")
+      address = Braintree::Address.create!(:customer_id => customer.id, :street_address => "123 E Main St")
+      Braintree::Address.find(customer.id, address.id).should == address
+    end
+    
+    it "raises a NotFoundError if it cannot be found because of customer id" do
+      customer = Braintree::Customer.create!(:last_name => "Wilson")
+      address = Braintree::Address.create!(:customer_id => customer.id, :street_address => "123 E Main St")
+      expect do
+        Braintree::Address.find("invalid", address.id)
+      end.to raise_error(
+        Braintree::NotFoundError,
+        "address for customer \"invalid\" with id #{address.id.inspect} not found")
+    end
+
+    it "raises a NotFoundError if it cannot be found because of address id" do
+      customer = Braintree::Customer.create!(:last_name => "Wilson")
+      address = Braintree::Address.create!(:customer_id => customer.id, :street_address => "123 E Main St")
+      expect do
+        Braintree::Address.find(customer, "invalid")
+      end.to raise_error(
+        Braintree::NotFoundError,
+        "address for customer \"#{customer.id}\" with id \"invalid\" not found")
+    end
+  end
+  
+  describe "self.update" do
+    it "raises NotFoundError if the address can't be found" do
+      customer = Braintree::Customer.create!(:last_name => "Wilson")
+      address = Braintree::Address.create!(:customer_id => customer.id, :street_address => "123 E Main St")
+      expect do
+        Braintree::Address.update(customer.id, "bad-id", {})
+      end.to raise_error(Braintree::NotFoundError)
+    end
+
+    it "returns a success response with the updated address if valid" do
+      customer = Braintree::Customer.create!(:last_name => "Miller")
+      address = Braintree::Address.create!(
+        :customer_id => customer.id,
+        :street_address => "1812 E Old St",
+        :extended_address => "Suite Old 201",
+        :locality => "Old Chicago",
+        :region => "IL",
+        :postal_code => "60620",
+        :country_name => "United States of America"
+      )
+      result = Braintree::Address.update(
+        customer.id,
+        address.id,
+        :street_address => "123 E New St",
+        :extended_address => "New Suite 3",
+        :locality => "Chicago",
+        :region => "Illinois",
+        :postal_code => "60621",
+        :country_name => "United States of America"
+      )
+      result.success?.should == true
+      result.address.street_address.should == "123 E New St"
+      result.address.extended_address.should == "New Suite 3"
+      result.address.locality.should == "Chicago"
+      result.address.region.should == "Illinois"
+      result.address.postal_code.should == "60621"
+      result.address.country_name.should == "United States of America"
+    end
+    
+    it "returns an error response if invalid" do
+      customer = Braintree::Customer.create!(:last_name => "Miller")
+      address = Braintree::Address.create!(
+        :customer_id => customer.id,
+        :country_name => "United States of America"
+      )
+      result = Braintree::Address.update(
+        customer.id,
+        address.id,
+        :street_address => "123 E New St",
+        :country_name => "United States of Invalid"
+      )
+      result.success?.should == false
+      result.errors.for(:address).on(:country_name)[0].message.should == "Country name is not an accepted country."
+    end
+  end
+
+  describe "self.update!" do
+    it "raises NotFoundError if the address can't be found" do
+      customer = Braintree::Customer.create!(:last_name => "Wilson")
+      address = Braintree::Address.create!(:customer_id => customer.id, :street_address => "123 E Main St")
+      expect do
+        Braintree::Address.update!(customer.id, "bad-id", {})
+      end.to raise_error(Braintree::NotFoundError)
+    end
+
+    it "returns the updated address if valid" do
+      customer = Braintree::Customer.create!(:last_name => "Miller")
+      address = Braintree::Address.create!(
+        :customer_id => customer.id,
+        :street_address => "1812 E Old St",
+        :extended_address => "Suite Old 201",
+        :locality => "Old Chicago",
+        :region => "IL",
+        :postal_code => "60620",
+        :country_name => "United States of America"
+      )
+      updated_address = Braintree::Address.update!(
+        customer.id,
+        address.id,
+        :street_address => "123 E New St",
+        :extended_address => "New Suite 3",
+        :locality => "Chicago",
+        :region => "Illinois",
+        :postal_code => "60621",
+        :country_name => "United States of America"
+      )
+      updated_address.should == address
+      updated_address.street_address.should == "123 E New St"
+      updated_address.extended_address.should == "New Suite 3"
+      updated_address.locality.should == "Chicago"
+      updated_address.region.should == "Illinois"
+      updated_address.postal_code.should == "60621"
+      updated_address.country_name.should == "United States of America"
+    end
+    
+    it "raises a ValidationsFailed invalid" do
+      customer = Braintree::Customer.create!(:last_name => "Miller")
+      address = Braintree::Address.create!(
+        :customer_id => customer.id,
+        :country_name => "United States of America"
+      )
+      expect do
+        Braintree::Address.update!(
+          customer.id,
+          address.id,
+          :street_address => "123 E New St",
+          :country_name => "United States of Invalid"
+        )
+      end.to raise_error(Braintree::ValidationsFailed)
+    end
+  end
+
+  
+  describe "delete" do
+    it "deletes the address" do
+      customer = Braintree::Customer.create!(:last_name => "Wilson")
+      address = Braintree::Address.create!(:customer_id => customer.id, :street_address => "123 E Main St")
+      address.delete.success?.should == true
+      expect do
+        Braintree::Address.find(customer.id, address.id)
+      end.to raise_error(Braintree::NotFoundError)
+    end
+  end
+  
+  describe "update" do
+    it "returns a success response and updates the address if valid" do
+      customer = Braintree::Customer.create!(:last_name => "Miller")
+      address = Braintree::Address.create!(
+        :customer_id => customer.id,
+        :street_address => "1812 E Old St",
+        :extended_address => "Suite Old 201",
+        :locality => "Old Chicago",
+        :region => "IL",
+        :postal_code => "60620",
+        :country_name => "United States of America"
+      )
+      result = address.update(
+        :street_address => "123 E New St",
+        :extended_address => "New Suite 3",
+        :locality => "Chicago",
+        :region => "Illinois",
+        :postal_code => "60621",
+        :country_name => "United States of America"
+      )
+      result.success?.should == true
+      result.address.should == address
+      address.street_address.should == "123 E New St"
+      address.extended_address.should == "New Suite 3"
+      address.locality.should == "Chicago"
+      address.region.should == "Illinois"
+      address.postal_code.should == "60621"
+      address.country_name.should == "United States of America"
+    end
+    
+    it "returns an error response if invalid" do
+      customer = Braintree::Customer.create!(:last_name => "Miller")
+      address = Braintree::Address.create!(
+        :customer_id => customer.id,
+        :country_name => "United States of America"
+      )
+      result = address.update(
+        :street_address => "123 E New St",
+        :country_name => "United States of Invalid"
+      )
+      result.success?.should == false
+      result.errors.for(:address).on(:country_name)[0].message.should == "Country name is not an accepted country."
+    end
+  end
+
+  describe "update!" do
+    it "returns true and updates the address if valid" do
+      customer = Braintree::Customer.create!(:last_name => "Miller")
+      address = Braintree::Address.create!(
+        :customer_id => customer.id,
+        :street_address => "1812 E Old St",
+        :extended_address => "Suite Old 201",
+        :locality => "Old Chicago",
+        :region => "IL",
+        :postal_code => "60620",
+        :country_name => "United States of America"
+      )
+      address.update!(
+        :street_address => "123 E New St",
+        :extended_address => "New Suite 3",
+        :locality => "Chicago",
+        :region => "Illinois",
+        :postal_code => "60621",
+        :country_name => "United States of America"
+      ).should == address
+      address.street_address.should == "123 E New St"
+      address.extended_address.should == "New Suite 3"
+      address.locality.should == "Chicago"
+      address.region.should == "Illinois"
+      address.postal_code.should == "60621"
+      address.country_name.should == "United States of America"
+    end
+    
+    it "raises a ValidationsFailed invalid" do
+      customer = Braintree::Customer.create!(:last_name => "Miller")
+      address = Braintree::Address.create!(
+        :customer_id => customer.id,
+        :country_name => "United States of America"
+      )
+      expect do
+        address.update!(
+          :street_address => "123 E New St",
+          :country_name => "United States of Invalid"
+        )
+      end.to raise_error(Braintree::ValidationsFailed)
+    end
+  end
+end