Refactor buffer processing for clarity and add edge case tests

- Extract storeLine() and accumulate() helper closures to eliminate
  duplicated line processing and truncation logic
- Simplify main loop by using early return pattern (newlineIdx < 0 -> break)
- Add test for empty response body edge case
- Add test for exact maxLineSize boundary condition (10MB)

The refactored code reduces nesting and makes the flow clearer:
accumulate handles byte collection with truncation detection,
storeLine handles ring buffer storage with truncation markers.

Author: SamMorrowDrums

pkg/buffer/buffer.go

@@ -48,79 +48,61 @@ func ProcessResponseAsRingBufferToEnd(httpResp *http.Response, maxJobLogLines in
 	var currentLine strings.Builder
 	lineTruncated := false
 
+	// storeLine saves the current line to the ring buffer and resets state
+	storeLine := func() {
+		line := currentLine.String()
+		if lineTruncated && len(line) > maxDisplayLength {
+			line = line[:maxDisplayLength]
+		}
+		if lineTruncated {
+			line += "... [TRUNCATED]"
+		}
+		lines[writeIndex] = line
+		validLines[writeIndex] = true
+		totalLines++
+		writeIndex = (writeIndex + 1) % maxJobLogLines
+		currentLine.Reset()
+		lineTruncated = false
+	}
+
+	// accumulate adds bytes to currentLine up to maxLineSize, sets lineTruncated if exceeded
+	accumulate := func(data []byte) {
+		if lineTruncated {
+			return
+		}
+		remaining := maxLineSize - currentLine.Len()
+		if remaining <= 0 {
+			lineTruncated = true
+			return
+		}
+		if remaining > len(data) {
+			remaining = len(data)
+		}
+		currentLine.Write(data[:remaining])
+		if currentLine.Len() >= maxLineSize {
+			lineTruncated = true
+		}
+	}
+
 	for {
 		n, err := httpResp.Body.Read(readBuf)
 		if n > 0 {
 			chunk := readBuf[:n]
 			for len(chunk) > 0 {
-				// Find the next newline in the chunk
 				newlineIdx := bytes.IndexByte(chunk, '\n')
-
-				if newlineIdx >= 0 {
-					// Found a newline - complete the current line
-					if !lineTruncated {
-						remaining := maxLineSize - currentLine.Len()
-						if remaining > newlineIdx {
-							remaining = newlineIdx
-						}
-						if remaining > 0 {
-							currentLine.Write(chunk[:remaining])
-						}
-						if currentLine.Len() >= maxLineSize {
-							lineTruncated = true
-						}
-					}
-
-					// Store the completed line
-					line := currentLine.String()
-					if lineTruncated {
-						// Only keep first maxDisplayLength chars for truncated lines
-						if len(line) > maxDisplayLength {
-							line = line[:maxDisplayLength]
-						}
-						line += "... [TRUNCATED]"
-					}
-					lines[writeIndex] = line
-					validLines[writeIndex] = true
-					totalLines++
-					writeIndex = (writeIndex + 1) % maxJobLogLines
-
-					// Reset for next line
-					currentLine.Reset()
-					lineTruncated = false
-					chunk = chunk[newlineIdx+1:]
-				} else {
-					// No newline in remaining chunk - accumulate if not truncated
-					if !lineTruncated {
-						remaining := maxLineSize - currentLine.Len()
-						if remaining > len(chunk) {
-							remaining = len(chunk)
-						}
-						if remaining > 0 {
-							currentLine.Write(chunk[:remaining])
-						}
-						if currentLine.Len() >= maxLineSize {
-							lineTruncated = true
-						}
-					}
+				if newlineIdx < 0 {
+					accumulate(chunk)
 					break
 				}
+				accumulate(chunk[:newlineIdx])
+				storeLine()
+				chunk = chunk[newlineIdx+1:]
 			}
 		}
 
 		if err == io.EOF {
-			// Handle final line without newline
 			if currentLine.Len() > 0 {
-				line := currentLine.String()
-				if lineTruncated {
-					if len(line) > maxDisplayLength {
-						line = line[:maxDisplayLength]
-					}
-					line += "... [TRUNCATED]"
-				}
-				lines[writeIndex] = line
-				validLines[writeIndex] = true
-				totalLines++
+				storeLine()
 			}
 			break
 		}

pkg/buffer/buffer_test.go

@@ -117,6 +117,39 @@ func TestProcessResponseAsRingBufferToEnd(t *testing.T) {
 		assert.NotContains(t, result, "TRUNCATED")
 	})
 
+	t.Run("empty response body", func(t *testing.T) {
+		resp := &http.Response{
+			Body: io.NopCloser(strings.NewReader("")),
+		}
+
+		result, totalLines, respOut, err := ProcessResponseAsRingBufferToEnd(resp, 10)
+		if respOut != nil && respOut.Body != nil {
+			defer respOut.Body.Close()
+		}
+		require.NoError(t, err)
+		assert.Equal(t, 0, totalLines)
+		assert.Equal(t, "", result)
+	})
+
+	t.Run("line at exactly maxLineSize boundary", func(t *testing.T) {
+		// Create a line at exactly maxLineSize (10MB) - should be truncated
+		exactLine := strings.Repeat("z", 10*1024*1024)
+		body := "before\n" + exactLine + "\nafter\n"
+		resp := &http.Response{
+			Body: io.NopCloser(strings.NewReader(body)),
+		}
+
+		result, totalLines, respOut, err := ProcessResponseAsRingBufferToEnd(resp, 10)
+		if respOut != nil && respOut.Body != nil {
+			defer respOut.Body.Close()
+		}
+		require.NoError(t, err)
+		assert.Equal(t, 3, totalLines)
+		assert.Contains(t, result, "before")
+		assert.Contains(t, result, "TRUNCATED")
+		assert.Contains(t, result, "after")
+	})
+
 	t.Run("ring buffer keeps truncated line when in last N", func(t *testing.T) {
 		// Long line followed by only 2 more lines, with ring buffer size 5
 		longLine := strings.Repeat("y", 11*1024*1024)