Add path parameter support for undo operations (#3623)

Support extracting path parameters from request URLs for use in undo
operations. This enables cleanup of resources identified by path
parameters (e.g., /api/v2/resource/{id}).

Co-authored-by: Claude Sonnet 4.5 <noreply@anthropic.com>

Author: MintsInc

tests/scenarios/actions.go

@@ -343,6 +343,34 @@ func GetRequestsUndo(ctx gobdd.Context, version string, operationID string) (fun
 						}
 					}
 					sourceJSONData = requestJSON
+				} else if *undo.Undo.Parameters[i-1].Origin == "path" {
+					// Extract from stored path parameters
+					pathParams := GetPathParameters(ctx)
+					if undo.Undo.Parameters[i-1].Source != nil {
+						paramName := *undo.Undo.Parameters[i-1].Source
+						if val, ok := pathParams[paramName]; ok {
+							// Convert the stored value to the expected type
+							object := reflect.New(undoOperation.Type().In(i))
+							sourceJSON, err := datadog.Marshal(val)
+							if err != nil {
+								t.Fatalf("Error marshalling path parameter '%s': %v", paramName, err)
+								return
+							}
+							err = datadog.Unmarshal(sourceJSON, object.Interface())
+							if err != nil {
+								t.Fatalf("Error unmarshalling path parameter '%s': %v", paramName, err)
+								return
+							}
+							in[i] = object.Elem()
+							continue // Skip template/source processing for path parameters
+						} else {
+							t.Fatalf("Path parameter '%s' not found", paramName)
+							return
+						}
+					} else {
+						t.Fatalf("Path origin requires 'source' field")
+						return
+					}
 				} else if *undo.Undo.Parameters[i-1].Origin == "response" {
 					sourceJSONData = responseJSON
 				}

tests/scenarios/scenarios.go

@@ -83,6 +83,7 @@ type jsonResponseKey struct{}
 type dataKey struct{}
 type cleanupKey struct{}
 type pathParamCountKey struct{}
+type pathParametersKey struct{}
 
 // GetIgnoredTags returns list of ignored tags.
 func GetIgnoredTags() []string {
@@ -326,6 +327,29 @@ func SetData(ctx gobdd.Context, value map[string]interface{}) {
 	ctx.Set(dataKey{}, value)
 }
 
+// GetPathParameters returns stored path parameters by name.
+func GetPathParameters(ctx gobdd.Context) map[string]interface{} {
+	c, err := ctx.Get(pathParametersKey{})
+	if err != nil {
+		params := make(map[string]interface{})
+		ctx.Set(pathParametersKey{}, params)
+		return params
+	}
+	return c.(map[string]interface{})
+}
+
+// SetPathParameter stores a path parameter.
+func SetPathParameter(ctx gobdd.Context, name string, value interface{}) {
+	params := GetPathParameters(ctx)
+	params[name] = value
+	ctx.Set(pathParametersKey{}, params)
+}
+
+// ClearPathParameters clears stored path parameters.
+func ClearPathParameters(ctx gobdd.Context) {
+	ctx.Set(pathParametersKey{}, make(map[string]interface{}))
+}
+
 // GetRequestParameters helps to build a request.
 func GetRequestParameters(ctx gobdd.Context) map[string]interface{} {
 	c, err := ctx.Get(requestParamsKey{})

tests/scenarios/step_definitions.go

@@ -89,6 +89,7 @@ func newRequest(t gobdd.StepTest, ctx gobdd.Context, name string) {
 	ctx.Set(requestParamsKey{}, make(map[string]interface{}))
 	ctx.Set(requestArgsKey{}, make([]interface{}, 0))
 	ctx.Set(pathParamCountKey{}, 1)
+	ClearPathParameters(ctx)
 
 }
 func statusIs(t gobdd.StepTest, ctx gobdd.Context, expected int, text string) {
@@ -141,9 +142,13 @@ func addParameterFrom(t gobdd.StepTest, ctx gobdd.Context, name string, path str
 		datadog.Unmarshal(data, varType.Interface())
 		GetRequestParameters(ctx)[name] = varType.Elem()
 		ctx.Set(requestArgsKey{}, append(GetRequestArguments(ctx), varType.Elem()))
+		// Store path parameter for undo operations
+		SetPathParameter(ctx, name, varType.Elem().Interface())
 	} else {
 		GetRequestParameters(ctx)[name] = value
 		ctx.Set(requestArgsKey{}, append(GetRequestArguments(ctx), value))
+		// Store path parameter for undo operations
+		SetPathParameter(ctx, name, value.Interface())
 	}
 }
 
@@ -159,6 +164,10 @@ func addPathArgumentWithValue(t gobdd.StepTest, ctx gobdd.Context, param string,
 	ctx.Set(pathParamCountKey{}, pathCount.(int)+1)
 
 	templatedValue := Templated(t, GetData(ctx), value)
+
+	// Store path parameter by name for undo operations
+	SetPathParameter(ctx, param, templatedValue)
+
 	var varType reflect.Value
 
 	if request.Type().IsVariadic() && pathCount.(int) > numArgs-2 {