This PR needs a skip-news label.

Okay here's our goal - making the unittest easy to understand and easy to write. Ideally, we only need data in our unittest, no logic at all. All the logic should be dealt with in our utility method.

I don't think I understand what you're proposing. Your example has a test setup (the server_messages = ...), an execution of the system under test (the self.do_test), and some assertions about the observed behavior of the system under test. Those exactly correspond to the given/when/then structure of all of these tests.

Taking one of my tests, chosen mostly at random:

    def test_handling_pdb_prompts(self):
        """Test responding to pdb's normal prompts."""
        # GIVEN
        prompts_and_inputs = [
            ("(Pdb) ", "blah ["),
            ("...   ", "blah ]"),
            ("(Pdb) ", ""),
            ("(Pdb) ", "b ["),
            ("(Pdb) ", "! b ["),
            ("...   ", "b ]"),
        ]
        prompts = [pi[0] for pi in prompts_and_inputs]
        inputs = [pi[1] for pi in prompts_and_inputs]
        num_prompt_msgs = sum(pi[0] == "(Pdb) " for pi in prompts_and_inputs)
        messages = [
            {"command_list": ["b"]},
        ] + [{"prompt": "(Pdb) ", "state": "pdb"}] * num_prompt_msgs
        sockfile = MockDebuggerSocket(messages)
        client = self.create_pdb_client(sockfile)
        # WHEN
        with (
            unittest.mock.patch("pdb.input", side_effect=inputs) as input_mock,
        ):
            client.cmdloop()
        # THEN
        expected_outgoing = [
            {"reply": "blah [\nblah ]"},
            {"reply": ""},
            {"reply": "b ["},
            {"reply": "!b [\nb ]"},
        ]
        self.assertEqual(sockfile.outgoing, expected_outgoing)
        self.assertFalse(client.write_failed)
        self.assertEqual(client.state, "pdb")
        input_mock.assert_has_calls([unittest.mock.call(p) for p in prompts])

How would you prefer this test look? It's got two streams of input being fed to the system under test (the prompt messages coming from the PDB server and the user input on stdin), and it's testing that when the user's input is:

"blah [\nblah ]\n\nb [\n! b [\nb ]"

• that it consumes 4 prompt messages from the server
• that it makes 6 input() calls total (the 4 (Pdb) prompts the server asked for plus 2 ... continuation prompts)
• that the blah [ line and the ! b [ line lead to a continuation prompt
• that the blah ] and b ] lines complete the command started on the previous line and don't lead to another continuation prompt
• that the empty input line line and the b [ line are submitted to the server directly without starting a continuation line

Can you show how you would set up the test to provide that input and make those assertions?

I would expect something like

# not sure if message is the perfect variable name but that's irrelevant
messages = [
    ("server", {"command_list": ["b"]}),
    ("server", {"prompt": "(Pdb) ", "state": "pdb"}),
    ("client", {"prompt": "(Pdb) ", "input": "blah ["}),
    ("client", {"prompt": "... ", "input": "blah ]"}),
    ("server", {"prompt": "(Pdb) ", "state": "pdb"}),
    ...
]

self.do_test(messages, expected_outgoing=expected_outgoing, ...)

In reality, we actually feed the mock server (sockfile) all the messages and just do the loop. However, this order thing gives us the possibility to check the actual message order, and gives a better idea of what's really going on.

Notice that - we don't have to check prompt on the client side for every single test, it could be omitted so the test case would be simpler.

# not sure if message is the perfect variable name but that's irrelevant
messages = [
    ("server", {"command_list": ["b"]}),
    ("server", {"prompt": "(Pdb) ", "state": "pdb"}),
    ("client", {"input": "blah ["}),
    ("client", {"input": "blah ]"}),
    ("server", {"prompt": "(Pdb) ", "state": "pdb"}),
    ...
]

self.do_test(messages, expected_outgoing=expected_outgoing, ...)

What I want is 0 logic in the test case itself. I can just translate the events I expected to some data structure and I got my test case.

What I want is 0 logic in the test case itself. I can just translate the events I expected to some data structure and I got my test case.

OK, I've pushed a new commit that does this, please take another look.

No idea what the failure in the tsan test is about, but it seems unrelated to my changes.