This lesson's interactive features are locked, please to keep using them

Headers

We've got the request line, now it's time to parse the request headers.

Now, when we say "headers" it's important to note that the RFC doesn't call them that.... The RFC uses the term field-line, but it's basically the same thing. From 5. Field Syntax

Each field line consists of a case-insensitive field name followed by a colon (":"), optional leading whitespace, the field line value, and optional trailing whitespace.

     field-line   = field-name ":" OWS field-value OWS

One important point to note: there can be an unlimited amount of whitespace before and after the field-value (Header value). However, when parsing a field-name, there must be no spaces before the field name, nor betwixt the colon and the field name. In other words, these are valid:

'Host: localhost:42069'
'Host:           localhost:42069    '

But this is not:

Host : localhost:42069

Assignment

Create a new package in your internal directory called headers.

I made it a separate package because we'll use the headers package both for parsing requests and for sending responses. This is a stylistic choice rather than a Design (with A Capital D™) choice.
Create a headers.go file in the headers package and add the following new type:
```
type Headers map[string]string
```

Create a constructor function for the Headers type:

func NewHeaders() Headers {
    return make(Headers)
}

Create a new method for parsing request data into the Headers map:

func (h Headers) Parse(data []byte) (n int, done bool, err error)

Create a new headers_test.go file in the headers package. Here are two simple tests I wrote:

// Test: Valid single header
headers := NewHeaders()
data := []byte("Host: localhost:42069\r\n\r\n")
n, done, err := headers.Parse(data)
require.NoError(t, err)
require.NotNil(t, headers)
assert.Equal(t, "localhost:42069", headers["Host"])
assert.Equal(t, 23, n)
assert.False(t, done)

// Test: Invalid spacing header
headers = NewHeaders()
data = []byte("       Host: localhost:42069\r\n\r\n")
n, done, err = headers.Parse(data)
require.Error(t, err)
assert.Equal(t, 0, n)
assert.False(t, done)

Update your parse method to pass this single test. It should:
- Mutate the Headers by adding newly parsed key-value pairs
- Return n (the number of bytes consumed), done (whether or not it has finished parsing headers), and err (if it encountered an error)
- Look for a CRLF, if it doesn't find one, assume you haven't been given enough data yet. Consume no data, return false for done, and nil for err.
- If you do find a CRLF, but it's at the start of the data, you've found the end of the headers, so return the proper values immediately.
- Remove any extra whitespace from the key and value, but ensure there are no spaces between the colon and the key.
- Assuming the format was valid (if it isn't return an error), add the key/value pair to the Headers map and return the number of bytes consumed. Note: The Parse function should only return done=true when the data starts with a CRLF, which can't happen when it finds a new key/value pair.
- It's important to understand that this function will be called over and over until all the headers are parsed, and it can only parse one key/value pair at a time.
Add more tests to account for all the edge cases described above. Here are the names of my tests:
- "Valid single header"
- "Valid single header with extra whitespace"
- "Valid 2 headers with existing headers"
- "Valid done"
- "Invalid spacing header"

Run and submit the CLI tests.