TechnikNews
/
PublicAPIs
mirror of https://github.com/public-apis/public-apis
1
2
Fork 0
Code Issues 0 Releases 0 Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
4286 Commits
2 Branches
69 MiB
 
 
Tree: e3f51ae6c2
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'e3f51ae6c2'
${ noResults }
PublicAPIs/scripts/tests/test_validate_format.py

312 lines
11 KiB
Raw Blame History 

  1. # -*- coding: utf-8 -*-

  2. 

  3. import unittest

  4. 

  5. from validate.format import error_message

  6. from validate.format import get_categories_content

  7. from validate.format import check_alphabetical_order

  8. from validate.format import check_title

  9. from validate.format import check_description, max_description_length

  10. from validate.format import check_auth, auth_keys

  11. from validate.format import check_https, https_keys

  12. from validate.format import check_cors, cors_keys

  13. 

  14. 

  15. class TestValidadeFormat(unittest.TestCase):

  16.     

  17.     def test_error_message_return_and_return_type(self):

  18.         line_num_unity = 1

  19.         line_num_ten = 10

  20.         line_num_hundred = 100

  21.         line_num_thousand = 1000

  22. 

  23.         msg = 'This is a unit test'

  24. 

  25.         err_msg_unity = error_message(line_num_unity, msg)

  26.         err_msg_ten = error_message(line_num_ten, msg)

  27.         err_msg_hundred = error_message(line_num_hundred, msg)

  28.         err_msg_thousand = error_message(line_num_thousand, msg)

  29. 

  30.         self.assertIsInstance(err_msg_unity, str)

  31.         self.assertIsInstance(err_msg_ten, str)

  32.         self.assertIsInstance(err_msg_hundred, str)

  33.         self.assertIsInstance(err_msg_thousand, str)

  34. 

  35.         self.assertEqual(err_msg_unity, '(L002) This is a unit test')

  36.         self.assertEqual(err_msg_ten, '(L011) This is a unit test')

  37.         self.assertEqual(err_msg_hundred, '(L101) This is a unit test')

  38.         self.assertEqual(err_msg_thousand, '(L1001) This is a unit test')

  39. 

  40.     def test_if_get_categories_content_return_correct_data_of_categories(self):

  41.         fake_contents = [

  42.             '### A',

  43.             'API | Description | Auth | HTTPS | CORS |',

  44.             '|---|---|---|---|---|',

  45.             '| [AA](https://www.ex.com) | Desc | `apiKey` | Yes | Yes |',

  46.             '| [AB](https://www.ex.com) | Desc | `apiKey` | Yes | Yes |',

  47.             '',

  48.             '### B',

  49.             'API | Description | Auth | HTTPS | CORS |',

  50.             '|---|---|---|---|---|',

  51.             '| [BA](https://www.ex.com) | Desc | `apiKey` | Yes | Yes |',

  52.             '| [BB](https://www.ex.com) | Desc | `apiKey` | Yes | Yes |'

  53.         ]

  54. 

  55.         result = get_categories_content(fake_contents)

  56.         self.assertIsInstance(result, tuple)

  57. 

  58.         categories, category_line_num = result

  59.         self.assertIsInstance(categories, dict)

  60.         self.assertIsInstance(category_line_num, dict)

  61. 

  62.         expected_result = ({'A': ['AA', 'AB'], 'B': ['BA', 'BB']}, {'A': 0, 'B': 6})

  63. 

  64.         for res, ex_res in zip(result, expected_result):

  65. 

  66.             with self.subTest():

  67.                 self.assertEqual(res, ex_res)

  68. 

  69.     def test_if_check_alphabetical_order_return_correct_msg_error(self):

  70.         correct_lines = [

  71.             '### A',

  72.             'API | Description | Auth | HTTPS | CORS |',

  73.             '|---|---|---|---|---|',

  74.             '| [AA](https://www.ex.com) | Desc | `apiKey` | Yes | Yes |',

  75.             '| [AB](https://www.ex.com) | Desc | `apiKey` | Yes | Yes |',

  76.             '',

  77.             '### B',

  78.             'API | Description | Auth | HTTPS | CORS |',

  79.             '|---|---|---|---|---|',

  80.             '| [BA](https://www.ex.com) | Desc | `apiKey` | Yes | Yes |',

  81.             '| [BB](https://www.ex.com) | Desc | `apiKey` | Yes | Yes |'

  82.         ]

  83. 

  84.         incorrect_lines = [

  85.             '### A',

  86.             'API | Description | Auth | HTTPS | CORS |',

  87.             '|---|---|---|---|---|',

  88.             '| [AB](https://www.ex.com) | Desc | `apiKey` | Yes | Yes |',

  89.             '| [AA](https://www.ex.com) | Desc | `apiKey` | Yes | Yes |',

  90.             '',

  91.             '### B',

  92.             'API | Description | Auth | HTTPS | CORS |',

  93.             '|---|---|---|---|---|',

  94.             '| [BB](https://www.ex.com) | Desc | `apiKey` | Yes | Yes |',

  95.             '| [BA](https://www.ex.com) | Desc | `apiKey` | Yes | Yes |'

  96.         ]

  97. 

  98. 

  99.         err_msgs_1 = check_alphabetical_order(correct_lines)

  100.         err_msgs_2 = check_alphabetical_order(incorrect_lines)

  101. 

  102.         self.assertIsInstance(err_msgs_1, list)

  103.         self.assertIsInstance(err_msgs_2, list)

  104. 

  105.         self.assertEqual(len(err_msgs_1), 0)

  106.         self.assertEqual(len(err_msgs_2), 2)

  107. 

  108.         expected_err_msgs = [

  109.             '(L001) A category is not alphabetical order',

  110.             '(L007) B category is not alphabetical order'

  111.         ]

  112. 

  113.         for err_msg, ex_err_msg in zip(err_msgs_2, expected_err_msgs):

  114. 

  115.             with self.subTest():

  116.                 self.assertEqual(err_msg, ex_err_msg)

  117.     

  118.     def test_check_title_with_correct_title(self):

  119.         raw_title = '[A](https://www.ex.com)'

  120. 

  121.         err_msgs = check_title(0, raw_title)

  122. 

  123.         self.assertIsInstance(err_msgs, list)

  124.         self.assertEqual(len(err_msgs), 0)

  125.         self.assertEqual(err_msgs, [])

  126. 

  127.     def test_check_title_with_markdown_syntax_incorrect(self):

  128.         raw_title = '[A(https://www.ex.com)'

  129. 

  130.         err_msgs = check_title(0, raw_title)

  131. 

  132.         self.assertIsInstance(err_msgs, list)

  133.         self.assertEqual(len(err_msgs), 1)

  134.         

  135.         err_msg = err_msgs[0]

  136.         expected_err_msg = '(L001) Title syntax should be "[TITLE](LINK)"'

  137. 

  138.         self.assertEqual(err_msg, expected_err_msg)

  139. 

  140.     def test_check_title_with_api_at_the_end_of_the_title(self):

  141.         raw_title = '[A API](https://www.ex.com)'

  142. 

  143.         err_msgs = check_title(0, raw_title)

  144.         

  145.         self.assertIsInstance(err_msgs, list)

  146.         self.assertEqual(len(err_msgs), 1)

  147.         

  148.         err_msg = err_msgs[0]

  149.         expected_err_msg = '(L001) Title should not end with "... API". Every entry is an API here!'

  150. 

  151.         self.assertEqual(err_msg, expected_err_msg)

  152. 

  153.     def test_check_description_with_correct_description(self):

  154.         desc = 'This is a fake description'

  155. 

  156.         err_msgs = check_description(0, desc)

  157. 

  158.         self.assertIsInstance(err_msgs, list)

  159.         self.assertEqual(len(err_msgs), 0)

  160. 

  161.         self.assertEqual(err_msgs, [])

  162.     

  163.     def test_check_description_with_first_char_is_not_capitalized(self):

  164.         desc = 'this is a fake description'

  165. 

  166.         err_msgs = check_description(0, desc)

  167. 

  168.         self.assertIsInstance(err_msgs, list)

  169.         self.assertEqual(len(err_msgs), 1)

  170.         

  171.         err_msg = err_msgs[0]

  172.         expected_err_msg = '(L001) first character of description is not capitalized'

  173. 

  174.         self.assertIsInstance(err_msg, str)

  175.         self.assertEqual(err_msg, expected_err_msg)

  176.     

  177.     def test_check_description_with_punctuation_in_the_end(self):

  178.         base_desc = 'This is a fake description'

  179.         punctuation = r"""!"#$%&'*+,-./:;<=>?@[\]^_`{|}~"""

  180.         desc_with_punc = [base_desc + punc for punc in punctuation]

  181.         

  182.         for desc in desc_with_punc:

  183. 

  184.             with self.subTest():

  185.                 err_msgs = check_description(0, desc)

  186. 

  187.                 self.assertIsInstance(err_msgs, list)

  188.                 self.assertEqual(len(err_msgs), 1)

  189.         

  190.                 err_msg = err_msgs[0]

  191.                 expected_err_msg = f'(L001) description should not end with {desc[-1]}'

  192. 

  193.                 self.assertIsInstance(err_msg, str)

  194.                 self.assertEqual(err_msg, expected_err_msg)

  195. 

  196.     def test_check_description_that_exceeds_the_character_limit(self):

  197.         long_desc = 'Desc' * max_description_length

  198.         long_desc_length = len(long_desc)

  199. 

  200.         err_msgs = check_description(0, long_desc)

  201. 

  202.         self.assertIsInstance(err_msgs, list)

  203.         self.assertEqual(len(err_msgs), 1)

  204. 

  205.         err_msg = err_msgs[0]

  206.         expected_err_msg = f'(L001) description should not exceed {max_description_length} characters (currently {long_desc_length})'

  207. 

  208.         self.assertIsInstance(err_msg, str)

  209.         self.assertEqual(err_msg, expected_err_msg)

  210. 

  211.     def test_check_auth_with_correct_auth(self):

  212.         auth_valid = [f'`{auth}`' for auth in auth_keys if auth != 'No']

  213.         auth_valid.append('No')

  214. 

  215.         for auth in auth_valid:

  216.             with self.subTest():

  217.                 err_msgs = check_auth(0, auth)

  218.                 self.assertIsInstance(err_msgs, list)

  219. 

  220.                 self.assertEqual(len(err_msgs), 0)

  221. 

  222.                 self.assertEqual(err_msgs, [])

  223. 

  224.     def test_check_auth_without_backtick(self):

  225.         auth_without_backtick = [auth for auth in auth_keys if auth != 'No']

  226. 

  227.         for auth in auth_without_backtick:

  228.             with self.subTest():

  229.                 err_msgs = check_auth(0, auth)

  230.                 self.assertIsInstance(err_msgs, list)

  231. 

  232.                 self.assertEqual(len(err_msgs), 1)

  233.                 

  234.                 err_msg = err_msgs[0]

  235.                 expected_err_msg = '(L001) auth value is not enclosed with `backticks`'

  236. 

  237.                 self.assertIsInstance(err_msg, str)

  238.                 self.assertEqual(err_msg, expected_err_msg)

  239. 

  240.     def test_check_auth_with_invalid_auth(self):

  241.         auth_invalid = ['Yes', 'yes', 'no', 'random', 'Unknown']

  242. 

  243.         for auth in auth_invalid:

  244.             with self.subTest():

  245.                 err_msgs = check_auth(0, auth)

  246.                 self.assertIsInstance(err_msgs, list)

  247. 

  248.                 self.assertEqual(len(err_msgs), 2)

  249.                 

  250.                 err_msg_1 = err_msgs[0]

  251.                 err_msg_2 = err_msgs[1]

  252. 

  253.                 expected_err_msg_1 = f'(L001) auth value is not enclosed with `backticks`'

  254.                 expected_err_msg_2 = f'(L001) {auth} is not a valid Auth option'

  255. 

  256.                 self.assertIsInstance(err_msg_1, str)

  257.                 self.assertIsInstance(err_msg_2, str)

  258.                 self.assertEqual(err_msg_1, expected_err_msg_1)

  259.                 self.assertEqual(err_msg_2, expected_err_msg_2)

  260. 

  261.     def test_check_https_with_valid_https(self):

  262.         for https in https_keys:

  263.             with self.subTest():

  264.                 err_msgs = check_https(0, https)

  265.                 self.assertIsInstance(err_msgs, list)

  266. 

  267.                 self.assertEqual(len(err_msgs), 0)

  268. 

  269.                 self.assertEqual(err_msgs, [])

  270. 

  271.     def test_check_https_with_invalid_https(self):

  272.         invalid_https_keys = ['yes', 'no', 'Unknown', 'https', 'http']

  273. 

  274.         for https in invalid_https_keys:

  275.             with self.subTest():

  276.                 err_msgs = check_https(0, https)

  277.                 self.assertIsInstance(err_msgs, list)

  278. 

  279.                 self.assertEqual(len(err_msgs), 1)

  280. 

  281.                 err_msg = err_msgs[0]

  282.                 expected_err_msg = f'(L001) {https} is not a valid HTTPS option'

  283. 

  284.                 self.assertIsInstance(err_msg, str)

  285.                 self.assertEqual(err_msg, expected_err_msg)

  286. 

  287.     def test_check_cors_with_valid_cors(self):

  288.         for cors in cors_keys:

  289.             with self.subTest():

  290.                 err_msgs = check_cors(0, cors)

  291.                 self.assertIsInstance(err_msgs, list)

  292. 

  293.                 self.assertEqual(len(err_msgs), 0)

  294. 

  295.                 self.assertEqual(err_msgs, [])

  296. 

  297.     def test_check_cors_with_invalid_cors(self):

  298.         invalid_cors_keys = ['yes', 'no', 'unknown', 'cors']

  299. 

  300.         for cors in invalid_cors_keys:

  301.             with self.subTest():

  302.                 err_msgs = check_cors(0, cors)

  303.                 self.assertIsInstance(err_msgs, list)

  304. 

  305.                 self.assertEqual(len(err_msgs), 1)

  306. 

  307.                 err_msg = err_msgs[0]

  308.                 expected_err_msg = f'(L001) {cors} is not a valid CORS option'

  309. 

  310.                 self.assertIsInstance(err_msg, str)

  311.                 self.assertEqual(err_msg, expected_err_msg)