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.
4293 Commits
2 Branches
67 MiB
 
 
Tree: bc02fa517f
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'bc02fa517f'
${ noResults }
PublicAPIs/scripts/tests/test_validate_format.py

467 lines
18 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. from validate.format import check_entry

  14. from validate.format import check_file_format, min_entries_per_category, num_segments

  15. 

  16. 

  17. class TestValidadeFormat(unittest.TestCase):

  18.     

  19.     def test_error_message_return_and_return_type(self):

  20.         line_num_unity = 1

  21.         line_num_ten = 10

  22.         line_num_hundred = 100

  23.         line_num_thousand = 1000

  24. 

  25.         msg = 'This is a unit test'

  26. 

  27.         err_msg_unity = error_message(line_num_unity, msg)

  28.         err_msg_ten = error_message(line_num_ten, msg)

  29.         err_msg_hundred = error_message(line_num_hundred, msg)

  30.         err_msg_thousand = error_message(line_num_thousand, msg)

  31. 

  32.         self.assertIsInstance(err_msg_unity, str)

  33.         self.assertIsInstance(err_msg_ten, str)

  34.         self.assertIsInstance(err_msg_hundred, str)

  35.         self.assertIsInstance(err_msg_thousand, str)

  36. 

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

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

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

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

  41. 

  42.     def test_if_get_categories_content_return_correct_data_of_categories(self):

  43.         fake_contents = [

  44.             '### A',

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

  46.             '|---|---|---|---|---|',

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

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

  49.             '',

  50.             '### B',

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

  52.             '|---|---|---|---|---|',

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

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

  55.         ]

  56. 

  57.         result = get_categories_content(fake_contents)

  58.         self.assertIsInstance(result, tuple)

  59. 

  60.         categories, category_line_num = result

  61.         self.assertIsInstance(categories, dict)

  62.         self.assertIsInstance(category_line_num, dict)

  63. 

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

  65. 

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

  67. 

  68.             with self.subTest():

  69.                 self.assertEqual(res, ex_res)

  70. 

  71.     def test_if_check_alphabetical_order_return_correct_msg_error(self):

  72.         correct_lines = [

  73.             '### A',

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

  75.             '|---|---|---|---|---|',

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

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

  78.             '',

  79.             '### B',

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

  81.             '|---|---|---|---|---|',

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

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

  84.         ]

  85. 

  86.         incorrect_lines = [

  87.             '### A',

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

  89.             '|---|---|---|---|---|',

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

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

  92.             '',

  93.             '### B',

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

  95.             '|---|---|---|---|---|',

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

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

  98.         ]

  99. 

  100. 

  101.         err_msgs_1 = check_alphabetical_order(correct_lines)

  102.         err_msgs_2 = check_alphabetical_order(incorrect_lines)

  103. 

  104.         self.assertIsInstance(err_msgs_1, list)

  105.         self.assertIsInstance(err_msgs_2, list)

  106. 

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

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

  109. 

  110.         expected_err_msgs = [

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

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

  113.         ]

  114. 

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

  116. 

  117.             with self.subTest():

  118.                 self.assertEqual(err_msg, ex_err_msg)

  119.     

  120.     def test_check_title_with_correct_title(self):

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

  122. 

  123.         err_msgs = check_title(0, raw_title)

  124. 

  125.         self.assertIsInstance(err_msgs, list)

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

  127.         self.assertEqual(err_msgs, [])

  128. 

  129.     def test_check_title_with_markdown_syntax_incorrect(self):

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

  131. 

  132.         err_msgs = check_title(0, raw_title)

  133. 

  134.         self.assertIsInstance(err_msgs, list)

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

  136.         

  137.         err_msg = err_msgs[0]

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

  139. 

  140.         self.assertEqual(err_msg, expected_err_msg)

  141. 

  142.     def test_check_title_with_api_at_the_end_of_the_title(self):

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

  144. 

  145.         err_msgs = check_title(0, raw_title)

  146.         

  147.         self.assertIsInstance(err_msgs, list)

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

  149.         

  150.         err_msg = err_msgs[0]

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

  152. 

  153.         self.assertEqual(err_msg, expected_err_msg)

  154. 

  155.     def test_check_description_with_correct_description(self):

  156.         desc = 'This is a fake description'

  157. 

  158.         err_msgs = check_description(0, desc)

  159. 

  160.         self.assertIsInstance(err_msgs, list)

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

  162.         self.assertEqual(err_msgs, [])

  163.     

  164.     def test_check_description_with_first_char_is_not_capitalized(self):

  165.         desc = 'this is a fake description'

  166. 

  167.         err_msgs = check_description(0, desc)

  168. 

  169.         self.assertIsInstance(err_msgs, list)

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

  171.         

  172.         err_msg = err_msgs[0]

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

  174. 

  175.         self.assertIsInstance(err_msg, str)

  176.         self.assertEqual(err_msg, expected_err_msg)

  177.     

  178.     def test_check_description_with_punctuation_in_the_end(self):

  179.         base_desc = 'This is a fake description'

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

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

  182.         

  183.         for desc in desc_with_punc:

  184. 

  185.             with self.subTest():

  186.                 err_msgs = check_description(0, desc)

  187. 

  188.                 self.assertIsInstance(err_msgs, list)

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

  190.         

  191.                 err_msg = err_msgs[0]

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

  193. 

  194.                 self.assertIsInstance(err_msg, str)

  195.                 self.assertEqual(err_msg, expected_err_msg)

  196. 

  197.     def test_check_description_that_exceeds_the_character_limit(self):

  198.         long_desc = 'Desc' * max_description_length

  199.         long_desc_length = len(long_desc)

  200. 

  201.         err_msgs = check_description(0, long_desc)

  202. 

  203.         self.assertIsInstance(err_msgs, list)

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

  205. 

  206.         err_msg = err_msgs[0]

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

  208. 

  209.         self.assertIsInstance(err_msg, str)

  210.         self.assertEqual(err_msg, expected_err_msg)

  211. 

  212.     def test_check_auth_with_valid_auth(self):

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

  214.         auth_valid.append('No')

  215. 

  216.         for auth in auth_valid:

  217.             with self.subTest():

  218.                 err_msgs = check_auth(0, auth)

  219.                 self.assertIsInstance(err_msgs, list)

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

  221.                 self.assertEqual(err_msgs, [])

  222. 

  223.     def test_check_auth_without_backtick(self):

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

  225. 

  226.         for auth in auth_without_backtick:

  227.             with self.subTest():

  228.                 err_msgs = check_auth(0, auth)

  229.                 self.assertIsInstance(err_msgs, list)

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

  231. 

  232.                 err_msg = err_msgs[0]

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

  234. 

  235.                 self.assertIsInstance(err_msg, str)

  236.                 self.assertEqual(err_msg, expected_err_msg)

  237. 

  238.     def test_check_auth_with_invalid_auth(self):

  239.         auth_invalid_without_backtick = ['Yes', 'yes', 'no', 'random', 'Unknown']

  240.         auth_invalid_with_backtick = ['`Yes`', '`yes`', '`no`', '`random`', '`Unknown`']

  241. 

  242.         for auth in auth_invalid_without_backtick:

  243.             with self.subTest():

  244.                 err_msgs = check_auth(0, auth)

  245.                 self.assertIsInstance(err_msgs, list)

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

  247. 

  248.                 err_msg_1 = err_msgs[0]

  249.                 err_msg_2 = err_msgs[1]

  250. 

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

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

  253. 

  254.                 self.assertIsInstance(err_msg_1, str)

  255.                 self.assertIsInstance(err_msg_2, str)

  256.                 self.assertEqual(err_msg_1, expected_err_msg_1)

  257.                 self.assertEqual(err_msg_2, expected_err_msg_2)

  258. 

  259.         for auth in auth_invalid_with_backtick:

  260.             with self.subTest():

  261.                 err_msgs = check_auth(0, auth)

  262.                 self.assertIsInstance(err_msgs, list)

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

  264. 

  265.                 err_msg = err_msgs[0]

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

  267. 

  268.                 self.assertIsInstance(err_msg, str)

  269.                 self.assertEqual(err_msg, expected_err_msg)

  270. 

  271.     def test_check_https_with_valid_https(self):

  272.         for https in https_keys:

  273.             with self.subTest():

  274.                 err_msgs = check_https(0, https)

  275.                 self.assertIsInstance(err_msgs, list)

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

  277.                 self.assertEqual(err_msgs, [])

  278. 

  279.     def test_check_https_with_invalid_https(self):

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

  281. 

  282.         for https in invalid_https_keys:

  283.             with self.subTest():

  284.                 err_msgs = check_https(0, https)

  285.                 self.assertIsInstance(err_msgs, list)

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

  287. 

  288.                 err_msg = err_msgs[0]

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

  290. 

  291.                 self.assertIsInstance(err_msg, str)

  292.                 self.assertEqual(err_msg, expected_err_msg)

  293. 

  294.     def test_check_cors_with_valid_cors(self):

  295.         for cors in cors_keys:

  296.             with self.subTest():

  297.                 err_msgs = check_cors(0, cors)

  298.                 self.assertIsInstance(err_msgs, list)

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

  300.                 self.assertEqual(err_msgs, [])

  301. 

  302.     def test_check_cors_with_invalid_cors(self):

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

  304. 

  305.         for cors in invalid_cors_keys:

  306.             with self.subTest():

  307.                 err_msgs = check_cors(0, cors)

  308.                 self.assertIsInstance(err_msgs, list)

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

  310. 

  311.                 err_msg = err_msgs[0]

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

  313. 

  314.                 self.assertIsInstance(err_msg, str)

  315.                 self.assertEqual(err_msg, expected_err_msg)

  316. 

  317.     def test_check_entry_with_correct_segments(self):

  318.         correct_segments = ['[A](https://www.ex.com)', 'Desc', '`apiKey`', 'Yes', 'Yes']

  319. 

  320.         err_msgs = check_entry(0, correct_segments)

  321.         

  322.         self.assertIsInstance(err_msgs, list)

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

  324.         self.assertEqual(err_msgs, [])

  325. 

  326.     def test_check_entry_with_incorrect_segments(self):

  327.         incorrect_segments = ['[A API](https://www.ex.com)', 'desc.', 'yes', 'yes', 'yes']

  328. 

  329.         err_msgs = check_entry(0, incorrect_segments)

  330.         expected_err_msgs = [

  331.             '(L001) Title should not end with "... API". Every entry is an API here!',

  332.             '(L001) first character of description is not capitalized',

  333.             '(L001) description should not end with .',

  334.             '(L001) auth value is not enclosed with `backticks`',

  335.             '(L001) yes is not a valid Auth option',

  336.             '(L001) yes is not a valid HTTPS option',

  337.             '(L001) yes is not a valid CORS option'

  338.         ]

  339. 

  340.         self.assertIsInstance(err_msgs, list)

  341.         self.assertEqual(len(err_msgs), 7)

  342.         for err_msg in err_msgs:

  343.             with self.subTest():

  344.                 self.assertIsInstance(err_msg, str)

  345.         self.assertEqual(err_msgs, expected_err_msgs)

  346. 

  347.     def test_check_file_format_with_correct_format(self):

  348.         correct_format = [

  349.             '## Index',

  350.             '* [A](#a)',

  351.             '* [B](#b)',

  352.             '',

  353.             '### A',

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

  355.             '|---|---|---|---|---|',

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

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

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

  359.             '',

  360.             '### B',

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

  362.             '|---|---|---|---|---|',

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

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

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

  366.         ]

  367. 

  368.         err_msgs = check_file_format(lines=correct_format)

  369. 

  370.         self.assertIsInstance(err_msgs, list)

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

  372.         self.assertEqual(err_msgs, [])

  373. 

  374.     def test_check_file_format_with_category_header_not_added_to_index(self):

  375.         incorrect_format = [

  376.             '## Index',

  377.             '',

  378.             '### A',

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

  380.             '|---|---|---|---|---|',

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

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

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

  384.         ]

  385. 

  386.         err_msgs = check_file_format(lines=incorrect_format)

  387.         expected_err_msg = '(L003) category header (A) not added to Index section'

  388. 

  389.         self.assertIsInstance(err_msgs, list)

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

  391.         err_msg = err_msgs[0]

  392.         self.assertEqual(err_msg, expected_err_msg)

  393. 

  394.     def test_check_file_format_with_category_without_min_entries(self):

  395.         incorrect_format = [

  396.             '## Index',

  397.             '* [A](#a)',

  398.             '* [B](#b)',

  399.             '',

  400.             '### A',

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

  402.             '|---|---|---|---|---|',

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

  404.             '',

  405.             '### B',

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

  407.             '|---|---|---|---|---|',

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

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

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

  411.         ]

  412. 

  413.         category_with_err = 'A'

  414.         num_in_category = 1

  415. 

  416.         err_msgs = check_file_format(lines=incorrect_format)

  417.         expected_err_msg = f'(L005) {category_with_err} category does not have the minimum {min_entries_per_category} entries (only has {num_in_category})'

  418. 

  419.         self.assertIsInstance(err_msgs, list)

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

  421.         err_msg = err_msgs[0]

  422.         self.assertEqual(err_msg, expected_err_msg)

  423. 

  424.     def test_check_file_format_entry_without_all_necessary_columns(self):

  425.         incorrect_format = [

  426.             '## Index',

  427.             '* [A](#a)',

  428.             '',

  429.             '### A',

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

  431.             '|---|---|---|---|---|',

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

  433.             '| [AB](https://www.ex.com) | Desc | `apiKey` |',  # missing https and cors

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

  435.         ]

  436. 

  437.         current_segments_num = 3

  438. 

  439.         err_msgs = check_file_format(lines=incorrect_format)

  440.         expected_err_msg = f'(L008) entry does not have all the required columns (have {current_segments_num}, need {num_segments})'

  441. 

  442.         self.assertIsInstance(err_msgs, list)

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

  444.         err_msg = err_msgs[0]

  445.         self.assertEqual(err_msg, expected_err_msg)

  446. 

  447.     def test_check_file_format_without_1_space_between_the_segments(self):

  448.         incorrect_format = [

  449.             '## Index',

  450.             '* [A](#a)',

  451.             '',

  452.             '### A',

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

  454.             '|---|---|---|---|---|',

  455.             '| [AA](https://www.ex.com) | Desc |`apiKey`| Yes | Yes |',  # space between segment of auth column missing

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

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

  458.         ]

  459. 

  460.         err_msgs = check_file_format(lines=incorrect_format)

  461.         expected_err_msg = f'(L007) each segment must start and end with exactly 1 space'

  462. 

  463.         self.assertIsInstance(err_msgs, list)

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

  465.         err_msg = err_msgs[0]

  466.         self.assertEqual(err_msg, expected_err_msg)