3.23.0

braintreeps · braintreeps · commit 24edd45e117f · 2015-12-02T16:03:25.000Z
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -1,3 +1,7 @@
+## 3.23.0
+* Add better defaults to client token generation when using an access token by consolidating client token defaults into ClientTokenGateway
+* Add PaymentMethodGateway#revoke
+
 ## 3.22.0
 * Add VenmoAccount
 * Add support for Set Transaction Context supplementary data.
diff --git a/braintree/client_token.py b/braintree/client_token.py
@@ -10,18 +10,9 @@ class ClientToken(object):
 
     @staticmethod
     def generate(params={}, gateway=None):
-
         if gateway is None:
             gateway = Configuration.gateway().client_token
 
-        if "options" in params and not "customer_id" in params:
-            for option in ["verify_card", "make_default", "fail_on_duplicate_payment_method"]:
-                if option in params["options"]:
-                    raise exceptions.InvalidSignatureError("cannot specify %s without a customer_id" % option)
-
-        if "version" not in params:
-            params["version"] = 2
-
         return gateway.generate(params)
 
     @staticmethod
diff --git a/braintree/client_token_gateway.py b/braintree/client_token_gateway.py
@@ -1,6 +1,6 @@
 import braintree
-from braintree.client_token import ClientToken
 from braintree.resource import Resource
+from braintree.client_token import ClientToken
 from braintree import exceptions
 
 class ClientTokenGateway(object):
@@ -9,10 +9,17 @@ def __init__(self, gateway):
         self.config = gateway.config
 
 
-    def generate(self, params):
-        if params:
-            Resource.verify_keys(params, ClientToken.generate_signature())
-            params = {'client_token': params}
+    def generate(self, params={}):
+        if "options" in params and not "customer_id" in params:
+            for option in ["verify_card", "make_default", "fail_on_duplicate_payment_method"]:
+                if option in params["options"]:
+                    raise exceptions.InvalidSignatureError("cannot specify %s without a customer_id" % option)
+
+        if "version" not in params:
+            params["version"] = 2
+
+        Resource.verify_keys(params, ClientToken.generate_signature())
+        params = {'client_token': params}
 
         response = self.config.http().post(self.config.base_merchant_path() + "/client_token", params)
 
diff --git a/braintree/payment_method_gateway.py b/braintree/payment_method_gateway.py
@@ -58,28 +58,45 @@ def grant(self, payment_method_token, allow_vaulting):
             raise ValueError
 
         try:
-            response = self._post(
+            return self._post(
                 "/payment_methods/grant",
                 {
                     "payment_method": {
                         "shared_payment_method_token": payment_method_token,
                         "allow_vaulting": allow_vaulting
                     }
                 },
-                parse_response=False
+                "payment_method_nonce"
             )
+        except NotFoundError:
+            raise NotFoundError("payment method with payment_method_token " + repr(payment_method_token) + " not found")
 
-            return PaymentMethodNonce(self.gateway, response["payment_method_nonce"])
+    def revoke(self, payment_method_token):
+        if payment_method_token is None or not str(payment_method_token).strip():
+            raise ValueError
+
+        try:
+            return self._post(
+                "/payment_methods/revoke",
+                {
+                    "payment_method": {
+                        "shared_payment_method_token": payment_method_token
+                    }
+                },
+                None
+            )
         except NotFoundError:
             raise NotFoundError("payment method with payment_method_token " + repr(payment_method_token) + " not found")
 
-    def _post(self, url, params={}, parse_response=True):
+    def _post(self, url, params={}, result_key="payment_method"):
         response = self.config.http().post(self.config.base_merchant_path() + url, params)
         if "api_error_response" in response:
             return ErrorResult(self.gateway, response["api_error_response"])
-        elif parse_response:
+        elif result_key is None:
+            return SuccessfulResult()
+        else:
             payment_method = self._parse_payment_method(response)
-            return SuccessfulResult({"payment_method": payment_method})
+            return SuccessfulResult({result_key: payment_method})
         return response
 
     def _put(self, url, params={}):
@@ -107,6 +124,10 @@ def _parse_payment_method(self, response):
             return CoinbaseAccount(self.gateway, response["coinbase_account"])
         elif "venmo_account" in response:
             return VenmoAccount(self.gateway, response["venmo_account"])
+        elif "payment_method_nonce" in response:
+            return PaymentMethodNonce(self.gateway, response["payment_method_nonce"])
+        elif "success" in response:
+            return None
         else:
             name = list(response)[0]
             return UnknownPaymentMethod(self.gateway, response[name])
diff --git a/braintree/version.py b/braintree/version.py
@@ -1 +1 @@
-Version = "3.22.0"
+Version = "3.23.0"
diff --git a/setup.py b/setup.py
@@ -1,7 +1,7 @@
 from distutils.core import setup
 setup(
     name="braintree",
-    version="3.22.0",
+    version="3.23.0",
     description="Braintree Python Library",
     author="Braintree",
     author_email="support@braintreepayments.com",
diff --git a/tests/integration/test_payment_method.py b/tests/integration/test_payment_method.py
@@ -911,21 +911,26 @@ def test_update_updates_a_paypal_accounts_token(self):
         self.assertTrue(updated_result.is_success == False)
         self.assertTrue(updated_result.errors.deep_errors[0].code == "92906")
 
+    def test_payment_method_grant_raises_on_non_existent_tokens(self):
+        granting_gateway, credit_card = TestHelper.create_payment_method_grant_fixtures()
+        self.assertRaises(NotFoundError, granting_gateway.payment_method.grant, "non-existant-token", False)
+
     def test_payment_method_grant_returns_one_time_nonce(self):
         """
         Payment method grant returns a nonce that is transactable by a partner merchant exactly once
         """
         granting_gateway, credit_card = TestHelper.create_payment_method_grant_fixtures()
         grant_result = granting_gateway.payment_method.grant(credit_card.token, False)
+        self.assertTrue(grant_result.is_success)
 
         result = Transaction.sale({
-            "payment_method_nonce": grant_result.nonce,
-            "amount": TransactionAmounts.Authorize,
+            "payment_method_nonce": grant_result.payment_method_nonce.nonce,
+            "amount": TransactionAmounts.Authorize
         })
         self.assertTrue(result.is_success)
         result = Transaction.sale({
-            "payment_method_nonce": grant_result.nonce,
-            "amount": TransactionAmounts.Authorize,
+            "payment_method_nonce": grant_result.payment_method_nonce.nonce,
+            "amount": TransactionAmounts.Authorize
         })
         self.assertFalse(result.is_success)
 
@@ -936,7 +941,7 @@ def test_payment_method_grant_returns_a_nonce_that_is_not_vaultable(self):
 
         result = PaymentMethod.create({
             "customer_id": customer_id,
-            "payment_method_nonce": grant_result.nonce
+            "payment_method_nonce": grant_result.payment_method_nonce.nonce
         })
         self.assertFalse(result.is_success)
 
@@ -947,10 +952,27 @@ def test_payment_method_grant_returns_a_nonce_that_is_vaultable(self):
 
         result = PaymentMethod.create({
             "customer_id": customer_id,
-            "payment_method_nonce": grant_result.nonce
+            "payment_method_nonce": grant_result.payment_method_nonce.nonce
         })
         self.assertTrue(result.is_success)
 
+    def test_payment_method_revoke_renders_a_granted_nonce_unusable(self):
+        granting_gateway, credit_card = TestHelper.create_payment_method_grant_fixtures()
+        grant_result = granting_gateway.payment_method.grant(credit_card.token, False)
+
+        revoke_result = granting_gateway.payment_method.revoke(credit_card.token)
+        self.assertTrue(revoke_result.is_success)
+
+        result = Transaction.sale({
+            "payment_method_nonce": grant_result.payment_method_nonce.nonce,
+            "amount": TransactionAmounts.Authorize
+        })
+        self.assertFalse(result.is_success)
+
+    def test_payment_method_revoke_raises_on_non_existent_tokens(self):
+        granting_gateway, credit_card = TestHelper.create_payment_method_grant_fixtures()
+        self.assertRaises(NotFoundError, granting_gateway.payment_method.revoke, "non-existant-token")
+
 class CreditCardForwardingTest(unittest.TestCase):
     def setUp(self):
         braintree.Configuration.configure(
diff --git a/tests/integration/test_settlement_batch_summary.py b/tests/integration/test_settlement_batch_summary.py
@@ -34,7 +34,8 @@ def test_generate_returns_transactions_settled_on_a_given_day(self):
         self.assertTrue(result.is_success)
         visa_records = [row for row in result.settlement_batch_summary.records if row['card_type'] == 'Visa'][0]
         count = int(visa_records['count'])
-        self.assertEquals(float(visa_records['amount_settled']), float(TransactionAmounts.Authorize) * count)
+        self.assertGreaterEqual(count, 1)
+        self.assertGreaterEqual(float(visa_records['amount_settled']), float(TransactionAmounts.Authorize))
 
     def test_generate_can_be_grouped_by_a_custom_field(self):
         result = Transaction.sale({
diff --git a/tests/integration/test_transaction.py b/tests/integration/test_transaction.py
@@ -1622,52 +1622,6 @@ def test_submit_for_settlement_with_invalid_params(self):
         except KeyError as e:
             self.assertEquals("'Invalid keys: invalid_param'", str(e))
 
-    def test_submit_for_settlement_with_order_id_on_unsupported_processor(self):
-        transaction = Transaction.sale({
-            "merchant_account_id": TestHelper.fake_amex_direct_merchant_account_id,
-            "amount": TransactionAmounts.Authorize,
-            "credit_card": {
-                "number": CreditCardNumbers.AmexPayWithPoints.Success,
-                "expiration_date": "05/2009"
-            }
-        }).transaction
-
-        params = { "order_id": "ABC123" }
-
-        result = Transaction.submit_for_settlement(transaction.id, Decimal("900"), params)
-
-        self.assertFalse(result.is_success)
-        self.assertEquals(
-            ErrorCodes.Transaction.ProcessorDoesNotSupportUpdatingOrderId,
-            result.errors.for_object("transaction").on("base")[0].code
-        )
-
-    def test_submit_for_settlement_with_descriptor_on_unsupported_processor(self):
-        transaction = Transaction.sale({
-            "merchant_account_id": TestHelper.fake_amex_direct_merchant_account_id,
-            "amount": TransactionAmounts.Authorize,
-            "credit_card": {
-                "number": CreditCardNumbers.AmexPayWithPoints.Success,
-                "expiration_date": "05/2009"
-            }
-        }).transaction
-
-        params = {
-            "descriptor": {
-                "name": "123*123456789012345678",
-                "phone": "3334445555",
-                "url": "ebay.com"
-            }
-        }
-
-        result = Transaction.submit_for_settlement(transaction.id, Decimal("900"), params)
-
-        self.assertFalse(result.is_success)
-        self.assertEquals(
-            ErrorCodes.Transaction.ProcessorDoesNotSupportUpdatingDescriptor ,
-            result.errors.for_object("transaction").on("base")[0].code
-        )
-
     def test_submit_for_settlement_with_validation_error(self):
         transaction = Transaction.sale({
             "amount": TransactionAmounts.Authorize,
@@ -2392,6 +2346,9 @@ def test_find_exposes_disputes(self):
         self.assertEquals(Dispute.Reason.Fraud, dispute.reason)
         self.assertEquals("disputedtransaction", dispute.transaction_details.id)
         self.assertEquals(Decimal("1000.00"), dispute.transaction_details.amount)
+        self.assertEquals(Dispute.Kind.Chargeback, dispute.kind)
+        self.assertEquals(date(2014, 3, 1), dispute.date_opened)
+        self.assertEquals(date(2014, 3, 7), dispute.date_won)
 
     def test_find_exposes_three_d_secure_info(self):
         transaction = Transaction.find("threedsecuredtransaction")
@@ -2928,7 +2885,7 @@ def test_transaction_facilitator(self):
         grant_result = granting_gateway.payment_method.grant(credit_card.token, False)
 
         result = Transaction.sale({
-            "payment_method_nonce": grant_result.nonce,
+            "payment_method_nonce": grant_result.payment_method_nonce.nonce,
             "amount": TransactionAmounts.Authorize,
         })
         self.assertTrue(result.transaction.facilitator_details is not None)
diff --git a/tests/unit/test_dispute.py b/tests/unit/test_dispute.py
@@ -16,7 +16,10 @@ def test_constructor(self):
             "received_date": date(2013, 4, 10),
             "reply_by_date": date(2013, 4, 10),
             "reason": "fraud",
-            "transaction_ids": ["asdf", "qwer"]
+            "transaction_ids": ["asdf", "qwer"],
+            "date_opened": date(2013, 4, 1),
+            "date_won": date(2013, 4, 2),
+            "kind": "chargeback",
         }
 
         dispute = Dispute(attributes)
@@ -28,3 +31,6 @@ def test_constructor(self):
         self.assertEquals(dispute.status, Dispute.Status.Open)
         self.assertEquals(dispute.transaction_details.id, "transaction_id")
         self.assertEquals(dispute.transaction_details.amount, Decimal("100.00"))
+        self.assertEquals(dispute.date_opened, date(2013, 4, 1))
+        self.assertEquals(dispute.date_won, date(2013, 4, 2))
+        self.assertEquals(dispute.kind, Dispute.Kind.Chargeback)
diff --git a/tests/unit/test_payment_method_gateway.py b/tests/unit/test_payment_method_gateway.py
@@ -111,3 +111,14 @@ def test_nonce_grant_params(self):
 
         with self.assertRaises(ValueError):
             payment_method_gateway.grant(None, False)
+
+    def test_nonce_revoke_params(self):
+        payment_method_gateway = PaymentMethodGateway(BraintreeGateway(None))
+        with self.assertRaises(ValueError):
+            payment_method_gateway.revoke("")
+
+        with self.assertRaises(ValueError):
+            payment_method_gateway.revoke("\t")
+
+        with self.assertRaises(ValueError):
+            payment_method_gateway.revoke(None)

Original file line number	Diff line number	Diff line change
`@@ -1 +1 @@`
`1`		`-Version = "3.22.0"`
	`1`	`+Version = "3.23.0"`