Mostly this looks fine. With the caveat that CGI is very legacy, and frowned upon in the modern python ecosystem, at least for new code.

I am glad you chose to include a dirt simple "hello world".

bind()

 with HTTPServer(("", 8000), ... 

I think that lets random hosts probe your TCP port. Prefer to specify "localhost" there.

There may be room to DRY this up a little bit, given the redundancy with TEST_CGI_URL.

And in test_server_is_closed_after_exit(), the short URL we see isn't a bad thing, but we could as easily specify TEST_CGI_URL again. I mean, at some point you may need to change the URL because an unrelated daemon has allocated port 8000, and we ideally would change it in just one place.

extra assert

 assert isinstance(response, HTTPResponse) 

Maybe that was helpful to you during initial debugging? But I can't imagine it reveals anything interesting about the code you actually want to test.

Consider deleting it, or testing that response.status indicates Success.

extra downcase

 self.assertIn("hello world", content.lower()) 

The call to .lower() is surprising. Just verify that "Hello world" came back.

boilerplate text

This is simple and works great, but is not very convenient for copy-n-pasting revised headers or text:

echo "Content-Type: text/plain" echo "" echo "Hello world" 

Consider rephrasing as a here-doc.

cat << EOF Content-Type: text/plain Hello world EOF 

In python we would tend to use a triple """ to accomplish the same thing.

Binding to all interfaces

As mentioned by @J_H:

bind()

with HTTPServer(("", 8000), ... 

I think that lets random hosts probe your TCP port. Prefer to specify "localhost" there.

Indeed, leaving the address empty has the following behavior:

By default, the server binds itself to all interfaces

Source: Python docs. You can use localhost or 127.0.0.1. Using localhost might fall back on an IPv6 address, but that should be OK as long as your IPv6 stack is working properly.

Port already bound

He made another valid point: port 8000 may already be in use on your machine at the time the test is being run. It's best to let Python choose a random port that is available. The secret trick is to use port 0 (zero). Then to retrieve the assigned port you just need this:

httpd.server_port 

This is what I do in my own tests.

I would make it a fixture in your conftest.py. In fact, the whole server instance should be a fixture. Anyway, port and address should not be hardcoded more than once in your code.

Randomize

The test should already be sufficient, but as J_H said it's a good idea to always check the status code as well. Also, to make the tests even more realistic, you could randomize the expected response by using fixtures. The idea is to generate a random string every time, via a dedicated function (fixture with scope "session"), then test the existence of that string across your tests. The reasoning is that hello world is widely used in code and not very random. For example, some API test endpoints might return that kind of response by design.

I am more familiar with pytest than unittest, but I understand that fixtures exist in unittest too and should work in a similar fashion.

Tightening

The test can be more strict. First, by being case-sensitive. You are using assertIn, so the response only has to contain hello world, but could carry unrelated text. You could trim the response, and then look for the exact string you are expecting.

Layout

The test_can_invoke_cgi function has too much wasted vertical whitespace. There is no need for a blank line between every line of code. This is fine:

def test_can_invoke_cgi(self): TEST_CGI_URL = "http://localhost:8000/cgi-bin/hello_world.sh" self.enterContext(_setup_cgi_http_server()) with urllib.request.urlopen(TEST_CGI_URL) as response: assert isinstance(response, HTTPResponse) content = response.read().decode("utf-8") self.assertIn("hello world", content.lower()) 

Naming

The class name TestCGIHTTPServer is hard to read. I realize you are just following the pattern of the imported function names, but it is hard to understand with all the capital letters bunched together. It might be better to go against convention and not use all caps for the acronyms. For example, TestCgiHttpServer uses a form of "camel case", like the PEP 8 style guide recommends.

Comments

This is a helpful comment:

# prevents handle_request() from hanging httpd.timeout = 0.25 

You could elaborate on it by specifying the time unit as well as describing why you chose that magic number.

PEP 8 also recommends docstrings for classes and function. This comment:

# custom handler for my dir structure class _TestHandler(CGIHTTPRequestHandler): 

can be converted to a docstring:

class _TestHandler(CGIHTTPRequestHandler): """Custom handler for my directory structure"""