Test & Code

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:

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 

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

Links:

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.

Links:

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:

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

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.

pytest-check allows multiple failed "checks" per test function, so you can see the whole picture of what's going wrong.

Links:

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.

We discuss:

Links:

pytest-repeat 

This episode also discusses the attempted April Fools episode.

Links:

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

Links:

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.

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

Links:

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. 

In this episode

python.org has put up an "In memoriam" page for Michael Foord, and many people have shared stories and memories.

Links:

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

In this episode:

Links:

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

In this episode, we'll discuss:

Links:

Errata:

This episode kicks off a series on pytest plugins.

In this episode:

Links:

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

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?

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:

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.

I recorded this interview as an episode for one of my other podcasts, Python People. But I think it's got some great pre-conference advice, so I'm sharing it here on Python Test as well.

We talk about: 
- Juggling at PyCon
- How to get the most out of PyCon
    - Watching talks
    - Hallway track
    - Open spaces
    - Lightening talks
    - Expo hall / vendor space
    - Poster sessions
    - Job fair
    - A welcoming community
    - Tutorials 
    - Sprints
    - But mostly about the people of Python and PyCon.

"Python enables smart people to work faster" - Rob Ludwick

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:

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:

Links:

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:

BTW.

Links from the show:

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

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

Links:

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.

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:

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.

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:

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:

Plugins discussed:

Test Driven Development. Red, Green, Refactor. 

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

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

This episode covers:

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

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.

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.

This is the start of a series focused on examining TDD and related lightweight practices and processes.

Links from the show:

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:

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

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.

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.

Special Guest: Hynek Schlawack.

Links:

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:

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.

Links:

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.

Links:

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.

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. 

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

Here's an example, from pytest-crayons:

Links:

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:

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 systemMulti-process support out of the boxAsync supportChanges to the fixture systemExtend the assert rewriting to make it modularAdd matchers to assert mechanismBan test class inheritance

Brian's list: 

Extend assert rewriting for custom rewriting, like checkpytester matchers available for all testsThrow out nose and unittest compatibility pluginsThrow out setup_module, teardown_module and other xunit style functionsRemove a bunch of the hook functionsDocumentation improvement of remaining hook functions which include examples of how to use itStart running tests before collection is doneSplit collection and running into two processesHave the fixtures be able to know the result of the test during teardown

Links:

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?

Patrick Mineault has written "The Good Research Code Handbook". 
 It's a website. It's concise. 
 And it will put you on the right path to writing better software.
 Even if you don't write science based software, and even if you already have a CS degree, there's some good information worth reading.

Special Guest: Patrick Mineault.

Links:

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. 

Piper joins us this episode and we talk about PursuedPyBear, learning to code, and learning CS concepts with game development. 

PursuedPyBear, ppb, is a game framework great for learning with, with goals of being fun, education friendly, an example of idiomatic Python, hardware library agnostic, and built on event driven and object oriented concepts.

Special Guest: Piper Thunstrom.

Links:

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:

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:

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.

Links:

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:

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:

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

Links:

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.

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:

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:

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:

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.

Hiring is one of the essential processes for building a great team.
 However, it's a high noise, low signal process.

Nathan Aschbacher has a relatively unorthodox tech hiring approach. 
 He's trying to make it very humane, with a better signal to noise ratio. 

Nathan is not intereseted in bizarre interview processes where the interviewer doesn't know anything about the interviewee beforehand, all people are asked the same questions, and people are asked to code on white boards.

Instead, he states "if the goal is to try to figure out if the person can do the work with your team, and your trying to build the team that you are adding this person to, they need to know what the team is like, and determine if they want to be part of the team, and the team needs to know what the person is like and if they would be addititve to the team.

So what's Nathan's process:

We discuss the process, and also:

And of course, there's the story of how Nathan ended up interviewing someone with Zoo experience an no technical experience for a technical role. Of course, it was a misunderstanding of a job requirement around experience with ZooKeeper. But it's a good story.

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.

Links:

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.

For me, the normal way TDD is taught just doesn't work. So I'm trying to come up with a spin on some old ideas to make it work for me. I'm hoping it works for you as well.

I'm calling the new thing Lean TDD. It's inspired by decades of experience writing software and influence from dozens of sources, including Pragmatic Programmer, Lean Software Development, Test-Driven Development by Example, and many blog posts and wiki articles. 

The main highlights, however, come from the collision of ideas between Lean and TDD and how I've tried to resolve the seemingly opposing processes.

Links:

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.

"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 correctlyPrevent future regressionsDocument the code’s behaviorProvide design guidanceSupport refactoring

Brian's order:

Verify the code is working correctlyPrevent future regressionsSupport refactoringProvide design guidanceDocument the code’s behavior

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

Links:

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:

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. 

Brandon Braner is building Released.sh. It's a cool idea, but it's not done yet. 

Brandon and I talk about building side projects:

Special Guest: Brandon Braner.

Links:

Answering these questions are the goals of this episode.

Links:

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:

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

Pauls workflow allow you to develop non-linearly, but commit cleanly.

Links:

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 

Links:

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.

Links:

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.

Links:

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

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

All with pytest. So cool.

Special Guest: Prayson Daniel.

Links:

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.

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.

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:

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

In this episode, we cover:

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

Some sample code. 
 unittest only:

unittest with pytest markers:

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

The episode covers:

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:

Flags to control pytest output:

Flags to start a command-line debugger:

This list is also found in Chapter 13 of Python Testing with pytest, 2nd edition.
The chapter is "Debugging Test Failures" and covers way more than just debug flags, while walking through debugging 2 test failures.

Links:

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.

Special Guest: Stéphane Bidoul.

Links:

What flavor of TDD do you practice? 

In this episode we talk about:

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.

Links:

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.

Lean manufacturing and lean software development caused people to talk about and examine waste and value, even in fields where we didn't really think about waste that much to begin with.

Software is just ones and zeros. Is there waste? 
 When I delete a file, nothing goes into the landfill.

The mistake I'm making here is confusing the common English definition of waste when what we're talking about is the Lean definition of waste.

This episode tries to clear up the confusion.

Links:

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:

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:

Links:

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.

Gio Lodi, author of TDD in Swift, joins the show to discuss Test Driven Development, software workflows, bottom up vs top down, rapid feedback, developer vs customer facing tests, and more.

Links:

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.

Anthony Sottile discusses pre-commit, for using locally by developers, and pre-commit.ci, which can run actions during merge requests.

"Git hook scripts are useful for identifying simple issues before submission to code review. We run our hooks on every commit to automatically point out issues in code such as missing semicolons, trailing whitespace, and debug statements. By pointing these issues out before code review, this allows a code reviewer to focus on the architecture of a change while not wasting time with trivial style nitpicks." - pre-commit.com

"Developers spend a fair chunk of time during their development flow fixing relatively trivial problems in their code. pre-commit.ci both enforces that these issues are discovered, which is opt in for each developer workflow via pre-commit, but also fixes the issues automatically, letting developers focus their time on more valuable problems." - A user of pre-commit.ci

Links:

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.

Links:

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:

What's the most important thing that it doesn't do yet?

Links:

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.

Links:

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

Links:

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:

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.

What's happening is that I'm playing adventure, which you can pip install thanks to Brandon Rohdes. Adventure is a faithful port to Python 3 from the original 1977 FORTRAN code by Crowther and Woods that lets you explore Colossal Cave, where others have found fortunes in treasure and gold, ...

In this episode, we talk with Brandon Rhodes about this marvelous game.

Links:

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.

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:

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

Special Guest: Corey Quinn.

Links:

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:

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:

The example code discussed in the episode: script.py

Suggestion by @cfbolz if you need to import pytest:

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. 

We talk about:

Links:

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:

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.

Links:

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:

Special Guest: Martin Héroux.

Links:

Completely nerding out about pytest markers with Anthony Sottile.

Some of what we talk about:

Links:

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:

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:

Also discussed:

Links:

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?

Martin works in research and this discussion is about software and testing in scientific research and academia.

Special Guest: Martin Héroux.

Links:

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.

Special Guests: Nalin Parbhu and Ola Omiyale.

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.

Special Guest: Anders Hovmöller.

Links: