Parsing the Body

We're almost done parsing the request! (Which, frankly, is the hardest part of an HTTP server imo.)

Remember, an HTTP-message has this format:

     HTTP-message   = start-line CRLF
                      *( field-line CRLF )
                      CRLF
                      [ message-body ]

Our current code parses the

start-line (request line for requests)
field-line (headers)
extra CRLF between headers and the body

Let's tackle the [ message-body ]: but beware, it still has an edge case...

According to RFC9110 8.6:

A user agent SHOULD send Content-Length in a request...

And "should" has a specific meaning in RFCs per RFC2119:

This word, or the adjective "RECOMMENDED", mean that there may exist valid reasons in particular circumstances to ignore a particular item, but the full implications must be understood and carefully weighed before choosing a different course.

All this to say, for our implementation we're going to assume that if there is no Content-Length header, there is no body present. This is a safe assumption for our purposes, though it might not be true in all cases in the wild.

Assignment

In the request package, update your (r *Request) parse method to parse the body in addition to the request line.

Add a .Body field to the Request struct. It should be a []byte. This is where we'll store the raw body bytes.
Create a new test function. This one will focus on parsing the body correctly. Here are my first test cases:

// Test: Standard Body
reader := &chunkReader{
	data: "POST /submit HTTP/1.1\r\n" +
		"Host: localhost:42069\r\n" +
		"Content-Length: 13\r\n" +
		"\r\n" +
		"hello world!\n",
	numBytesPerRead: 3,
}
r, err := RequestFromReader(reader)
require.NoError(t, err)
require.NotNil(t, r)
assert.Equal(t, "hello world!\n", string(r.Body))

// Test: Body shorter than reported content length
reader = &chunkReader{
	data: "POST /submit HTTP/1.1\r\n" +
		"Host: localhost:42069\r\n" +
		"Content-Length: 20\r\n" +
		"\r\n" +
		"partial content",
	numBytesPerRead: 3,
}
r, err = RequestFromReader(reader)
require.Error(t, err)

Add some more test cases. Here are the names of some of my additional test cases:
- "Standard Body" (valid)
- "Empty Body, 0 reported content length" (valid)
- "Empty Body, no reported content length" (valid)
- "Body shorter than reported content length" (should error)
- "No Content-Length but Body Exists" (shouldn't error; we're assuming Content-Length will be present if a body exists)
Update the header parsing to move the state machine to a new "parsing body" state when it's done instead of the done state.
Add a new .Get method to the Headers struct; it should take a key and return the value for that key, keeping case insensitivity in mind.
Add a case for the new state in the state machine:
- If there isn't a Content-Length header, move to the done state – nothing to parse.
- Append all the data to the requests .Body field.
- If the length of the body is greater than the Content-Length header, return an error.
- If the length of the body is equal to the Content-Length header, move to the done state.
- Report that you've consumed the entire length of the data you were given.

Run and submit the CLI tests.