Add request body and transfer support to request action

Author: bukka

TODO.md

@@ -48,11 +48,6 @@ in the future.
 
 #### Structure - Instances, Actions, Servers, Services
 
-- extend request action to support file upload
-  - it should chunked update and set option to set delay between chunks to be able to create server timeouts
-  - it should also allow doing partial unfinished uploads
-  - it is to support all requirements for testing https://github.com/php/php-src/pull/2180
-  - test exceeding LimitRequestBody
 - add typed parameters substitution for integers
   - this is to be able to, for example, parameterize status code
   - alternatively, it might be easier to allow automatic string to int conversion
@@ -76,6 +71,10 @@ in the future.
 - support `protocols` field in bench action
   - extract the common logic
 - extend protocols to support http3 in bench and request action
+- extend request body to support multipart form data
+  - it should support form fields
+  - it should support files
+- look into extending bench to support request body (see if all request action options will be possible)
 - integrate better instance action identification
   - it should introduce name for each action and also pass parent name to nested actions in `parallel` or `not`
 - add execute action custom environment variables support
@@ -107,6 +106,7 @@ in the future.
   - consider more consistent naming differentiating that service port is public and server port is private
 - add support for ephemeral port allocation that should be the default if not ports specified
   - it should be also possible to overwrite port to ephemeral selection even if specified
+- Add Temp dir support to Dirs as it might be useful, for example, for nginx temp paths
 - consider adding support default Dirs so it is not required to specify in the config
   - could be either the actual enum name or another tag
 - add a special resource file structure that could be used for scripts but also for certs and keys

app/foundation.go

@@ -19,6 +19,7 @@ import (
 	"net/http"
 	"os"
 	"os/user"
+	"time"
 
 	"github.com/google/uuid"
 	"github.com/spf13/afero"
@@ -42,6 +43,7 @@ type Foundation interface {
 	VegetaAttacker() VegetaAttacker
 	VegetaMetrics() VegetaMetrics
 	GenerateUuid() string
+	Sleep(ctx context.Context, duration time.Duration) error
 }
 
 type DefaultFoundation struct {
@@ -140,3 +142,19 @@ func (f *DefaultFoundation) VegetaAttacker() VegetaAttacker {
 func (f *DefaultFoundation) GenerateUuid() string {
 	return uuid.New().String()
 }
+
+func (f *DefaultFoundation) Sleep(ctx context.Context, duration time.Duration) error {
+	if duration <= 0 {
+		return nil
+	}
+
+	timer := time.NewTimer(duration)
+	defer timer.Stop()
+
+	select {
+	case <-ctx.Done():
+		return ctx.Err()
+	case <-timer.C:
+		return nil
+	}
+}

conf/parser/parser_test.go

@@ -1677,6 +1677,7 @@ func Test_ConfigParser_ParseStruct(t *testing.T) {
 		})
 	}
 }
+
 func Test_ConfigParser_ParseConfig(t *testing.T) {
 	tests := []struct {
 		name           string
@@ -1934,6 +1935,29 @@ func Test_ConfigParser_ParseConfig(t *testing.T) {
 										},
 									},
 								},
+								map[string]interface{}{
+									"request": map[string]interface{}{
+										"service": "web_service",
+										"path":    "/upload",
+										"method":  "POST",
+										"body": map[string]interface{}{
+											"content": "test",
+											"transfer": map[string]interface{}{
+												"encoding":       "chunked",
+												"content_length": 30,
+												"chunk_size":     10,
+												"chunk_delay":    5000,
+											},
+										},
+									},
+								},
+								map[string]interface{}{
+									"expect/web_service": map[string]interface{}{
+										"response": map[string]interface{}{
+											"status": 200,
+										},
+									},
+								},
 							},
 						},
 					},
@@ -2115,6 +2139,37 @@ func Test_ConfigParser_ParseConfig(t *testing.T) {
 										},
 									},
 								},
+								&types.RequestAction{
+									Service:    "web_service",
+									Timeout:    0,
+									When:       "on_success",
+									OnFailure:  "fail",
+									Id:         "last",
+									Scheme:     "http",
+									Path:       "/upload",
+									EncodePath: true,
+									Method:     "POST",
+									Body: types.RequestBody{
+										Content:        "test",
+										RenderTemplate: true,
+										Transfer: types.TransferConfig{
+											Encoding:      "chunked",
+											ChunkSize:     10,
+											ChunkDelay:    5000,
+											ContentLength: 30,
+										},
+									},
+								},
+								&types.ResponseExpectationAction{
+									Service:   "web_service",
+									Timeout:   0,
+									When:      "on_success",
+									OnFailure: "fail",
+									Response: types.ResponseExpectation{
+										Request: "last",
+										Status:  200,
+									},
+								},
 							},
 						},
 					},

conf/types/action.go

@@ -113,6 +113,19 @@ type TLSClientConfig struct {
 	CACert     string `wst:"ca_certificate"`
 }
 
+type TransferConfig struct {
+	Encoding      string `wst:"encoding,enum=chunked|none,default=none"`
+	ChunkSize     int    `wst:"chunk_size"`
+	ChunkDelay    int    `wst:"chunk_delay"`
+	ContentLength int    `wst:"content_length"`
+}
+
+type RequestBody struct {
+	Content        string         `wst:"content"`
+	RenderTemplate bool           `wst:"render_template,default=true"`
+	Transfer       TransferConfig `wst:"transfer"`
+}
+
 type RequestAction struct {
 	Service    string          `wst:"service"`
 	Timeout    int             `wst:"timeout"`
@@ -125,6 +138,7 @@ type RequestAction struct {
 	EncodePath bool            `wst:"encode_path,default=true"`
 	Method     string          `wst:"method,enum=GET|HEAD|DELETE|POST|PUT|PATCH|PURGE,default=GET"`
 	Headers    Headers         `wst:"headers"`
+	Body       RequestBody     `wst:"body,string=Content"`
 	TLS        TLSClientConfig `wst:"tls"`
 }
 

mocks/generated/app/mock_Foundation.go

@@ -0,0 +1,83 @@
+// Copyright 2025 Jakub Zelenka and The WST Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package request
+
+import (
+	"context"
+	"io"
+	"time"
+
+	"github.com/wstool/wst/app"
+)
+
+// chunkControlledReader implements io.Reader with control over chunk sizes and delays.
+// Each Read() call returns at most chunkSize bytes, which forces the HTTP client to
+// make multiple Read() calls, effectively controlling the chunk sizes sent over the wire
+// when using chunked transfer encoding.
+type chunkControlledReader struct {
+	ctx        context.Context
+	fnd        app.Foundation
+	data       []byte
+	chunkSize  int
+	chunkDelay time.Duration
+	offset     int
+	readCount  int
+}
+
+func (r *chunkControlledReader) Read(p []byte) (n int, err error) {
+	// Check context cancellation
+	select {
+	case <-r.ctx.Done():
+		return 0, r.ctx.Err()
+	default:
+	}
+
+	// If all data has been read, return EOF (no delay before EOF)
+	if r.offset >= len(r.data) {
+		return 0, io.EOF
+	}
+
+	// Add delay before each chunk (except the first one)
+	if r.readCount > 0 && r.chunkDelay > 0 {
+		if err := r.fnd.Sleep(r.ctx, r.chunkDelay); err != nil {
+			return 0, err
+		}
+	}
+	r.readCount++
+
+	// Determine how much to read in this chunk
+	chunkSize := r.chunkSize
+	if chunkSize <= 0 {
+		// If chunk size not specified, use the full buffer provided by HTTP client
+		chunkSize = len(p)
+	}
+
+	// Calculate how much data to copy
+	remaining := len(r.data) - r.offset
+	toRead := chunkSize
+	if toRead > remaining {
+		toRead = remaining
+	}
+	if toRead > len(p) {
+		// Never read more than the provided buffer can hold
+		toRead = len(p)
+	}
+
+	// Copy data to buffer
+	n = copy(p, r.data[r.offset:r.offset+toRead])
+	r.offset += n
+
+	return n, nil
+}