Python testing in Visual Studio Code (2023)

FromPython-extensionsupports testing with embedded Pythonunitram ipytest.

Some knowledge of unit testing

(If you are already familiar with unit testing, skip tosolutions.)

Aunitis a specific piece of code to test, such as a function or class.Unit teststherefore, there are other pieces of code that specifically execute a unit of code with a full range of different inputs, including edge and edge cases. Unittest and pytest frameworks can also be used to write unit tests.

Suppose you have a function to check the format of an account number that a user enters in a web form:

pok confirm format_account_number(account_array): # Return False if not valid, True if valid #...

Unit tests only apply to unitskoppel- its arguments and return values ​​- not with its implementation (that's why the code is not shown in the function body; you would often use other well-tested libraries to implement the function). In this example, the function accepts any string and returns true if the string contains a properly formed account number, otherwise it returns false.

To thoroughly test this function, you should pass in all possible inputs: valid strings, misspelled strings (with one or two characters or with invalid characters), strings that are too short or too long, empty strings, empty arguments, strings with control characters ( non-text codes), a string of HTML code, strings of injection attacks (such as SQL statements or JavaScript code), and so on. It is especially important to test security cases, such as injection attacks, if the validated string is later used in database queries or displayed in the application interface.

You then define the expected return value (or values) of the function for each input. In this example, the function should again return true only for properly formatted strings. (Whether the number itself is a real account is another matter, which can be resolved elsewhere with a database query.)

With all the arguments and expected return values, you can now write your own tests, which are code snippets that call a function with specified inputs, then compare the actual return value with the expected return value (this comparison is calledclaim):

# Import code for testingimportamplifier# Import the framework for testing (this is a hypothetical module)importtest_frame# This is a generic example, not specific to a test environmentclass Test_TestAccountValidator(test_frame.TestBaseClass): pok test_validator_valid_string(): # The exact assertion call also depends on the framework under condition(validate_account_number_format(„1234567890”),WHERE) #... pok test_validator_empty_string(): # The exact assertion call also depends on the framework under condition(validate_account_number_format(""),LIE) #... pok test_validator_sql_injection(): # The exact assertion call also depends on the framework under condition(validate_account_number_format("drop database master"),LIE) # ... tests for all other cases

The exact code structure depends on the testing platform you are using, and specific examples are provided later in this article. Anyway, as you can see, each test is simple: call the function with an argument and validate the expected return value.

The combined results of all tests is a test report that tells you whether the function (unit) behaves as expected in all test cases. This means that if the device passes all the tests, you can be sure that it will work properly. (Exercisetest-driven developmentwhere you write tests first and then write code to pass more and more tests until they all pass).

Because unit tests are small, isolated pieces of code (unit tests avoid external dependencies and use dummy data or otherwise simulated input), they are fast and cheap to run. This feature means that unit tests can be run early and often. Developers usually run unit tests before committing code to a repository; closed submission systems can also run unit tests before merging commits. Many continuous integration systems also run unit tests after each build. Running a unit test early often means you'll get the hang of it quicklyregression,these are unexpected changes in the behavior of code that previously passed all unit tests. Since a test error can easily be attributed to a specific code change, it is easy to find and fix the cause of the error, which is undoubtedly better than discovering the problem much later in the process!

Read on for general unit testing informationUnit testson Wikipedia. Please review some useful examples of unit testshttps://github.com/gwtw/py-sorting, a repository of tests of various sorting algorithms.

Example of test instructions

Python tests are Python classes that reside in separate files from the code under test. Each test framework specifies the structure and naming of tests and test files. After you write your tests and enable the test environment, VS Code locates those tests and provides various commands to run and debug them.

In this section, create a folder and open it in VS Code. Then create a file calledinc_dec.pywith the following test code:

pok to increase(x): yieldx +1pok reduction(x): yieldX -1

With this code, you can experience working with tests in VS Code, as described in the following sections.

Set the tests

After installing the Python extension and opening the Python file in the editor, a test beaker icon will appear in the VS Code activity bar. The cup icon is forTest Explorerdisplay. When you open Test Explorer, you will see the fileSet the testsif you don't have the testing framework enabled. After selectingSet the testsyou will be asked to select the test environment and the folder containing the tests. If you use unittest, you will also be prompted to select a sample glob file to use to identify the test files.

Remark: A global file pattern is a defined string pattern that matches file or folder names based on wildcards and then includes or excludes them.

You can set up your tests at any time using a filePython: set testsfrom regulationCommand palette. Testing can also be configured manually by setting uppython.testing.unittestEnabledLubpython.testen.pytestEnabled, which can be done in the settings editor or in thesettings.jsonfile as described in VS CodeInstitutionsdocumentation. Each platform also has specific configuration settings, as described in SecTest the configuration settingsfor their flyers and designs.

If both platforms are enabled, only the python extension will workpytest.

If you enable pytest, VS Code will prompt you to install the framework if it is not already present in the currently running environment:

Create tests

Each testing framework has its own conventions for naming test files and structuring tests within the framework, as described in the following sections. Each case contains two test methods, one of which is intentionally set to fail for demonstration purposes.

Testing in a unit test

Create a file namedtest_jednostkitest.pywhich contains a test class with two test methods:

importinc_dec# Test codeimportunit# Testni kadroviclass Test_TestIncrementDecrement(unit.Test case): pok text_increment(Sam): Sam.assertEqual(inc_dec.increment(3),4) # This test is intended to fail for demonstration purposes. pok test_val(Sam): Sam.assertEqual(inc_dec.decrement(3),4)I __do__=='__main__':unit test.main()

Testing on demand

Create a file namedtest_pytest.pywhich contains two test methods:

importinc_dec# Test codepok text_increment(): under conditioninc_dec.increment(3) ==4# This test is intended to fail for demonstration purposes.pok test_val(): under conditioninc_dec.decrement(3) ==4

The test will reveal

By default, the Python extension attempts to detect tests when the environment is enabled. You can also activate test detection at any time withTest: refresh the testscommand from the command palette.

python.testing.autoTestDiscoverOnSaveEnabledplacedWHEREby default, which means test detection is also triggered automatically when you add, delete, or update a python file in your workspace. To disable this function, set the value toLIE, which can be done in the settings editor or in thesettings.jsonfile as described in VS CodeInstitutionsdocumentation. You must reload the window for this setting to take effect.

Test Discovery applies the discovery patterns for the current frame (which can be changed using theTest the configuration settings). The default behavior is as follows:

• python.testen.unittestArgs: search for any python (.py) with "test" in the name in the top-level project folder. All test files must be importable modules or packages. You can customize the file matching pattern using-Pconfiguration settings and customize the folder with the file-Tinstitution.

• python.testing.pytestArgs: search for any python (.py) whose name starts with "test_" or ends with "_test" is located somewhere in the current directory and all subdirectories.

Advice: Sometimes tests placed in subfolders are not detected because such test files cannot be imported. Create an empty file named__init__.pyin this folder.

If the test detection is successful, the tests will be displayed in the test viewer:

If detection fails (for example, the test framework is not installed or there is a syntax error in the test file), an error message is displayed in Test Explorer. You can checkPythonoutput panel to see the full error message (use the fileDisplay>Exitmenu command to displayExitpanel, then selectPythonfrom the drop-down list on the right).

Once VS Code recognizes the tests, it offers several ways to run those tests, as described inRun tests.

Run tests

You can run the tests in one of the following ways:

• With the test file open, select the green run icon that appears in the space next to the test definition line, as shown in the previous section. This command executes only that one method.

  

• CombiCommand paletteby running one of the following commands:

  • Test: Run all tests- Runs all detected tests.
  • Test: Run tests on the current file- Runs all tests in the file opened in the editor.
  • Test: Move the test cursor- Executes only the test method under the cursor in the editor.

• CombiTest Explorer:

  • Select the play button at the top to run all detected testsTest Explorer:

    

  • To run a specific group of tests or a single test, select a file, class, or test, then select the play button to the right of that item:

    

  • You can also run selected tests using the Test Explorer. do this,Ctrl+click(DearCmd+klikon macOS) on the tests you want to run, right-click them, then select themRun the test.

After a test run, VS Code displays the results directly in the editor as gutter decorations. Failed tests are also highlighted in the editor, with a preview showing the test run error message and a history of all test runs. You can pressTo escapeto close the view and you can disable it by opening the user settings (Settings: Open Settings (UI)to command inCommand palette) and change the valueTesting: automatic preview openingsettingNever.

wTest Explorer, the results for each test and any classes or files containing those tests are displayed. Folders display a failed icon if any of the tests in that folder fail.

VS Code also displays the test resultsPython test logoutput panel.

Run tests in parallel

Support for running tests in parallel with pytest is available atpytest-xdistpackage. To enable parallel testing:

1. Open the integrated terminal and installpytest-xdistpackage. For more information, please seeproject documentation page.

   For windows

   py-3-m pip install pytest-xdist

   For macOS/Linux

   python3 -m pip instalater pytest-xdist

2. Then create a file calledthis pytestin the project directory and add the content below, specifying the number of processors you want to use. For example, to configure it for 4 CPUs:

   [pytest] contract=-n4

   Or if you usepyproject.tomlduration

   [tool.pytest.ini_options] contract="-n 4"

3. Run tests that are now running in parallel.

Debugging testing

Sometimes you may need to go through and analyze the tests in the debugger because the tests themselves have a flaw in the code that you need to find or to better understand why the tested area of ​​code is not working. To learn more about debugging or to understand how it works in VS Code, read onPython-foutpospresing configand generic VS codeDebugowanieArticle.

For exampletest_valthe default functions fail because the assertion itself is false. The following steps show you how to analyze the test:

1. Set the breakpoint at the first line in the filetest_valfunction.

2. Right-click the gutter ornament next to the attribute definition and selectDebug-testor chooseDebug-testicon next to this test wTest Explorer. VS Code starts the debugger and stops at a breakpoint.

   

3. wDebug consoleboard, enterinc_dec.decrement(3)to see that the actual score is 2, while the expected score given in the test is the incorrect value of 4.

4. Stop the debugger and correct the wrong code:

   #unitSam.assertEqual(inc_dec.decrement(3),2)#pytestunder conditioninc_dec.decrement(3) ==2

5. Save the file and run the tests again to confirm they pass and check that the gutter trim also shows a pass status.

   Remark: When you run a test or debug, the test file is not saved automatically. Remember to always save your test changes before you run it, otherwise you'll likely get confused by the results as they still reflect the previous version of the file!

You can use the following commands from the command palette to debug tests:

• Test: Fout tracking in all tests- Start the debugger for all tests in the workspace.
• Test: Fix the tests in the current file- Run the debug tests defined in the file opened in the editor.
• Test: Cursor debug test- Run the debugger only for the method where the cursor is pointed to the editor. You can also use the so-calledDebug-testicon in Test Explorer to launch the debugger for all tests in the selected scope and all tests found.

You can also change the default behavior of clicking gutter borders to debug tests instead of running them by modifying a filetestiranje.defaultGutterClickActionset the value todebuggingin yourssettings.jsonduration.

The debugger works with tests in the same way as other Python code, including breakpoints, variable inspections, and so on. To customize the debug test settings, you can specify"cel": ["foutopsporingstest"]wrun.jsonbestand w.vscodefolder from your workspace. This configuration is used at startupTest: Fout tracking in all tests,Test: Fix the tests in the current fileandTest: Cursor debug testcommandos.

For example, the following configuration in the filerun.jsonfile is disabledtylkoMójKodsetup debug test:

{ "to do":"Python: foutopsporingstests", "tip":"Python", "Application":"start", "plan":"${stock}", "intention": ["debug test"], "comfort":"integrated terminal", "only my code":LIE}

If you have more than one configuration item s"cel": ["foutopsporingstest"], the first definition is used because we currently do not support multiple definitions for this type of request.

Commando's testen

Below are all supported commands for testing with the Python extension in VS Code. All can be found using the command palette:

IntelliSense za pytest

pilanceoffers IntelliSense features to help you work more efficientlypytest connectorsandparametric testing.

As you enter the test function parameters, Pylance gives you an inventoryaccessorieswhich contains the names of the z arguments@pytest.mark.parameterizedecorators and existing pytest devices defined in the test file or in thekonkurs.py.Code navigationfeatures likeGo to definitionandFind all referencesandrenaming symbol refactoringare also supported.

When you hover over a device reference or a parameterized argument reference, Pylance displays a derived type annotation, either based on the values ​​returned from the device or based on the derived types of the arguments passed to the parameter setter.

Pylance also offerscode actionsto add type flags to test functions that have repair parameters. Insertion of hints for derived lamp parameter types can also be enabled by settingpython.analysis.inlayHints.pytestParametersRadeWHEREin user settings.

Test the configuration settings

Python test behavior is based on global VS Code UI settings, as well as settings specific to Python and each enabled framework.

General user interface settings

The settings that affect the test interface are provided by VS Code itself and can be found in theVS Code Settings Editorwhen you search for "Test".

General Python settings

unit test configuration settings

The arguments of the standard unit test are as follows:

• -wsets the default verbosity. Remove this argument for simpler output.
• -S .specifies the home directory for test discovery. If you have tests in the "test" folder, change the argument to-attempt(meaning'-s', 'test'in the table of arguments).
• -p *test*.pyis the discovery pattern used to search for tests. In this case it is accidental.pyfile containing the word "test". If you rename your test files, such as appending "_test" to each file name, use a pattern like*_test.pyin the corresponding field argument.

To stop the test run on the first failure, add a quick fail option"-F"in the table of arguments.

SeeUnittest command line interfacefor the full range of available options.

pytest configuration settings

You can also configure pytest with a filethis pytestfile as described inpytest configuration.

RemarkIf you installed the pytest-cov coverage module, VS Code doesn't stop at breakpoints during debugging because pytest-cov uses the same technique to access the source code you're running. Enable to prevent this behavior-- These peopleWpytestArgswhen debugging tests, for example by adding"env": {"PYTEST_ADDOPTS": "--no-cov"}for debugging configuration. (SeeDebugging testingabove on how to configure this startup configuration.) (For more information seeFoutopsporing u PyCharmuin the pytest-cov documentation.)

IntelliSense settings

Also see

• Python environments- Specify which python interpreter is used for editing and debugging.
• Item reference- Explore the full range of Python-related settings in VS Code.

20.01.2023