In a nutshell,

1. pytest (and Tox/Nox, but those are more for CI/CD) is the industry standard, so use that unless you really like the boilerplate of unittest for whatever reason.

2. Write tests that each test a particular edge case or feature, including correct rising of exceptions. The number of tests doesn't matter, but follow the KISS principle for individual tests.

3. If you need setup code for your tests, make those as fixtures in a conftest.py file and have your tests call those.

4. Try breaking up your tests either per-file, or in some other logical grouping.

5. Try not to write your tests too tightly coupled with the actual program, because if you need to change your tests every time you make a change to the codebase that's not good.

On that note, try to also design your codebase to be easier to test:

1. Write "pure" functions (meaning, they don't depend on external mutable state and they give the same output from the same passed arguments every time if possible).

2. Encapsulate all mutable state in classes (in other words, don't use global variables - constants are fine).

3. Keep your individual functions/methods relatively short, and have them mostly do one thing.

More on reddit.com

Testing is one of those things that's gets more useful the larger your codebase and number of contributors grow. They are like proofs that your software works correctly. Once you start refactoring, you'll need the proofs to ensure that your program still works correctly and if it doesn't, you'll get immediate feedback. People that get into this style of programming will do unit testing for their own personal projects because it results in far less debugging later. Debugging an entire system for a small bug that normal unit tests would have easily caught, just sucks. More on reddit.com

First off, its important to get terminology right. TDD is a technique not a framework. You could do TDD with pytest or unit test if you choose to. TDD stands for test driven development. It means you write your tests firsts and make your code match your tests. I have only seen TDD work well in agile teams where each sprint involves a small amount of work every period. I have not seen a good adaption of it to a legacy code base for example. Even if your company is not following the TDD technique its important that dev use unit testing as part of their build cycle. There is a lot more to be said about this if you research this on your own. If the only form of testing being done is manual qa then the overall software policy is very expensive. If the only way to catch bugs is by qa at the end of the dev cycle then the cycle has to begin all over again with fixing bugs. In other words bugs caught by unit testing earlier in the cycle will cheaper to fix than after deployment. More on reddit.com

My way to understand this is the following: In order to know if my code is running properly would be to run my code against a set of known inputs that generate an expected output. And so, I could run my code to check for this. Unit testing would be the next step and write some code which does that for me. And so. I would run the tests that run my code to check my program is running as I expect. Hope this helps. More on reddit.com