From c0aecbaa1d7e6c79f8d92256591f3916c10149e1 Mon Sep 17 00:00:00 2001 From: Jovial Joe Jayarson Date: Mon, 27 Feb 2023 16:01:15 +0530 Subject: [PATCH] maint: reformats `card` module, fix typo --- tests/test_btc_address.py | 2 +- tests/test_card.py | 166 +++++++++++---------------- validators/card.py | 230 ++++++++++++++++++++++---------------- 3 files changed, 201 insertions(+), 197 deletions(-) diff --git a/tests/test_btc_address.py b/tests/test_btc_address.py index 5ba1fc0d..e354edfd 100644 --- a/tests/test_btc_address.py +++ b/tests/test_btc_address.py @@ -1,7 +1,7 @@ """Test BTC address.""" # -*- coding: utf-8 -*- -# standard +# external import pytest # local diff --git a/tests/test_card.py b/tests/test_card.py index d76dbcf2..95261305 100644 --- a/tests/test_card.py +++ b/tests/test_card.py @@ -1,44 +1,29 @@ +"""Test Card.""" # -*- coding: utf-8 -*- + +# external import pytest +# local from validators import ( - amex, + ValidationFailure, card_number, - diners, - discover, - jcb, mastercard, unionpay, - ValidationFailure, - visa + discover, + diners, + visa, + amex, + jcb, ) -visa_cards = [ - '4242424242424242', - '4000002760003184' -] -mastercard_cards = [ - '5555555555554444', - '2223003122003222' -] -amex_cards = [ - '378282246310005', - '371449635398431' -] -unionpay_cards = [ - '6200000000000005' -] -diners_cards = [ - '3056930009020004', - '36227206271667' -] -jcb_cards = [ - '3566002020360505' -] -discover_cards = [ - '6011111111111117', - '6011000990139424' -] +visa_cards = ["4242424242424242", "4000002760003184"] +mastercard_cards = ["5555555555554444", "2223003122003222"] +amex_cards = ["378282246310005", "371449635398431"] +unionpay_cards = ["6200000000000005"] +diners_cards = ["3056930009020004", "36227206271667"] +jcb_cards = ["3566002020360505"] +discover_cards = ["6011111111111117", "6011000990139424"] @pytest.mark.parametrize( @@ -51,140 +36,117 @@ + jcb_cards + discover_cards, ) -def test_returns_true_on_valid_card_number(value): +def test_returns_true_on_valid_card_number(value: str): + """Test returns true on valid card number.""" assert card_number(value) -@pytest.mark.parametrize('value', [ - '4242424242424240', - '4000002760003180', - '400000276000318X' -]) -def test_returns_failed_on_valid_card_number(value): +@pytest.mark.parametrize("value", ["4242424242424240", "4000002760003180", "400000276000318X"]) +def test_returns_failed_on_valid_card_number(value: str): + """Test returns failed on valid card number.""" assert isinstance(card_number(value), ValidationFailure) -@pytest.mark.parametrize('value', visa_cards) -def test_returns_true_on_valid_visa(value): +@pytest.mark.parametrize("value", visa_cards) +def test_returns_true_on_valid_visa(value: str): + """Test returns true on valid visa.""" assert visa(value) @pytest.mark.parametrize( "value", - mastercard_cards - + amex_cards - + unionpay_cards - + diners_cards - + jcb_cards - + discover_cards, + mastercard_cards + amex_cards + unionpay_cards + diners_cards + jcb_cards + discover_cards, ) -def test_returns_failed_on_valid_visa(value): +def test_returns_failed_on_valid_visa(value: str): + """Test returns failed on valid visa.""" assert isinstance(visa(value), ValidationFailure) -@pytest.mark.parametrize('value', mastercard_cards) -def test_returns_true_on_valid_mastercard(value): +@pytest.mark.parametrize("value", mastercard_cards) +def test_returns_true_on_valid_mastercard(value: str): + """Test returns true on valid mastercard.""" assert mastercard(value) @pytest.mark.parametrize( "value", - visa_cards - + amex_cards - + unionpay_cards - + diners_cards - + jcb_cards - + discover_cards, + visa_cards + amex_cards + unionpay_cards + diners_cards + jcb_cards + discover_cards, ) -def test_returns_failed_on_valid_mastercard(value): +def test_returns_failed_on_valid_mastercard(value: str): + """Test returns failed on valid mastercard.""" assert isinstance(mastercard(value), ValidationFailure) -@pytest.mark.parametrize('value', amex_cards) -def test_returns_true_on_valid_amex(value): +@pytest.mark.parametrize("value", amex_cards) +def test_returns_true_on_valid_amex(value: str): + """Test returns true on valid amex.""" assert amex(value) @pytest.mark.parametrize( "value", - visa_cards - + mastercard_cards - + unionpay_cards - + diners_cards - + jcb_cards - + discover_cards, + visa_cards + mastercard_cards + unionpay_cards + diners_cards + jcb_cards + discover_cards, ) -def test_returns_failed_on_valid_amex(value): +def test_returns_failed_on_valid_amex(value: str): + """Test returns failed on valid amex.""" assert isinstance(amex(value), ValidationFailure) -@pytest.mark.parametrize('value', unionpay_cards) -def test_returns_true_on_valid_unionpay(value): +@pytest.mark.parametrize("value", unionpay_cards) +def test_returns_true_on_valid_unionpay(value: str): + """Test returns true on valid unionpay.""" assert unionpay(value) @pytest.mark.parametrize( "value", - visa_cards - + mastercard_cards - + amex_cards - + diners_cards - + jcb_cards - + discover_cards, + visa_cards + mastercard_cards + amex_cards + diners_cards + jcb_cards + discover_cards, ) -def test_returns_failed_on_valid_unionpay(value): +def test_returns_failed_on_valid_unionpay(value: str): + """Test returns failed on valid unionpay.""" assert isinstance(unionpay(value), ValidationFailure) -@pytest.mark.parametrize('value', diners_cards) -def test_returns_true_on_valid_diners(value): +@pytest.mark.parametrize("value", diners_cards) +def test_returns_true_on_valid_diners(value: str): + """Test returns true on valid diners.""" assert diners(value) @pytest.mark.parametrize( "value", - visa_cards - + mastercard_cards - + amex_cards - + unionpay_cards - + jcb_cards - + discover_cards, + visa_cards + mastercard_cards + amex_cards + unionpay_cards + jcb_cards + discover_cards, ) -def test_returns_failed_on_valid_diners(value): +def test_returns_failed_on_valid_diners(value: str): + """Test returns failed on valid diners.""" assert isinstance(diners(value), ValidationFailure) -@pytest.mark.parametrize('value', jcb_cards) -def test_returns_true_on_valid_jcb(value): +@pytest.mark.parametrize("value", jcb_cards) +def test_returns_true_on_valid_jcb(value: str): + """Test returns true on valid jcb.""" assert jcb(value) @pytest.mark.parametrize( "value", - visa_cards - + mastercard_cards - + amex_cards - + unionpay_cards - + diners_cards - + discover_cards, + visa_cards + mastercard_cards + amex_cards + unionpay_cards + diners_cards + discover_cards, ) -def test_returns_failed_on_valid_jcb(value): +def test_returns_failed_on_valid_jcb(value: str): + """Test returns failed on valid jcb.""" assert isinstance(jcb(value), ValidationFailure) -@pytest.mark.parametrize('value', discover_cards) -def test_returns_true_on_valid_discover(value): +@pytest.mark.parametrize("value", discover_cards) +def test_returns_true_on_valid_discover(value: str): + """Test returns true on valid discover.""" assert discover(value) @pytest.mark.parametrize( "value", - visa_cards - + mastercard_cards - + amex_cards - + unionpay_cards - + diners_cards - + jcb_cards, + visa_cards + mastercard_cards + amex_cards + unionpay_cards + diners_cards + jcb_cards, ) -def test_returns_failed_on_valid_discover(value): +def test_returns_failed_on_valid_discover(value: str): + """Test returns failed on valid discover.""" assert isinstance(discover(value), ValidationFailure) diff --git a/validators/card.py b/validators/card.py index 8b8cbeea..42230fb2 100644 --- a/validators/card.py +++ b/validators/card.py @@ -1,183 +1,225 @@ +"""Card.""" +# -*- coding: utf-8 -*- + +# standard import re +# local from .utils import validator @validator -def card_number(value): - """ - Return whether or not given value is a valid card number. - - This validator is based on Luhn algorithm. +def card_number(value: str): + """Return whether or not given value is a valid generic card number. - .. luhn: - https://github.com/mmcloughlin/luhn + This validator is based on [Luhn's algorithm][1]. - Examples:: + [1]: https://github.com/mmcloughlin/luhn + Examples: >>> card_number('4242424242424242') - True - + # Output: True >>> card_number('4242424242424241') - ValidationFailure(func=card_number, args={'value': '4242424242424241'}) + # Output: ValidationFailure(func=card_number, args={'value': '4242424242424241'}) + + Args: + value: + Generic card number string to validate - .. versionadded:: 0.15.0 + Returns: + (Literal[True]): + If `value` is a valid generic card number. + (ValidationFailure): + If `value` is an invalid generic card number. - :param value: card number string to validate + > *New in version 0.15.0*. """ try: digits = list(map(int, value)) odd_sum = sum(digits[-1::-2]) - even_sum = sum([sum(divmod(2 * d, 10)) for d in digits[-2::-2]]) + even_sum = sum(sum(divmod(2 * d, 10)) for d in digits[-2::-2]) return (odd_sum + even_sum) % 10 == 0 except ValueError: return False @validator -def visa(value): - """ - Return whether or not given value is a valid Visa card number. - - Examples:: +def visa(value: str): + """Return whether or not given value is a valid Visa card number. + Examples: >>> visa('4242424242424242') - True - + # Output: True >>> visa('2223003122003222') - ValidationFailure(func=visa, args={'value': '2223003122003222'}) + # Output: ValidationFailure(func=visa, args={'value': '2223003122003222'}) + + Args: + value: + Visa card number string to validate - .. versionadded:: 0.15.0 + Returns: + (Literal[True]): + If `value` is a valid Visa card number. + (ValidationFailure): + If `value` is an invalid Visa card number. - :param value: Visa card number string to validate + > *New in version 0.15.0*. """ - pattern = re.compile(r'^4') + pattern = re.compile(r"^4") return card_number(value) and len(value) == 16 and pattern.match(value) @validator -def mastercard(value): - """ - Return whether or not given value is a valid Mastercard card number. - - Examples:: +def mastercard(value: str): + """Return whether or not given value is a valid Mastercard card number. + Examples: >>> mastercard('5555555555554444') - True - + # Output: True >>> mastercard('4242424242424242') - ValidationFailure(func=mastercard, args={'value': '4242424242424242'}) + # Output: ValidationFailure(func=mastercard, args={'value': '4242424242424242'}) + + Args: + value: + Mastercard card number string to validate - .. versionadded:: 0.15.0 + Returns: + (Literal[True]): + If `value` is a valid Mastercard card number. + (ValidationFailure): + If `value` is an invalid Mastercard card number. - :param value: Mastercard card number string to validate + > *New in version 0.15.0*. """ - pattern = re.compile(r'^(51|52|53|54|55|22|23|24|25|26|27)') + pattern = re.compile(r"^(51|52|53|54|55|22|23|24|25|26|27)") return card_number(value) and len(value) == 16 and pattern.match(value) @validator -def amex(value): - """ - Return whether or not given value is a valid American Express card number. - - Examples:: +def amex(value: str): + """Return whether or not given value is a valid American Express card number. + Examples: >>> amex('378282246310005') - True - + # Output: True >>> amex('4242424242424242') - ValidationFailure(func=amex, args={'value': '4242424242424242'}) + # Output: ValidationFailure(func=amex, args={'value': '4242424242424242'}) + + Args: + value: + American Express card number string to validate - .. versionadded:: 0.15.0 + Returns: + (Literal[True]): + If `value` is a valid American Express card number. + (ValidationFailure): + If `value` is an invalid American Express card number. - :param value: American Express card number string to validate + > *New in version 0.15.0*. """ - pattern = re.compile(r'^(34|37)') + pattern = re.compile(r"^(34|37)") return card_number(value) and len(value) == 15 and pattern.match(value) @validator -def unionpay(value): - """ - Return whether or not given value is a valid UnionPay card number. - - Examples:: +def unionpay(value: str): + """Return whether or not given value is a valid UnionPay card number. + Examples: >>> unionpay('6200000000000005') - True - + # Output: True >>> unionpay('4242424242424242') - ValidationFailure(func=unionpay, args={'value': '4242424242424242'}) + # Output: ValidationFailure(func=unionpay, args={'value': '4242424242424242'}) + + Args: + value: + UnionPay card number string to validate - .. versionadded:: 0.15.0 + Returns: + (Literal[True]): + If `value` is a valid UnionPay card number. + (ValidationFailure): + If `value` is an invalid UnionPay card number. - :param value: UnionPay card number string to validate + > *New in version 0.15.0*. """ - pattern = re.compile(r'^62') + pattern = re.compile(r"^62") return card_number(value) and len(value) == 16 and pattern.match(value) @validator -def diners(value): - """ - Return whether or not given value is a valid Diners Club card number. - - Examples:: +def diners(value: str): + """Return whether or not given value is a valid Diners Club card number. + Examples: >>> diners('3056930009020004') - True - + # Output: True >>> diners('4242424242424242') - ValidationFailure(func=diners, args={'value': '4242424242424242'}) + # Output: ValidationFailure(func=diners, args={'value': '4242424242424242'}) + + Args: + value: + Diners Club card number string to validate - .. versionadded:: 0.15.0 + Returns: + (Literal[True]): + If `value` is a valid Diners Club card number. + (ValidationFailure): + If `value` is an invalid Diners Club card number. - :param value: Diners Club card number string to validate + > *New in version 0.15.0*. """ - pattern = re.compile(r'^(30|36|38|39)') - return ( - card_number(value) and len(value) in [14, 16] and pattern.match(value) - ) + pattern = re.compile(r"^(30|36|38|39)") + return card_number(value) and len(value) in {14, 16} and pattern.match(value) @validator -def jcb(value): - """ - Return whether or not given value is a valid JCB card number. - - Examples:: +def jcb(value: str): + """Return whether or not given value is a valid JCB card number. + Examples: >>> jcb('3566002020360505') - True - + # Output: True >>> jcb('4242424242424242') - ValidationFailure(func=jcb, args={'value': '4242424242424242'}) + # Output: ValidationFailure(func=jcb, args={'value': '4242424242424242'}) + + Args: + value: + JCB card number string to validate - .. versionadded:: 0.15.0 + Returns: + (Literal[True]): + If `value` is a valid JCB card number. + (ValidationFailure): + If `value` is an invalid JCB card number. - :param value: JCB card number string to validate + > *New in version 0.15.0*. """ - pattern = re.compile(r'^35') + pattern = re.compile(r"^35") return card_number(value) and len(value) == 16 and pattern.match(value) @validator -def discover(value): - """ - Return whether or not given value is a valid Discover card number. - - Examples:: +def discover(value: str): + """Return whether or not given value is a valid Discover card number. + Examples: >>> discover('6011111111111117') - True - + # Output: True >>> discover('4242424242424242') - ValidationFailure(func=discover, args={'value': '4242424242424242'}) + # Output: ValidationFailure(func=discover, args={'value': '4242424242424242'}) + + Args: + value: + Discover card number string to validate - .. versionadded:: 0.15.0 + Returns: + (Literal[True]): + If `value` is a valid Discover card number. + (ValidationFailure): + If `value` is an invalid Discover card number. - :param value: Discover card number string to validate + > *New in version 0.15.0*. """ - pattern = re.compile(r'^(60|64|65)') + pattern = re.compile(r"^(60|64|65)") return card_number(value) and len(value) == 16 and pattern.match(value)