PythonTest

Explore Python dependencies with `pipdeptree` and `uv pip tree`

Tue, 11 Nov 2025 07:24:00 +0800

Sometimes you just want to know about your dependencies, and their dependencies.

I’ve been using pipdeptree for a while, but recently switched to uv pip tree.
Let’s take a look at both tools.

pipdeptree

pipdeptree is pip installable, but I don’t want pipdeptree itself to be reported alongside everything else installed, so I usually install it outside of a project. We can use it system wide by:

Installing with uv tool install pipdeptree.
- Then running with pipdeptree --python auto
Running without installing with uvx pipdeptree --python auto

usage

The --python auto tells pipdeptree to look at the current environment.

Announcing the Lean TDD book

Sun, 02 Nov 2025 00:00:00 +0000

There are many great ideas that I’ve gotten from TDD, Lean, Pragmatic, and more. For the past few years, I’ve really wanted to write a book about TDD, with an emphasis on using Lean teachings to cut out all the waste, and then grow TDD into more of a project wide process.

To motivate myself to just get it done finally, I’ve started. And I’m using a holistic project wide process.

Polite lazy imports for Python package maintainers

Sun, 26 Oct 2025 23:13:00 +0800

If you are a maintainer of a Python package, it’s nice if you pay attention to the time it takes to import your package.

Further, if you’ve got a Python package with multiple components where it’s probable that many users will only use part of the package, then it’s super nice if you set up your __init__.py files for lazy importing.

Previously - lazy importing other packages

In Python lazy imports you can use today, I discussed:

Python lazy imports you can use today

Mon, 13 Oct 2025 19:00:00 +0800

There’s a proposal, PEP 810 – Explicit lazy imports for Python to natively support lazy importing starting in Python 3.15.

However, it has not been accepted yet, and even if it is accepted, 3.15 is a year away. What do we do now?

The techniques covered in this post that allow you to use lazy importing NOW with Python 3.13, Python 3.12, …, really every version of Python.

Let’s look at a small code example that imports something.

Installing Python 3.14 on Mac or Windows

Fri, 10 Oct 2025 20:14:00 +0800

The easiest way to install Python 3.14 (or 3.13, 3.12, 3.11, 3.10, 3.10, …)

I originally wrote this post in 2022 for Python 3.11.
From 2022 through 2024, I remained of the belief that installing from python.org was the best option for most people.

However, 2025 changed that for me, with uv and uv python supporting the installation of Python versions. It’s a really pleasant and clean way to keep Python versions up to date and install new versions.

Testing against Python 3.14

Fri, 10 Oct 2025 16:10:00 +0800

Python 3.14 is here.

If you haven’t done so, it’s time to update your projects to test against 3.14.

The following procedure is what I’m following for a handful of projects. Your process of course may be different if you use different tools.

Honestly, I’m partly writing this down so I don’t have to remember it all in a year when 3.15 rolls around.

Installing Python 3.14

Installing with uv

uv self update
uv python install 3.14

While it’s true that creating a virtual environment with uv venv .venv --python 3.14 will install 3.14 if it isn’t already there, you still gotta run uv self update. So I just usually install it while I’m at it.

pytest-check 2.6.0 release

Mon, 06 Oct 2025 21:30:00 +0800

There’s a new release of pytest-check. Version 2.6.0.

This is a cool contribution from the community.

The problem

In July, bluenote10 reported that check.raises() doesn’t behave like pytest.raises() in that the AssertionError returned from check.raises() doesn’t have a queryable value.

Example of pytest.raises():

with pytest.raises(Exception) as e:
    do_something()
assert str(e.value) == "<expected error message>"

We’d like check.raises() to act similarly:

with check.raises(Exception) as e:
    do_something()
assert str(e.value) == "<expected error message>"

But that didn’t work prior to 2.6.0. The issue was that the value returned from check.raises() didn’t have any .value atribute.

Timeline of Selected Software Events

Sat, 13 Sep 2025 00:00:00 +0000

There are a lot of events in the history of software development. This is a list of dates that have some significance in either the stuff I work with or methodologies. I’ve compiled this list for my own benefit in thinking about my history and how these things have led to my current software philosophies.

I’m publishing the list as a “what the heck, why not?” kinda thing. If I’ve gotten something wrong, feel free to contact me.

Python People podcast now at pythontest.com/pythonpeople

Fri, 05 Sep 2025 00:00:00 +0000

Like the recent archival of Test and Code, the Python People podcast has also moved. Python People is now at pythontest.com/pythonpeople.

Is it also archived? As in done?

I don’t think so. I think I might start that up again at some point.

But for now, it’s on a long-ish term pause.

BTW, the RSS feeds for both Python People and Test and Code should be redirected correctly, so you shouldn’t have to change anything in your podcast player.

Test and Code Archive is now available

Mon, 01 Sep 2025 00:00:00 +0000

I really appreciate all of the positive feedback I’ve gotten when I announced that I was stopping the Test & Code podcast. I mean, I didn’t get any “good idea, you that’s a terrible show” feedback, thankfully.
But I did get a lot of people saying that I should keep it alive somehow.

So, it’s now archived here: Test and Code Archive

That link also includes a link to the xml that you need if you want to plop that into the “subscribe via URL” box on really any podcast player.

Test and Code 238 - So Long, and Thanks for All the Fish

Fri, 15 Aug 2025 00:00:00 +0000

A farewell to a fun 10 years.

Also, I should have tested it better. :)
In the audio I got the numbers wrong. Doh!
This is episode 238, not 237. Oh well.

I'll still be around, of course, at:

pythontest.com - where I write about developing software with tests
pythonbytes.fm - Python news and headlines, delivered directly to your earbuds

Thanks for all the fun over the last 10 years.
I wish you the best.

Test and Code 237 - FastAPI Cloud - Sebastián Ramírez

Mon, 11 Aug 2025 00:00:00 +0000

In this episode, Brian interviews Sebastián Ramírez, creator of FastAPI, about its rapid rise in developer popularity and the launch of FastAPI Cloud. Sebastian explains how FastAPI Cloud addresses deployment challenges small teams face. He shares his transition from open-source to startup founder, focusing on simplifying deployment against the complexity of tools like Kubernetes.

Links:

pytest fixtures nuts and bolts - revisited

Wed, 06 Aug 2025 06:13:00 -0700

In 2013/2014 I wrote a 4 part series on pytest fixtures.
It started out fine-ish. And then by part 4 I crammed way too many concepts into one huge post.

Well, I’ve recently reviewed all of this, and

split the posts into one concept each
made sure all of the info was correct for modern versions of Python and pytest
reran the examples to make sure the output is correct

Here’s the new/old series:

Test and Code 236 - Git Tips for Testing - Adam Johnson

Wed, 30 Jul 2025 00:00:00 +0000

In this episode, host Brian Okken and guest Adam Johnson explore essential Git features, highlighted by Adam's updated book, "Boost Your Git DX."

Key topics include

"cherry picking" for selective commits
"git stash" for managing in-progress work
"git diff", and specifically its `--name-only` flag, which provides a streamlined method for developers to identify which files have changed, which can be used to determine which tests need to be run
"git bisect" for efficiently pinpointing bugs.

This conversation offers valuable strategies for developers at any skill level to enhance their Git proficiency and optimize their coding workflows.

Test and Code 235 - pytest-django - Adam Johnson

Tue, 22 Jul 2025 00:00:00 +0000

In this episode, special guest Adam Johnson joins the show and examines pytest-django, a popular plugin among Django developers. He highlights its advantages over the built-in unittest framework, including improved test management and debugging. Adam addresses transition challenges, evolving fixture practices, and offers tips for optimizing test performance. This episode is a concise guide for developers looking to enhance their testing strategies with pytest-django.

Time Machine back to 2012

Tue, 27 May 2025 00:00:00 +0000

I’m doing some blog cleanup.

New look

I just recently have this shiny new theme for the blog.
I’m really loving the colors, and the ability to shamelessly plug my courses in the right side-bar. (Below the content if you’re reading on mobile).

New analytics

I don’t want to track anyone.

But I do want to know:

which posts are popular
which not so much
what are people 404-ing on

To that end, I was using Netlify server side analytics.
It was ok, but also rather restrictive.

Unravelling t-strings with pytest

Mon, 26 May 2025 09:22:00 +0800

Brett Cannon recently released a great article explaining how Python 3.14’s new t-strings work.

Here’s the article: Unravelling t-strings.

He built up the functionality of how t-strings work in a way that you can follow along even if you don’t have 3.14.0b1 (where t-strings are instroduced), all the way up to the last example.

He walks through

Evaluating the Python expression
Applying specified conversions
Applying format specs
Using an Interpolation class to hold details of replacement fields
Using Template class to hold parsed data

The end result is very close to an example used in PEP 750.

Test and Code 234 - pytest-metadata - provides access to test session metadata

Wed, 07 May 2025 00:00:00 +0000

pytest-metadata is described as a plugin for pytest that provides access to test session metadata.
That is such a humble description for such a massively useful plugin.
If you're already using pytest-html, you have pytest-metadata already installed, as pytest-metadata is one of the dependencies for pytest-html.
However, pytest-metadata is very useful even on its own.

Links:

pytest-metadata - The plugin we're talking about in this episode
pytest-base-url - Adds the base URL to the metadata.
pytest-html - Displays the metadata at the start of each report.
- See S2:E6: pytest-html - a plugin that generates HTML reports for test results
pytest-reporter-html1 - Presents metadata as part of the report.
pytest-selenium - Adds the driver, capabilities, and remote server to the metadata.

If you've got other plugins that work well with pytest-metadata, please let me know.

Test and Code 233 - pytest-check - allow multiple failures per test

Fri, 02 May 2025 00:00:00 +0000

pytest-check is a pytest plugin that allows multiple failures per test.

Normally, a test function will fail and stop running with the first failed assert. That's totally fine for tons of kinds of software tests. However, there are times where you'd like to check more than one thing, and you'd really like to know the results of each check, even if one of them fails.

Test and Code 232 - The role of AI in software testing - Anthony Shaw

Fri, 25 Apr 2025 00:00:00 +0000

AI is helping people write code.
Tests are one of those things that some people don't like to write.

Can AI play a role in creating automated software tests?
Well, yes. But it's a nuanced yes.

Anthony Shaw comes on the show to discuss the topic and try to get AI to write some test for my very own cards project.

Test and Code 231 - pytest-repeat - works fine on Python 3.14

Thu, 10 Apr 2025 00:00:00 +0000

pytest-repeat

is a pytest plugin that makes it easy to repeat a single test, or multiple tests, a specific number of times.
works fine on Python 3.14
is tested on Python 3.9-3.14
probably works fine still on 3.7 & 3.8

This episode also discusses the attempted April Fools episode.

Links:

pytest-repeat
The April Fools episode: Python 3.14 won't repeat with pytest-repeat

Test and Code 230 - Python 3.14 won't repeat with pytest-repeat

Tue, 01 Apr 2025 00:00:00 +0000

pytest-repeat is a pytest plugin that makes it easy to repeat a single test, or multiple tests, a specific number of times.

Note: This was an April Fools attempt, so the statement ...
"Unfortunately, it doesn't seem to work with Python 3.14, even though there is no rational reason why it shouldn't work."
... is NOT true.

Listen to the NEXT episode to get an explanation

Test and Code 229 - pytest-html - a plugin that generates HTML reports for test results

Thu, 27 Mar 2025 00:00:00 +0000

pytest-html has got to be one of my all time favorite plugins.
pytest-html is a plugin for pytest that generates a HTML report for test results.
This episode digs into some of the super coolness of pytest-html.

Transcript

pytest-html has got to be one of my all-time favorite plugins. pytest-html is a plugin for pytest that generates an HTML report for test results. This episode digs into some of the super coolness of this plugin. Getting started with pytest-html is easy enough. You just run pytest with an –html flag and give it a file name, like something like report.html or something, and it will generate a report. By default, it actually puts a bunch of the extra stuff, like the CSS and everything, into a directory. But you can pass in a flag, –self-contained-html, and it will stick all of that into one file.

Test and Code 228 - pytest-md and pytest-md-report - Markdown reports for pytest

Fri, 28 Feb 2025 00:00:00 +0000

Markdown reports as either text or markdown tables.
Two fun plugins discussed.

Links:

Transcript

The standard pytest output is actually pretty good. It’s come a long way since I started using pytest. There’s nice percentages if even by default, you can see the test files that ran and all the test cases themselves show up as dots for passing. And and then a percent of the the test suite complete shows up on the right. And it’s pretty nice, actually.

Test and Code 227 - Mocking in Python with unittest.mock - Michael Foord

Fri, 07 Feb 2025 00:00:00 +0000

This episode is a replay of a 2021 interview I did with Michael Foord.
We lost Michael in January, and I'd like to revisit this interview as a tribute.

Michael Foord was a pivotal figure in the Python community and the creator of the mock library that's now unittest.mock.
But he did so much more as well.
His contributions continue to resonate within the developer community.
This interview is just a small peek at his influence.

Test and Code 226 - pytest-mock - Mocking in pytest

Fri, 31 Jan 2025 00:00:00 +0000

pytest-mock is currently the #3 pytest plugin.
pytest-mock is a wrapper around unittest.mock.

In this episode:

Why the pytest-mock plugin is awesome
What is mocking, patching, and monkey patching
What, if any, is the difference between mock, fake, spy, stub.
Why we might need these in testing
Some history of mock in Python and how mock became unittest.mock
From unittest.mock
- patch.object
- patch.object with autospec
- using these as context managers
pytest-mock:
- The mocker fixture
- Cleanup in teardown
- Using mocker.patch, mocker.spy, and mocker.stub
- Why it's awesome and why you might want to use it over straight unittest.mock

Links:

Test and Code 225 - pytest-cov - The pytest plugin for measuring coverage

Thu, 23 Jan 2025 00:00:00 +0000

pytest-cov is a pytest plugin that helps produce coverage reports using Coverage.py.

In this episode, we'll discuss:

what Coverage.py is
why you should measure code coverage on both your source and test code
what pytest-cov is
extra features pytest-cov gives you over and above coverage.py
and generally why using both is awesome

Links:

Errata:

I mentioned that Coverage has the ability to show context (which line is covered by which test) for the past year or so.
- However, that feature was released in Oct 2018. coverage 5.0 alpha
- That's over 6 years. Oops. Sorry Ned.

Test and Code 224 - pytest plugins - a full series

Fri, 10 Jan 2025 00:00:00 +0000

This episode kicks off a series on pytest plugins.

In this episode:

Introduction to pytest plugins
The pytest.org pytest plugin list
Finding pytest related packages on PyPI
The Top pytest plugins list on pythontest.com
Exploring popular plugins
Learning from plugin examples

Links:

Top pytest plugins list
pytest.org plugin list
Top PyPI Packages
And links to plugins mentioned in the show can be found at pythontest.com/top-pytest-plugins

Transcript

I started using pytest primarily for the fixture system. pytest fixtures are kind of like setup and teardown in other test systems, but way more modular and flexible and usable across a test suite, and you can share them with other projects through the plugin system. The pytest plugin system allows plugins to share fixtures, but also allows them to share hook functions. So what’s a hook function?

Testing some tidbits with pytest

Mon, 16 Dec 2024 07:00:00 +0800

I noticed a fun post by Ned Batchelder called Testing some tidbits.

The post looks at different ways to see if a string has only 0 or 1 in it.

He posted a few ways on Bluesky/Mastodon and got a bunch of replies with more ways. And then wrote a small script to check to see if they worked.

It’s a fun post, and from it I learned about:

cleandoc - a way to strip leading blank space and maintain code block indentation
partition - splitting strings based on a substring
Using | to pass imports to eval() - I don’t use eval much.

I was a little dissapointed that with a title like “Testing some tidbits”, Ned didn’t use pytest or any other test framework.

Test and Code 223 - Writing Stuff Down is a Super Power

Sat, 16 Nov 2024 00:00:00 +0000

Taking notes well can help to listen better, remember things, show respect, be more accountable, free up mind space to solve problems.

This episode discusses

the benefits of writing things down
preparing for a meeting
taking notes in meetings
reviewing notes for action items, todo items, things to follow up on, etc.
taking notes to allow for better focus
writing well structured emails
writing blog posts and books

Start Here

Sun, 20 Oct 2024 00:00:00 +0000

If you’re looking for a great place to learn pytest, I recommend the course or book below.

However, I’m biased, as I’m the creator of both.

Resources

Python Testing with pytest, 2nd Edition - book - Great for learning pytest offline
pytest Courses - video - Great for learning pytest online
PythonTest Community - Discord community focused on pytest - ask/answer pytest and other testing questions

Topics I’ve talked about

If you’re looking for an old post, there’s the archive, of course.

Test and Code 222 - Import within a Python package

Sat, 07 Sep 2024 00:00:00 +0000

In this episode we're talking about importing part of a package into another part of the same package.

We'll look at: `from . import module` and `from .module import something`

and also: `import package` to access the external API from with the package.

Why would we use `import package` if `from . import api` would work fine?

Top pytest Plugins

Sun, 25 Aug 2024 00:00:00 +0000

This is intended to find the most popular (as determined by download count) pytest plugins, as plugins usually have “pytest” in the name.
Counts are the number of downloads over 30 days.

The list

Data last updated: 2026-03-01 07:34:08

#	Package	Downloads	Summary
1	pytest-cov	125,305,202	pytest plugin for measuring coverage. Test and Code episode pytest-cov : The pytest plugin for measuring coverage
2	pytest-asyncio	117,135,896	pytest support for asyncio
3	pytest-xdist	78,297,479	pytest xdist plugin for distributed testing, most importantly across multiple CPUs
4	pytest-mock	69,170,032	Thin-wrapper around the mock package for easier use with pytest Test and Code episode pytest-mock : Mocking in pytest
5	pytest-timeout	37,182,213	pytest plugin to abort hanging tests
6	pytest-rerunfailures	25,663,680	pytest plugin to re-run tests to eliminate flaky failures
7	pytest-metadata	24,408,102	pytest plugin for test session metadata Test and Code episode pytest-metadata - provides access to test session metadata
8	pytest-json-ctrf	22,842,493	pytest plugin to generate json report in CTRF (Common Test Report Format)
9	hypothesis	20,982,553	The property-based testing library for Python Includes a small pytest plugin.
10	pytest-html	17,563,741	pytest plugin for generating HTML reports Test and Code episode pytest-html - a plugin that generates HTML reports for test results
11	pytest-env	15,943,891	pytest plugin that allows you to add environment variables.
12	pytest-django	11,603,452	A Django plugin for pytest. Test and Code episode pytest-django with Adam Johnson
13	pytest-split	10,533,490	pytest plugin which splits the test suite to equally sized sub suites based on test execution time.
14	pytest-repeat	8,350,041	pytest plugin for repeating tests Test and Code episode pytest-repeat - works fine on Python 3.14
15	pytest-benchmark	8,315,492	A `pytest` fixture for benchmarking code. It will group the tests into rounds that are calibrated to the chosen timer.
16	pytest-socket	7,601,339	pytest Plugin to disable socket calls during tests
17	pytest-json-report	7,564,182	A pytest plugin to report test results as JSON files Seems no longer supported, but leaving here to recommend pytest-json-report-wip
18	pytest-unordered	6,973,050	Test equality of unordered collections in pytest
19	syrupy	6,620,009	pytest Snapshot Test Utility
20	pytest-custom-exit-code	6,158,551	Exit pytest test session with custom exit code in different scenarios
21	pytest-icdiff	5,928,051	use icdiff for better error messages in pytest assertions
22	pytest-instafail	5,873,996	pytest plugin to show failures instantly
23	pytest-base-url	5,641,589	pytest plugin for URL based testing
24	allure-pytest	5,322,892	Allure pytest integration
25	pytest-playwright	5,170,972	A pytest wrapper with fixtures for Playwright to automate web browsers
26	pytest-sugar	5,112,898	pytest-sugar is a plugin for pytest that changes the default look and feel of pytest (e.g. progressbar, show tests that fail instantly).
27	pytest-httpx	5,064,018	Send responses to httpx.
28	pytest-ordering	5,037,417	pytest plugin to run your tests in a specific order
29	pytest-randomly	4,780,644	pytest plugin to randomly order tests and control random.seed.
30	pytest-order	4,041,347	pytest plugin to run your tests in a specific order
31	pytest-postgresql	3,991,269	Postgresql fixtures and fixture factories for pytest.
32	pytest-subtests	3,690,646	unittest subTest() support and subtests fixture Test and Code episode Subtests in Python with unittest and pytest
33	pytest-dotenv	3,685,182	A py.test plugin that parses environment files before running tests
34	pytest-httpserver	3,145,931	pytest-httpserver is a httpserver for pytest
35	pytest-recording	3,087,825	A pytest plugin powered by VCR.py to record and replay HTTP traffic
36	pytest-retry	3,020,640	Adds the ability to retry flaky tests in CI environments
37	pytest-aiohttp	3,018,940	pytest plugin for aiohttp support
38	pytest-check	2,954,706	A pytest plugin that allows multiple failures per test. Test and Code episode pytest-check - allow multiple failures per test
39	pytest-homeassistant-custom-component	2,801,887	Experimental package to automatically extract test plugins for Home Assistant custom components
40	pytest-assume	2,447,318	A pytest plugin that allows multiple failures per test
41	pytest-dependency	2,329,886	Manage dependencies of tests
42	pytest-random-order	2,284,243	Randomise the order in which pytest tests are run with some control over the randomness
43	pytest-test-groups	2,083,376	A pytest plugin for running a subset of your tests by splitting them in to equally sized groups.
44	pytest-bdd	2,050,511	BDD for pytest
45	pytest-vcr	2,025,627	Plugin for managing VCR.py cassettes
46	pytest-github-actions-annotate-failures	2,007,505	pytest plugin to annotate failed tests with a workflow command for GitHub Actions
47	pytest-freezegun	1,866,755	Wrap tests with fixtures in freeze_time
48	pytest-profiling	1,845,617	Profiling plugin for py.test
49	pytest-timeouts	1,828,904	Linux-only pytest plugin to control durations of various test case execution phases
50	pytest-codspeed	1,798,294	pytest plugin to create CodSpeed benchmarks
51	pytest-snapshot	1,755,451	A plugin for snapshot testing with pytest.
52	pytest-celery	1,750,171	pytest plugin for Celery
53	pytest-factoryboy	1,625,085	Factory Boy support for pytest.
54	pytest-docker-tools	1,610,018	Docker integration tests for pytest
55	pytest-watcher	1,540,853	Automatically rerun your tests on file modifications
56	pytest-testmon	1,526,670	selects tests affected by changed files and methods
57	pytest-memray	1,425,108	A simple plugin to use with pytest
58	pytest-lazy-fixture	1,280,740	It helps to use fixtures in pytest.mark.parametrize
59	pytest-flask	1,262,488	A set of py.test fixtures to test Flask applications.
60	pytest-durations	1,213,197	pytest plugin reporting fixtures and test functions execution time.
61	pytest-docker	1,181,569	Simple pytest fixtures for Docker and Docker Compose based tests
62	pytest-datadir	1,057,704	pytest plugin for test data directories and files
63	pytest-flakefinder	1,010,174	Runs tests multiple times to expose flakiness.
64	pytest-find-dependencies	922,621	A pytest plugin to find dependencies between tests
65	pytest-race	889,881	Race conditions tester for pytest
66	pytest-pretty	865,708	pytest plugin for printing summary data as I want it
67	pytest-watch	855,265	Local continuous test runner with pytest and watchdog.
68	pytest-alembic	841,571	A pytest plugin for verifying alembic migrations.
69	pytest-freezer	778,522	pytest plugin providing a fixture interface for spulec/freezegun
70	pytest-testinfra	767,645	Test infrastructures
71	pytest-azurepipelines	751,875	Formatting PyTest output for Azure Pipelines UI
72	pytest-lazy-fixtures	714,581	Allows you to use fixtures in @pytest.mark.parametrize.
73	pytest-opentelemetry	706,850	A pytest plugin for instrumenting test runs via OpenTelemetry
74	pytest-sftpserver	704,874	py.test plugin to locally test sftp server connections.
75	pytest-ansible	664,956	Plugin for pytest to simplify calling ansible modules from tests or fixtures
76	pytest-cases	655,209	Separate test code from test cases in pytest.
77	pytest-deadfixtures	605,247	A simple plugin to list unused fixtures in pytest
78	pytest-examples	599,593	pytest plugin for testing examples in docstrings and markdown files.
79	pytest-reportportal	592,977	Agent for Reporting results of tests to the Report Portal
80	pytest-reportlog	568,744	Replacement for the –resultlog option, focused in simplicity and extensibility
81	pytest-nunit	554,243	A pytest plugin for generating NUnit3 test result XML output
82	pytest-doctestplus	549,919	pytest plugin with advanced doctest features.
83	pytest-qt	545,262	pytest support for PyQt and PySide applications
84	pytest-subprocess	528,726	A plugin to fake subprocess for pytest
85	pytest-plus	499,847	PyTest Plus Plugin :: extends pytest functionality
86	pytest-regressions	486,887	Easy to use fixtures to write regression tests.
87	pytest-mypy	461,022	A pytest Plugin for Mypy
88	pytest-pylint	454,995	pytest plugin to check source code with pylint
89	pytest-clarity	454,653	A plugin providing an alternative, colourful diff output for failing assertions.
90	pytest-trio	450,877	pytest plugin for trio
91	pytest-mpl	442,485	pytest plugin to help with testing figures output from Matplotlib
92	pytest-flake8	426,761	pytest plugin to check FLAKE8 requirements
93	pytest-describe	414,568	Describe-style plugin for pytest
94	pytest-picked	406,468	Run the tests related to the changed files
95	pytest-variables	405,198	pytest plugin for providing variables to tests/fixtures
96	pytest-cache	398,439	pytest plugin with mechanisms for caching across test runs
97	pytest-shutil	394,822	A goodie-bag of unix shell and environment tools for py.test
98	pytest-mock-resources	373,956	A pytest plugin for easily instantiating reproducible mock resources.
99	pytest-remotedata	360,116	pytest plugin for controlling remote data access.
100	pytest-selenium	356,422	pytest plugin for Selenium
101	pytest-markdown-docs	353,872	Run markdown code fences through pytest
102	pytest-localserver	350,646	pytest plugin to test server connections locally.
103	pytest-spark	344,991	pytest plugin to run the tests with support of pyspark.
104	pylint-pytest	341,480	A Pylint plugin to suppress pytest-related false positives.
105	pytest-csv	339,376	CSV output for pytest.
106	pytest-md-report	339,223	A pytest plugin to generate test outcomes reports with markdown table format. Test and Code episode pytest-md and pytest-md-report: Markdown reports for pytest
107	pytest-filter-subpackage	329,238	pytest plugin for filtering based on sub-packages
108	pytest-mysql	324,493	MySQL process and client fixtures for pytest
109	pytest-tornasync	289,774	py.test plugin for testing Python 3.5+ Tornado code
110	pytest-structlog	284,104	Structured logging assertions
111	pytest-cpp	273,839	Use pytest’s runner to discover and execute C++ tests
112	pytest-arraydiff	266,617	pytest plugin to help with comparing array output from tests
113	pytest-timestamper	264,137	pytest plugin to add a timestamp prefix to the pytest output
114	pytest-astropy	264,127	Meta-package containing dependencies for testing
115	pytest-astropy-header	258,250	pytest plugin to add diagnostic information to the header of the test output
116	pytest-loguru	237,305	pytest Loguru
117	pytest-reraise	236,118	Make multi-threaded pytest test cases fail when they should
118	pytest-console-scripts	227,545	pytest plugin for testing console scripts
119	pytest-md	226,323	Plugin for generating Markdown reports for pytest results Test and Code episode pytest-md and pytest-md-report: Markdown reports for pytest
120	pytest-mypy-plugins	218,659	pytest plugin for writing tests for mypy plugins
121	pytest-harvest	215,603	Store data created during your pytest tests execution, and retrieve it at the end of the session, e.g. for applicative benchmarking purposes.
122	pytest-regex	211,716	Select pytest tests with regular expressions
123	pytest-tornado	210,813	A py.test plugin providing fixtures and markers to simplify testing of asynchronous tornado applications.
124	pytest-skip-slow	203,868	A pytest plugin to skip `@pytest.mark.slow` tests by default.
125	pytest-twisted	203,665	A twisted plugin for pytest.
126	pytest-xvfb	201,497	A pytest plugin to run Xvfb (or Xephyr/Xvnc) for tests.
127	pytest-json	200,010	Generate JSON test reports
128	pytest-incremental	199,516	an incremental test runner (pytest plugin)
129	pytest-tagging	199,431	a pytest plugin to tag tests
130	pytest-redis	198,294	Redis fixtures and fixture factories for pytest.
131	pytest-helpers-namespace	195,058	pytest Helpers Namespace Plugin
132	pytest-logger	194,894	Plugin configuring handlers for loggers from Python logging module.
133	pytest-anyio	189,462	The pytest anyio plugin is built into anyio. You don’t need this package.
134	pytest-integration	188,595	Organizing pytests by integration or not
135	pytest-pep8	185,146	pytest plugin to check PEP8 requirements
136	pytest-reporter	176,495	Generate pytest reports with templates
137	pytest-fixture-config	176,410	Fixture configuration utils for py.test
138	pytest-xprocess	169,681	A pytest plugin for managing processes across test runs.
139	flake8-pytest-style	168,525	A flake8 plugin checking common style issues or inconsistencies with pytest-based tests.
140	pytest-slack	167,471	pytest to Slack reporting plugin
141	pytest-reporter-html1	163,271	A basic HTML report template for pytest
142	pytest-embedded-serial	162,110	Make pytest-embedded plugin work with Serial.
143	pytest-runtime-xfail	161,911	Call runtime_xfail() to mark running test as xfail.
144	pytest-excel	160,721	pytest plugin for generating excel reports
145	pytest-parametrization	157,914	Simpler PyTest parametrization
146	pytest-grpc	156,456	pytest plugin for grpc
147	pytest-embedded-serial-esp	154,346	Make pytest-embedded plugin work with Espressif target boards.
148	pytest-pytestrail	148,044	pytest plugin for interaction with TestRail
149	pytest-bazel	147,120	A pytest runner with bazel support
150	pytest-operator	142,474	Fixtures for Charmed Operators
151	pytest-black	136,294	A pytest plugin to enable format checking with black
152	pytest-jira-xray	136,187	pytest plugin to integrate tests with JIRA XRAY
153	pytest-webdriver	134,864	Selenium webdriver fixture for py.test
154	pytest-ruff	133,945	pytest plugin to check ruff requirements.
155	pytest-depends	132,473	Tests that depend on other tests
156	pytest-responses	131,855	py.test integration for responses
157	pytest-emoji	131,812	A pytest plugin that adds emojis to your test result report
158	pytest-rng	130,494	Fixtures for seeding tests and making randomness reproducible
159	pytest-insta	129,164	A practical snapshot testing plugin for pytest
160	pytest-html-merger	129,161	pytest HTML reports merging utility
161	pytest-deepassert	122,908	A pytest plugin for enhanced assertion reporting with detailed diffs
162	pytest-tap	122,849	Test Anything Protocol (TAP) reporting plugin for pytest
163	pytest-print	117,278	pytest-print adds the printer fixture you can use to print messages to the user (directly to the pytest runner, not stdout)
164	pytest-datafiles	116,280	py.test plugin to create a ’tmp_path’ containing predefined files/directories.
165	pytest-cmake	114,360	Provide CMake module for pytest
166	pytest-ignore-test-results	114,326	A pytest plugin to ignore test results.
167	allure-pytest-bdd	114,176	Allure pytest-bdd integration
168	pytestarch	112,858	Test framework for software architecture based on imports between modules
169	pytest-otel	112,140	OpenTelemetry plugin for pytest
170	pytest-embedded-jtag	111,272	Make pytest-embedded plugin work with JTAG.
171	pytest-golden	111,044	Plugin for pytest that offloads expected outputs to data files
172	pytest-schema	110,715	👍 Validate return values against a schema-like object in testing
173	pytest-monitor	107,410	pytest plugin for analyzing resource usage.
174	pytest-archon	106,427	Rule your architecture like a real developer
175	qase-pytest	106,325	Qase pytest Plugin for Qase TestOps and Qase Report
176	pytest-isort	103,669	py.test plugin to check import ordering using isort
177	allure-pytest-default-results	101,666	Generate default “unknown” results to show in Allure Report if test case does not run
178	pytest-spec	98,434	Library pytest-spec is a pytest plugin to display test execution output like a SPECIFICATION.
179	pytest-fail-slow	98,329	Fail tests that take too long to run
180	pytest-testrail	97,120	A pytest plugin for creating TestRail runs and adding results
181	pytest-explicit	96,089	A pytest plugin to ignore certain marked tests by default
182	types-pytest-lazy-fixture	95,069	Typing stubs for pytest-lazy-fixture
183	pytest-container	90,652	pytest fixtures for writing container based tests
184	pytest-xdist-worker-stats	90,455	A pytest plugin to list worker statistics after a xdist run.
185	pytest-mpi	90,258	pytest plugin to collect information from tests
186	pytest-func-cov	90,148	pytest plugin for measuring function coverage
187	pytest-loop	89,453	pytest plugin for looping tests
188	pytest-fastapi-deps	87,554	A fixture which allows easy replacement of fastapi dependencies for testing
189	pytest-logging	85,451	Configures logging and allows tweaking the log level with a py.test flag
190	pytest-rich	85,374	Leverage rich for richer test session output
191	pytest-threadleak	85,032	Detects thread leaks
192	pytest-stub	83,459	Stub packages, modules and attributes.
193	pytest-integration-mark	82,276	Automatic integration test marking and excluding plugin for pytest
194	pytest-pudb	81,947	pytest PuDB debugger integration
195	pytest-aio	81,141	pytest plugin for testing async python code
196	pytest-reverse	79,126	pytest plugin to reverse test order.
197	pytest-embedded	78,975	A pytest plugin that designed for embedded testing.
198	pytest-pikachu	78,374	Show surprise when tests are passing
199	pytest-codeblocks	77,437	Test code blocks in your READMEs
200	pytest-async	76,598	pytest-async - Run your coroutine in event loop without decorator

Current process is based on hugovk’s Top PyPI Packages. Package data is filtered for “pytest”.
There’s also a filter for deprecated and unmaintained plugins.
See source code.

Finding the top pytest plugins

Sun, 25 Aug 2024 05:00:00 +0800

What are the top downloaded pytest plugins?
I want to know this. And I’d like the answer updated regularly.
So today I decided to write a script to do that for me.

Grab data

Let’s start with Top PyPI Packages from Hugo van Kemenade. This list is “A monthly dump of the 8,000 most-downloaded packages from PyPI.”

Perfect.

Parse

Now:

Filter for “pytest” in the package name
Remove “pytest” itself.
- I could leave this in for comparison, but it would always be #1.
Renumber.
Include a link to the pypi.org package page.
Throw it all in a table.
Pipe it to a markdown blog page.

Added on 26-Aug:

Grab summaries from pypi.org via Warehouse API.
Thanks Jeff Triplett and Hugo for pointing me in that direction.

Test and Code 221 - How to get pytest to import your code under test

Mon, 03 Jun 2024 00:00:00 +0000

We've got some code we want to test, and some tests.
The tests need to be able to import the code under test, or at least the API to it, in order to run tests against it.
How do we do that? How do we set things up so that our tests can import our code?

In this episode, we discuss two options:

Python People 14 - Shauna Gordon-McKeon - Open Source Governance, Women's Soccer, and Django

Thu, 09 May 2024 00:00:00 +0000

This is a really fun talk with Shauna.

We talk about:

Going from academia to tech
Django
Open source project governance and Governing Open
Womens Soccer and the NWSL

Shauna's technical consulting business is Galaxy Rise Consulting

Show notes and resources can be found at pythontest.com/pythonpeople

Guests: Shauna Gordon-McKeon

Python People 13 - Rob Ludwick - Getting the most out of PyCon, including juggling

Sat, 04 May 2024 00:00:00 +0000

PyCon US is just around the corner. I've asked Rob Ludwick to come on the show to discuss how to get the most out of your PyCon experience. There's a lot to do. A lot of activities to juggle, including actual juggling, which is where we start the conversation.

Even if you never get a chance to go to PyCon, I hope this interview helps you get a feel for the welcoming aspect of the Python community.

Test and Code 220 - Getting the most out of PyCon, including juggling - Rob Ludwick

Sat, 04 May 2024 00:00:00 +0000

Even if you never get a chance to go to PyCon, I hope this interview helps you get a feel for the welcoming aspect of the Python community.

Test and Code 219 - Building Django Apps and SaaS Pegasus - Cory Zue

Tue, 23 Apr 2024 00:00:00 +0000

I'm starting a SaaS project using Django, and there are tons of decisions right out of the gate.
To help me navigate these decisions, I've brought on Cory Zue.
Cory is the creator of SaaS Pegasus, and has tons of experience with Django.

Some of the topics discussed:

Building Django applications
SaaS Pegasus
placecard.me
What boilerplate projects are
Django cookiecutter
Cookiecutter
Which database to use, probably PostgreSQL
Authentication choises, probably Allauth
Docker, Docker for development, Docker for deployment
Deployment targets / hosting services. Render, Heroku, Fly.io, for PaaS options.
Front end frameworks. Bootstrap, Tailwind, DaisyUI, TailwindUI
HTMX vs React vs straight Django templates
Rockets
Font Awesome
and of course, SaaS Pegasus

Test and Code 218 - Balancing test coverage with test costs - Nicole Tietz-Sokolskaya

Wed, 17 Apr 2024 00:00:00 +0000

Nicole is a software engineer and writer, and recently wrote about the trade-offs we make when deciding which tests to write and how much testing is enough.

We talk about:

Balancing schedule vs testing
How much testing is the right about of testing
Should code coverage be measured and tracked
Good refactoring can reduce code coverage
Is it worth testing error conditions?
Are rare error codes ok to just monitor?
API drift and autospec
Mitigating risk
Deciding what to test and what not to test
Focus testing on key money-making features
If there's a bug in this part of the code, how much business impact is there?
Performance testing needs to approximately match real world workloads
Cost of a service breaking vs the cost of creating, maintaining, and running tests
Keeping test suites quick to minimize getting distracted

Test and Code 217 - Podcasting / SaaS / Work Life Balance - Justin Jackson

Thu, 11 Apr 2024 00:00:00 +0000

If you've ever thought about starting a podcast or a SaaS project, you'll want to listen to this episode.

Justin is one of the people who motivated me to get started podcasting.
He's also running a successful SaaS company, transistor.fm, which hosts this podcast.

Topics:

Podcasting
Building new SaaS (software as a service) products
Balancing work, side hustle, and family
Great places to snowboard in British Columbia

BTW. This episode was recorded last summer before I switched to transistor.fm.
I'm now on Transistor for most of a year now, and I love it.

Test and Code 216 - ruff, uv, and Astral - Python tooling, much faster, with Rust

Mon, 11 Mar 2024 00:00:00 +0000

Charlie Marsh and team are using Rust to make Python tooling faster.

Ruff can take the place of Flake8, isort, and Black, and so much more.
uv can take the place of pip, pip-tools, and virtualenv
Astral is Charlie's venture backed company, and what they have with `ruff` and `uv` is just the start.

Since uv is the newest tool, there's quite a bit of the discussion diving into uv.

Test and Code 215 - Staying Technical as a Manager

Sun, 25 Feb 2024 00:00:00 +0000

Software engineers that move into leadership roles have a struggle between learning leadership skills, maintaining technical skills, and learning new leadership and technical skills.
Matt Makai went from individual contributor to developer relations to leadership in devrel.
We discuss how to stay technical, as well as dive into some results of his studies in how companies use developer relationship channels.

Python People 12 - Nikita Karamov - Russia, Germany, Django, and Jazzband

Thu, 08 Feb 2024 00:00:00 +0000

Nikita Karamov is a Python developer and maintainer on various open source Python projects.

Some topics covered:

Notes on university education in programming and engineering vs theory
Jazzband for maintaining Django projects
Contributing to open source makes you a better programmer
Moving from Russia to Germany during college
Cultural differences between Russia, Germany, and Oregon
The nice lack of drama in the Python community
A lack of universities teaching Python for web development

Links from the show

Test and Code 214 - Python Testing in VS Code

Tue, 06 Feb 2024 00:00:00 +0000

If you haven't tried running automated tests, especially with pytest, in VS Code recently, you should take another look.
The Python for VS Code interface for testing, especially for pytest, has changed recently.
On this episode we discuss the change with the software engineer working on the pytest changes, Eleanor Boyd, and the product manager, Courtney Webster.

Links from the episode:

pytest 8 is here

Mon, 29 Jan 2024 20:00:00 +0800

pytest 8.0.0 was released on 17-Jan-2024, and I’m pretty excited about it.

I’m not going to cover all fo the changes, I’ll just highlight a few.
For full set of changes, see the pytest changelog:

Version Compatibility

Dropped support for Python 3.7, as it reached EOL last June.

Features and Improvements

Improved Diffs

Improved diffs that pytest prints when an assertion fails, including:

Test and Code 213 - Repeating Tests

Fri, 19 Jan 2024 00:00:00 +0000

If a test fails in a test suite, I'm going to want to re-run the test. I may even want to re-run a test, or a subset of the suite, a bunch of times.
There are a few pytest plugins that help with this:

We talk about each of these in this episode.

Transcript

Let’s talk about repeating tests. I said, let’s talk about repeating tests. I couldn’t help myself. So today, we’re gonna talk about repeating tests and why we might wanna do that and how to use plugins to repeat the tests. If a test fails in the test suite, I’m gonna wanna rerun it.

Python People 11 - Pamela Fox - Teaching Python, Accessibility, and Tools

Tue, 16 Jan 2024 00:00:00 +0000

Pamela Fox is a Python Cloud Developer Advocate at Microsoft.

Topics include:

Girl Develop It
Django Girls
Girls Who Code
Teaching a language vs teaching a tool
What a dev advocate does
Accessibility (A11y) testing
Playwright
axe-core
Snapshot testing
pytest plugin authoring
Flask SQLAlchemy
Relearning Go

Links from the show:

Python People 10 - Julian Sequeira - Pybites, Australia, Mindset, and Teaching New Programmers

Sat, 13 Jan 2024 00:00:00 +0000

Julian Sequeira is a cofounder of Pybites.
He's a Python coach, a podcaster, a career mindset advocate, and is learning guitar.

Topics include:

Learning guitar
Vacationing in Canada
Pybites
Splitting finances with Bob
Building a community and a team
Coaching
Conscious positivity
Australia is full of animals that want to kill you. Except kangaroos.
Teaching Python to non-technical people

Show notes and resources can be found at pythonpeople.fm
This podcast produced in conjunction with pythontest.com

Guests: Julian Sequeira

Test and Code 212 - Canon TDD - by Kent Beck

Sat, 13 Jan 2024 00:00:00 +0000

In 2002, Kent Beck released a book called "Test Driven Development by Example".
In December of 2023, Kent wrote an article called "Canon TDD".
With Kent's permission, this episode contains the full content of the article.

Brian's commentary is saved for a followup episode.

Links:

Transcript

The late 1990s , Extreme Programming brought us a concept called “Test First Programming”. In 2002, Kent Beck released a book called “Test Driven Development by Example”. In December of 2023, Kent wrote an article called “Canon TDD”. With Kent’s permission, I am going to read that article in this episode. I’m gonna save my commentary for a follow-up episode.

Python People 9 - Will Vincent - Django, Writing Technical Books

Sun, 07 Jan 2024 00:00:00 +0000

Will Vincent is a former board member of the Django Software Foundation. He's written 3 books on Django, writes a django newsletter, is a podcast co-host for Django Chat.

Show notes and resources can be found at pythonpeople.fm
This podcast produced in conjunction with pythontest.com

Guests: Will Vincent

Test and Code 211 - Stamp out test dependencies with pytest plugins

Fri, 15 Dec 2023 00:00:00 +0000

We want to be able to run tests in a suite, and debug them in isolation, and have the behavior be the same.
If the behavior is different in isolation vs in a suite, it's a nightmare to debug.

In this episode, we'll talk about:

Causes of dependence
Testing for dependencies using plugins
Debugging test dependencies

Plugins discussed:

pytest-randomly
pytest-reverse
pytest-random-order

Test and Code 210 - TDD - Refactor while green

Wed, 29 Nov 2023 00:00:00 +0000

Test Driven Development. Red, Green, Refactor.

Do we have to do the refactor part?
Does the refactor at the end include tests?
Or can I refactor the tests at any time?
Why is refactor at the end?

This episode is to talk about this with a an example.

Transcript

Test driven development. Red, green refactor. Do we have to do the refactor part? Does the refactor at the end include tests? Or can I refactor the test at any time?

Testing argparse Applications

Thu, 16 Nov 2023 07:20:00 -0800

I was asked recently about how to test the argument parsing bit of an application that used argparse. argparse is a built in Python library for dealing with parsing command line arguments for command line interfaces, CLI’s.

You know, like git clone <repo address>.

git is the application.
<repo address> is a command line argument.
clone is a sub-command.

Well, that might be a bad example, as I’m not going to use subcommands in my example, but lots of this still applies, even if you are using subcommands. Anyway, loads of applications use command line arguments, also sometimes called flags and options.

Test and Code 209 - Testing argparse Applications

Thu, 16 Nov 2023 00:00:00 +0000

How do you test the argument parsing bit of an application that uses argparse?

This episode covers:

Design for Test: Structuring your app or script so it's easier to test.
pytest & capsys for testing stdout
Adding debug and preview flags for debugging and testing
And reverting to subprocess.run if you can't modify the code under test

Also, there's a full writeup and code samples available:

pytest slow order

Thu, 02 Nov 2023 14:39:00 -0700

I received a question the other day about combining the notion of marking slow tests and ordering them to run the slow tests first.

This post describes a bit of background and a solution to the problem.

@pytest.mark.slow

It’s possible to mark slow tests with @pytest.mark.slow and then either run or skip the slow tests.

To run slow tests: pytest -m slow
To skip slow tests: pytest -m "not slow"

With the pytest-skip-slow plugin, you can:

Test and Code 208 - Tests with no assert statements

Sun, 29 Oct 2023 00:00:00 +0000

Why on earth would you want to write a test with no assert statements?
After all, aren't assert statements how you decide wether a test passes or fails?

In this episode, we walk through a handful of useful examples of test code without asserts.
We also talk about how these types of tests are a great way to dip your toe into testing.

Python People 8 - Carlton Gibson - Django, Spain, Parenting, and Open Source

Wed, 25 Oct 2023 00:00:00 +0000

Carlton recently stepped down as a Django Fellow, maintains many Django related projects, is starting two SaaS companies, and is a podcast host on "Django Chat".

Some of what we talk about:

Being a Django fellow for 5 years
Maintaining several Django related open source projects
Client work
Time with family
Building a couple Software as a Service projects
Kids and travel
Kids and food
Living in Spain as a British citizen
How Brexit has affected his options
Being an open source maintainer and that it's ok to pause it when life takes precedence.
Being kind to other maintainers and acknowledging them as human
Django 5 form template imporovements
Good places to be a tourist in Spain
Spains wonderful train system

Show notes and resources can be found at pythonpeople.fm
This podcast produced in conjunction with pythontest.com

Guests: Carlton Gibson

Upgrading to Python 3.12 and my battle with virtualenv cache

Mon, 02 Oct 2023 12:29:07 -0700

edited Oct 3, 2023 with a new fix and a new understanding of the problem

Initial title was …

Python 3.12 + "AttributeError: module ‘pkgutil’ has no attribute ‘ImpImporter’. Did you mean: ‘zipimporter’?"

This is a tale of upgrading Python 3.12

I ran into this error while I was trying to update a project to test on Python 3.12:

  ...
  File "/Users/okken/Library/Application Support/virtualenv/wheel/house/pip-23.0.1-py3-none-any.whl/pip/_internal/metadata/importlib/_envs.py", line 123, in _find_eggs_in_zip
    from pip._vendor.pkg_resources import find_eggs_in_zip
  File "/Users/okken/Library/Application Support/virtualenv/wheel/house/pip-23.0.1-py3-none-any.whl/pip/_vendor/pkg_resources/__init__.py", line 2164, in <module>
    register_finder(pkgutil.ImpImporter, find_on_path)
                    ^^^^^^^^^^^^^^^^^^^
AttributeError: module 'pkgutil' has no attribute 'ImpImporter'. Did you mean: 'zipimporter'?

py312: internal error

Specifically:

Test and Code 207 - pytest course, pytest-repeat and pytest-flakefinder

Mon, 25 Sep 2023 00:00:00 +0000

New course: "The Complete pytest Course"
pytest-repeat, which I'm starting to contribute to
- Give `--repeat-scope` a try. You can use it to change from repeating every test to repeating the session, module, or class.
pytest-flakefinder, which is an alternative to pytest-repeat
pytest-check is completely unrelated, but mentioned in the show

Transcript

Okay. We’re gonna talk about a whole bunch of stuff in this episode. It’s kind of a catch up thing. I’ve been working on a video course, for Pytest. Basically, it’s based on I know I already have a course that’s on the talk Python training.

Python People 7 - Mariatta Wijaya - Python Documentation, PyLadies, Keeping Fish, Public Speaking

Thu, 14 Sep 2023 00:00:00 +0000

Mariatta has been a contributor to Python for many years and is a very inspiring public speaker.

Some of what we talk about:

Python Documentation Working Group
GitHub bots, There's an API for that
PyLadies
PyLadiesCon
Typo of the Day (maintainerd, verbossity, work-lie balance, etc.)
A fish aquarium
Cooking, Baking
History of Tempura
Working with APIs with Python
Public Speaking / Giving Talks
The power of seeing other women give talks

Show notes and resources can be found at pythonpeople.fm
This podcast produced in conjunction with pythontest.com

Guests: Mariatta Wijaya

Python People 6 - Naomi Ceder - Quick Python, Leadership Transitions, Diversity

Tue, 29 Aug 2023 00:00:00 +0000

Naomi is an elected fellow of the PSF, and has served as chair of its board of directors.

Topics:
- Building replacement leadership for every endeavor you start
- What the PSF board does
- Keeping Python's growth in increasing diversity
- Learning foreign languages
- PyCon Charlas
- London
- Guitar and music
- The Quick Python Book
- Community building
- Retiring

Show notes and resources can be found at pythonpeople.fm
This podcast produced in conjunction with pythontest.com

Guests: Naomi Ceder

Test and Code 206 - TDD in Context

Wed, 23 Aug 2023 00:00:00 +0000

TDD (Test Driven Development) started from Test First Programming, and has been around at least since the 90's.

However, software tools and available CI systems have changed quite a bit since then.
Maybe it's time to re-examine the assumptions, practices, processes, and principles of TDD.

At least in the context of my software engineering career, modifications to TDD, at least the version of TDD as it's frequently taught, have been necessary.

Python People 5 - Bob Belderbos - Python Challengs, Coaching, Spain

Wed, 09 Aug 2023 00:00:00 +0000

Bob Belderbos built Pybites with Julian Sequeira. Pybites started with code challenges to help people learn Python, and has grown into a learning platform and community, and now includes coaching.

We talk about:

The history of Pybites
Code challenges
Coaching and now even growing the team of coaches
Spain
Books

Links:

and you can hear your name on the show. How cool is that?

Show notes and resources can be found at pythonpeople.fm
This podcast produced in conjunction with pythontest.com

Guests: Bob Belderbos

Python People 4 - Barry Warsaw - OG Python, Bass Guitar, Tai Chi

Fri, 04 Aug 2023 00:00:00 +0000

Barry Warsaw has been with Python almost from the beginning, and is still at it.

The early days of Python
The tone and feel of the Python community came from Guido
Tai Chi
Meditation
Bass Guitar

Stick around until the very end of the show for a special treat, Barry Warsaw and The Zen of Python.

Links from the show:

Show notes and resources can be found at pythonpeople.fm
This podcast produced in conjunction with pythontest.com

Guests: Barry Warsaw

Test and Code 205 - pytest autouse fixtures

Mon, 31 Jul 2023 00:00:00 +0000

On a recent episode of PythonBytes, I suggested it's hard to come up with good examples for pytest autouse fixtures, as there aren't very many good reasons to use them. James Falcon was kind enough to reach out and correct me.

In this episode, we describe:

what fixtures are
what autouse fixtures are
great reasons to use them

Python People 3 - Brett Cannon - Core Python, Fountain Pens

Tue, 25 Jul 2023 00:00:00 +0000

Topics:

“I don't know about the rest of you... I came for the language, but I stayed for the community." Brett Cannon, Python Core Dev, Pycon US 2014 Opening remarks
Public speaking
Being encouraging to others
Why Canada
Meanings of Back Bacon, Toque, and Pop
Walking in Vancouver
Snowshoeing
Philosophy and thinking logically
Proving the existence of God
Rewriting code. “You’re probably going to have to write this 3 times before you’re happy with it.”
1 week per month on technical debt.
Fountain pens
Writing a gratitude journal
Books
“What goes on in your brain is not the same as everyone else’s.”
"Steeped in the world of tea." - nice pun

Links from the show:

Python People 2 - Paul Everitt - Early Python, Coaching

Tue, 18 Jul 2023 00:00:00 +0000

Paul Everitt is a developer advocate for JetBrains and PyCharm.
Covered topics include:

The transition of Python from BDFL to steering committee
Brainstorming topics for this podcast
Django, function based vs class based views, and Nancy Pelosi
Coaching Lacrosse, "we're not in the lacrosse business, we're in the leadership business"
Sports, if done the right way, can be a positive influence
We don't need heroes, we need the next generation of heroes
Volunteering work is a lot like open source
Skateboarding and collaboration over competition

Test and Code 204 - Free Your Inner Nonfiction Writer - Johanna Rothman

Tue, 18 Jul 2023 00:00:00 +0000

Learn how to write nonfiction fast and well.
Johanna Rothman joins the show to discuss writing nonfiction.

Johanna's book: Free Your Inner Nonfiction Writer

Guests: Johanna Rothman

Transcript

Brian: On test and code today, I am thrilled to have Johanna Rothman. She is a fellow author from the

wonderful Pragmatic Bookshelf Company, and, and we’re gonna talk about a whole bunch of stuff, including, writing books. So, welcome, Johanna.

Test and Code 203 - Open Source at Intel

Mon, 17 Jul 2023 00:00:00 +0000

Open Source is important to Intel and has been for a very long time.

Joe Curley, vice president and general manager of software products and ecosystem, and Arun Gupta, vice president and general manager for open ecosystems, join the show to discuss open source, OneAPI, and open ecosystems at Intel.

Guests: Arun Gupta, Joe Curley

Transcript

Brian: Welcome to Test and Code. We have a couple of special guests from Intel, Joe Kerley and Arun Gupta, and I wanted to have them on to talk about Intel’s involvement is with open source. Let’s do a quick introduction, for each of you. Let’s start with Arun. Can you introduce yourself?

Python People 1 - Michael Kennedy - Talk Python and Motorcycles

Thu, 06 Jul 2023 00:00:00 +0000

Michael is the host of the podcasts Talk Python to Me and Python Bytes and runs the Python online course site Talk Python Training.
He is also pretty serious about motorcycling, spends some time with simulated racing, and used to play billiards for cash.

Show notes and resources can be found at pythonpeople.fm
This podcast produced in conjunction with pythontest.com

Guests: Michael Kennedy

Test and Code 202 - Using Towncrier to Keep a Changelog - Hynek Schlawack

Wed, 31 May 2023 00:00:00 +0000

Hynek joins the show to discuss towncrier.

At the top of the towncrier documentation, it says "towncrier is a utility to produce useful, summarized news files (also known as changelogs) for your project."

Towncrier is used by "Twisted, pytest, pip, BuildBot, and attrs, among others."

This is the last of 3 episodes focused on keeping a CHANGELOG.

Episode 200 kicked off the series with keepachangelog.com and Olivier Lacan
In 201 we had Ned Batchelder discussing scriv.

Test and Code 201 - Avoid merge conflicts on your CHANGELOG with scriv - Ned Batchelder

Thu, 25 May 2023 00:00:00 +0000

Last week we talked about the importance of keeping a changelog.
This week we talk with Ned Batchelder about scriv, a tool to help maintain that changelog.

Scriv "is a command-line tool for helping developers maintain useful changelogs. It manages a directory of changelog fragments. It aggregates them into entries in a CHANGELOG file."

Links:

nedbat/scriv: Changelog management tool

Test and Code 200 - Keep a CHANGELOG

Fri, 19 May 2023 00:00:00 +0000

A changelog is a file which contains a curated, chronologically ordered list of notable changes for each version of a project.
This episode is about what a changelog is, with an interview with Olivier Lacan, creator of keepachangelog.com.
The next two episodes talk about some tools to help software project teams keep changelogs while avoiding merge conflicts.

Special Guest: Olivier Lacan.

Test and Code 199 - Is Azure Right for a Side Project? - Pamela Fox

Thu, 04 May 2023 00:00:00 +0000

For a web side project to go from "working on desktop" to "live in the cloud", one decision that needs to be made is where to host everything. One option is Microsoft Azure. Lots of corporate sites use it. Is it right for side projects?

Pamela Fox, a Cloud Advocate for Python at Microsoft, joins the show to help us with that question.

Test and Code 198 - Testing Django Web Applications - Carlton Gibson, Will Vincent

Thu, 27 Apr 2023 00:00:00 +0000

Django has some built in ways to test your application. There's also pytest-django and other plugins that help with testing. Carlton Gibson and Will Vincent from the Django Chat Podcast join the show to discuss how to get started testing your Django application.

Guests: Carlton Gibson, Will Vincent

Transcript

Brian: One of the most popular questions I get is, how do I test my web application? But I am starting a project and I’m thinking about this of, like, how do I make sure it’s working right? So how do I how do I start testing with Django, and what do I need to think about?

Test and Code 197 - Python project trove classifiers - Do you need this bit of pyproject.toml metadata? - Brett Cannon

Tue, 04 Apr 2023 00:00:00 +0000

Classifiers are one bit of Python project metadata that predates PyPI.

Classifiers are weird.

They were around in setuptools days, and are still here with pyproject.toml.

What are they?
Why do we need them?
Do we need them?
Which classifiers should I include?
Why are they called "trove classifiers" in the Python docs

Brett Cannon joins the show to discuss these wacky bits of metadata.

Test and Code 196 - I am not a supplier - Thomas Depierre

Thu, 30 Mar 2023 00:00:00 +0000

Should we think of open source components the same way we think of physical parts for manufactured goods?

There are problems with supply chain analogy when applied to software.

Thomas Depierre discusses some of those issues in this episode.

Links:

I am not a supplier - article

Guests: Thomas Depierre

Sharing is Caring - Sharing pytest Fixtures - PyCascades 2023

Sun, 19 Mar 2023 00:00:00 +0000

Slides and code and such for a talk for PyCascades 2023.

Talk page: Sharing is Caring - Sharing pytest Fixtures
Summary:

pytest rocks, obviously. When people start using pytest as a team, they often come up with cool fixtures that would be great to share across projects. In fact, many great Python packages come pre-loaded with pytest fixtures. This talk describes how easy it is to share fixtures using the pytest plugin model.

Test and Code 195 - What would you change about pytest? - Anthony Sottile

Wed, 08 Mar 2023 00:00:00 +0000

Anthony Sottile and Brian discuss changes that would be cool for pytest, even unrealistic changes. These are changes we'd make to pytest if we didn't ahve to care about backwards compatibilty.

Anthony's list:

The import system
Multi-process support out of the box
Async support
Changes to the fixture system
Extend the assert rewriting to make it modular
Add matchers to assert mechanism
Ban test class inheritance

Brian's list:

pytest tips and tricks

Mon, 27 Feb 2023 00:00:00 +0000

This is a set of tips/tricks for learning and using pytest.
I’ll probably build on the list, so feel free to share with me items you think should be in the list.
Many items really deserve more explanation, and maybe full posts. Let me know if there’s something you’d like more in depth discussion of.

Note: I’m not numbering these, because I don’t want to keep track of order. Also, this is more of a brain dump, and not a prioritized list.

Fixing Circular Imports in Python with Protocol

Mon, 23 Jan 2023 00:00:00 +0000

The problem started when I had two classes that needed to talk to each other. Sometimes, classes need to talk to each other in both directions.

The following example is made up, but mostly behaves like the original problem.

Let’s say I have a Director and an Actor.
The Director tells the Actor to do_action().
In order to do the action, the Actor needs to get_data() from the Director.

Here’s our director.py:

Testing with Python 3.12

Mon, 05 Dec 2022 00:00:00 +0000

Python 3.12.0a2 is out. So now may be a great time to get your projects to start testing against 3.12.

Note about alpha releases of Python

This is from the same link as above: “During the alpha phase, features may be added up until the start of the beta phase (2023-05-08) and, if necessary, may be modified or deleted up until the release candidate phase (2023-07-31). Please keep in mind that this is a preview release and its use is not recommended for production environments.”

Talk - Sharing is Caring - pytest fixture edition

Sat, 10 Sep 2022 00:00:00 +0000

I gave a talk at PyBay 2022 with the above title. It’s about sharing fixtures.

The source code, and the slides, are at github.com/okken/pytest_fixture_sharing.

Test and Code 193 - The Good Research Code Handbook - Patrick Mineault

Tue, 30 Aug 2022 00:00:00 +0000

I don't think it's too much of a stretch to say that software is part of most scientific research now.
From astronomy, to neuroscience, to chemistry, to climate models.
If you work in research that hasn't been affected by software yet, just wait.

But how good is that software?

How much of common best practices in software development are making it to those writing software in the sciences?

Test and Code 192 - Learn to code through game development with PursuedPyBear - Piper Thunstrom

Sat, 06 Aug 2022 00:00:00 +0000

The first game I remember coding, or at least copying from a magazine, was in Basic. It was Lunar Lander.

Learning to code a game is a way that a lot of people get started and excited about programming.

Of course, I don't recommend Basic. Now we've got Python. And one of the game engines available for Python is PursuedPyBear, a project started by Piper Thunstrom.

Test and Code 191 - Running your own site for fun and absolutely no profit whatsoever - Brian Wisti

Fri, 01 Jul 2022 00:00:00 +0000

Having a personal site is a great playground for learning tons of skills. Brian Wisti discusses the benefits of running a his own blog over the years.

Links:

Guests: Brian Wisti

Test and Code 190 - Testing PyPy - Carl Friedrich Bolz-Tereick

Tue, 21 Jun 2022 00:00:00 +0000

PyPy is a fast, compliant alternative implementation of Python.
cPython is implemented in C.

PyPy is implemented in Python.
What does that mean?

And how do you test something as huge as an alternative implementation of Python?

Special Guest: Carl Friedrich Bolz-Tereick.

Links:

Guests: CF Bolz-Tereick

Test and Code 189 - attrs and dataclasses - Hynek Schlawack

Tue, 07 Jun 2022 00:00:00 +0000

In Python, before dataclasses, we had attrs.
Before attrs, it wasn't pretty.

The story of attrs and dataclasses is actually intertwined.
They've built on each other.
And in the middle of it all, Hynek.

Hynek joins the show today to discuss some history of attrs and dataclasses, and some differences.

If you ever need to create a custom class in Python, you should listen to this episode.

Test and Code 188 - Python's Rich, Textual, and Textualize - Innovating the CLI

Tue, 17 May 2022 00:00:00 +0000

Will McGugan has brought a lot of color to CLIs within Python due to Rich.
Then Textual started rethinking full command line applications, including layout with CSS.
And now Textualize, a new startup, is bringing CLI apps to the web.

Links:

Guests: Will McGugan

Test and Code 187 - Teaching Web Development, including Front End Testing

Fri, 13 May 2022 00:00:00 +0000

When you are teaching someone web development skills, when is the right time to start teaching code quality and testing practices?

Karl Stolley believes it's never too early. Let's hear how he incorporates code quality in his courses.

Our discussion includes:

starting people off with good dev practices and tools
linting
html and css validation
visual regression testing
using local dev servers, including https
incorporating testing with git hooks
testing to aid in css optimization and refactoring
Backstop
Nightwatch
BrowserStack
the tree legged stool of learning and progressing as a developer: testing, version control, and documentation

Karl is also writing a book on WebRTC, so we jump into that a bit too.

Test and Code 186 - Developer and Team Productivity

Thu, 12 May 2022 00:00:00 +0000

Being productive is obviously a good thing.
Can we measure it?
Should we measure it?
There's been failed attempts, like lines of code, etc. in the past.
Currently, there are new tools to measure productivity, like using git metrics.

Nick Hodges joins the show to discuss the good and the bad of developer and team productivity, including how we can improve productivity.

Test and Code 185 - Python + Django + Rich + Testing == Awesome

Wed, 11 May 2022 00:00:00 +0000

Django has a handful of console commands to help manage and develop sites.
django-rich adds color and nice formatting. Super cool.
In a recent release, django-rich also adds nice colorized tracebacks to the Django test runner.

Links:

Guests: Adam Johnson, David Smith

Current Git CLI workflow

Wed, 13 Apr 2022 00:00:00 +0000

Workflow

Most of my interactions with git CLI, especially for quick changes, is:

$ git checkout main
$ git pull
$ git checkout -b okken_something
< code changes >
$ git commit -a -m 'quick message'
$ git push

Then the code review and merge happen on the server.

Commands

Let’s break that down.

git checkout main
- Start at the main branch.
git pull
- Grab any changes from remote repo.
git checkout -b okken_something
- Create and switch to a new branch to start work.
git commit -a -m 'quick message'
- Commit changes.
- The -a automatically “adds” changed and deleted files, but not untracked files.
- See commit -a docs.
git push
- Push to the remote repo.
- Normally this would show an error that the branch name doesn’t exist on the remote.
- However, I have a config setting that automatically creates a branch on remote.
- config setting: git config --global push.default current
- See push.default docs.

With Autocorrect

Even if I mistype a command, it will work:

Test and Code 184 - Twisted and Testing Event Driven / Asynchronous Applications - Glyph

Mon, 21 Mar 2022 00:00:00 +0000

Twisted has been supporting asynchronous / event driven applications way before asyncio. Twisted, and Glyph, have also been encouraging automated tests for a very long time.

Twisted uses a technique that should be usable by other applications, even those using asyncio or other event driven architectures.

Links:

Community Service Award Recipient Glyph Lefkowitz — The PSF article I was referring to early in the episode
Twisted
twisted/klein
twisted/treq
django/daphne — Django Channels HTTP/WebSocket server
Scrapy
So Easy You Can Even Do It in JavaScript: Event-Driven Architecture for Regular Programmers - YouTube
Feature test - twitter engineering
Python Testing with pytest — Some reading for Glyph if he wants to learn to love pytest
pytest-twisted
pygame
Pyodide
Brython

Test and Code 183 - Managing Software Teams - Ryan Cheley

Wed, 16 Mar 2022 00:00:00 +0000

Ryan Cheley joins me today to talk about some challenges of managing software teams, and how to handle them.
We end up talking about a lot of skills that are excellent for software engineers as well as managers.

Some topics discussed:

handling code reviews
asking good questions
being honest about what you can't do with current resources and data
discussing tradeoffs and offering solutions that can be completed faster than the ideal solution
balancing engineering and managing
making sure documentation happens
remote teams
- encouraging collaboration
- encouraging non-work-related conversations
- watching out for overworking

Test and Code 182 - An Unorthodox Technical Interview and Hiring Process - Nathan Aschbacher

Tue, 08 Mar 2022 00:00:00 +0000

Don't you just love technical interviews, with someone who just saw your resume or CV 5 minutes ago asking you to write some code on a whiteboard. Probably code that has nothing to do with anything you've done before or anything you will do at the company.

No? Neither does Nathan Aschbacher.
So when he started building the team at his company, he decided to do things differently.

Test and Code 181 - Boost Your Django DX - Adam Johnson

Mon, 28 Feb 2022 00:00:00 +0000

We talk with Adam Johnson about his new book, "Boost Your Django DX".

Developer experience includes tools and practices to make developers more effective and efficient, and just plain make software development more fun and satisfying.
One of the things I love about this book is that it's not just for Django devs.
I'd guess that about half the book is about topics that all Python developers would find useful, from virtual environments to linters to testing.
But of course, also tons of tips and tools for working with Django.

Test and Code 180 - Lean TDD

Mon, 21 Feb 2022 00:00:00 +0000

Lean TDD is an attempt to reconcile some conflicting aspects of Test Driven Development and Lean Software Development.

I've mentioned Lean TDD on the podcast a few times and even tried to do a quick outline at the end of episode 162.

This episode is a more complete outline, or at least a first draft.

If you feel you've got a good understanding of TDD, and it's working awesome for you, that's great. Keep doing what you're doing. There are no problems.

Lean TDD

Sun, 20 Feb 2022 00:00:00 +0000

Preface

Lean TDD is an attempt to reconcile some conflicting aspects of Test Driven Development and Lean Software Development.

I’ve mentioned Lean TDD on the podcast a few times and even tried to do a quick outline at the end of episode 162.

This post is a more complete outline, or at least a first draft.

In audio form

The initial version of this post is also available in audio form as Test & Code, episode 180.

Test and Code 179 - Exploratory Testing

Tue, 08 Feb 2022 00:00:00 +0000

Exploratory testing is absolutely an essential part of a testing strategy.
This episode discusses what exploratory testing is, its benefits, and how it fits within a framework of relying on automated tests for most of our testing.

Test and Code 178 - The Five Factors of Automated Software Testing

Mon, 31 Jan 2022 00:00:00 +0000

"There are five practical reasons that we write tests. Whether we realize it or not, our personal testing philosophy is based on how we judge the relative importance of these reasons." - Sarah Mei

This episode discusses the factors.

Sarah's order:

Verify the code is working correctly
Prevent future regressions
Document the code’s behavior
Provide design guidance
Support refactoring

Brian's order:

Verify the code is working correctly
Prevent future regressions
Support refactoring
Provide design guidance
Document the code’s behavior

The episode includes reasons why I've re-ordered them.

Test and Code 177 - Unit Test vs Integration Test and The Testing Trophy

Thu, 27 Jan 2022 00:00:00 +0000

A recent Twitter thread by Simon Willison reminded me that I've been meaning to do an episode on the testing trophy.
This discussion is about the distinction between unit and integration tests, what those terms mean, and where we should spend our testing time.

Links:

Simon Willison's Twitter Thread
The Testing Trophy and Testing Classifications — Kent C Dodds
Write tests. Not too many. Mostly integration. — Kent C Dodds
On the Diverse And Fantastical Shapes of Testing — Martin Fowler

Test and Code 176 - SaaS Side Projects - Brandon Braner

Tue, 18 Jan 2022 00:00:00 +0000

The idea of having a software as a service product sound great, doesn't it?

Solve a problem with software. Have a nice looking landing page and website. Get paying customers.

Eventually have it make enough revenue so you can turn it into your primary source of income.

There's a lot of software talent out there. We could solve lots of problems.
But going from idea to product to first customer is non-trivial.
Especially as a side hustle.
This episode discusses some of the hurdles from idea to first customer.

Test and Code 175 - Who Should Do QA?

Wed, 12 Jan 2022 00:00:00 +0000

Who should do QA?
How does that change with different projects and teams?
What does "doing QA" mean, anyway?

Answering these questions are the goals of this episode.

Links:

Test Automation - Who Should be Involved? | Thoughtworks

Test and Code 174 - pseudo-TDD - Paul Ganssle

Wed, 22 Dec 2021 00:00:00 +0000

In this episode, I talk with Paul Ganssle about a fun workflow that he calls pseudo-TDD.
Pseudo-TDD is a way to keep your commit history clean and your tests passing with each commit.
This workflow includes using pytest xfail and some semi-advanced version control features.

Some strict forms of TDD include something like this:

write a failing test that demonstrates a lacking feature or defect
write the source code to get the test to pass
refactor if necessary
repeat

In reality, at least for me, the software development process is way more messy than this, and not so smooth and linear.

Test and Code 173 - Why NOT unittest?

Fri, 17 Dec 2021 00:00:00 +0000

In the preface of "Python Testing with pytest" I list some reasons to use pytest, under a section called "why pytest?". Someone asked me recently, a different but related question "why NOT unittest?".

unittest is an xUnit style framework. For me, xUnit style frameworks are fatally flawed for software testing.

That's what this episode is about, my opinion of

Test and Code 172 - Designing Better Software with a Prototype Mindset

Tue, 30 Nov 2021 00:00:00 +0000

A prototype is a a preliminary model of something, from which other forms are developed or copied.
In software, we think of prototypes as early things, or a proof of concept.
We don't often think of prototyping during daily software development or maintenance. I think we should.
This episode is about growing better designed software with the help of a prototype mindset.

Test and Code 171 - How and why I use pytest's xfail - Paul Ganssle

Mon, 22 Nov 2021 00:00:00 +0000

Paul Ganssle, is a software developer at Google, core Python dev, and open source maintainer for many projects, has some thoughts about pytest's xfail.
He was an early skeptic of using xfail, and is now an proponent of the feature.
In this episode, we talk about some open source workflows that are possible because of xfail.

Special Guest: Paul Ganssle.

Test and Code 170 - pytest for Data Science and Machine Learning - Prayson Daniel

Wed, 17 Nov 2021 00:00:00 +0000

Prayson Daniel, a principle data scientist, discusses testing machine learning pipelines with pytest.

Prayson is using pytest for some pretty cool stuff, including:

unit tests, of course
testing pipeline stages
counterfactual testing
performance testing

All with pytest. So cool.

Special Guest: Prayson Daniel.

Links:

Python Bytes 250, with Prayson Daniel — Listen to this for more of an introduction to Prayson

Test and Code 169 - Service and Microservice Performance Monitoring - Omri Sass

Thu, 11 Nov 2021 00:00:00 +0000

Performance monitoring and error detection is just as important with services and microservices as with any system, but with added complexity. Omri Sass joins the show to explain telemetry and monitoring of services and of systems with services.

Special Guest: Omri Sass.

Test and Code 168 - Understanding Complex Code by Refactoring into Larger Functions

Tue, 02 Nov 2021 00:00:00 +0000

To understand complex code, it can be helpful to remove abstractions, even if it results in larger functions. This episode walks through a process I use to refactor code that I need to debug and fix, but don't completely understand.

Test and Code 167 - React, TypeScript, and the Joy of Testing - Paul Everitt

Thu, 21 Oct 2021 00:00:00 +0000

Paul has a tutorial on testing and TDD with React and TypeScript.
We discuss workflow and the differences, similarities between testing with React/TypeScript and Python.
We also discuss what lessons that we can bring from front end testing to Python testing.

Special Guest: Paul Everitt.

Links:

React, TypeScript, and TDD — Paul Everitt's tutorial
React Testing Library

Test and Code 166 - unittest expectedFailure and xfail

Thu, 14 Oct 2021 00:00:00 +0000

xfail isn't just for pytest tests. Python's unittest has @unittest.expectedFailure.

In this episode, we cover:

using @unittest.expectedFailure
the results of passing and failing tests with expectedFailure
using pytest as a test runner for unittest
using pytest markers on unittest tests

Docs for expectedFailure:
https://docs.python.org/3/library/unittest.html#skipping-tests-and-expected-failures

Some sample code.
unittest only:

import unittest

class ExpectedFailureTestCase(unittest.TestCase):

@unittest.expectedFailure
def test_fail(self):
    self.assertEqual(1, 0, "broken")

@unittest.expectedFailure
def test_pass(self):
    self.assertEqual(1, 1, "not broken")

unittest with pytest markers:

Test and Code 165 - pytest xfail policy and workflow

Thu, 07 Oct 2021 00:00:00 +0000

A discussion of how to use the xfail feature of pytest to help with communication on software projects.

The episode covers:

What is xfail
Why I use it
Using reason effectively by including issue tracking numbers
Using xfail_strict
Adding --runxfail when transitioning from development to feature freeze
What to do about test failures
How all of this might help with team communication

Test and Code 164 - Debugging Python Test Failures with pytest

Tue, 14 Sep 2021 00:00:00 +0000

An overview of the pytest flags that help with debugging.
From Chapter 13, Debugging Test Failures, of Python Testing with pytest, 2nd edition.

pytest includes quite a few command-line flags that are useful for debugging.

We talk about thes flags in this episode.

Flags for selecting which tests to run, in which order, and when to stop:

-lf / --last-failed: Runs just the tests that failed last.
-ff / --failed-failed: Runs all the tests, starting with the last failed.
-x / --exitfirst: Stops the tests session afterEd: after?Author: yep the first failure.
--maxfail=num: Stops the tests after num failures.
-nf / --new-first: Runs all the tests, ordered by file modification time.
--sw / --stepwise: Stops the tests at the first failure. Starts the tests at the last failure next time.
--sw-skip / --stepwise-skip: Same as --sw, but skips the first failure.

Flags to control pytest output:

Test and Code 163 - pip install ./local_directory - Stéphane Bidoul

Fri, 20 Aug 2021 00:00:00 +0000

pip : "pip installs packages" or maybe "Package Installer for Python"
pip is an invaluable tool when developing with Python.
A lot of people know pip as a way to install third party packages from pypi.org
You can also use pip to install from other indexes (or is it indices?)

You can also use pip to install a package in a local directory.
That's the part I want to jump in and explore with Stéphane Bidoul.
The way pip installs from a local directory is about to change, and the story is fascinating.

Test and Code 162 - Flavors of TDD

Tue, 03 Aug 2021 00:00:00 +0000

What flavor of TDD do you practice?

In this episode we talk about:

Classical vs Mockist TDD
Detroit vs London (I actually refer to it in the episode as Chicago instead of Detroit. Oh well.)
Static vs Behavior
Inside Out vs Outside In
Double Loop TDD
BDD
FDD
Tracer Bullets
Rules of TDD
Team Structure
Lean TDD

This is definitely an episode I'd like feedback on. Reach out to me for further questions or if I missed some crucial variant of TDD that you know and love.

Test and Code 161 - Waste in Software Development

Tue, 20 Jul 2021 00:00:00 +0000

Software development processes create value, and have waste, in the Lean sense of the word waste.
Lean manufacturing and lean software development changed the way we look at value and waste.
This episode looks at lean definitions of waste, so we can see it clearly when we encounter it.

I'm going to use the term waste and value in future episodes. I'm using waste in a Lean sense, so we can look at software processes critically, see the value chain, and try to reduce waste.

Test and Code 160 - DRY, WET, DAMP, AHA, and removing duplication from production code and test code

Thu, 08 Jul 2021 00:00:00 +0000

Should your code be DRY or DAMP or something completely different?
How about your test code? Do different rules apply?
Wait, what do all of these acronyms mean?

We'll get to all of these definitions, and then talk about how it applies to both production code and test code in this episode.

Links:

Test and Code 159 - Python, pandas, and Twitter Analytics - Matt Harrison

Fri, 02 Jul 2021 00:00:00 +0000

When learning data science and machine learning techniques, you need to work on a data set.
Matt Harrison had a great idea: Why not use your own Twitter analytics data?
So, he did that with his own data, and shares what he learned in this episode, including some of his secrets to gaining followers.

In this episode we talk about:

Test and Code 158 - TDD in Swift - Gio Lodi

Fri, 18 Jun 2021 00:00:00 +0000

Iterative processes that include writing test code and production code together, such as TDD, help make coding fun.

All of us that care about developing quality code with the help of testing can learn from each other, regardless of programming language.

Today we step outside our normal Python comfort zone and talk with Gio about TDD in Swift.

Test and Code 157 - pre-commit - Anthony Sottile

Fri, 11 Jun 2021 00:00:00 +0000

pre-commit started as a framework for running linters and code formatters during git actions via git hooks. It's grown and expanded and now supports an extensive list of languages and actions and manual running of actions. But even at it's core, it's great for letting computers nitpick about whitespace and formatting, so that code reviews can focus on architecture and design.

Pinning Application Dependencies with pip-tools compile

Wed, 09 Jun 2021 00:00:00 +0000

pip-tools has more functionality than this, but compile alone is quite useful.

Start with a loose list of dependencies in requirements.in:

typer
rich

The requirements.in file can have things like >= and such if you have some restrictions on your dependencies.

Now install pip-tools:

pip install pip-tools

Then, in create a requirements.txt file with compile:

pip-compile requirements.in

or:

python -m piptools compile requirements.in

The output will be shown on stdout, but also in requirements.txt:

Test and Code 156 - Flake8 - Python linting framework with Pyflakes, pycodestyle, McCabe, and more - Anthony Sottile

Thu, 03 Jun 2021 00:00:00 +0000

Flake8 is a command-line tool for linting Python projects.
By default, it includes lint checks provided Pyflakes, pycodestyle, and McCabe
It's also a platform, and allows plugins to extend the checks.
Flake8 will run third-party extensions if they are found and installed.

But what does all of that mean?

Anthony Sottile is a maintainer of flake8 and has kindly offered to explain it to us.

Test and Code 155 - Four Questions to Ask Frequently During Software Projects - Tim Ottinger

Fri, 28 May 2021 00:00:00 +0000

Tim Ottinger has four questions that work great in many situations, from doing homework, to cooking, to writing code, to entire software projects.

They are actually awesome questions to ask during a software project.

We discuss the questions, where they came from, and look at some uses in software.

The questions:

What is it that needs to be done?
What do we need in order to do it?
Where can we get what we need?
How can we tell if we’re doing it right?

Bonus question that can be swapped out for #1:

Test and Code 154 - Don't Mock your Database - Jeff Triplett

Fri, 21 May 2021 00:00:00 +0000

You need tests for your web app. And it has a database. What do you do with the database during testing? Should you use the real thing? or mock it? Jeff Triplett says don't mock it.

In this episode, we talk with Jeff about testing web applications, specifically Django apps, and of course talk about the downsides of database mocking.

Test and Code 153 - Playwright for Python - end to end testing of web apps - Ryan Howard

Thu, 13 May 2021 00:00:00 +0000

Playwright is an end to end automated testing framework for web apps with Python support and even a pytest plugin.

Links:

Test and Code 152 - Python Packaging - Brett Cannon

Thu, 06 May 2021 00:00:00 +0000

I always learn a lot when I talk to Brett, and this episode is no exception.
We talk about the packaging workflow, tools, changes, pyproject.toml, flit, setuptools, and so much more.
I hope you learn as much as I did in this great discussion.

Links:

Test and Code 151 - Python Adventure - Brandon Rhodes

Tue, 27 Apr 2021 00:00:00 +0000

Adventure, or Colossal Cave Adventure, was written between 1975 and 1977 in Fortran. Brandon Rhodes ported it to Python 3, initial release in 2011, and still maintains it. We talk to Brandon about this wonderful game.

YOU ARE STANDING AT THE END OF A ROAD BEFORE A SMALL BRICK BUILDING. AROUND YOU IS A FOREST. A SMALL STREAM FLOWS OUT OF THE BUILDING AND DOWN A GULLY.

east

Test and Code 150 - A Practical Testing Strategy

Thu, 15 Apr 2021 00:00:00 +0000

Coming up with a testing strategy doesn't have to be stressful. Prioritizing features to test, and generating test cases for each feature can be fairly quick and painless. This episode covers a strategy for both that can be applied to many types of software.

Test and Code 149 - I don't test my code, "crappy Python" is all I write - Corey Quinn

Tue, 30 Mar 2021 00:00:00 +0000

Corey Quinn is the Chief Cloud Economist at The Duckbill Group. He's also a podcaster and writes a newsletter. And he also automates things with Python. But he doesn't write tests. Let's find out why.

Reason for the interview. Rough summary of a twitter conversation:

Corey: What podcasts should I try to get an invite onto?
ToonArmyCaptain: Python Bytes, Test & Code, Talk Python
Corey: But... I don't test my code, "crappy Python" is all I write, and I'd feel like a giant imposter. So yeah, I'd be game. link
So here we are.

This diagram is referenced in the show, the Last Week In AWS Newsletter Production Pipeline.

Test and Code 148 - Coverage.py and testing packages

Fri, 12 Mar 2021 00:00:00 +0000

How do you test installed packages using coverage.py?

Also, a couple followups from last week's episode on using coverage for single file applications.

Links:

Test and Code 147 - Testing Single File Python Applications/Scripts with pytest and coverage

Fri, 05 Mar 2021 00:00:00 +0000

Have you ever written a single file Python application or script?
Have you written tests for it?
Do you check code coverage?

This is the topic of this weeks episode, spurred on by a listener question.

The questions:

For single file scripts, I'd like to have the test code included right there in the file. Can I do that with pytest?
If I can, can I use code coverage on it?

The example code discussed in the episode: script.py

Test and Code 146 - Automation Tools for Web App and API Development and Maintenance - Michael Kennedy

Sun, 28 Feb 2021 00:00:00 +0000

Building any software, including web apps and APIs requires testing.
There's automated testing, and there's manual testing.

In between that is exploratory testing aided by automation tools.

Michael Kennedy joins the show this week to share some of the tools he uses during development and maintenance.

We talk about tools used for semi-automated exploratory testing.
We also talk about some of the other tools and techniques he uses to keep Talk Python Training, Talk Python, and Python Bytes all up and running smoothly.

Test and Code 145 - For Those About to Mock - Michael Foord

Thu, 18 Feb 2021 00:00:00 +0000

A discussion about mocking in Python with the original contributor of unittest.mock, Michael Foord.

Of course we discuss mocking and unittest.mock.

We also discuss:

testing philosophy
unit testing and what a unit is
TDD
where Michael's towel is, and what color

Micheal was instrumental in the building of testing tools for Python, and continues to be a pragmatic source of honest testing philosopy in a field that has a lot of contradictory information.

Test and Code 144 - TDD in Science - Martin Héroux

Fri, 12 Feb 2021 00:00:00 +0000

Test Driven Development, TDD, is not easy to incorporate in your daily development.

Martin and Brian discuss TDD and testing and Martin's experience with testing, TDD, and using it for code involved with scientific research.

We discuss lots of topics around this, including:

What is TDD?
Should research software be tested in order to be trusted?
Time pressure and the struggle to get code done quickly. How do you make time for tests also?
Is testing worth it for code that will not be reused?
Sometimes it's hard to know how to test something.
Maybe people should learn to test alongside learning how to code.
A desire for a resource of testing concepts for non-CS people.
Are the testing needs and testing information needs different in different disciplines?
- Biology, Physics, Astrophysics, etc. Do they have different testing needs?
- Do we need a "how to test" resource for each?

Test and Code 143 - pytest markers - Anthony Sottile

Sun, 07 Feb 2021 00:00:00 +0000

Completely nerding out about pytest markers with Anthony Sottile.

Some of what we talk about:

Running a subset of tests with markers.
Using marker expressions with and, or, not, and parentheses.
Keyword expressions also can use and, or, not, and parentheses.
Markers and pytest functionality that use mark, such as parametrize, skipif, etc.
Accessing markers with itermarkers and get_closest_marker through item.
Passing values, metadata through markers to fixtures or hook functions.

Links:

Test and Code 142 - MongoDB - Mark Smith

Mon, 25 Jan 2021 00:00:00 +0000

MongoDB is possibly the most recognizable NoSQL document database.
Mark Smith, a developer advocate for MongoDB, answers my many questions about MongoDB.
We cover some basics, but also discuss some advanced features that I never knew about before this conversation.

Special Guest: Mark Smith.

Links:

Test and Code 141 - Visual Testing - Angie Jones

Wed, 30 Dec 2020 00:00:00 +0000

Visual Testing has come a long way from the early days of x,y mouse clicks and pixel comparisons. Angie Jones joins the show to discuss how modern visual testing tools work and how to incorporate visual testing into a complete testing strategy.

Some of the discussion:

Classes of visual testing:
- problems with pixel to pixel testing
- DOM comparisons, css, html, etc.
- AI driven picture level testing, where failures look into the DOM to help describe the problem.
Where visual testing fits into a test strategy.
Combining "does this look right" visual testing with other test workflows.
"A picture is worth a thousand assertions" - functional assertions built into visual testing.
Baselining pictures in the test workflow.

Also discussed:

Test and Code 140 - Testing in Scientific Research and Academia - Martin Héroux

Fri, 18 Dec 2020 00:00:00 +0000

Scientists learn programming as they need it.
Some of them learn it in college, but even if they do, that's not their focus.
It's not surprising that sharing the software used for scientific research and papers is spotty, at best.
And what about testing?
We'd hope that the software behind scientific research is tested.
But why would we expect that?
We're lucky if CS students get a class or two that even mentions automated tests.
Why would we expect other scientists to just know how to test their code?

Test and Code 139 - Test Automation - Shifting Testing Throughout the Software Lifecycle - Nalin Parbhu

Fri, 04 Dec 2020 00:00:00 +0000

Talking with Nalin Parbhu about the software evolution towards more test automation and the creation of Infuse and useMango.

We talk a software development and "shift left" where automated tests and quality checks have moved earlier into the software lifecycle.

Software approaches and where quality fits in
Shift left
Test automation
Roles of software developers, SDETs (software development engineer in test), testers, QA, etc.
Developers doing testing and devops
Automated testing vs manual testing
Regression testing, UI testing, black bock testing
Unit testing, white box, API, end to end testing
User acceptance testing (UAT)
Mullet Methodology (Agile at the front, Waterfall at the back)
Waterwheel Methodology (Requirements -> iterative development -> QA)
What's an agile team?
Developer resistance to testing
Manifesto for agile software development
Iterative development
Adapting to change
Agility: being able to change course quickly

Special Guests: Nalin Parbhu and Ola Omiyale.

Test and Code 138 - Mutation Testing in Python with mutmut - Anders Hovmöller

Thu, 19 Nov 2020 00:00:00 +0000

Your test suite tells you about the quality of your code under test.

Mutation testing is a way to tell you about the quality of your test suite.

Anders Hovmöller wrote mutmut for mutation testing in Python, and can be used with pytest, unittest, and others.

In this episode, Anders explains mutation testing, how mutation testing with mutmut works, and good workflows.

Test and Code 137 - Become an Author - Matt Harrison interviews Brian Okken

Thu, 05 Nov 2020 00:00:00 +0000

Matt Harrison, author of many Python books, is putting together a course, Effective Book Authoring, to help other people write and publish books.
As part of this course, he's including interviews with people who have already written books, including me. This is that interview.

We discuss:

Why I wrote "Python Testing with pytest"
Self publishing vs working with a publisher
The writing, editing, and publishing process
Writing format
Book promotion
Advice to other writers

Special Guest: Matt Harrison.

Test and Code 136 - Wearable Technology - Sophy Wong

Mon, 26 Oct 2020 00:00:00 +0000

Wearable technology is not just smart consumer devices like watches and activity trackers.

Wearable tech also includes one off projects by designers, makers, and hackers and there are more and more people producing tutorials on how to get started. Wearable tech is also a great way to get both kids and adults excited about coding, electronics, and in general, engineering skills.

Test and Code 135 - Speeding up Django Test Suites - Adam Johnson

Tue, 20 Oct 2020 00:00:00 +0000

All test suites start fast. But as you grow your set of tests, each test adds a little bit of time to the suite.
What can you do about it to keep test suites fast?
Some things, like parallelization, are applicable to many domains.
What about, for instance, Django applications?
Well, Adam Johnson has thought about it a lot, and is here to tell us how we can speed up our Django test suites.

Test and Code 134 - Business Outcomes and Software Development - Benjamin Harding

Mon, 12 Oct 2020 00:00:00 +0000

Within software projects, there are lots of metrics we could measure. But which ones really matter. Instead of a list, Benjamin Harding shares with us a way of thinking about business outcomes that can help us with every day decision making.

We talk about:

Business outcomes vs vanity metrics
As a developer, how do you keep business outcomes in mind
Thinking about customer value all the time
Communicating decisions and options in terms of costs and impact on business outcomes
Company culture and it's role in reinforcing a business outcome mindset
And even the role of team lead as impact multiplier

I really enjoyed this conversation. But I admit that at first, I didn't realize how important this is on all software development. Metrics are front and center in a web app. But what about a service, or an embedded system with no telemetry. It still matters, maybe even more so. Little and big decisions developers face every day that have impact on costs and benefits with respect to customer value and business outcome, even if it's difficult to measure.

Test and Code 133 - Major League Hacking - Jon Gottfried

Mon, 05 Oct 2020 00:00:00 +0000

Hackathons have been spreading around the world; many at university campuses. Major League Hacking, MLH, has been encouraging and helping hackathons.

Hacking can be thought of as tinkering. Taking things apart and putting them back together as an interesting experience. There's always been some of this as part of software culture.

The people at Major League Hacking have taken this to a whole new level, bringing together Tech creators who enjoy playing around with and crating new technology, on campuses, and now in virtual spaces, all over the world.

Test and Code 132 - mocking in Python - Anna-Lena Popkes

Mon, 28 Sep 2020 00:00:00 +0000

Using mock objects during testing in Python.

Anna-Lena joins the podcast to teach us about mocks and using unittest.mock objects during testing.

We discuss:

the different styles of using mocks
pros and cons of mocks
dependency injection
adapter pattern
mock hell
magical universe
and much more

Special Guest: Anna-Lena Popkes.

Links:

Personal webpage of Anna-Lena Popkes
Magical Universe — Awesome Python features explained using the world of magic
Test & Code 102: Cosmic Python, TDD, testing and external dependencies — The episode where Harry Percival discusses mocking.
Talk: Harry Percival - Stop Using Mocks (for a while) - YouTube — Talk: Harry Percival - Stop Using Mocks (for a while)
unittest.mock
Autospeccing
Mock Hell Talk (45 min version) Edwin Jung - PyCon 2019
Mock Hell Talk (30 min version) - Edwin Jung - PyConDE
PyCon Estonia
KI macht Schule!
Talk Python #186 : 100 Days of Python in a Magical Universe

Test and Code 131 - Test Smarter, Not Harder

Mon, 21 Sep 2020 00:00:00 +0000

Some people avoid writing tests. Some drudge through it painfully.
There is a better way.
In this episode, I'm going to share some advice from Luke Plant on how to "Test Smarter, Not Harder".

Links:

Test smarter, not harder - lukeplant.me.uk — The original article by Luke

Test and Code 130 - virtualenv activation prompt consistency across shells - an open source dev and test adventure - Brian Skinn

Sun, 13 Sep 2020 00:00:00 +0000

virtualenv supports six shells: bash, csh, fish, xonsh, cmd, posh. Each handles prompts slightly differently. Although the virtualenv custom prompt behavior should be the same across shells, Brian Skinn noticed inconsistencies. He set out to fix those inconsistencies. That was the start of an adventure in open source collaboration, shell prompt internals, difficult test problems, and continuous integration quirks.

Test and Code 129 - How to Test Anything - David Lord

Mon, 07 Sep 2020 00:00:00 +0000

I asked people on twitter to fill in "How do I test _____?" to find out what people want to know how to test.
Lots of responses. David Lord agreed to answer them with me.
In the process, we come up with lots of great general advice on how to test just about anything.

Specific Questions people asked:

Test and Code 128 - pytest-randomly - Adam Johnson

Fri, 28 Aug 2020 00:00:00 +0000

Software tests should be order independent. That means you should be able to run them in any order or run them in isolation and get the same result.

However, system state often gets in the way and order dependence can creep into a test suite.
One way to fight against order dependence is to randomize test order, and with pytest, we recommend the plugin pytest-randomly to do that for you.

Test and Code 127 - WFH, WTF? - Tips and Tricks for Working From Home - Reuven Lerner and Julian Sequeira

Mon, 24 Aug 2020 00:00:00 +0000

Many people have been working from home now that are not used to working from home.
Or at least are working from home more than they ever did before. That's definitely true for me.
Even though I've been working from home since March, I wanted some tips from people who have been doing it longer.

Julian Sequeira, of PyBites fame, has been working from home for about a year.
Reuven Lerner, an amazing Python trainer, has been working from home for much longer.

Test and Code 126 - Data Science and Software Engineering Practices ( and Fizz Buzz ) - Joel Grus

Sun, 16 Aug 2020 00:00:00 +0000

Researches and others using data science and software need to follow solid software engineering practices. This is a message that Joel Grus has been promoting for some time.

Joel joins the show this week to talk about data science, software engineering, and even Fizz Buzz.

Topics include:

Software Engineering practices and data science
Difficulties with Jupyter notebooks
Code reviews on experiment code
Unit tests on experiment code
Finding bugs before doing experiments
Tests for data pipelines
Tests for deep learning models
Showing researchers the value of tests by showing the bugs found that wouldn't have been found without them.
"Data Science from Scratch" book
- Showing testing during teaching Data Science
"Ten Essays on Fizz Buzz" book
- Meditations on Python, mathematics, science, engineerign and design
- Testing Fizz Buzz
- Different algorithms and solutions to an age old interview question.
If not Fizz Buzz, what makes a decent coding interview question.
pytest
hypothesis
Math requirements for data science

Special Guest: Joel Grus.

Test and Code 125 - pytest 6 - Anthony Sottile

Fri, 07 Aug 2020 00:00:00 +0000

pytest 6 is out. Specifically, 6.0.1, as of July 31.

And there's lots to be excited about.
Anthony Sottile joins the show to discuss features, improvements, documentation updates and more.

Full release notes / changelog

Some of what we talk about:

How to update (at least, how I do it)
- Run your test suites with 5.4.3 or whatever the last version you were using
- Update to 6
- Run again. Same output? Probably good.
- If there are any warnings, maybe fix those.
- You can also run with pytest -W error to turn warnings into errors.
- Then find out all the cool stuff you can do now
New Features
- pytest now supports pyproject.toml files for configuration.
  - but remember, toml syntax is different than ini files. mostly quotes are needed
- pytest now includes inline type annotations and exposes them to user programs.
  - Most of the user-facing API is covered, as well as internal code.
- New command-line flags --no-header and --no-summary
- A warning is now shown when an unknown key is read from a config INI file.
  - The --strict-config flag has been added to treat these warnings as errors.
- New required_plugins configuration option allows the user to specify a list of plugins, including version information, that are required for pytest to run. An error is raised if any required plugins are not found when running pytest.
Improvements
- You can now pass output to things like less and head that close the pipe passed to them.
  - thank you!!!
- Improved precision of test durations measurement.
  - use --durations=10 -vv to capture and show durations
- Rich comparison for dataclasses and attrs-classes is now recursive.
- pytest --version now displays just the pytest version,
  - while pytest --version --version displays more verbose information including plugins.
- --junitxml now includes the exception cause in the message XML attribute for failures during setup and teardown.
Improved Documentation
- Add a note about --strict and --strict-markers and the preference for the latter one.
- Explain indirect parametrization and markers for fixtures.
Bug Fixes
Deprecations
Trivial/Internal Changes
Breaking Changes you might need to care about before upgrading
- PytestDeprecationWarning are now errors by default.
  - Check the deprecations and removals page if you are curious.
- -k and -m internals were rewritten to stop using eval(), this results in a few slight changes but overall makes them much more consistent
- testdir.run().parseoutcomes() now always returns the parsed nouns in plural form.
  - I'd say that's an improvement

Special Guest: Anthony Sottile.

Test and Code 124 - pip dependency resolver changes

Mon, 03 Aug 2020 00:00:00 +0000

pip is the package installer for Python.

Often, when you run pip, especially the first time in a new virtual environment, you will see something like:

WARNING: You are using pip version 20.1.1; however, version 20.2 is available.

You should consider upgrading via the 'python -m pip install --upgrade pip' command.

And you should. Because 20.2 has a new dependency resolver.

Test and Code 123 - GitHub Actions - Tania Allard

Fri, 24 Jul 2020 00:00:00 +0000

Lots of Python projects are starting to use GitHub Actions for Continous Integration & Deployment (CI/CD), as well as other workflows.

Tania Allard, a Senior Cloud Developer Advocate at Microsoft, joins the show to answer some of my questions regarding setting up a Python project to use Actions.

Some of the topics covered:

How to get started with GitHub Actions for a Python project?
What are workflow files?
Does it matter what the file name is called?
Can I have / Should I have more than one workflow?

Special Guest: Tania Allard.

Test and Code 122 - Better Resumes for Software Engineers - Randall Kanna

Thu, 16 Jul 2020 00:00:00 +0000

A great resume is key to landing a great software job.
There's no surprise there.
But so many people make mistakes on their resume that can very easily be fixed.

Randall Kanna is on the show today to help us understand how to improve our resumes, and in turn, help us have better careers.

Special Guest: Randall Kanna.

Test and Code 121 - Industrial 3D Printing and Python, Finite State Machines, and Simulating Hardware - Len Wanger

Thu, 09 Jul 2020 00:00:00 +0000

Len Wanger works on industrial 3D printers. And I was pleased to find out that
there's a bunch of Python in those printers as well.

In this episode we talk about:

3D printers
What are the different types of 3D printers?
Where are 3D printed industrial parts being used?
Why use one type of additive manufacturing over another?
Python in 3D printing hardware.
What are Finite State Machines, FSMs?
Benefits of FSMs for testing, logging, and breaking a complex behavior into small testable parts.
Benefits of simulation in writing and testing software to control hardware.

Special Guest: Len Wanger.

Test and Code 120 - FastAPI and Typer - Sebastián Ramírez

Fri, 03 Jul 2020 00:00:00 +0000

FastAPI is a modern, fast (high-performance), web framework for building APIs with Python based on standard Python type hints.
Typer is a library for building CLI applications, also based on Python type hints.
Type hints and many other details are intended to make it easier to develop, test, and debug applications using FastAPI and Typer.

The person behind FastAPI and Typer is Sebastián Ramírez.

Test and Code 119 - Editable Python Installs, Packaging Standardization, and pyproject.toml - Brett Cannon

Fri, 26 Jun 2020 00:00:00 +0000

There's stuff going on in Python packaging and pyproject.toml.

Brett and I talk about some upcoming work on Python packaging, such as:

editable installs
the need for standardization
configuration of other tools in pyproject.toml

And then get off on tangents and talk about:

why it's good to have packages like pip, toml, setuptools, wheel, etc not part of the standard library
should we remove some stuff from the standard library
the standard library using unittest for testing the standard library
- why not hypothesis
- I didn't bring up "why not pytest?" but you know I was thinking it.
why CPython and not C++Python
and more

Special Guest: Brett Cannon.

Test and Code 118 - Code Coverage and 100% Coverage

Thu, 25 Jun 2020 00:00:00 +0000

Code Coverage or Test Coverage is a way to measure what lines of code and branches in your code that are utilized during testing.
Coverage tools are an important part of software engineering.

But there's also lots of different opinions about using it.

Should you try for 100% coverage?
What code can and should you exclude?
What about targets?

I've been asked many times what I think about code coverage or test coverage.
This episode is a train of thought brain dump on what I think about code coverage.

Test and Code 117 - Python extension for VS Code - Brett Cannon

Thu, 18 Jun 2020 00:00:00 +0000

The Python extension for VS Code is most downloaded extension for VS Code.
Brett Cannon is the manager for the distributed development team of the Python extension for VS Code.

In this episode, Brett and I discuss the Python extension and VS Code, including:

pytest support
virtual environment support
how settings work, including user and workspace settings
multi root projects
testing Python in VS Code
debugging and pydevd
jump to cursor feature
upcoming features

Special Guest: Brett Cannon.

Test and Code 116 - 15 amazing pytest plugins - Michael Kennedy

Sun, 07 Jun 2020 00:00:00 +0000

pytest plugins are an amazing way to supercharge your test suites, leveraging great solutions from people solving test problems all over the world. In this episode Michael and I discuss 15 favorite plugins that you should know about.

We also discuss fixtures and plugins and other testing tools that work great with pytest

tox
GitHub Actions
Coverage.py
Selenium + splinter with pytest-splinter
Hypothesis

And then our list of pytest plugins:

Test and Code 115 - Catching up with Nina Zakharenko

Sat, 30 May 2020 00:00:00 +0000

One of the great things about attending in person coding conferences, such as PyCon, is the hallway track, where you can catch up with people you haven't seen for possibly a year, or maybe even the first time you've met in person.

Nina is starting something like the hallway track, online, on twitch, and it's already going, so check out the first episode of Python Tea.

Test and Code 114 - The Python Software Foundation (PSF) Board Elections - Ewa Jodlowska / Christopher Neugebauer

Sun, 24 May 2020 00:00:00 +0000

"The mission of the Python Software Foundation is to promote, protect, and advance the Python programming language, and to support and facilitate the growth of a diverse and international community of Python programmers."

That's a lot of responsibility, and to that end, the PSF Board Directors help out quite a bit.

If you want to be a part of the board, you can. There's an election coming up right around the corner and you gotta get your nomination in by May 31. You can also join the PSF if you want to vote for who gets to be part of the board.

Test and Code 113 - Technical Debt - James Smith

Fri, 15 May 2020 00:00:00 +0000

Technical debt has to be dealt with on a regular basis to have a healthy product and development team.

The impacts of technical debt include emotional drain on engineers and slowing down development and can adversely affect your hiring ability and retention.

But really, what is technical debt? Can we measure it? How do we reduce it, and when?

Test and Code 112 - Six Principles of Readable Tests - David Seddon

Fri, 08 May 2020 00:00:00 +0000

"Code is read much more often than it is written." - Guido van Rossum
This is true for both production code and test code.

When you are trying to understand why a test is failing, you'll be very grateful to the test author if they've taken the care to make it readable.

David Seddon came up with 6 principles to help us write more readable tests.
We discuss these, as well as more benefits of readable tests.

Test and Code 111 - Subtests in Python with unittest and pytest - Paul Ganssle

Sat, 02 May 2020 00:00:00 +0000

In both unittest and pytest, when a test function hits a failing assert, the test stops and is marked as a failed test.

What if you want to keep going, and check more things?

There are a few ways. One of them is subtests.

Python's unittest introduced subtests in Python 3.4.

pytest introduced support for subtests with changes in pytest 4.4 and a plugin, called pytest-subtests.
Subtests are still not really used that much.

Test and Code 110 - Testing Django - from unittest to pytest - Adam Parkin

Sat, 25 Apr 2020 00:00:00 +0000

Django supports testing out of the box with some cool extensions to unittest. However, many people are using pytest for their Django testing, mostly using the pytest-django plugin.

Adam Parkin, who is known online as CodependentCodr, joins us to talk about migrating an existing Django project from unittest to pytest. Adam tells us just how easy this is.

Special Guest: Adam Parkin.

Test and Code 109 - Testing in Financial Services - Eric Bergemann

Tue, 14 Apr 2020 00:00:00 +0000

Financial services have their own unique testing development challenges. But they also have lots of the same challenges as many other software projects.

Eric Bergemann joins Brian Okken to discuss:

Specific testing challenges in the financial services domain
CI/CD : Continuous Integration, Continuous Deployment
TDD : Test Driven Development
Confidence from testable applications
Testing strategies to add coverage to legacy systems
Testing the data and test cases themselves
DevOps
Continuous testing
Manual testing procedures
BDD & Gherkin
Hiring in vs training industry knowledge

Special Guest: Eric Bergemann.

Test and Code 108 - PySpark - Jonathan Rioux

Thu, 09 Apr 2020 00:00:00 +0000

Apache Spark is a unified analytics engine for large-scale data processing.
PySpark blends the powerful Spark big data processing engine with the Python programming language to provide a data analysis platform that can scale up for nearly any task.

Johnathan Rioux, author of "PySpark in Action", joins the show and gives us a great introduction of Spark and PySpark to help us decide how to get started and decide whether or not to decide if Spark and PySpark are right you.

Test and Code 107 - Property Based Testing in Python with Hypothesis - Alexander Hultnér

Fri, 27 Mar 2020 00:00:00 +0000

Hypothesis is the Python tool used for property based testing.
Hypothesis claims to combine "human understanding of your problem domain with machine intelligence to improve the quality of your testing process while spending less time writing tests."

In this episode Alexander Hultnér introduces us to property based testing in Python with Hypothesis.

Some topics covered:

What is property based testing
Thinking differently for property based testing
Using hypothesis / property based testing in conjunction with normal testing
Failures saved and re-run
What parts of development/testing is best suited for hypothesis / property based testing
Comparing function implementations
Testing against REST APIs that use Open API / Swagger with schemathesis
Changing the number of tests in different test environments
System, integration, end to end, and unit tests

Special Guest: Alexander Hultnér.

Test and Code 106 - Visual Testing - How IDEs can make software testing easier - Paul Everitt

Fri, 20 Mar 2020 00:00:00 +0000

IDEs can help people with automated testing.

In this episode, Paul Everitt and Brian discuss ways IDEs can encourage testing and make it easier for everyone, including beginners. We discuss features that exist and are great, as well as what is missing.

The conversation also includes topics around being welcoming to new contributors for both open source and professional projects.

Test and Code 105 - TAP - Test Anything Protocol - Matt Layman

Wed, 11 Mar 2020 00:00:00 +0000

The Test Anything Protocol, or TAP, is a way to record test results in a language agnostic way, predates XML by about 10 years, and is still alive and kicking.

Matt Layman has contributed to Python in many ways, including his educational newsletter, and his Django podcast, Django Riffs.

Matt is also the maintainer of tap.py and pytest-tap, two tools that bring the Test Anything Protocol to Python.

Test and Code 104 - Top 28 pytest plugins - Anthony Sottile

Wed, 04 Mar 2020 00:00:00 +0000

pytest is awesome by itself. pytest + plugins is even better.
In this episode, Anthony Sottile and Brian Okken discuss the top 28 pytest plugins.

Some of the plugins discussed (we also mention a few plugins related to some on this list):

pytest-cov
pytest-timeout
pytest-xdist
pytest-mock
pytest-runner
pytest-instafail
pytest-django
pytest-html
pytest-metadata
pytest-asyncio
pytest-split-tests
pytest-sugar
pytest-rerunfailures
pytest-env
pytest-cache
pytest-flask
pytest-benchmark
pytest-ordering
pytest-watch
pytest-pythonpath
pytest-flake8
pytest-pep8
pytest-repeat
pytest-pylint
pytest-randomly
pytest-selenium
pytest-mypy
pytest-freezegun

Honorable mention:

pytest-black
pytest-emoji
pytest-poo

Special Guest: Anthony Sottile.

Test and Code 103 - Django - Lacey Williams Henschel

Sat, 29 Feb 2020 00:00:00 +0000

Django is without a doubt one of the most used web frameworks for Python. Lacey Williams Henschel is a Django consultant and has joined me to talk about Django, the Django community, and so much more.

Topics:

Django
The Django Community
Django Girls
Django Girls Tutorial
DjangoCon
Software Testing
Using tests during learning
pytest-django
testing Django
Wagtail

Special Guest: Lacey Williams Henschel.

Links:

Test and Code 102 - Cosmic Python, TDD, testing and external dependencies - Harry Percival

Thu, 27 Feb 2020 00:00:00 +0000

Harry Percival has completed his second book, "Architecture Patterns with Python".
So of course we talk about the book, also known as "Cosmic Python".
We also discuss lots of testing topics, especially related to larger systems and systems involving third party interfaces and APIs.

Topics

Harry's new book, "Architecture Patterns with Python". a.k.a. Cosmic Python
TDD : Test Driven Development
Test Pyramid
Tradeoffs of different architectural choices
Mocks and their pitfalls
Avoiding mocks
Separating conceptual business logic
Dependency injection
Dependency inversion
Identifying external dependencies
Interface adapters to mimize the exposed surface area of external dependencies
London School vs Classic/Detroit School of TDD
Testing strategies for testing external REST APIs

Links:

Test and Code 101 - Application Security - Anthony Shaw

Wed, 19 Feb 2020 00:00:00 +0000

Application security is best designed into a system from the start.
Anthony Shaw is doing something about it by creating an editor plugin that actually helps you write more secure application code while you are coding.

On today's Test & Code, Anthony and I discuss his security plugin, but also application security in general, as well as other security components you need to consider.

Test and Code 100 - A/B Testing - Leemay Nassery

Thu, 13 Feb 2020 00:00:00 +0000

Let's say you have a web application and you want to make some changes to improve it.
You may want to A/B test it first to make sure you are really improving things.

But really what is A/B testing?

That's what we'll find out on this episode with Leemay Nassery.

Special Guest: Leemay Nassery.

Test and Code 99 - Software Maintenance and Chess

Thu, 30 Jan 2020 00:00:00 +0000

I play a form of group chess that has some interesting analogies to software development and maintenance of existing systems. This episode explains group chess and explores a few of those analogies.

Test and Code 98 - pytest-testmon - selects tests affected by changed files and methods - Tibor Arpas

Tue, 21 Jan 2020 00:00:00 +0000

pytest-testmon is a pytest plugin which selects and executes only tests you need to run. It does this by collecting dependencies between tests and all executed code (internally using Coverage.py) and comparing the dependencies against changes. testmon updates its database on each test execution, so it works independently of version control.

In this episode, I talk with testmon creator Tibor Arpas about testmon, about it's use and how it works.

Test and Code 97 - 2019 Retrospective, 2020 Plans, and an amazing decade

Tue, 31 Dec 2019 00:00:00 +0000

This episode is not just a look back on 2019, and a look forward to 2020.
Also, 2019 is the end of an amazingly transofrmative decade for me, so I'm going to discuss that as well.

top 10 episodes of 2019

10: episode 46, Testing Hard To Test Applications - Anthony Shaw
9: episode 64, Practicing Programming to increase your value
8: episode 70, Learning Software without a CS degree - Dane Hillard
7: episode 75, Modern Testing Principles - Alan Page
6: episode 72, Technical Interview Fixes - April Wensel
5: episode 69, Andy Hunt - The Pragmatic Programmer
4: episode 73, PyCon 2019 Live Recording
3: episode 71, Memorable Tech Talks, The Ultimate Guide - Nina Zakharenko
2: episode 76, TDD: Don’t be afraid of Test-Driven Development - Chris May
1: episode 89, Improving Programming Education - Nicholas Tollervey

Looking back on the last decade
Some amazing events, like 2 podcasts, a book, a blog, speaking events, and teaching has led me to where we're at now.

Test and Code 96 - Azure Pipelines - Thomas Eckert

Mon, 16 Dec 2019 00:00:00 +0000

Pipelines are used a lot in software projects to automated much of the work around build, test, deployment and more. Thomas Eckert talks with me about pipelines, specifically Azure Pipelines. Some of the history, and how we can use pipelines for modern Python projects.

Special Guest: Thomas Eckert.

Links:

Test and Code 95 - Data Science Pipeline Testing with Great Expectations - Abe Gong

Sat, 30 Nov 2019 00:00:00 +0000

Data science and machine learning are affecting more of our lives every day. Decisions based on data science and machine learning are heavily dependent on the quality of the data, and the quality of the data pipeline.

Some of the software in the pipeline can be tested to some extent with traditional testing tools, like pytest.

But what about the data? The data entering the pipeline, and at various stages along the pipeline, should be validated.

Test and Code 94 - The real 11 reasons I don't hire you - Charity Majors

Mon, 18 Nov 2019 00:00:00 +0000

You've applied for a job, maybe lots of jobs.
Depending on the company, you've gotta get through:

a resume review
a coding challange
a phone screen
maybe another code example
an in person interview

If you get the job, and you enjoy the work, awesome, congratulations.

If you don't get the job, it'd be really great to know why.

Sometimes it isn't because you aren't a skilled engineer.

Test and Code 93 - Software Testing, Book Writing, Teaching, Public Speaking, and PyCarolinas - Andy Knight

Wed, 30 Oct 2019 00:00:00 +0000

Andy Knight is the Automation Panda.

Andy Knight is passionate about software testing, and shares his passion through public speaking, writing on automationpanda.com, teaching as an adjunct professor, and now also through writing a book and organizing a new regional Python conference.

Topics of this episode include:

Andy's book on software testing
Being an adjunct professor
Public speaking and preparing talk proposals
- including tips from Andy about proposals and preparing for talks
PyCarolinas

Special Guest: Andy Knight.

Test and Code 92 - 9 Steps to Crater Quality and Destroy Customer Satisfaction - Cristian Medina

Sun, 20 Oct 2019 00:00:00 +0000

Cristian Medina wrote an article recently called "Test Engineering Anti-Patterns: Destroy Your Customer Satisfaction and Crater Your Quality By Using These 9 Easy Organizational Practices"

Of course, it's sarcastic, and aims to highlight many problems with organizational practices that reduce software quality.

The article doesn't go out of character, and only promotes the anti-patterns.
However, in this interview, we discuss each point, and the corollary of what you really should do. At least, our perspectives.

Test and Code 91 - Python 3.8 - there's a lot more new than most people are talking about

Wed, 16 Oct 2019 00:00:00 +0000

Python 3.8.0 final is live and ready to download.

On todays episode, we're going to run through what's new, picking out the bits that I think are the most interesting and affect the most people, including

new language features
standard library changes
optimizations in 3.8

Not just the big stuff everyone's already talking about. But also some little things that will make programming Python even more fun and easy.

Test and Code 90 - Dynamic Scope Fixtures in pytest 5.2 - Anthony Sottile

Fri, 11 Oct 2019 00:00:00 +0000

pytest 5.2 was just released, and with it, a cool fun feature called dynamic scope fixtures. Anthony Sottile so tilly is one of the pytest core developers, so I thought it be fun to have Anthony describe this new feature for us.

We also talk about parametrized testing and really what is fixture scope and then what is dynamic scope.

Test and Code 89 - Improving Programming Education - Nicholas Tollervey

Sat, 28 Sep 2019 00:00:00 +0000

Nicholas Tollervey is working toward better ways of teaching programming. His projects include the Mu Editor, PyperCard, and CodeGrades. Many of us talk about problems with software education. Nicholas is doing something about it.

Special Guest: Nicholas Tollervey.

Links:

Code With Mu — a simple Python editor for beginner programmers
Made With Mu — A blog to celebrate projects that use the Mu Python code editor to create cool stuff.
PyperCard — Easy GUIs for All
CodeGrades

Test and Code 88 - Error Monitoring, Crash Reporting, Performance Monitoring - JD Trask

Fri, 20 Sep 2019 00:00:00 +0000

Tools like error monitoring, crash reporting, and performance monitoring are tools to help you create a better user experience and are fast becoming crucial tools for web development and site reliability. But really what are they? And when do you need them?

You've built a cool web app or service, and you want to make sure your customers have a great experience.

Test and Code 87 - Paths to Parametrization - from one test to many

Wed, 11 Sep 2019 00:00:00 +0000

There's a cool feature of pytest called parametrization.
It's totally one of the superpowers of pytest.

It's actually a handful of features, and there are a few ways to approach it.
Parametrization is the ability to take one test, and send lots of different input datasets into the code under test, and maybe even have different output checks, all within the same test that you developed in the simple test case.

Test and Code 86 - Teaching testing best practices with 4 testing maxims - Josh Peak

Fri, 06 Sep 2019 00:00:00 +0000

You've incorporated software testing into your coding practices and know from experience that it helps you get your stuff done faster with less headache.

Awesome.

Now your colleagues want in on that super power and want to learn testing.

How do you help them?

That's where Josh Peak is. He's helping his team add testing to their workflow to boost their productivity.

Test and Code 85 - Speed Up Test Suites - Niklas Meinzer

Mon, 26 Aug 2019 00:00:00 +0000

Good software testing strategy is one of the best ways to save developer time and shorten software development delivery cycle time.

Software test suites grow from small quick suites at the beginning of a project to larger suites as we add tests, and the time to run the suites grows with it.

Fortunately, pytest has many tricks up it's sleave to help shorten those test suite times.

Test and Code 84 - CircuitPython - Scott Shawcroft

Tue, 20 Aug 2019 00:00:00 +0000

Adafruit enables beginners to make amazing hardware/software projects.
With CircuitPython, these projects can now use Python.

The combination of Python's ease of use and Adafruit's super cool hardware and a focus on a successful beginner experience makes learning to write code that controls hardware super fun.

In this episode, Scott Shawcroft, the project lead, talks about the past, present, and future of CircuitPython, and discusses the focus on the beginner.

Test and Code 83 - PyBites Code Challenges behind the scenes - Bob Belderbos

Fri, 16 Aug 2019 00:00:00 +0000

Bob Belderbos and Julian Sequeira started PyBites a few years ago.
They started doing code challanges along with people around the world and writing about it.

Then came the codechalleng.es platform, where you can do code challenges in the browser and have your answer checked by pytest tests. But how does it all work?

Bob joins me today to go behind the scenes and share the tech stack running the PyBites Code Challenges platform.

Test and Code 82 - pytest - favorite features since 3.0 - Anthony Sottile

Wed, 31 Jul 2019 00:00:00 +0000

Anthony Sottile is a pytest core contributor, as well as a maintainer and contributor to
many other projects. In this episode, Anthony shares some of the super cool features of pytest that have been added since he started using it.

We also discuss Anthony's move from user to contributor, and how others can help with the pytest project.

Test and Code 81 - TDD with flit

Wed, 17 Jul 2019 00:00:00 +0000

In the last episode, we talked about going from script to supported package.
I worked on a project called subark and did the packaging with flit.

Today's episode is a continuation where we add new features to a supported package and how to develop and test a flit based package.

Covered:

viewing stages of a project with git tags
flit support for editable installs
flit description entry in pyproject.toml to put README on pypi.
development dependencies in pyproject.toml
editor layout for optimal TDD-ing
test case grouping
modifications to traditional TDD that helps me develop faster.

code and command snippets from episode:

Test and Code 80 - From Python script to Maintainable Package

Thu, 04 Jul 2019 00:00:00 +0000

This episode is a story about packaging, and flit, tox, pytest, and coverage.
And an alternate solution to "using the src".

Python makes it easy to build simple tools for all kinds of tasks.
And it's great to be able to share small projects with others on your team, in your company, or with the world.

When you want to take a script from "just a script" to maintainable package, there are a few steps, but none of it's hard.

Test and Code 79 - Fixing misinformation about software testing

Thu, 27 Jun 2019 00:00:00 +0000

Some information about software testing is just wrong.
I'm not talking about opinions. I have lots of opinions and they differ from other peoples opinions. I'm talking about misinformation and old information that is no longer applicable.

I've ran across a few lateley that I want to address.

All of the following are wrong:

Integrated tests can't work. I can prove it with wacky math.
Tests have to be blazing fast or they won't get run.
TDD is about design, not about testing.

This episode discusses why these are wrong.

Test and Code 78 - I don't write tests because ...

Wed, 19 Jun 2019 00:00:00 +0000

Roadblocks to writing tests, and what to do about it.

Some developers either don't write tests, or don't like writing tests.
Why not? I love writing tests.
In this episode we examine lots of roadblocks to testing, and start coming up with solutions for these.

Links:

Test and Code 77 - Testing Complex Systems with Maintainable Test Suites

Tue, 11 Jun 2019 00:00:00 +0000

Creating maintainable test suites for complex systems. The episode describes some complexities involved with hardware testing, then shares techniques for shifting complexity out of the test cases.

quick overview of what test instruments are
discussion of API and communication with instruments
techniques for shifting complexity out of test cases

These techniques should apply to all test suites dealing with complex systems:

Test and Code 76 - TDD - Don’t be afraid of Test-Driven Development - Chris May

Wed, 29 May 2019 00:00:00 +0000

Test Driven Development, TDD, can be intimidating to try.
Why is that? And how can we make it less scary?
That's what this episode is about.

Chris May is a Python developer and the co-founder of PyRVA, the Richmond Virginia Python group.
In this episode, Chris shares his experience with adding testing and TDD to his work flow.

Test and Code 75 - Modern Testing Principles - Alan Page

Thu, 23 May 2019 00:00:00 +0000

Software testing, if done right, is done all the time, throughout the whole life of a software project. This is different than the verification and validation of a classical model of QA teams. It's more of a collaborative model that actually tries to help get great software out the door faster and iterate quicker.

One of the people at the forefront of this push is Alan Page. Alan and his podcast cohost Brent Jensen tried to boil down what modern testing looks like in the Modern Testing Principles.

Test and Code 74 - Technical Interviews - Preparing For, What to Expect, and Tips for Success - Derrick Mar

Tue, 21 May 2019 00:00:00 +0000

In this episode, I talk with Derrick Mar, CTO and co-founder of Pathrise.
This is the episode you need to listen to to get ready for software interviews.

We discuss four aspects of technical interviews that interviewers are looking for:
- communication
- problem solving
- coding
- verification
How to practice for the interview.
Techniques for synchronizing with interviewer and asking for hints.

Test and Code 73 - PyCon 2019 Live Recording

Fri, 03 May 2019 00:00:00 +0000

This is a "Yay! It's PyCon 2019" episode.
PyCon is very important to me.
But it's kinda hard to put a finger on why.
So I figured I'd ask more people to help explain why it's important.
I ask a few simple questions to people about Python and PyCon and get some great insights into both the language popularity and the special place this conference holds to many people.

Test and Code 72 - Technical Interview Fixes - April Wensel

Mon, 29 Apr 2019 00:00:00 +0000

Some typical technical interview practices can be harmful and get in the way of hiring great people. April Wensel offers advice to help fix the technical interview process.

She recommends:

hire for mindset and attitude
look for empathy and mentorship skills
allow candidates to show their strengths instead of hunting for weaknesses
have the candidate leave feeling good about themselves and your company, regardless of the hiring decision

Some topics discussed:

Test and Code 71 - Memorable Tech Talks, The Ultimate Guide - Nina Zakharenko

Fri, 05 Apr 2019 00:00:00 +0000

Nina Zakharenko gives some great advice about giving tech talks.
We talk about a blog series that Nina wrote called "The Ultimate Guide To Memorable Tech Talks". This episode is full of great help and encouragement for your own public speaking adventures.

Some of what we discuss:

overcoming the fear of public speaking
breathing and pausing during talks
planning your talk as well as planning your time to get ready for the talk
writing proposals and getting feedback on proposals
Nina's talk in PyCascades on programming Adafruit chips
types of talks that are often rejected
pre-recording demos to avoid live demo problems
why you should speak, even if you are an introvert
benefits of public speaking
a super cool announcement at the end

Special Guest: Nina Zakharenko.

Test and Code 70 - Learning Software without a CS degree - Dane Hillard

Fri, 29 Mar 2019 00:00:00 +0000

Dane and Brian discuss skills needed for people that become software developers from non-traditional paths.

Dane is also writing a book to address many of these skill gaps, Code Like a Pro, that's currently in an early access phase. Use code podtest&code19 to get a discount. And, sign up as a Friend of the Show to enter for a chance to win a free copy of the eBook version.

Test and Code 69 - Andy Hunt - The Pragmatic Programmer

Thu, 21 Mar 2019 00:00:00 +0000

Andy Hunt and Dave Thomas wrote the seminal software development book, The Pragmatic Programmer. Together they founded The Pragmatic Programmers and are well known as founders of the agile movement and authors of the Agile Manifesto. They founded the Pragmatic Bookshelf publishing business in 2003.

The Pragmatic Bookshelf published it's most important book, in my opinion, in 2017 with the first pytest book available from any publisher.

Test and Code 68 - test and commit or revert (TCR) - Thomas Deniffel

Tue, 12 Mar 2019 00:00:00 +0000

With conventional TDD, you write a failing test, get it to pass, then refactor.
Then run the tests again to make sure your refactoring didn't break anything.
But what if it did break something?
Kent Beck has been recommending to commit your code to revision control after every green test run.
Oddmund Strømme suggested a symmetrical idea to go ahead and revert the code when a test fails.
Kent writes that he hated the idea, but had to try it.
Then wrote about it last September.
And now we have TCR, "(test && commit) || revert".

Test and Code 67 - Teaching Python in Middle School

Thu, 28 Feb 2019 00:00:00 +0000

In today's episode we talk with Kelly Paredes & Sean Tibor.
They teach Python in a middle school in Florida, and talk about this experience on the podcast "Teaching Python".

I love that they include physical computing right from the start, and everything else they are doing.

It's a fun interview.

Special Guests: Kelly Paredes and Sean Tibor.

Test and Code 66 - Brian is interviewed by Phil Burgess

Tue, 26 Feb 2019 00:00:00 +0000

I was recently interviewed on a podcast called "IT Career Energizer Podcast".
Phil Burgess is the host of the podcast, and it was a lot of fun.

I think it turned out well, and I wanted to share it with you here, with Phil's permission, of course.

Special Guest: Phil Burgess.

Links:

IT Career Energizer Podcast

Test and Code 65 - one assert per test

Sun, 17 Feb 2019 00:00:00 +0000

Is it ok to have more than one assert statement in a test?
I've seen articles that say no, you should never have more than one assert.
I've also seen some test code made almost unreadable due to trying to avoid more than one assert per test.

Where did this recommendation even come from? What are the reasons?
What are the downsides to both perspectives?

Test and Code 64 - Practicing Programming to increase your value

Thu, 07 Feb 2019 00:00:00 +0000

I want you to get the most out of being a software developer, or test engineer, or whatever you do that makes this podcast relevant to your life.

By "get the most" I mean:

the most fun
the most value
more career options
probably more responsibility
maybe even more money, that'd be cool

I want you to start (or continue) studying and practicing your skills.

Test and Code 63 - Python Corporate Training - Matt Harrison

Thu, 31 Jan 2019 00:00:00 +0000

I hear and I forget.
I see and I remember.
I do and I understand.
-- Confucius

Matt Harrison is an author and instructor of Python and Data Science. This episode focuses on his training company, MetaSnake, and corporate training.

Matt's written several books on Python, mostly self published. So of course we talk about that.

But the bulk of the conversation is about corporate training, with Brian playing the role of someone considering starting a corporate training role, and asking Matt, an experienced expert in training, how to start and where to go from there.

Test and Code 62 - Python Training - Reuven Lerner

Sat, 12 Jan 2019 00:00:00 +0000

There are a lot of learning styles and a lot of ways to learn Python. If you started Python through a class at work, or through an online course, or maybe an email series, it's possibly you may have learned from Reuven Lerner.

If your first encounter with pytest was reading an article in Linux Journal recently, that would be the writing of Reuven.

Test and Code 61 - A retrospective

Mon, 31 Dec 2018 00:00:00 +0000

A look back on 3 years of podcasting, and a bit of a look forward to what to expect in 2019.

Top 5 episodes:

Honorable mention: 32: David Hussman - Agile vs Agility, Dude's Law, and more

Test and Code 60 - 100 Days of Code - Julian Sequeira

Fri, 28 Dec 2018 00:00:00 +0000

Julian Sequeira is Co-Founder of PyBit.es (a blog/platform created to teach and learn Python) and a Python Trainer at Talk Python Training.
He's also a survivor of the 100DaysOfCode in Python Challenge.

We talk about the 100 days challenge, about learning Python, and about how cool it is to learn within a community.

Special Guest: Julian Sequeira.

Links:

Test and Code 59 - Genesynth, nox, urllib3, and PyCascades - Thea Flowers

Fri, 21 Dec 2018 00:00:00 +0000

Thea Flowers is a Pythonista and open source advocate. She helps empower developers of all backgrounds and experience levels using Python and open source software and hardware.

Thea is the creator of Nox, the co-chair of PyCascades 2019, the lead maintainer of urllib3, and a member of the Python Packaging Authority and Packaging Working Group.

Thea works on Google Cloud Platform's wonderful Developer Relations team where she works on API client libraries and community outreach.

Test and Code 58 - REST APIs, testing with Docker containers and pytest

Fri, 14 Dec 2018 00:00:00 +0000

Let's say you've got a web application you need to test.
It has a REST API that you want to use for testing.

Can you use Python for this testing even if the application is written in some other language? Of course.
Can you use pytest? duh. yes. what else?
What if you want to spin up docker instances, get your app running in that, and run your tests against that environment?
How would you use pytest to do that?
Well, there, I'm not exactly sure. But I know someone who does.

Test and Code 57 - What is Data Science? - Vicki Boykis

Tue, 11 Dec 2018 00:00:00 +0000

Data science, data engineering, data analysis, and machine learning are part of the recent massive growth of Python.

But really what is data science?

Vicki Boykis helps me understand questions like:

No really, what is data science?
What does a data pipeline look like?
What is it like to do data science, data analysis, data engineering?
Can you do analysis on a laptop?
How big does data have to be to be considered big?
What are the challenges in data science?
Does it make sense for software engineers to learn data engineering, data science, pipelines, etc?
How could someone start learning data science?

Also covered:

Test and Code 56 - Being a Guest on a Podcast - Michael Kennedy

Fri, 07 Dec 2018 00:00:00 +0000

Michael Kennedy of Talk Python and Python Bytes fame joins Brian to talk about being a great guest and what to expect.

Even if you have never wanted to be on a podcast, you might learn some great tips. A few of the things we talk about will be helpful for other endeavors, like public speaking, guest blog posts, look for unsolicited job opportunities.

Test and Code 55 - When 100% test coverage just isn't enough - Mahmoud Hashemi

Mon, 03 Dec 2018 00:00:00 +0000

What happens when 100% test code coverage just isn't enough.
In this episode, we talk with Mahmoud Hashemi about glom, a very cool project in itself, but a project that needs more coverage than 100%.
This problem affects lots of projects that use higher level programming constructs, like domain specific languages (DSLs), sub languages mini languages, compilers, and db query languages.

Test and Code 54 - Python 1994 - Paul Everitt

Sun, 25 Nov 2018 00:00:00 +0000

Paul talks about the beginning years of Python.
Talking about Python's beginnings is also talking about the Python community beginnings.
Yes, it's reminiscing, but it's fun.

Special Guest: Paul Everitt.

Links:

Test and Code 53 - Seven Databases in Seven Weeks - Luc Perkins

Sun, 18 Nov 2018 00:00:00 +0000

Luc Perkins joins the show to talk about "Seven Databases in Seven Weeks: A guide to modern databases and the NoSQL movement."

We discuss a bit about each database: Redis, Neo4J, CouchDB, MongoDB, HBase, Postgres, and DynamoDB.

Special Guest: Luc Perkins.

Links:

Test and Code 52 - pyproject.toml - the future of Python packaging - Brett Cannon

Mon, 05 Nov 2018 00:00:00 +0000

Brett Cannon discusses the changes afoot in Python packaging as a result of PEP 517, PEP 518, starting with "How did we get here?" and "Where are we going?"

Discussed:

flit
Poetry
tox
Continuous Integration
setup.py, MANIFEST.in, etc.
pipenv
what's with lock files
applications (doesn't go on PyPI) vs libraries (goes on PyPI)
workflows
dependency resolution
deployment dependencies vs development dependencies
will lock files be standarized
multiple lock files
requirements.txt

Special Guest: Brett Cannon.

Test and Code 51 - Feature Testing

Tue, 30 Oct 2018 00:00:00 +0000

Andy Knight joins me in discussing the concept of feature testing.

A feature tests is "a test verifying a service or library as the customer would use it, but within a single process." That was a quote from an article that appeared on the Twitter engineering blog. The article describes a shift away from class tests towards feature tests, the benefits of the shift, and some reactions to it.

Test and Code 50 - Flaky Tests and How to Deal with Them

Thu, 25 Oct 2018 00:00:00 +0000

Anthony Shaw joins Brian to discuss flaky tests and flaky test suites.

What are flaky tests?
Is it the same as fragile tests?
Why are they bad?
How do we deal with them?
What causes flakiness?
How can we fix them?
How can we avoid them?
Proactively rooting out flakiness
Test design
GUI tests
Sharing solutions

Special Guest: Anthony Shaw.

Test and Code 49 - tox - Oliver Bestwalter

Mon, 15 Oct 2018 00:00:00 +0000

tox is a simple yet powerful tool that is used by many Python projects.

tox is not just a tool to help you test a Python project against multiple versions of Python. In this interview, Oliver and Brian just scratch the surface of this simple yet powerful automation tool.

This is from the tox documentation:

tox is a generic virtualenv management and test command line tool you can use for:

Test and Code 48 - A GUI for pytest

Sun, 07 Oct 2018 00:00:00 +0000

The story of how I came to find a good user interface for running and debugging automated tests is interleaved with a multi-year effort of mine to have a test workflow that’s works smoothly with product development and actually speeds things up. It’s also interleaved with the origins of the blog pythontesting.net, this podcast, and the pytest book I wrote with Pragmatic.

Test and Code 47 - Automation Panda - Andy Knight

Fri, 28 Sep 2018 00:00:00 +0000

Interview with Andy Knight, the Automation Panda.

Selenium & WebDriver
Headless Chrome
Gherkin
BDD
Given When Then
pytest-bdd
PyCharm
Writing Good Gherkin
Overhead of Gherkin and if it's worth it
When to use pytest vs pytest-bdd
The art of test automation

Special Guest: Andy Knight.

Links:

Test and Code 46 - Testing Hard To Test Applications - Anthony Shaw

Sun, 02 Sep 2018 00:00:00 +0000

How do you write tests for things that aren’t that easy to write tests for?

That question is a possibly terrible summary of a question sent to me by a listener. And to help me start answering that question, I asked a friend of mine to help, Antony Shaw.

Of course, different types of applications have different test strategies, so there’s not a universal answer. But I know some of you out there have experience and expertise around how to tackle this problem.

Test and Code 45 - David Heinemeier Hansson - Software Development and Testing, TDD, and exploratory QA

Mon, 13 Aug 2018 00:00:00 +0000

David Heinemeier Hansson is the creator of Ruby on Rails, founder & CTO at Basecamp (formerly 37signals). He's a best selling author, public speaker, and even a Le Mans class winning racing driver.

All of that, of course, is awesome. But that's not why I asked him on the show. In 2014, during a RailsConf keynote, he started a discussion about damage caused by TDD. This was followed by a few blog posts, and then a series of recorded hangouts with Martin Fowler and Kent Beck. This is what I wanted to talk with David about; this unconventional yet practical and intuitive view of how testing and development work together.

Test and Code 44 - Mentoring - Nina Zakharenko

Sat, 21 Jul 2018 00:00:00 +0000

Nina Zakharenko is a cloud developer advocate at Microsoft focusing on Python. She's also an excellent public speaker. We talk about her experience with mentoring, both being a mentor, and utilizing mentors. We also talk about public speaking, her move to Microsoft, and to Portland, and the Microsoft/GitHub merge.

Special Guest: Nina Zakharenko.

Links:

Test and Code 44 - Preparing for Technical Talks with Kelsey Hightower - bonus episode

Mon, 16 Jul 2018 00:00:00 +0000

After I had wrapped up the interview with Kelsey Hightower for episode 43, I asked him one last question.

You see, I admire the his presentation style.
So I asked him if he would share with me how he prepared for his presentations.

His answer is so thoughtful and makes so much sense, I couldn't keep it to myself.

Test and Code 43 - Kelsey Hightower - End to End and Integration Testing

Thu, 05 Jul 2018 00:00:00 +0000

I first heard Kelsey speak during his 2017 PyCon keynote.
He's an amazing speaker, and I knew right then I wanted to hear more about what he does and hear more of his story.

We discuss testing, of course, but we take it further and discuss:

tests for large systems, like kubernetes
Testing in real world scenarios with all the configuration and everything
Becoming a complete engineer by thinking about the end to end flow from the users perspective
Learning from other roles, and the value of roles to allow focus and expertise
We even get into Chaos Engineering and testing live systems.

Special Guest: Kelsey Hightower.

Test and Code 42 - Using Automated Tests to Help Teach Python - Trey Hunner

Wed, 27 Jun 2018 00:00:00 +0000

This interview with Trey Hunner discusses his use of automated tests to help teach programming.

Automated testing is a huge part of developing great software. But many new developers don't get exposed to testing for quite a while. But this is changing.

New ways to teach programming include automated tests from the beginning.

Trey Hunner is one of the PSF directors and a Python and Django team trainer, and he has been using automated tests to help people learn Python.

Test and Code 41 - Testing in DevOps and Agile - Anthony Shaw

Wed, 18 Apr 2018 00:00:00 +0000

We talk with Anthony Shaw about some of the testing problems facing both DevOps teams, and Agile teams. We also talk about his recent pull request accepted into pytest.

Special Guest: Anthony Shaw.

Links:

Test and Code 40 - On Podcasting - Adam Clark

Tue, 10 Apr 2018 00:00:00 +0000

Adam is the host of The Gently Mad podcast, and teaches the steps in creating and growing a podcast in his course Irresistible Podcasting.

He was one of the people who inspired Brian to get the Test & Code podcast started in the first place. Brian took his course in 2015. Adam is in the process of updating the course, and building a community around it.

Test and Code 39 - Thorough software testing for critical features

Thu, 29 Mar 2018 00:00:00 +0000

Complete and exhaustive testing is not possible. Nor would it be fun, or maintainable, or a good use of your time.

However, some functionality is important enough to make sure the test behavior coverage is thorough enough to have high confidence in it's quality.

In this episode, we discuss 3 techniques that can be combined to quickly generate test cases. We then talk about how to implement them efficiently in pytest.

Test and Code 38 - Prioritize software tests with RCRCRC

Tue, 13 Mar 2018 00:00:00 +0000

RCRCRC was developed by Karen Nicole Johnson.

In this episode we discuss the mnemonic/heuristic and use it to prioritize tests for the cards application.

Recent: new features, new areas of code
Core: essential functions must continue to work, your products USPs (Unique Selling Propositions)
Risk: some areas of an application pose more risk, perhaps areas important to customers but not used regularly by the development team.
Configuration sensitive: code that’s dependent on environment settings or operating system specifics
Repaired: tests to reproduce bugs, tests for functionality that has been recently repaired.
Chronic: functionality that frequently breaks

Links:

Test and Code 37 - What tests to write first

Thu, 08 Mar 2018 00:00:00 +0000

This episode starts down the path of test strategy with the first tests to write in either a legacy system or a project just getting off it's feet.

We cover:

My approach to testing existing systems.
Put names to strategies so we can refer to them later.
Explain the strategies in general terms and explain why they are useful.
Discuss how these strategies are used in an example project. (The code is available on github).

Strategies covered today:

Test and Code 36 - Stephanie Hurlburt - Mentoring and Open Office Hours

Tue, 13 Feb 2018 00:00:00 +0000

Stephanie is a co-founder and graphics engineer at Binomial.

She works on Basis, an image compressor, and has customers in games, video, mapping, and any application that has lots of image data.

Stephanie has also been encouraging experienced engineers to open up their twitter DMs to questions from anyone, to help mentor people not only in technical questions, but in career questions as well.

Test and Code 35 - Continuing Education and Certificate Programs at UW

Thu, 01 Feb 2018 00:00:00 +0000

There are lots of ways to up your skills.
Of course, I'm a big fan of learning through reading books, such as upping your testing skills by reading Python Testing with pytest.
And then there are online learning systems and MOOCs.

At the other end of the spectrum is a full blown university degree.

One option kind of in the middle is continuing education programs available through some universities, such as University of Washington.

Test and Code 34 - TDD and Test First

Sun, 31 Dec 2017 00:00:00 +0000

An in depth discussion of Test Driven Development (TDD) should include a discussion of Test First. So that's where we start.

Why write tests first?
How do you know what tests to write?
What are the steps for test first?
Isn't this just TDD?
Functional Tests vs Unit Tests

Links:

Test and Code 33 - Katharine Jarmul - Testing in Data Science

Thu, 30 Nov 2017 00:00:00 +0000

A discussion with Katharine Jarmul, aka kjam, about some of the challenges of data science with respect to testing.

Some of the topics we discuss:

experimentation vs testing
testing pipelines and pipeline changes
automating data validation
property based testing
schema validation and detecting schema changes
using unit test techniques to test data pipeline stages
testing nodes and transitions in DAGs
testing expected and unexpected data
missing data and non-signals
corrupting a dataset with noise
fuzz testing for both data pipelines and web APIs
datafuzz
hypothesis
testing internal interfaces
documenting and sharing domain expertise to build good reasonableness
intermediary data and stages
neural networks
speaking at conferences

Special Guest: Katharine Jarmul.

Test and Code 32 - David Hussman - Agile vs Agility, Dude's Law, and more

Tue, 03 Oct 2017 00:00:00 +0000

A wonderful discussion with David Hussman. David and Brian look back at what all we've learned in XP, TDD, and other Agile methodologies, where things have gone awry, how to bring the value back, and where testing fits into all of this.

How to build the wrong thing faster
Agile vs Agility
Product vs Process
Where testing fits into software development practices.
"Integration tests, there's a name that needs to be refactored desperately."
Integration tests are "story tests". They tell the story of the product.
XP and TDD and the relationship with tests
To test for design, use microtests, xUnit style.
User Advocy tests are often lacking, but are needed to learn about the product.
"I just keep writing tests until I'm not scared anymore." - Kent Beck
Dude's Law: Value = Why/How
People often focus so much on the how that they forget about why they are doing something.
Subcutaneous Tests
"The hardest part of programming is thinking."
Refactoring vs Repaving
Agility means being able to quickly change direction
During experimentation and learning, what matters isn't how much you got done, but how much you learn.
"The best way to get automation is to make developers do manual tests."

Special Guest: David Hussman.

Test and Code 31 - I'm so sick of the testing pyramid

Wed, 27 Sep 2017 00:00:00 +0000

What started as a twitter disagreement carries over into this civil discussion of software testing.
Brian and Paul discuss testing practices such as the testing pyramid, TDD, unit testing, system testing, and balancing test effort.

the Testing Pyramid
the Testing Column
TDD
unit testing
balancing unit with system tests, functional tests
API testing
subcutaneous testing
customer facing tests

Special Guest: Paul Merrill.

Test and Code 30 - Legacy Code - M. Scott Ford

Mon, 31 Jul 2017 00:00:00 +0000

M. Scott Ford is the founder and chief code whisperer at Corgibytes, a company focused on helping other companies with legacy code.

Topics include:

How M. Scott Ford got into forming a company that works on legacy code.
Technical debt
Process debt
Software testing
The testing pyramid
iterative development
kanban
readable code and readable test code

Special Guest: M. Scott Ford.

Test and Code 29 - Kobiton and QASymphony - Josh Lieberman

Fri, 30 Jun 2017 00:00:00 +0000

Kobiton is a service to test mobile apps on real devices.
QASymphony offers software testing and QA tools.

Special Guest: Josh Lieberman.

Test and Code 28 - Chaos Engineering and Experimentation at Netflix - Casey Rosenthal

Fri, 07 Apr 2017 00:00:00 +0000

Today we have an interview with Casey Rosenthal of Netflix.

One of the people making sure Netflix runs smoothly is Casey Rosenthall.
He is the manager for the Traffic, Intuition, and Chaos teams at Netflix.
He's got a great perspective on quality and large systems.

We talk about

Chaos Engineering
Experimentation vs Testing
Testing Strategy
Visualization of large amounts of data representing Steady State

Special Guest: Casey Rosenthal.

Test and Code 27 - Mahmoud Hashemi - unit, integration, and system testing

Sun, 26 Feb 2017 00:00:00 +0000

What is the difference between a unit test, an integration test, and a system test? Mahmoud Hashemi helps me to define these terms, as well as discuss the role of all testing variants in software development.

What is the difference between a unit test, an integration test, and a system test?
TDD
testing pyramid vs testing column
the role of testing in software development
web frameworks
listen to wikipedia
hatnote
the world’s largest photo competition
Enterprise Software with Python

Links:

Test and Code 25 - Selenium, pytest, Mozilla – Dave Hunt

Thu, 01 Dec 2016 00:00:00 +0000

Interview with Dave Hunt
d

We Cover:

Selenium Driver
pytest
pytest plugins:
tox
Dave Hunt’s “help wanted” list on github
Mozilla

Also:

fixtures
xfail
CI and xfail and html reports
CI and capturing
pytest code sprint
working remotely for Mozilla

Guests: Dave Hunt

Test and Code 26 - pyresttest – Sam Van Oort

Thu, 01 Dec 2016 00:00:00 +0000

Interview with Sam Van Oort about pyresttest, "A REST testing and API microbenchmarking tool"

pyresttest

A question in the Test & Code Slack channel was raised about testing REST APIs. There were answers such as pytest + requests, of course, but there was also a mention of pyresttest, https://github.com/svanoort/pyresttest, which I hadn't heard of. I checked out the github repo, and was struck by how user friendly the user facing test definitions were. So I contacted the developer, Sam Van Oort, and asked him to come on the show and tell me about this tool and why he developed it.

PythonBytes.fm

Thu, 10 Nov 2016 08:49:03 +0000

Michael Kennedy from Talk Python to Me and I have launched a new podcast, called Python Bytes, “Python headlines delivered directly to your earbuds”. It’s a weekly short format podcast. Please check it out.

The first few weeks of a podcast can really make a difference if we can get a bunch of listeners to try it right away. Please consider leaving a review on iTunes. Even if you don’t use iTunes to listen, early reviews can really help with visibility.

Test and Code 24 - pytest - Raphael Aurich

Thu, 10 Nov 2016 00:00:00 +0000

pytest is an extremely popular test framework used by many projects and companies.

In this episode, I interview Raphael Aurich (@hackebrot), a core contributor to both pytest and cookiecutter. We discuss how Raphael got involved with both projects, his involvement in cookiecutter, pytest, "adopt pytest month", the pytest code sprint, and of course some of the cool new features in pytest 3.

Test and Code 23 - Lessons about testing and TDD from Kent Beck

Fri, 30 Sep 2016 00:00:00 +0000

Kent Beck's twitter profile says "Programmer, author, father, husband, goat farmer". But I know him best from his work on extreme programming, test first programming, and test driven development. He's the one. The reason you know about TDD is because of Kent Beck.

I first ran across writings from Kent Beck as started exploring Extreme Programming in the early 2000's.

Test and Code 22 - Converting Manual Tests to Automated Tests

Sat, 24 Sep 2016 00:00:00 +0000

How do you convert manual tests to automated tests?

This episode looks at the differences between manual and automated tests and presents two strategies for converting manual to automated.

Test and Code 21 - Terminology - test fixtures, subcutaneous testing, end to end testing, system testing

Wed, 31 Aug 2016 00:00:00 +0000

A listener requested that I start covering some terminology.
I think it's a great idea.

Covered in this episode:

Test Fixtures
Subcutaneous Testing
End to End Testing (System Testing)

I also discuss:

A book rewrite
Progress on transcripts
A story from the slack channel

Test and Code 20 - Talk Python To Me - Michael Kennedy

Fri, 29 Jul 2016 00:00:00 +0000

I talk with Michael about:

Episodes of his show having to do with testing.
His transition from employee to podcast host and online training entrepreneur.
His Python training courses.
The Pyramid Web framework.

Courses by Michael

Testing related podcast Episodes from Talk Python To Me:

Guests: Michael Kennedy

Test and Code 19 - Python unittest - Robert Collins

Wed, 15 Jun 2016 00:00:00 +0000

Interview with Robert Collins, current core maintainer of Python's unittest module.

Some of the topics covered

How did Robert become the maintainer of unittest?
unittest2 as a rolling backport of unittest
test and class parametrization with subtest and testscenarios
Which extension to unittest most closely resembles Pytest fixtures?
Comparing Pytest and unittest
Will unittest ever get assert rewriting?
Future changes to unittest

I've been re-studying unittest recently and I mostly wanted to ask Robert a bunch of clarifying questions.

Test and Code 18 - Testing in Startups and Hiring Software Engineers - Joe Stump

Tue, 19 Apr 2016 00:00:00 +0000

In this episode, I interview with Joe Stump, cofounder of Sprintly (https://sprint.ly), to give the startup perspective to development and testing.

Joe has spent his career in startups.
He's also been involved with hiring and talent acquisition for several startups.

We talk about testing, continuous integration, code reviews, deployment, tolerance to defects, and how some of those differ between large companies and small companies and startups.

Test and Code 17 - The Travis Foundation - Laura Gaetano

Mon, 11 Apr 2016 00:00:00 +0000

The Travis Foundation. Interview with Laura Gaetano

Links and things we talked about:

Guests: Laura ✨🎨

Python featured in April issue of PragPub

Wed, 06 Apr 2016 18:04:43 +0000

PragPub April 2016 featuring Python (and me)

PragPub is the digital magazine put out by Pragmatic Bookshelf, Michael Swaine, and Nancy Groth.

I’m especially excited about it because I have two articles featured.
I mostly know Michael from the many years of reading Dr Dobb’s.
And I respect Pragmatic Bookshelf for their work in technical publishing.

So I was thrilled to be asked to contribute.

From the Contents page:

Test and Code 16 - Welcome to Test and Code

Thu, 31 Mar 2016 00:00:00 +0000

This is a small episode.

I'm changing the name from the "Python Test Podcast" to "Test & Code".
I just want to discuss the reasons behind this change, and take a peek at what's coming up in the future for this podcast.

Links

Test and Code 15 - Lean Software Development

Wed, 09 Mar 2016 00:00:00 +0000

An introduction to Lean Software Development

This is a quick intro to the concepts of Lean Software Development.

I'm starting a journey of trying to figure out how to apply lean principles to software development in the context of 2016/2017.

Links

Lean Software Development book by Mary & Tom Poppendieck
wikipedia entry for Lean Software Development
Patreon supporters of the show
Talk Python to Me Podcast
Python Jumpstart by Building 10 Apps - video course
pytest sprint
pytest.org
pytest/tox indiegogo campaign

Test and Code 14 - Continuous Integration with Travis CI – Josh Kalderimis

Thu, 25 Feb 2016 00:00:00 +0000

Interview with Josh Kalderimis from Travis CI.

Josh is a co-founder and Chief Post-It Officer at Travis CI.

Topics

What is Continuous Integration, CI
What is Travis CI
Some history of the company
travis-ci.org vs travis-ci.com and merging the two
Enterprise and the importance of security
Feature questions
- Travis vs Jenkins
- Travis notification through Slack
- Reporting history of Travis results
- Dealing with pytest results status other than pass/fail
- Capturing std out and stderr logging from tests
- Build artifacts
- Tox and Travis
- Using Selenium
What does a Chief Post-It Officer do
Differentiation between Travis and other CI options
Using Slack to keep remote teams communicating well
Travis team
Funding open source projects
Travis Foundation
Rails Girls Summer of Code
Open source grants
Mustaches and beards
Shite shirts
New Zealand
What does Team Periwinkle do

Links

Test and Code 13 - Ian Cordasco – Betamax

Wed, 17 Feb 2016 00:00:00 +0000

Testing apps that use requests without using mock.

Interview with Ian Cordasco (@sigmavirus24)

Topics:

Betamax - python library for replaying requests interactions for use in testing.
requests
github3.py
Pycon 2015 talk: Ian Cordasco - Cutting Off the Internet: Testing Applications that Use Requests - PyCon 2015
Pytest and using Betamax with pytest fixtures
The utility (or uselessness) of teaching programming with Java (My own rant mainly)
Rackspace and Ian’s role at Rackspace and OpenStack
Python Code Quality Authority: flake8, pep8, mccabe, pylint, astroid, …
Static code analysis and what to use which tool when.
Raymond Hettinger - Beyond PEP 8 -- Best practices for beautiful intelligible code - PyCon 2015

Links:

Given-When-Then

Wed, 10 Feb 2016 06:54:35 +0000

Designing your test methods using a simple structure such as given-when-then will help you:

Communicate the purpose of your test more clearly
Focus your thinking while writing the test
Make test writing faster
Make it easier to re-use parts of your test
Highlight the assumptions you are making about the test preconditions
Highlight what outcomes you are expecting and testing against.

In this post I’ll be talking about designing your test cases/test methods using given-when-then.

Test and Code 12 - Coverage.py with Ned Batchelder

Tue, 09 Feb 2016 00:00:00 +0000

In this episode I interview Ned Batchelder.

I know that coverage.py is very important to a lot of people to understand how much of their code is being covered by their test suites.
Since I'm far from an expert on coverage, I asked Ned to discuss it on the show.

I'm also quite a fan of Ned's 2014 PyCon talk "Getting Started Testing", so I definitely asked him about that.

Test and Code 11 - pytest assert magic

Thu, 04 Feb 2016 00:00:00 +0000

How pytest, unittest, and nose deal with assertions.

The job of the test framework to tell developers how and why their tests failed is a difficult job.

In this episode I talk about assert helper functions and the 3 methods pytest uses to get around having users need to use assert helper functions.

Test and Code 10 - Test Case Design using Given-When-Then from BDD

Sun, 31 Jan 2016 00:00:00 +0000

Given-When-Then is borrowed from BDD and is my favorite structure for test case design.

It doesn’t matter if you are using pytest, unittest, nose, or something completely different, this episode will help you write better tests.

The Given-When-Then structure for test method/function development.
How and why to utilize fixtures for your given or precondition code.
Similarities with other structure discriptions.
- Setup-Test-Teardown
- Setup-Excercise-Verify-Teardown.
- Arrange-Act-Assert
- Preconditions-Trigger-Postconditions.
Benefits
- Communicate the purpose of your test more clearly
- Focus your thinking while writing the test
- Make test writing faster
- Make it easier to re-use parts of your test
- Highlight the assumptions you are making about the test preconditions
- Highlight what outcomes you are expecting and testing against.

Links discussed in the show:

Test and Code 9 - Harry Percival - Testing Web Apps with Python, Selenium, Django

Mon, 18 Jan 2016 00:00:00 +0000

Intro to Harry Percival, his background and story of how he got into TDD and ended up writing a book
Comparing using unittest and pytest with applicability to testing django projects.
Functional end to end testing with selenium.
The django test client for middle level tests.
test isolation
django and isolated unit tests
unit tests vs integration tests
Testing done by the development team without an external QA
Double loop TDD: Functional test first, then unit tests
Spikes: investigations without tests
Harry's experience with having a freely available web version of a book that is also intended to be sold.

Update: Comment from Harry Percival on 19-Jan-2014
I might have been a bit down on unit tests vs functional tests in that "unit tests never fail comment".

Test and Code 8 - Agile vs Agility - Agile Is Dead (Long Live Agility)

Tue, 15 Dec 2015 00:00:00 +0000

In today's podcast, I dodge the question of "What do you think of Agile?" by reading an essay from Dave Thomas

Test and Code 7 - The Waterfall Model and “Managing the Development of Large Software Systems”

Wed, 21 Oct 2015 00:00:00 +0000

The waterfall model has been used and modified and changed and rebelled against since before I started programming. Waterfall such an important character in the story of software development that we should get to know it a better.

Test and Code 6 - Writing software is like nothing else

Tue, 20 Oct 2015 00:00:00 +0000

My experience with writing software comes from my experience: where I grew up, what eras I lived through, what my economical and geographical experiences have been, when I learned to code, and what projects I've worked on.

Test and Code 5 - Test Classes - No OO experience required

Wed, 23 Sep 2015 00:00:00 +0000

Setup and Teardown
Benefits of Test Fixtures
- code reuse
- cleanup of resources
- errors vs failures
- focusing your thinking on what you are testing and what you are not
- scoping for efficiency
Brief look at pytest named fixtures

References

Test and Code 4 - Test Fixtures - Setup, Teardown, and so much more

Fri, 11 Sep 2015 00:00:00 +0000

Setup and Teardown
Benefits of Test Fixtures
- code reuse
- cleanup of resources
- errors vs failures
- focusing your thinking on what you are testing and what you are not
- scoping for efficiency
Brief look at pytest named fixtures

References

Test and Code 3 - Why test?

Wed, 02 Sep 2015 00:00:00 +0000

Answering a listener question.

Why testing?

What are the benefits?
Why automated testing over manual testing?
Why test first?
Why do automated testing during development?
Why test to the user level API?

After describing my ideal test strategy and project, I list:

Business related, practical benefits of testing
Personal reasons to embrace testing
Pragmatic, day to day, developer benefits of testing

Transcript

Hello everyone, my name is Brian Okken. Welcome to the Python test podcast. (Now Test & Code)

Test and Code 2 - Pytest vs Unittest vs Nose

Thu, 20 Aug 2015 00:00:00 +0000

I list my requirements for a framework and discuss how Pytest, Unittest, and Nose measure up to those requirements.

Mentioned:

I did the audio processing differently for this episode. Please let me know how it sounds, if there are any problems, etc.

Transcript

Hello everyone. My name is Brian Okken. Welcome to the Python Test Podcast (Now called ‘Test & Code’).

pytest expect fixture plugin, iteration 1

Tue, 10 Mar 2015 13:28:02 +0000

This is the first iteration that implements ’expect’ as a fixture.

This is really the third attempt at an ’expect()’ implementation that allows multiple failures per test.

First attempt was a general solution that works with any test framework, but with a slightly clunky API. The main problem with it was that it required the test to call a final ‘assert_expectations()’ from the test code. If you forgot to call that function, the failures weren’t reported.
Second attempt was a pytest plugin implementation that eliminated the need for the ‘assert_expectations()’ call in the test because it was called automatically. I wasn’t thrilled with this solution. But it works.
In the solution I’m presenting in this post, I’m moving all of the code into one file and implementing ’expect’ as a pytest fixture.

The end result of all of this is now a plugin called pytest-check

I think there are advantages to having ’expect’ as a fixture.
Let me know what you think.

Test First Programming / Test First Development

Tue, 03 Mar 2015 08:19:09 +0000

Occasionally referred to as “Test First Development”, “Test First Programming” is a beautiful concept that radically changed the way I approach software development.

The ideas of “Test First Programming” and “Test Driven Development” are often muddled together.
However, “Test First” is powerful enough to stand on it’s own.
I think it’s important to present the concepts separately.

“TDD” and many other agile practices build on “Test First”.
This isn’t just about remembering the past.
The lessons learned from “Test First” are still very important.

pytest delayed assert / multiple failure plugin, iteration 1

Thu, 19 Feb 2015 05:17:48 +0000

In Delayed assert / multiple failures per test, I presented a first attempt at writing an expect() function that will allow
a test function to collect multiple failures and not stop execution until the end of the test.

The end result of all of this is now a plugin called pytest-check

There’s one big thing about that method that I don’t like.
I don’t like having to call assert_expectations() within the test.
It would be cool to push that part into a plugin.

Delayed assert / multiple failures per test

Fri, 13 Feb 2015 08:20:14 +0000

The end result of all of this is now a plugin called pytest-check

A test stops execution once it hits a failing assert statement.
That’s kinda the point of an assert statement, though, so that’s not surprising.

However, sometimes it’s useful to continue with the test even with a failing assert.

I’m going to present one method for getting around this restriction, to test multiple things, allow multiple failures per test, and continue execution after a failure.

Why Most Unit Testing is Waste

Fri, 01 Aug 2014 12:55:48 +0000

I don’t rememember how I ran across this article by James O Coplien. However, I was immediately impressed with the thought and experience that went into this paper. Regardless of your viewpoints towards unit tests vs. other types of automated tests, this article is important to read.
If your first reaction to the title is anger, please take a deep breath, try to keep an open mind, and actually READ what Cope has to say. I am going to reserve my own reactions to this to a future post, as I don’t want to color your views before you read it. I am posting the entire article with no changes other than formatting.

My reaction to “Is TDD Dead?”

Sun, 25 May 2014 07:26:48 +0000

Whatever your stance on the merits or pitfalls of Test Driven Development, I think it’s worthwhile and educational to pay attention to a discussion that’s going on lately.

Testing is crucial. But is unit test focused TDD the right path?

I care about the conversation about TDD because I see serious flaws in the conventional understanding of TDD.

Much of the current view of TDD includes:

Units are tested in isolation of the rest of the system.
Unit tests are more important than any other form of testing.
A “unit” is a class or a function. Nothing larger is a “unit”.
If you test more than one class, that’s an integration test.
If you test from the API with all resources, that’s a system test. Let QA deal with that later. Isn’t that exactly where waterfall failed?
You can’t write any production code without a failing test.
You have to write only one test at a time, and it must fail.
Tests have to be fast.
Therefore, they cannot touch hardware, the file system, other services, or database.
Tests should be short.

All of this rubs me the wrong way.
I’ll get to my thoughts later, but my concern about this cemented view of TDD caused me to be very interested in the current talks.

On to the discussion

I came in after the 2nd video, while doing research on Agile and TDD.
I’m not sure if the order matters, but here’s a list of what I know about the discussions.

Mixing pytest fixture scope

Tue, 25 Mar 2014 13:00:31 +0000

Let’s say I’ve got:

a function scope fixture ‘resource_c’
that uses a module scoped fixture ‘fixture_b’
that uses a session scoped fixture ‘fixture_a’

This all works fine.

conftest.py:

import pytest

@pytest.fixture(scope="session")
def resource_a():
    print('\n[setup] resource_a()')
    yield
    print('[teardown] resource_a()')


@pytest.fixture(scope="module")
def resource_b(resource_a):
    print('[setup] resource_b()')
    yield
    print('[teardown] resource_b()')


@pytest.fixture(scope="function")
def resource_c(resource_b):
    print('[setup] resource_c()')
    yield
    print('\n[teardown] resource_c()')

test_alpha.py:

def test_one(resource_c):
    print('In test_one()')

def test_two(resource_c):
    print('In test_two()')

test_beta.py:

def test_three(resource_c):
    print('In test_three()')

def test_four(resource_c):
    print('In test_four()')

This seems reasonable to me.
What do you think will happen?

pytest session scoped fixtures

Tue, 25 Mar 2014 13:00:31 +0000

In pytest fixture scope, I noted that you can specify session scope so that a fixture will only run once per test session and be available across multiple test functions, classes, and modules.

In this post, I’m going to show a simple example so you can see it in action.

Here’s the table from the previous post:

A separate file for fixtures, conftest.py

With function, class, and module scope, it is completely reasonable for the fixture code to be in the same file as the tests.
But now suddenly, with session, that doesn’t make sense anymore.

Using pytest fixtures by naming them

Wed, 05 Feb 2014 06:23:04 +0000

The easiest way to use a fixture is to name it.

We can put the fixture name in the parameter list for each test that needs it:

import pytest

@pytest.fixture()
def before():
    print('\nbefore each test')

def test_1(before):
    print('test_1()')

def test_2(before):
    print('test_2()')

The fixture is going to be called for every test that names the fixture in it’s parameter list.

Output:

$ pytest -s test_fixture.py 
=========== test session starts ============
collected 2 items                          

test_fixture.py 
before each test
test_1()
.
before each test
test_2()
.

============ 2 passed in 0.05s =============

This post is part of a series on pytest fixtures

Modularity - pytest fixtures using other fixtures

Wed, 05 Feb 2014 06:22:11 +0000

Tests can use one or more fixture.

Fixtures themselves can also use one or more fixtures.

I’ll rewrite the example from Using multiple pytest fixtures, but instead of having the tests include all foo, bar, and baz fixtures, I’ll chain them together.

And one more wrinkle, ’test_two’ will only include ‘bar’.

@pytest.fixture(scope="module")
def foo():
    print('\nfoo setup - module fixture')
    yield
    print('foo teardown - module fixture')

@pytest.fixture()
def bar(foo):
    print('bar setup - function fixture')
    yield
    print('bar teardown - function fixture')

@pytest.fixture()
def baz(bar):
    print('baz setup - function fixture')
    yield
    print('baz teardown - function fixture')

def test_one(baz):
    print('in test_one()')

def test_two(bar): # only use bar
    print('in test_two()')

output

Using multiple pytest fixtures

Wed, 05 Feb 2014 06:22:10 +0000

In the examples I’ve used so far in this series , tests only are using at most one named fixture.

You can use more.

Simple example:

import pytest

@pytest.fixture(scope="module")
def foo():
    print('\nfoo setup - module fixture')
    yield
    print('foo teardown - module fixture')

@pytest.fixture()
def bar():
    print('bar setup - function fixture')
    yield
    print('bar teardown - function fixture')

@pytest.fixture()
def baz():
    print('baz setup - function fixture')
    yield
    print('baz teardown - function fixture')

def test_one(foo, bar, baz):
    print('in test_one()')

def test_two(foo, bar, baz):
    print('in test_two()')

$ pytest -s test_multiple.py
================== test session starts ==================
collected 2 items                                       

test_multiple.py 
foo setup - module fixture
bar setup - function fixture
baz setup - function fixture
in test_one()
.baz teardown - function fixture
bar teardown - function fixture
bar setup - function fixture
baz setup - function fixture
in test_two()
.baz teardown - function fixture
bar teardown - function fixture
foo teardown - module fixture

=================== 2 passed in 0.06s ===================

This post is part of a series on pytest fixtures

Parametrizing pytest fixtures with params

Wed, 05 Feb 2014 06:22:09 +0000

An optional parameter to the fixture decorator is params.

For each value in params, the fixture will be called with request.param filled in with that value.
Tests that use the fixture will be called once FOR EACH value in params.

Toy example

An example is in order here.

This first example is a silly one, but does show the mechanics, and the utility of both the -v flag and how well pytest deals with failures of parameterized tests.

pytest fixture scope

Wed, 05 Feb 2014 06:22:08 +0000

Scope controls how often a fixture gets called.

The default is “function”.

Here are the options for scope:

scope	When setup and teardown run
function	(default) Setup before each function, teardown after each function
class	Setup before first test of class, teardown after last test of class
module	Setup/Teardown bracketing tests of a module
package	Setup/Teardown bracketing tests of a package/directory
session	Setup/Teardown at the beginning and end of the entire test session / test run

Since the default scope is “function”, the cheese db example will open and close the db for every test.

pytest fixture return value

Wed, 05 Feb 2014 06:22:07 +0000

In the basic example, the fixture returns None.
It actually doesn’t have a return statement. So like any other function in Python, if you don’t supply a return (or yield) statement, it returns None.

However, you can return anything you want from the fixture function.
If your fixture is setting up some data, or reading a file, or opening a connection to a database, then access to that data or resources is what you ought to return from the fixture.

pytest fixture teardown

Wed, 05 Feb 2014 06:22:07 +0000

In the previous post about return value the ‘cheese_db’ fixture looked like this:

@pytest.fixture()
def cheese_db(request):
    # setup
    print('\n[setup] cheese_db, connect to db')

    # code to connect to your db 
    makeshift_cheese_db = {'Brie': 'No.', 'Camenbert': 'Ah! We have Camenbert, yessir.'}

    # return db to test code
    return makeshift_cheese_db

That’s really not going to work if we have a real database or other resource that we need to possibly, actually disconnect from when we’re done.

For resources where we need some code to happen “when we’re done” with them, we use the teardown section of fixtures.
The “teardown” section is just “anything after a yield”.

Using pytest fixtures with mark.usefixtures

Wed, 05 Feb 2014 06:22:06 +0000

Usefixtures example

Let’s go back to our basic example, but explore the use of usefixtures.

usefixtures is a marker that accepts a list of fixture names as strings, and applies it to something.

You can use it on an individual test. However, it’d be pretty silly as named parameters are easier.

However, this is what it’d look like to mark individual tests:

# test_usefixtures.py
import pytest

@pytest.fixture()
def before():
    print('\nbefore each test')

@pytest.mark.usefixtures("before") 
def test_1():
    ...

@pytest.mark.usefixtures("before") 
def test_2():
    ...

And it also works for test methods:

Using pytest autouse fixtures

Wed, 05 Feb 2014 06:22:05 +0000

Naming a fixture is the most straight-forward way to use fixtures. However, it also requires that we have to add the fixture name to every test that we want to use the fixture.

There are times when we want something to happen before every test, and the test itself doesn’t really need to know about it. For that, we can use autouse.

If you add autouse=True as a parameter to @pytest.fixture(), then all tests that have access to this fixture will use the fixture.

Basic pytest fixtures example

Wed, 05 Feb 2014 06:22:03 +0000

Fixtures hold setup code

Fixtures are a way to separate some code that we want to run before or after a test and put it in a different function than the test function itself.

Let’s say we have a couple of tests with common setup code:

def test_1():
    # setup code running before the test
    print('\nbefore each test')
    # actual test code
    print('test_1()')

def test_2():
    # setup code running before the test
    print('\nbefore each test')
    # actual test code
    print('test_2()')

We could use xunit fixtures, but we’re not going to

If we want to use xunit fixtures, we could create a setup function like:

pytest xUnit style fixtures

Sat, 28 Dec 2013 10:08:14 +0000

I’m going to cover the syntax for pytest support for xUnit style fixtures.
Then I’ll give a more reasonable and typical example, using just one set of fixture functions.
And then address the issue of having tests mixed in a file. Some that need the resource, and some that don’t.

Depending on what scope you want your fixtures, you define setup/teardown pairs.

Module (setup_module/teardown_module)
- Sets things up once for the module, teardown after everything.
Function (setup_function/teardown_function)
- Wraps every test function with calls.
- Gets called multiple times, once for each function
Class (setup_class/teardown_class)
- Like module level, but for classes, once for a class.
Method (setup_method/teardown_method)
- Like function level, but for classes.
- Gets called multiple times, once for each test method in a class

Unless you really need xUnit fixtures, I recommend completely ignoring this post.
It’s way better to move on and use only native pytest fixtures.

pytest fixtures nuts and bolts

Mon, 18 Nov 2013 01:54:23 +0000

Dealing with fixtures is one of the areas where pytest really shines.
This is rather an incredible understatement.

The xunit style of test fixtures that is used in both unittest and nose is of course supported with with pytest. And pytest rocks at this.

But there is another way to deal with fixtures. It’s to think of fixtures as a set of resources that need to be set up before a test starts, and cleaned up after. Test functions, methods, classes, name which fixtures they need. This way, fixtures aren’t set up for tests that don’t need them.

The power of “Thank You”

Tue, 01 Oct 2013 23:39:59 +0000

Fozzie: Nobody reads those names anyway, do they?
Kermit: Sure. They all have families.

– The Great Muppet Caper

Many projects have release notes that include the names of people that contributed to the release.

Who reads these names?
Well, at the very least, the people in that list read the names.

If your project doesn’t do this, I think it should.
My name was listed in a release notice today.
I’ll share the details, and try to point out why saying thanks to contributors is a good idea.

tip: dictionary get() works like getattr

Wed, 21 Aug 2013 19:14:26 +0000

You can’t use getattr() to look stuff up in a dictionary.
But the ‘default’ feature of getattr() is so useful.
What’s the dict way to do the same thing?

This is one of those posts that I’m writing because I keep having to look it up.
So if I write it, I’ll remember it. Hopefully.

getattr

I’ve been using the ‘default’ parameter to getattr for some time, and it’s super handy.
This is handy in lots of places, and avoids having to wrap things in try/except blocks.

I’m annoyed with Python’s ternary operator

Tue, 02 Jul 2013 16:14:23 +0000

The ternary operator is a way to concisely say:
“If test, then a, else b“,
with the value of the statement being the value of a or b.

language	how to say it
C	test ? a : b
C++	test ? a : b
javascript	test ? a : b
Perl (not perl 6)	test ? a : b
PHP	test ? a : b
Ruby	test ? a : b
Did I forget some language?	probably
Python	a if test else b (Why??)

Why??

Ok. Now that I’ve written this post, I’ll remember it.

pytest support for unittest style fixtures

Wed, 26 Jun 2013 21:07:11 +0000

unittest fixtures behave the same regardless if you run them from python -m unittest or pytest.

There used to be more of a story here.

Way back in 2013 with pytest 2.3.5 (when this post was originally written) there was an issue that the behavior of whether or not to run the teardown for unittest fixtures if the setup failed was different.

However, that’s been fixed A LONG TIME AGO.

Run a single test class with unittest and pytest

Wed, 19 Jun 2013 14:10:19 +0000

I’ve got the test code from my unittest fixture syntax and flow reference, and I want to try to run one class, say TestSkip from unittest and pytest to compare the the control flow.

Therefore, I need for each framework:

The option to make it as quiet as possible
- -q for both unittest and pytest
The option to turn off output capture
- -s works for pytest, not needed for unittest
The way to call an individual class
- details below
- note that moduleName == fileName (but without the extension)

unittest

Specify moduleName.className, like so:

What happens when unittest fixtures fail

Mon, 17 Jun 2013 16:50:05 +0000

In unittest fixture syntax and flow reference, I only presented fixture methods and functions that threw no exceptions.
However, in real production code, it is entirely possible for something to go wrong when setting up test fixtures.

This post is simply do demonstrate exactly what happens to the flow of your test code when an exception is thrown in a fixture function.

And, while I’m at it, I may as well demo the normal control flow when a test fails, asserts, or throws an exception.

unittest fixture syntax and flow reference

Sun, 16 Jun 2013 00:15:33 +0000

This post contains examples of how unittest test fixture functions and methods are written, and in what order they run. It may seem like a long post, but it’s mostly code examples and example output.

I want this to be a useful reference for both the syntax and flow of unittest fixtures.

Intro: Software Test Fixtures

The term test fixtures really means two things.
Test fixtures are the resources and initial conditions that a test needs to operate correctly and independently from other tests.
The phrase has also grown to mean the functions and methods that are used to do that resource and environment handling.

Complete coverage testing from the bottom of the pyramid up is a bad idea

Tue, 21 May 2013 14:14:49 +0000

or Complete coverage testing
or More is Better testing
or How not to test, part 1

The setup

For the sake of this post, let’s say I’ve got a Python package that needs testing.

It’s written completely in Python
It has a specification fully describing the API
The specification is so complete that it also covers behaviors and side effects
The API is the only interface this program exposes
It was written by us
It was written recently
It only uses base Python

Therefore:

pytest debug print logging in real time

Thu, 04 Apr 2013 02:23:18 +0000

There are many circumstances where it’s really great to display the print statements and logging from a test while a test is running, and not wait until the end.

Printing and logging in test code

Before you pipe in with “unit tests should be fast”, I’ll just remind you that pytest can be used for system tests, performance tests, and other long running tests, and can be used to test both software and hardware.

Python regex Search and Replace Examples

Fri, 08 Feb 2013 00:00:00 +0000

Search and replace is such a common task that it should be a tool that’s in every command line script author’s toolbox.
There are probably endless solutions to the problem.
I’ve put together my standard methods for tackling the problem.
I’ll also show similar Perl versions, mainly for comparisons.

use models

In most of the following discussion, I’m just replacing ‘foo’ with ‘bar’.
However ‘foo’ can be ANY regular expression.

Perl regex Search and Replace Examples

Thu, 07 Feb 2013 00:00:00 +0000

Search and replace is such a common task that it should be a tool that’s in every command line script author’s toolbox.
There are probably endless solutions to the problem.
I’ve put together my standard methods for tackling the problem, with Perl. You can also use Python, of course, as well as other tools like sed.

Use Models

In most of the following discussion, I’m just replacing ‘foo’ with ‘bar’.
However ‘foo’ can be ANY regular expression.

Don't use nose

Tue, 29 Jan 2013 15:51:12 +0000

As of 2025, nose hasn’t been updated for about 10 years.

I don’t recommend using it.
I recommend trying out pytest. :)

A note on the nose docs page recommends using a different project, such pytest or unittest:

Note to Users

Nose has been in maintenance mode for the past several years and will likely cease without a new person/team to take over maintainership. New projects should consider using Nose2, py.test, or just plain unittest/unittest2.

Running doctest from pytest

Tue, 15 Jan 2013 13:39:34 +0000

You can run some doctests from pytest, according to the documentation.
However, it can be a bit fiddly.

With my examples of putting doctests in text files, if I just try running:

$ pytest test_unnecessary_math.txt

I get the error:

... ModuleNotFoundError: No module named 'unnecessary_math'

It doesn’t seem to like the line “from unnecessary_math import multiply” from the .txt file, even thought he file unnecessary_math is in the same directory.

However, if I throw that same like into a conftest.py file, it seems to work:

Running unittest from pytest

Tue, 15 Jan 2013 13:38:34 +0000

To show how pytest handles unittests, here’s a sample run of pytest on the simple unittests I wrote in the unittest introduction:

$ pytest test_um_unittest.py 
======================== test session starts =========================
collected 2 items                                                    

test_um_unittest.py ..                                         [100%]

========================= 2 passed in 0.04s ==========================

$ pytest -v test_um_unittest.py
======================== test session starts =========================
collected 2 items                                                    

test_um_unittest.py::TestUM::test_numbers_3_4 PASSED           [ 50%]
test_um_unittest.py::TestUM::test_strings_a_3 PASSED           [100%]

========================= 2 passed in 0.05s ==========================

As you can see, I didn’t provide any extra options, pytest finds unittests automatically.

pytest introduction

Tue, 15 Jan 2013 13:36:34 +0000

I think of pytest as the run-anything, no boilerplate, no required api, use-this-unless-you-have-a-reason-not-to test framework.
This is really where testing gets fun.
As with previous intro’s on this site, I’ll run through an overview, then a simple example, then throw pytest at my markdown.py project.
I’ll also cover fixtures, test discovery, and running unittests with pytest.

No boilerplate, no required api

The doctest and unittest both come with Python.
They are pretty powerful on their own, and I think you should at least know about those frameworks, and learn how to run them at least on some toy examples, as it gives you a mental framework to view other test frameworks.

Confession … I still use perl on the command line

Wed, 09 Jan 2013 00:00:04 +0000

I have a confession to make.

I still use Perl. Regularly. But mostly as a command line tool. Is that a reason? or an excuse?

When I started using Python regularly, I tried to replace my Perl usage.
Nothing against Perl, I just wanted to force myself to use Python to aid in my learning of the language.

I still have quite a few Perl habits that are hard to break.

unittest introduction

Fri, 04 Jan 2013 05:22:18 +0000

The unittest test framework is python’s xUnit style framework.
It is a standard module that you already have if you’ve got python version 2.1 or greater.
In this post, I’ll cover the basics of how to create and run a simple test using unittest.
Then I’ll show how I’m using it to test markdown.py.

Overview of unittest

The unittest module used to be called PyUnit, due to it’s legacy as a xUnit style framework.
It works much the same as the other styles of xUnit, and if you’re familiar with unit testing in other languages, this framework (or derived versions), may be the most comfortable for you.

doctest introduction

Tue, 11 Dec 2012 09:16:43 +0000

The doctest test framework is a Python module that comes prepackaged with Python. This post covers the basics of how to put doctests in your code, and outside of your code in a separate file.

We start with a simple working example using a silly script called unnecessary_math.py. Then we go on to show how I’m using doctest to test markdown.py.

conceptual model of Python doctest

This is from python.org:

The doctest module searches for pieces of text that look like interactive Python sessions,
and then executes those sessions to verify that they work exactly as shown.

Software API/CLI interface adapters

Tue, 27 Nov 2012 14:07:19 +0000

While writing software, we are faced with lots and lots of interfaces.
The public interface for some tool or module or package or whatever is usually referred to as the API, the CLI, or simply the user interface.
In this post, when considering an interface, I am specifically referring to APIs and CLIs.

Sometimes, we find a software component that does exactly what we want, but the interface is not what we want.
That’s where software interface adapters come to the rescue.
Adapters are helpful in many stages of the design and development of just about anything.

Stub for markdown.py

Thu, 25 Oct 2012 16:32:15 +0000

To explore the concepts of functional testing using python and python testing frameworks, I’m building a project to test, markdown.py on github.

In this post, I’m discussing the stub implementation that I will use to set up the testing frameworks.

I’ve got my markdown.py requirements written.
An initial set, at least. Enough to get me started.

I want to move on to explore testing frameworks and testing strategy.

But to do that, it will be helpful to have something to test. So I’m going to write a stub for my script. Something that has the right name and interface. I can use it just as I will use the completed script. It just doesn’t work yet.

Markdown requirements

Thu, 25 Oct 2012 12:00:16 +0000

I’ve decided to write my own Markdown script,
possibly for dubious reasons.

I’m getting antsy to code.

But before I get started on the testing and implementation, I want to:

write the requirements
write a simple stub implementation
write a testing strategy
explore test frameworks

Then, FINALLY, I can start testing and implementing.

Let’s take a look at the requirements.

Requirements for Markdown

Written in Python
Use only Python standard library packages
All contained in one python file
Implement enough of the original Markdown functionality to be useful

That’s it for now.

Why Markdown

Wed, 17 Oct 2012 00:00:00 +0000

Markdown has very little to do with python testing.
But I need a project to test, so I’m writing my own Markdown script.
This is a brief introduction to Markdown from my perspective.

Writing HTML sucks. Use Markdown.

HTML is obviously pretty helpful and critical for the web.
One goal for HTML was that humans could reasonably easily read, write, and edit it.
And that kinda works. Sometimes.
But it’s not fun to read or write HTML. Actually, writing stuff in HTML by hand sucks.

Get In Touch

Mon, 01 Jan 0001 00:00:00 +0000

BlueSky: brianokken.bsky.social
Mastodon: @brianokken@fosstodon.org
LinkedIn: linkedin.com/in/okken
Sign up for the infrequent the newsletter
Or email: (below)

Mon, 01 Jan 0001 00:00:00 +0000

blog posts
new courses
exciting news
possibly not so exciting news but for some reason Brian thinks it’s important.

Basically, keep up with what I’m up to on a very infrequent basis.

Podcasts

Mon, 01 Jan 0001 00:00:00 +0000

Python Bytes

Python headlines delivered directly to your earbuds.

Topics: All of Python
- Developer tools
- Python projects
- Open Source

Stick around until the end, as we usually have a joke or something funny to close out the show.

Python People

The Python community is awesome because of the people.
Python People is a weekly podcast about getting to know the people who help make the Python community great.

pytest courses

Mon, 01 Jan 0001 00:00:00 +0000

The Complete pytest Course

pytest Primary Power (Chapters 1 - 6)

Everything you need to get started with pytest and use it effectively.

Learn about:

Test Functions
- Structure functions effectively
Fixtures
- setup, teardown, and so much more
Builtin Fixtures
- many common testing tasks are pre-built and ready to use
Parametrization
- turn one test into many test cases
Markers
- Builtin markers provided by pytest
- Custom markers for test selection
- Combining markers and fixtures to alter pytest behavior

pytest Working with Projects (Chapters 7 - 13)

Applying pytest to software projects.

Python Testing with pytest, 2nd Edition

Mon, 01 Jan 0001 00:00:00 +0000

Availabile through:

Pragmatic - includes pdf, epub, mobi (works with kindle)
bookshop.org - paperback
Amazon - paperback & kindle
Barnes & Noble - paperback
Waterstones - paperback
It might be at your local bookstore
Or request it from your library

The most gentle and comprehensive tutorial on pytest

I based the content, layout, and project within “Python Testing with pytest” on some assumptions about who might be reading this book.

Support PythonTest / Test & Code

Mon, 01 Jan 0001 00:00:00 +0000

If you’ve found PythonTest or the Test & Code podcast useful, please consider helping to support future content and keep current content online.

Learn pytest

Python Testing with pytest, 2nd Edition
- The pytest book.
- Great for learning pytest offline
pytest Courses
- video courses
- Great for learning pytest online

Join the PythonTest Community

The PythonTest Community is currently a Discord community

focused on pytest
ask/answer pytest and other testing questions
Community membership is included in pytest Courses, but if you’ve gotten the book, and still have a question, this is a great way to ask.
Joining the community also helps support Brian to continue producing Python, pytest, and other great content.

Even if there’s nothing you need here yet, maybe there will be.
Sign up for a very infrequent newsletter to make sure you don’t miss something fun.