refactor: rename ResponseBodyMode to BodyProcessingMode, values to Full/Chunks/Skip

Signed-off-by: Noy Itzikowitz <nitzikow@redhat.com>

Author: noyitz

pkg/config/loader/configloader.go

@@ -310,22 +310,22 @@ func buildPostProcessors(rawConfig *configapi.PluginRefList, handle plugin.Handl
 }
 
 // computeResponseBuffering pre-computes NeedsResponseBuffering for each profile based on the
-// ResponseBodyMode declared by each response plugin. If any response plugin returns BodyFull
+// BodyProcessingMode declared by each response plugin. If any response plugin returns Full
 // or doesn't implement ResponseBodyRequirement, the profile needs buffering.
 func computeResponseBuffering(profiles map[string]*requesthandling.Profile, logger logr.Logger) {
 	for name, profile := range profiles {
 		needsBuffering := false
 		var bufferingPlugins []string
 
 		for _, rp := range profile.ResponsePlugins {
-			mode := requesthandling.BodyFull
+			mode := requesthandling.Full
 			if req, ok := rp.(requesthandling.ResponseBodyRequirement); ok {
-				mode = req.ResponseBodyMode()
+				mode = req.BodyProcessingMode()
 			} else {
-				logger.Info("Response plugin does not declare ResponseBodyRequirement, defaulting to BodyFull",
+				logger.Info("Response plugin does not declare ResponseBodyRequirement, defaulting to Full",
 					"profile", name, "plugin", rp.TypedName())
 			}
-			if mode == requesthandling.BodyFull {
+			if mode == requesthandling.Full {
 				needsBuffering = true
 				bufferingPlugins = append(bufferingPlugins, rp.TypedName().Name)
 			}

pkg/config/loader/response_buffering_test.go

@@ -29,7 +29,7 @@ import (
 
 type fakeResponsePlugin struct {
 	name string
-	mode *requesthandling.ResponseBodyMode
+	mode *requesthandling.BodyProcessingMode
 }
 
 func (p *fakeResponsePlugin) TypedName() plugin.TypedName {
@@ -40,11 +40,11 @@ func (p *fakeResponsePlugin) ProcessResponse(_ context.Context, _ *plugin.CycleS
 	return nil
 }
 
-func (p *fakeResponsePlugin) ResponseBodyMode() requesthandling.ResponseBodyMode {
+func (p *fakeResponsePlugin) BodyProcessingMode() requesthandling.BodyProcessingMode {
 	if p.mode != nil {
 		return *p.mode
 	}
-	return requesthandling.BodyFull
+	return requesthandling.Full
 }
 
 var (
@@ -66,7 +66,7 @@ func (p *legacyResponsePlugin) ProcessResponse(_ context.Context, _ *plugin.Cycl
 
 var _ requesthandling.ResponseProcessor = &legacyResponsePlugin{}
 
-func modePtr(m requesthandling.ResponseBodyMode) *requesthandling.ResponseBodyMode { return &m }
+func modePtr(m requesthandling.BodyProcessingMode) *requesthandling.BodyProcessingMode { return &m }
 
 func TestComputeResponseBuffering(t *testing.T) {
 	logger := log.FromContext(logutil.NewTestLoggerIntoContext(context.Background()))
@@ -82,48 +82,48 @@ func TestComputeResponseBuffering(t *testing.T) {
 			wantBuffering: false,
 		},
 		{
-			name: "all BodyNotNeeded",
+			name: "all Skip",
 			plugins: []requesthandling.ResponseProcessor{
-				&fakeResponsePlugin{name: "a", mode: modePtr(requesthandling.BodyNotNeeded)},
-				&fakeResponsePlugin{name: "b", mode: modePtr(requesthandling.BodyNotNeeded)},
+				&fakeResponsePlugin{name: "a", mode: modePtr(requesthandling.Skip)},
+				&fakeResponsePlugin{name: "b", mode: modePtr(requesthandling.Skip)},
 			},
 			wantBuffering: false,
 		},
 		{
-			name: "all BodyChunked",
+			name: "all Chunks",
 			plugins: []requesthandling.ResponseProcessor{
-				&fakeResponsePlugin{name: "a", mode: modePtr(requesthandling.BodyChunked)},
+				&fakeResponsePlugin{name: "a", mode: modePtr(requesthandling.Chunks)},
 			},
 			wantBuffering: false,
 		},
 		{
-			name: "one BodyFull forces buffering",
+			name: "one Full forces buffering",
 			plugins: []requesthandling.ResponseProcessor{
-				&fakeResponsePlugin{name: "a", mode: modePtr(requesthandling.BodyNotNeeded)},
-				&fakeResponsePlugin{name: "b", mode: modePtr(requesthandling.BodyFull)},
+				&fakeResponsePlugin{name: "a", mode: modePtr(requesthandling.Skip)},
+				&fakeResponsePlugin{name: "b", mode: modePtr(requesthandling.Full)},
 			},
 			wantBuffering: true,
 		},
 		{
-			name: "legacy plugin without ResponseBodyRequirement defaults to BodyFull",
+			name: "legacy plugin without ResponseBodyRequirement defaults to Full",
 			plugins: []requesthandling.ResponseProcessor{
 				&legacyResponsePlugin{name: "old-plugin"},
 			},
 			wantBuffering: true,
 		},
 		{
-			name: "mixed: BodyChunked + legacy forces buffering",
+			name: "mixed: Chunks + legacy forces buffering",
 			plugins: []requesthandling.ResponseProcessor{
-				&fakeResponsePlugin{name: "a", mode: modePtr(requesthandling.BodyChunked)},
+				&fakeResponsePlugin{name: "a", mode: modePtr(requesthandling.Chunks)},
 				&legacyResponsePlugin{name: "legacy"},
 			},
 			wantBuffering: true,
 		},
 		{
-			name: "mixed: BodyNotNeeded + BodyChunked — no buffering",
+			name: "mixed: Skip + Chunks — no buffering",
 			plugins: []requesthandling.ResponseProcessor{
-				&fakeResponsePlugin{name: "a", mode: modePtr(requesthandling.BodyNotNeeded)},
-				&fakeResponsePlugin{name: "b", mode: modePtr(requesthandling.BodyChunked)},
+				&fakeResponsePlugin{name: "a", mode: modePtr(requesthandling.Skip)},
+				&fakeResponsePlugin{name: "b", mode: modePtr(requesthandling.Chunks)},
 			},
 			wantBuffering: false,
 		},
@@ -150,12 +150,12 @@ func TestComputeResponseBuffering_MultipleProfiles(t *testing.T) {
 	profiles := map[string]*requesthandling.Profile{
 		"streaming": {
 			ResponsePlugins: []requesthandling.ResponseProcessor{
-				&fakeResponsePlugin{name: "headers-only", mode: modePtr(requesthandling.BodyNotNeeded)},
+				&fakeResponsePlugin{name: "headers-only", mode: modePtr(requesthandling.Skip)},
 			},
 		},
 		"full-body": {
 			ResponsePlugins: []requesthandling.ResponseProcessor{
-				&fakeResponsePlugin{name: "translator", mode: modePtr(requesthandling.BodyFull)},
+				&fakeResponsePlugin{name: "translator", mode: modePtr(requesthandling.Full)},
 			},
 		},
 	}

pkg/framework/interface/requesthandling/plugins.go

@@ -57,35 +57,35 @@ type PostProcessor interface {
 	PostProcess(ctx context.Context, cycleState *plugin.CycleState, response *InferenceResponse) error
 }
 
-type ResponseBodyMode int
+type BodyProcessingMode int
 
 const (
-	// BodyNotNeeded indicates the plugin does not need the response body at all (headers-only plugin).
-	BodyNotNeeded ResponseBodyMode = iota
-	// BodyChunked indicates the plugin can process individual response body chunks as they stream through.
-	// Plugins declaring BodyChunked MUST also implement ChunkProcessor (validated at startup).
-	BodyChunked
-	// BodyFull indicates the plugin needs the complete response body buffered in memory before processing.
+	// Skip indicates the plugin does not need the response body at all (headers-only plugin).
+	Skip BodyProcessingMode = iota
+	// Chunks indicates the plugin can process individual response body chunks as they stream through.
+	// Plugins declaring Chunks MUST also implement ChunkProcessor (validated at startup).
+	Chunks
+	// Full indicates the plugin needs the complete response body buffered in memory before processing.
 	// This is the default for plugins that do not implement ResponseBodyRequirement (backward compatible).
-	BodyFull
+	Full
 )
 
-func (m ResponseBodyMode) String() string {
+func (m BodyProcessingMode) String() string {
 	switch m {
-	case BodyNotNeeded:
-		return "BodyNotNeeded"
-	case BodyChunked:
-		return "BodyChunked"
-	case BodyFull:
-		return "BodyFull"
+	case Skip:
+		return "Skip"
+	case Chunks:
+		return "Chunks"
+	case Full:
+		return "Full"
 	default:
 		return "Unknown"
 	}
 }
 
 // ResponseBodyRequirement allows response plugins to declare what level of access they need
-// to the response body. Plugins that don't implement this interface default to BodyFull
+// to the response body. Plugins that don't implement this interface default to Full
 // (backward compatible — the framework buffers the full response before calling ProcessResponse).
 type ResponseBodyRequirement interface {
-	ResponseBodyMode() ResponseBodyMode
+	BodyProcessingMode() BodyProcessingMode
 }