Unit test writing using a multi-step prompt (with the older API)

# Unit test writing using a multi-step prompt (with the older API) Complex tasks, such as writing unit tests, can benefit from multi-step prompts. In contrast to a single prompt, a multi-step prompt generates text from GPT-3 and then feeds that text back into subsequent prompts. This can help in cases where you want GPT-3 to explain its reasoning before answering, or brainstorm a plan before executing it. In this notebook, we use a 3-step prompt to write unit tests in Python using the following steps: 1. Given a Python function, we first prompt GPT-3 to explain what the function is doing. 2. Second, we prompt GPT-3 to plan a set of unit tests for the function. - If the plan is too short, we ask GPT-3 to elaborate with more ideas for unit tests. 3. Finally, we prompt GPT-3 to write the unit tests. The code example illustrates a few optional embellishments on the chained, multi-step prompt: - Conditional branching (e.g., only asking for elaboration if the first plan is too short) - Different models for different steps (e.g., `gpt-3.5-turbo-instruct` for the text planning steps and `gpt-4` for the code writing step) - A check that re-runs the function if the output is unsatisfactory (e.g., if the output code cannot be parsed by Python's `ast` module) - Streaming output so that you can start reading the output before it's fully generated (useful for long, multi-step outputs) The full 3-step prompt looks like this (using as an example `pytest` for the unit test framework and `is_palindrome` as the function): # How to write great unit tests with pytest In this advanced tutorial for experts, we'll use Python 3.9 and `pytest` to write a suite of unit tests to verify the behavior of the following function. ```python def is_palindrome(s): return s == s[::-1] ``` Before writing any unit tests, let's review what each element of the function is doing exactly and what the author's intentions may have been. - First,{GENERATED IN STEP 1} A good unit test suite should aim to: - Test the function's behavior for a wide range of possible inputs - Test edge cases that the author may not have foreseen - Take advantage of the features of `pytest` to make the tests easy to write and maintain - Be easy to read and understand, with clean code and descriptive names - Be deterministic, so that the tests always pass or fail in the same way `pytest` has many convenient features that make it easy to write and maintain unit tests. We'll use them to write unit tests for the function above. For this particular function, we'll want our unit tests to handle the following diverse scenarios (and under each scenario, we include a few examples as sub-bullets): -{GENERATED IN STEP 2} [OPTIONALLY APPENDED]In addition to the scenarios above, we'll also want to make sure we don't forget to test rare or unexpected edge cases (and under each edge case, we include a few examples as sub-bullets): -{GENERATED IN STEP 2B} Before going into the individual tests, let's first look at the complete suite of unit tests as a cohesive whole. We've added helpful comments to explain what each line does. ```python import pytest # used for our unit tests def is_palindrome(s): return s == s[::-1] #Below, each test case is represented by a tuple passed to the @pytest.mark.parametrize decorator {GENERATED IN STEP 3}