logo

qmk_firmware

custom branch of QMK firmware git clone https://anongit.hacktivis.me/git/qmk_firmware.git

test_cli_commands.py (14254B)

    

  1. import platform
  2. from subprocess import DEVNULL
  4. from milc import cli
  6. is_windows = 'windows' in platform.platform().lower()
  9. def check_subcommand(command, *args):
  10.     cmd = ['qmk', command, *args]
  11.     result = cli.run(cmd, stdin=DEVNULL, combined_output=True)
  12.     return result
  15. def check_subcommand_stdin(file_to_read, command, *args):
  16.     """Pipe content of a file to a command and return output.
  17.     """
  18.     with open(file_to_read, encoding='utf-8') as my_file:
  19.         cmd = ['qmk', command, *args]
  20.         result = cli.run(cmd, stdin=my_file, combined_output=True)
  21.     return result
  24. def check_returncode(result, expected=[0]):
  25.     """Print stdout if `result.returncode` does not match `expected`.
  26.     """
  27.     if result.returncode not in expected:
  28.         print('`%s` stdout:' % ' '.join(result.args))
  29.         print(result.stdout)
  30.         print('returncode:', result.returncode)
  31.     assert result.returncode in expected
  34. def test_format_c():
  35.     result = check_subcommand('format-c', '-n', 'quantum/matrix.c')
  36.     check_returncode(result)
  39. def test_format_c_all():
  40.     result = check_subcommand('format-c', '-n', '-a')
  41.     check_returncode(result, [0, 1])
  44. def test_compile():
  45.     result = check_subcommand('compile', '-kb', 'handwired/pytest/basic', '-km', 'default', '-n')
  46.     check_returncode(result)
  49. def test_compile_json():
  50.     result = check_subcommand('compile', '-kb', 'handwired/pytest/basic', '-km', 'default_json', '-n')
  51.     check_returncode(result)
  54. def test_flash():
  55.     result = check_subcommand('flash', '-kb', 'handwired/pytest/basic', '-km', 'default', '-n')
  56.     check_returncode(result)
  59. def test_flash_bootloaders():
  60.     result = check_subcommand('flash', '-b')
  61.     check_returncode(result, [1])
  64. def test_kle2json():
  65.     result = check_subcommand('kle2json', 'lib/python/qmk/tests/kle.txt', '-f')
  66.     check_returncode(result)
  67.     assert 'Wrote out' in result.stdout
  70. def test_doctor():
  71.     result = check_subcommand('doctor', '-n')
  72.     check_returncode(result, [0, 1])
  73.     assert 'QMK Doctor is checking your environment.' in result.stdout
  74.     assert 'QMK is ready to go' in result.stdout
  77. def test_hello():
  78.     result = check_subcommand('hello')
  79.     check_returncode(result)
  80.     assert 'Hello,' in result.stdout
  83. def test_format_python():
  84.     result = check_subcommand('format-python', '-n', '-a')
  85.     check_returncode(result)
  86.     assert 'Successfully formatted the python code.' in result.stdout
  89. def test_list_keyboards():
  90.     result = check_subcommand('list-keyboards')
  91.     check_returncode(result)
  92.     # check to see if a known keyboard is returned
  93.     # this will fail if handwired/pytest/basic is removed
  94.     assert 'handwired/pytest/basic' in result.stdout
  97. def test_list_keymaps():
  98.     result = check_subcommand('list-keymaps', '-kb', 'handwired/pytest/basic')
  99.     check_returncode(result)
  100.     assert 'default' in result.stdout
  101.     assert 'default_json' in result.stdout
  104. def test_list_keymaps_long():
  105.     result = check_subcommand('list-keymaps', '--keyboard', 'handwired/pytest/basic')
  106.     check_returncode(result)
  107.     assert 'default' in result.stdout
  108.     assert 'default_json' in result.stdout
  111. def test_list_keymaps_community():
  112.     result = check_subcommand('list-keymaps', '--keyboard', 'handwired/pytest/has_community')
  113.     check_returncode(result)
  114.     assert 'test' in result.stdout
  117. def test_list_keymaps_kb_only():
  118.     result = check_subcommand('list-keymaps', '-kb', 'contra')
  119.     check_returncode(result)
  120.     assert 'default' in result.stdout
  123. def test_list_keymaps_vendor_kb():
  124.     result = check_subcommand('list-keymaps', '-kb', 'ai03/lunar')
  125.     check_returncode(result)
  126.     assert 'default' in result.stdout
  129. def test_list_keymaps_vendor_kb_rev():
  130.     result = check_subcommand('list-keymaps', '-kb', 'kbdfans/kbd67/mkiirgb/v2')
  131.     check_returncode(result)
  132.     assert 'default' in result.stdout
  135. def test_list_keymaps_no_keyboard_found():
  136.     result = check_subcommand('list-keymaps', '-kb', 'asdfghjkl')
  137.     check_returncode(result, [2])
  138.     assert 'invalid keyboard_folder value' in result.stdout
  141. def test_json2c():
  142.     result = check_subcommand('json2c', 'keyboards/handwired/pytest/basic/keymaps/default_json/keymap.json')
  143.     check_returncode(result)
  144.     assert result.stdout == """#include QMK_KEYBOARD_H
  145. #if __has_include("keymap.h")
  146. #    include "keymap.h"
  147. #endif
  150. /* THIS FILE WAS GENERATED!
  151.  *
  152.  * This file was generated by qmk json2c. You may or may not want to
  153.  * edit it directly.
  154.  */
  156. const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
  157.     [0] = LAYOUT_ortho_1x1(KC_A)
  158. };
  162. #ifdef OTHER_KEYMAP_C
  163. #    include OTHER_KEYMAP_C
  164. #endif // OTHER_KEYMAP_C
  167. """
  170. def test_json2c_macros():
  171.     result = check_subcommand("json2c", 'keyboards/handwired/pytest/macro/keymaps/default/keymap.json')
  172.     check_returncode(result)
  173.     assert 'LAYOUT_ortho_1x1(QK_MACRO_0)' in result.stdout
  174.     assert 'case QK_MACRO_0:' in result.stdout
  175.     assert 'SEND_STRING("Hello, World!"SS_TAP(X_ENTER));' in result.stdout
  178. def test_json2c_stdin():
  179.     result = check_subcommand_stdin('keyboards/handwired/pytest/basic/keymaps/default_json/keymap.json', 'json2c', '-')
  180.     check_returncode(result)
  181.     assert result.stdout == """#include QMK_KEYBOARD_H
  182. #if __has_include("keymap.h")
  183. #    include "keymap.h"
  184. #endif
  187. /* THIS FILE WAS GENERATED!
  188.  *
  189.  * This file was generated by qmk json2c. You may or may not want to
  190.  * edit it directly.
  191.  */
  193. const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
  194.     [0] = LAYOUT_ortho_1x1(KC_A)
  195. };
  199. #ifdef OTHER_KEYMAP_C
  200. #    include OTHER_KEYMAP_C
  201. #endif // OTHER_KEYMAP_C
  204. """
  207. def test_json2c_no_json():
  208.     result = check_subcommand('json2c', 'keyboards/handwired/pytest/basic/keymaps/default/keymap.c')
  209.     check_returncode(result, [1])
  210.     assert 'Invalid JSON encountered' in result.stdout
  213. def test_info():
  214.     result = check_subcommand('info', '-kb', 'handwired/pytest/basic')
  215.     check_returncode(result)
  216.     assert 'Keyboard Name: pytest' in result.stdout
  217.     assert 'Processor: atmega32u4' in result.stdout
  218.     assert 'Layout:' not in result.stdout
  219.     assert 'k0' not in result.stdout
  222. def test_info_keyboard_render():
  223.     result = check_subcommand('info', '-kb', 'handwired/pytest/basic', '-l')
  224.     check_returncode(result)
  225.     assert 'Keyboard Name: pytest' in result.stdout
  226.     assert 'Processor: atmega32u4' in result.stdout
  227.     assert 'Layouts:' in result.stdout
  229.     if is_windows:
  230.         assert '|  |' in result.stdout
  231.     else:
  232.         assert '│  │' in result.stdout
  235. def test_info_keymap_render():
  236.     result = check_subcommand('info', '-kb', 'handwired/pytest/basic', '-km', 'default_json')
  237.     check_returncode(result)
  238.     assert 'Keyboard Name: pytest' in result.stdout
  239.     assert 'Processor: atmega32u4' in result.stdout
  241.     if is_windows:
  242.         assert '|A |' in result.stdout
  243.     else:
  244.         assert '│A │' in result.stdout
  247. def test_info_matrix_render():
  248.     result = check_subcommand('info', '-kb', 'handwired/pytest/basic', '-m')
  249.     check_returncode(result)
  250.     assert 'Keyboard Name: pytest' in result.stdout
  251.     assert 'Processor: atmega32u4' in result.stdout
  252.     assert 'LAYOUT_ortho_1x1' in result.stdout
  254.     if is_windows:
  255.         assert '|0A|' in result.stdout
  256.     else:
  257.         assert '│0A│' in result.stdout
  259.     assert 'Matrix for "LAYOUT_ortho_1x1"' in result.stdout
  262. def test_c2json():
  263.     result = check_subcommand("c2json", "-kb", "handwired/pytest/basic", "-km", "default", "keyboards/handwired/pytest/basic/keymaps/default/keymap.c")
  264.     check_returncode(result)
  265.     assert result.stdout.strip() == '{"keyboard": "handwired/pytest/basic", "keymap": "default", "layout": "LAYOUT_ortho_1x1", "layers": [["KC_A"]]}'
  268. def test_c2json_stdin():
  269.     result = check_subcommand_stdin("keyboards/handwired/pytest/basic/keymaps/default/keymap.c", "c2json", "-kb", "handwired/pytest/basic", "-km", "default", "-")
  270.     check_returncode(result)
  271.     assert result.stdout.strip() == '{"keyboard": "handwired/pytest/basic", "keymap": "default", "layout": "LAYOUT_ortho_1x1", "layers": [["KC_A"]]}'
  274. def test_clean():
  275.     result = check_subcommand('clean', '-a')
  276.     check_returncode(result)
  277.     assert (result.stdout.count('done') == 2 and 'userspace' not in result.stdout) or (result.stdout.count('done') == 3 and 'userspace' in result.stdout)
  280. def test_generate_api():
  281.     result = check_subcommand('generate-api', '--dry-run', '--filter', 'handwired/pytest')
  282.     check_returncode(result)
  285. def test_generate_rgb_breathe_table():
  286.     result = check_subcommand("generate-rgb-breathe-table", "-c", "1.2", "-m", "127")
  287.     check_returncode(result)
  288.     assert 'Breathing center: 1.2' in result.stdout
  289.     assert 'Breathing max:    127' in result.stdout
  292. def test_generate_config_h():
  293.     result = check_subcommand('generate-config-h', '-kb', 'handwired/pytest/basic')
  294.     check_returncode(result)
  295.     assert '#    define DEVICE_VER 0x0001' in result.stdout
  296.     assert '#    define DIODE_DIRECTION COL2ROW' in result.stdout
  297.     assert '#    define MANUFACTURER "none"' in result.stdout
  298.     assert '#    define PRODUCT "pytest"' in result.stdout
  299.     assert '#    define PRODUCT_ID 0x6465' in result.stdout
  300.     assert '#    define VENDOR_ID 0xFEED' in result.stdout
  301.     assert '#    define MATRIX_COLS 1' in result.stdout
  302.     assert '#    define MATRIX_COL_PINS { F4 }' in result.stdout
  303.     assert '#    define MATRIX_ROWS 1' in result.stdout
  304.     assert '#    define MATRIX_ROW_PINS { F5 }' in result.stdout
  307. def test_generate_rules_mk():
  308.     result = check_subcommand('generate-rules-mk', '-kb', 'handwired/pytest/basic')
  309.     check_returncode(result)
  310.     assert 'BOOTLOADER ?= atmel-dfu' in result.stdout
  311.     assert 'MCU ?= atmega32u4' in result.stdout
  314. def test_generate_version_h():
  315.     result = check_subcommand('generate-version-h')
  316.     check_returncode(result)
  317.     assert '#define QMK_VERSION' in result.stdout
  320. def test_format_json_keyboard():
  321.     result = check_subcommand('format-json', '--format', 'keyboard', 'lib/python/qmk/tests/minimal_info.json')
  322.     check_returncode(result)
  323.     assert result.stdout == '{\n    "keyboard_name": "tester",\n    "maintainer": "qmk",\n    "layouts": {\n        "LAYOUT": {\n            "layout": [\n                {"label": "KC_A", "matrix": [0, 0], "x": 0, "y": 0}\n            ]\n        }\n    }\n}\n'
  326. def test_format_json_keymap():
  327.     result = check_subcommand('format-json', '--format', 'keymap', 'lib/python/qmk/tests/minimal_keymap.json')
  328.     check_returncode(result)
  329.     assert result.stdout == '{\n    "version": 1,\n    "keyboard": "handwired/pytest/basic",\n    "keymap": "test",\n    "layout": "LAYOUT_ortho_1x1",\n    "layers": [\n                [\n                        "KC_A"\n                ]\n    ]\n}\n'
  332. def test_format_json_keyboard_auto():
  333.     result = check_subcommand('format-json', '--format', 'auto', 'lib/python/qmk/tests/minimal_info.json')
  334.     check_returncode(result)
  335.     assert result.stdout == '{\n    "keyboard_name": "tester",\n    "maintainer": "qmk",\n    "layouts": {\n        "LAYOUT": {\n            "layout": [\n                {"label": "KC_A", "matrix": [0, 0], "x": 0, "y": 0}\n            ]\n        }\n    }\n}\n'
  338. def test_format_json_keymap_auto():
  339.     result = check_subcommand('format-json', '--format', 'auto', 'lib/python/qmk/tests/minimal_keymap.json')
  340.     check_returncode(result)
  341.     assert result.stdout == '{\n    "keyboard": "handwired/pytest/basic",\n    "keymap": "test",\n    "layers": [\n        ["KC_A"]\n    ],\n    "layout": "LAYOUT_ortho_1x1",\n    "version": 1\n}\n'
  344. def test_find_exists():
  345.     result = check_subcommand('find', '-f', 'exists(rgb_matrix.split_count)', '-p', 'rgb_matrix.split_count')
  346.     check_returncode(result)
  347.     values = [s for s in result.stdout.splitlines() if 'rgb_matrix.split_count=' in s]
  348.     assert len(values) > 0
  349.     for s in values:
  350.         assert '=None' not in s
  351.         assert '=[' in s
  354. def test_find_absent():
  355.     result = check_subcommand('find', '-f', 'absent(rgb_matrix.split_count)', '-p', 'rgb_matrix.split_count')
  356.     check_returncode(result)
  357.     values = [s for s in result.stdout.splitlines() if 'rgb_matrix.split_count=' in s]
  358.     assert len(values) > 0
  359.     for s in values:
  360.         assert '=None' in s
  361.         assert '=[' not in s
  364. def test_find_length():
  365.     result = check_subcommand('find', '-f', 'length(matrix_pins.cols, 6)', '-p', 'matrix_pins.cols')
  366.     check_returncode(result)
  367.     values = [s for s in result.stdout.splitlines() if 'matrix_pins.cols=' in s]
  368.     assert len(values) > 0
  369.     for s in values:
  370.         assert s.count(',') == 5
  373. def test_find_contains():
  374.     result = check_subcommand('find', '-f', 'contains(matrix_pins.cols, B1)', '-p', 'matrix_pins.cols')
  375.     check_returncode(result)
  376.     values = [s for s in result.stdout.splitlines() if 'matrix_pins.cols=' in s]
  377.     assert len(values) > 0
  378.     for s in values:
  379.         assert "'B1'" in s
  382. def test_find_multiple_conditions():
  383.     # this is intended to match at least 'crkbd/rev1'
  384.     result = check_subcommand(
  385.         'find', '-f', 'exists(rgb_matrix.split_count)', '-f', 'contains(matrix_pins.cols, B1)', '-f', 'length(matrix_pins.cols, 6)', '-f', 'absent(eeprom.driver)', '-f', 'ws2812.pin == D3', '-p', 'rgb_matrix.split_count', '-p', 'matrix_pins.cols', '-p',
  386.         'eeprom.driver', '-p', 'ws2812.pin'
  387.     )
  388.     check_returncode(result)
  389.     rgb_matrix_split_count_values = [s for s in result.stdout.splitlines() if 'rgb_matrix.split_count=' in s]
  390.     assert len(rgb_matrix_split_count_values) > 0
  391.     for s in rgb_matrix_split_count_values:
  392.         assert '=None' not in s
  393.         assert '=[' in s
  394.     matrix_pins_cols_values = [s for s in result.stdout.splitlines() if 'matrix_pins.cols=' in s]
  395.     assert len(matrix_pins_cols_values) > 0
  396.     for s in matrix_pins_cols_values:
  397.         assert s.count(',') == 5
  398.         assert "'B1'" in s
  399.     eeprom_driver_values = [s for s in result.stdout.splitlines() if 'eeprom.driver=' in s]
  400.     assert len(eeprom_driver_values) > 0
  401.     for s in eeprom_driver_values:
  402.         assert '=None' in s
  403.     ws2812_pin_values = [s for s in result.stdout.splitlines() if 'ws2812.pin=' in s]
  404.     assert len(ws2812_pin_values) > 0
  405.     for s in ws2812_pin_values:
  406.         assert '=D3' in s