I was writing a small cli tool and wanted to try out typer. I’m a big fan of fast api, so I thought a cli library from the same author was worth a look. This blog post will cover a pattern I ended up using to help with testing.
The app and the first attempt at tests
I won’t go into too much detail about my actual problem, but I ended up with something like the following:
import typer def my_command(some_input: str): typer.echo(f"Starting up") # Do the first thing typer.echo(f"Result of first thing was X") # Do the second thing typer.echo(f"Result of second thing was X") # Do some clean up typer.echo(f"All done") if __name__ == "__main__": typer.run(my_command)
The value in the code I was writing was the output of
typer.echo. So I wanted to test it.
Initially in my tests I was monkey patching
typer.echo and asserting that it matched what
I wanted. This was okay, but I don’t like monkey patching with mocks as it often becomes
very tangled and complicated.
A solution? Yielding.
Since I already had a function representing my command invocation I thought it would be
really nice if I could just return the output. Then I could call the function and assert
that it had output what I wanted. However, given that quite significant delays could
happen in between each of my echo statements I didn’t really want to wait until the end
to get all my output. So instead
yield seemed like a good candidate. I updated my code
to look something like this:
@dataclass class Echo: message: str def my_command(some_input: str): yield Echo(f"Starting up") # Do the first thing yield Echo(f"Result of first thing was X") # Do the second thing yield Echo(f"Result of second thing was X") # Do some clean up yield Echo(f"All done")
Now my function was a generator. The code looked almost identical which was nice. I did need to add a layer on top to run this generator but this was not too complicated:
import typer def run_cli(generator_func): for output_line in generator_func(): typer.echo(output_line.message)
and now my test cases could look like this:
def test_something(): actual = list(my_command("input")) expected = [ Echo("first message"), Echo("second message"), Echo("etc.") ] assert actual == expected
I’m counting this as a success. My tests became a lot simpler which was my initial goal.
In addition, the
my_command function lost its dependency on the
typer library and became
agnostic to how the input is displayed to the user (though this wasn’t really my initial goal).