fix(response): buffer Do response body for every response

Unify the body-buffering paths in Client.Do so the response payload is
read into rawBody for every response -- success, error, and no-decode
(nil dataPointer) alike -- instead of only for decoded-success and error
responses. This makes the value-receiver String() render via the rawBody
fast-path in all cases (never draining Body), and keeps a subsequent
ParseError able to read an intact Body.

Update the RawBody and String doc comments on Response to match: rawBody
is populated for every Do response and is nil only for a hand-built
Response or one obtained through the unbuffered Stream path.

Signed-off-by: Sean Chittenden <sean.chittenden@crowdstrike.com>

Author: sean-

opensearch.go

@@ -529,35 +529,28 @@ func (c *Client) Do(ctx context.Context, method string, req Request, dataPointer
 		return response, fmt.Errorf("status: %d, err: %w", resp.StatusCode, err)
 	}
 
-	if dataPointer != nil && resp.Body != nil && !response.IsError() {
-		data, err := io.ReadAll(resp.Body)
-		if err != nil {
-			return response, fmt.Errorf("%w, status: %d, err: %w", ErrReadBody, resp.StatusCode, err)
-		}
-
-		response.rawBody = data
-		response.Body = io.NopCloser(bytes.NewReader(data))
-
-		if err := json.Unmarshal(data, dataPointer); err != nil {
-			return response, fmt.Errorf("%w, status: %d, body: %s, err: %w", ErrJSONUnmarshalBody, resp.StatusCode, data, err)
-		}
-	}
-
-	if resp.Body != nil && response.IsError() {
-		// Buffer error-response bodies into rawBody so String renders via the
-		// rawBody fast-path (never draining Body) and a subsequent ParseError
-		// still reads an intact Body. Without this, a value-receiver String
-		// call (e.g. log.Printf("%s", resp)) would consume the single-use
-		// error Body and leave ParseError with an empty payload. In the
-		// default buffered mode Perform already returned an in-memory
-		// NopCloser, so this just copies bytes already resident in memory.
+	if resp.Body != nil {
+		// Buffer the response payload into rawBody for every Do response --
+		// success, error, and no-decode (nil dataPointer) alike -- so the
+		// value-receiver String renders via the rawBody fast-path and never
+		// drains Body, and a subsequent ParseError still reads an intact Body.
+		// Without this, a String call (e.g. log.Printf("%s", resp)) would
+		// consume the single-use Body. In the default buffered mode Perform
+		// already returned an in-memory NopCloser, so this just copies bytes
+		// already resident in memory.
 		data, rerr := io.ReadAll(resp.Body)
 		if rerr != nil {
 			return response, fmt.Errorf("%w, status: %d, err: %w", ErrReadBody, resp.StatusCode, rerr)
 		}
 
 		response.rawBody = data
 		response.Body = io.NopCloser(bytes.NewReader(data))
+
+		if dataPointer != nil && !response.IsError() {
+			if err := json.Unmarshal(data, dataPointer); err != nil {
+				return response, fmt.Errorf("%w, status: %d, body: %s, err: %w", ErrJSONUnmarshalBody, resp.StatusCode, data, err)
+			}
+		}
 	}
 
 	return response, nil

response.go

@@ -61,12 +61,10 @@ type renderCache struct {
 // handling: copy with bytes.Clone if either is needed, or use
 // HijackBody to transfer ownership to the caller.
 //
-// Populated for both success and error responses buffered by Client.Do
-// (the default buffered mode). Returns nil when:
-//
-//   - The response was streamed without buffering (DisableResponseBuffering).
-//   - The Response was constructed directly (e.g. via NewResponse) rather
-//     than returned by Client.Do.
+// Populated for every response returned by Client.Do -- success, error, and
+// no-decode (nil dataPointer) alike. Returns nil only when the Response was
+// constructed directly (e.g. via NewResponse) or obtained through the
+// unbuffered Client.Stream path rather than Client.Do.
 func (r *Response) RawBody() []byte {
 	return r.rawBody
 }
@@ -96,14 +94,13 @@ func NewResponse(statusCode int, body io.ReadCloser, header http.Header) *Respon
 // String returns the response status and body as a string.
 //
 // String uses a value receiver, so both Response and *Response satisfy
-// fmt.Stringer. For any Response returned by Client.Do (success or error, in
-// the default buffered mode) it renders from the buffered rawBody and never
-// touches Body, so logging a response does not drain it. For a Response
-// holding only an unbuffered Body -- a streamed response
-// (DisableResponseBuffering) or a hand-built Response -- String reads Body
-// once to render it; repeat calls stay consistent via an internal cache, but
-// a value receiver cannot restore the caller's Body field, so that single-use
-// stream is consumed.
+// fmt.Stringer. For any Response returned by Client.Do it renders from the
+// buffered rawBody and never touches Body, so logging a response does not
+// drain it. For a Response holding only an unbuffered Body -- one obtained via
+// Client.Stream or constructed by hand -- String reads Body once to render it;
+// repeat calls stay consistent via an internal cache, but a value receiver
+// cannot restore the caller's Body field, so that single-use stream is
+// consumed.
 func (r Response) String() string {
 	body, rerr, ok := r.renderedBody()
 	if !ok {