Feature: add json-schema validator postprocessor in http/scenario gun

components/providers/scenario/config/hcl.go

@@ -65,6 +65,8 @@ type RequestPostprocessorHCL struct {
 	Body       *[]string          `hcl:"body" yaml:"body,omitempty"`
 	StatusCode *int               `hcl:"status_code" yaml:"status_code,omitempty"`
 	Size       *AssertSizeHCL     `hcl:"size,block" yaml:"size,omitempty"`
+	Source     string             `hcl:"source" yaml:"source,omitempty"`
+	Schema     string             `hcl:"schema" yaml:"schema,omitempty"`
 }
 
 type RequestPreprocessorHCL struct {

components/providers/scenario/http/postprocessor/assert_json_schema.go

@@ -0,0 +1,96 @@
+package postprocessor
+
+import (
+	"fmt"
+	"github.com/xeipuuv/gojsonschema"
+	"io"
+	"net/http"
+	"path/filepath"
+	"strings"
+)
+
+type AssertJsonSchema struct {
+	Source string `config:"source"`
+	Schema string `config:"schema"`
+}
+
+func (a AssertJsonSchema) Process(_ *http.Response, body io.Reader) (map[string]any, error) {
+	var schemaLoader gojsonschema.JSONLoader
+
+	switch a.Source {
+	case "file":
+		absPath, err := filepath.Abs(a.Schema)
+
+		if err != nil {
+			return nil, fmt.Errorf("assert/json-schema fail to get schema file absolute path: %w", err)
+		}
+
+		filePath := "file:///" + absPath
+		schemaLoader = gojsonschema.NewReferenceLoader(filePath)
+
+	case "url":
+		schemaLoader = gojsonschema.NewReferenceLoader(a.Schema)
+	case "json_string":
+		schemaLoader = gojsonschema.NewStringLoader(a.Schema)
+	default:
+		return nil, fmt.Errorf("unknown schema source %s", a.Source)
+	}
+
+	var b []byte
+	var err error
+
+	if body != nil {
+		b, err = io.ReadAll(body)
+		if err != nil {
+			return nil, fmt.Errorf("assert/json-schema can't read body: %w", err)
+		}
+	}
+
+	schema, err := gojsonschema.NewSchema(schemaLoader)
+
+	if err != nil {
+		return nil, fmt.Errorf("assert/json-schema can't create schema: %w", err)
+	}
+
+	respJson := gojsonschema.NewBytesLoader(b)
+	result, err := schema.Validate(respJson)
+
+	if err != nil {
+		return nil, fmt.Errorf("assert/json-schema validate error: %w", err)
+	}
+
+	if !result.Valid() {
+		var errors []string
+		for _, desc := range result.Errors() {
+			errors = append(errors, desc.String())
+		}
+
+		return nil, fmt.Errorf("assert/json-schema validation errors: %s", strings.Join(errors, ", "))
+	}
+
+	return nil, nil
+}
+
+func (a AssertJsonSchema) Validate() error {
+
+	if a.Source != "file" && a.Source != "url" && a.Source != "json_string" {
+		return fmt.Errorf("assert/json-schema unknown schema source %s", a.Source)
+	}
+
+	if a.Schema == "" {
+		var invalidSource string
+
+		switch a.Source {
+		case "file":
+			invalidSource = "file path"
+		case "url":
+			invalidSource = "url"
+		case "json_string":
+			invalidSource = "json string"
+		}
+
+		return fmt.Errorf("assert/json-schema invalid schema %s", invalidSource)
+	}
+
+	return nil
+}

components/providers/scenario/http/postprocessor/assert_json_schema_test.go

@@ -0,0 +1,186 @@
+package postprocessor
+
+import (
+	"bytes"
+	"fmt"
+	"github.com/stretchr/testify/assert"
+	"io"
+	"log"
+	"net/http"
+	"net/http/httptest"
+	"os"
+	"testing"
+)
+
+func TestAssertJsonSchema_Process(t *testing.T) {
+	type fields struct {
+		Source string
+		Schema string
+	}
+
+	type args struct {
+		resp *http.Response
+		body io.Reader
+	}
+
+	tests := []struct {
+		name    string
+		fields  fields
+		args    args
+		wantErr assert.ErrorAssertionFunc
+	}{
+		{
+			name: "Validate response from file",
+			fields: fields{
+				Source: "file",
+				Schema: "testdata/test_schema.json",
+			},
+			args: args{
+				resp: &http.Response{StatusCode: http.StatusOK, Header: http.Header{"Content-Type": []string{"application/json"}}, Body: nil},
+				body: bytes.NewReader([]byte(`{"message": "Hello, World!"}`)),
+			},
+			wantErr: assert.NoError,
+		},
+		{
+			name: "Validate response from json-string",
+			fields: fields{
+				Source: "json_string",
+				Schema: "{\"type\": \"object\"}",
+			},
+			args: args{
+				resp: &http.Response{StatusCode: http.StatusOK, Header: http.Header{"Content-Type": []string{"application/json"}}, Body: nil},
+				body: bytes.NewReader([]byte(`{"message": "Hello, World!"}`)),
+			},
+			wantErr: assert.NoError,
+		},
+		{
+			name: "Invalid Body",
+			fields: fields{
+				Source: "file",
+				Schema: "testdata/test_schema.json",
+			},
+			args: args{
+				resp: &http.Response{StatusCode: http.StatusOK, Header: http.Header{"Content-Type": []string{"application/json"}}, Body: nil},
+				body: nil, // for this postprocessor we don't care about response, we need only body for validate
+			},
+			wantErr: assert.Error,
+		},
+		{
+			name: "Invalid schema source",
+			fields: fields{
+				Source: "test_source",
+				Schema: "testdata/test_schema.json",
+			},
+			args: args{
+				resp: &http.Response{StatusCode: http.StatusOK, Header: http.Header{"Content-Type": []string{"application/json"}}, Body: nil},
+				body: bytes.NewReader([]byte(`{"message": "Hello, World!"}`)),
+			},
+			wantErr: assert.Error,
+		},
+		{
+			name: "Invalid schema file path",
+			fields: fields{
+				Source: "file",
+				Schema: "not_existing_schema.json",
+			},
+			args: args{
+				resp: &http.Response{StatusCode: http.StatusOK, Header: http.Header{"Content-Type": []string{"application/json"}}, Body: nil},
+				body: bytes.NewReader([]byte(`{"message": "Hello, World!"}`)),
+			},
+			wantErr: assert.Error,
+		},
+		{
+			name: "Invalid schema url path",
+			fields: fields{
+				Source: "url",
+				Schema: "https://example.com",
+			},
+			args: args{
+				resp: &http.Response{StatusCode: http.StatusOK, Header: http.Header{"Content-Type": []string{"application/json"}}, Body: nil},
+				body: bytes.NewReader([]byte(`{"message": "Hello, World!"}`)),
+			},
+			wantErr: assert.Error,
+		},
+		{
+			name: "Invalid schema json-string",
+			fields: fields{
+				Source: "json_string",
+				Schema: "",
+			},
+			args: args{
+				resp: &http.Response{StatusCode: http.StatusOK, Header: http.Header{"Content-Type": []string{"application/json"}}, Body: nil},
+				body: bytes.NewReader([]byte(`{"message": "Hello, World!"}`)),
+			},
+			wantErr: assert.Error,
+		},
+		{
+			name: "Schema validation error",
+			fields: fields{
+				Source: "json_string",
+				Schema: "{\"type\": \"array\"}",
+			},
+			args: args{
+				resp: &http.Response{StatusCode: http.StatusOK, Header: http.Header{"Content-Type": []string{"application/json"}}, Body: nil},
+				body: bytes.NewReader([]byte(`{"message": "Hello, World!"}`)),
+			},
+			wantErr: assert.Error,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			a := AssertJsonSchema{
+				Schema: tt.fields.Schema,
+				Source: tt.fields.Source,
+			}
+
+			process, err := a.Process(tt.args.resp, tt.args.body)
+			assert.Nil(t, process)
+			tt.wantErr(t, err, fmt.Sprintf("Process(%v, %v)", tt.args.resp, tt.args.body))
+		})
+	}
+}
+
+func TestAssertUrlJsonSchema_Process(t *testing.T) {
+	t.Run("Validate response with url schema", func(t *testing.T) {
+		server := httptest.NewServer(http.HandlerFunc(serveSchemaHandler))
+
+		a := AssertJsonSchema{
+			Schema: server.URL + "/?file=test_schema.json",
+			Source: "url",
+		}
+
+		resp := &http.Response{StatusCode: http.StatusOK, Header: http.Header{"Content-Type": []string{"application/json"}}, Body: nil}
+		body := bytes.NewReader([]byte(`{"message": "Hello, World!"}`))
+
+		process, err := a.Process(resp, body)
+
+		server.Close()
+
+		assert.Nil(t, process)
+		assert.NoError(t, err)
+	})
+}
+
+func serveSchemaHandler(w http.ResponseWriter, r *http.Request) {
+	schemaName := r.URL.Query().Get("file")
+	if schemaName == "" {
+		http.Error(w, "Missing file name", http.StatusBadRequest)
+		return
+	}
+
+	schemaPath := "testdata/" + schemaName
+
+	data, err := os.ReadFile(schemaPath)
+	if err != nil {
+		http.Error(w, "Failed to load schema: "+err.Error(), http.StatusInternalServerError)
+		return
+	}
+
+	w.Header().Set("Content-Type", "application/json")
+
+	_, err = w.Write(data)
+	if err != nil {
+		log.Fatal(err)
+	}
+}

components/providers/scenario/http/postprocessor/testdata/test_schema.json

@@ -0,0 +1,3 @@
+{
+  "type": "object"
+}

components/providers/scenario/import/import.go

@@ -45,6 +45,7 @@ func Import(fs afero.Fs) {
 		RegisterPostprocessor("var/xpath", NewVarXpathPostprocessor)
 		RegisterPostprocessor("var/header", NewVarHeaderPostprocessor)
 		RegisterPostprocessor("assert/response", NewAssertResponsePostprocessor)
+		RegisterPostprocessor("assert/json-schema", NewAssertJsonSchemaPostprocessor)
 
 		RegisterTemplater("text", func() gun.Templater {
 			return templater.NewTextTemplater()
@@ -112,3 +113,11 @@ func NewVarXpathPostprocessor(cfg postprocessor.Config) gun.Postprocessor {
 		Mapping: cfg.Mapping,
 	}
 }
+
+func NewAssertJsonSchemaPostprocessor(cfg postprocessor.AssertJsonSchema) (gun.Postprocessor, error) {
+	err := cfg.Validate()
+	if err != nil {
+		return nil, err
+	}
+	return &cfg, nil
+}

docs/content/en/generator/scenario-http-generator.md

@@ -365,6 +365,80 @@ request "your_request_name" {
 }
 ```
 
+##### assert/json-schema
+
+Checks response body matches the specified json-schema
+
+**HCL examples:**
+
+**Use json-schema from file:**
+
+```terraform
+request "your_request_name" {
+  postprocessor "assert/json-schema" {
+    source = "file"
+    schema = "my_json_schema.json"
+  }
+}
+```
+**Use json-schema from json-string:**
+
+```terraform
+request "your_request_name" {
+  postprocessor "assert/json-schema" {
+    source = "json_string"
+    schema = "{ \"type\" : \"object\" }"
+  }
+}
+```
+
+**Use json-schema located on the host:**
+
+**Important: specify the request scheme (http/https)**
+
+```terraform
+request "your_request_name" {
+  postprocessor "assert/json-schema" {
+    source = "url"
+    schema = "https://examplehost.com/#validation_schema.json"
+  }
+}
+```
+
+**YAML examples**
+
+**Use json-schema from file:**
+```yaml
+requests:
+  - name: "your_request_name"
+    postprocessors:
+      - type: assert/json-schema
+        source: file
+        schema: "my_json_schema.json"
+```
+
+**Use json-schema from json-string:**
+```yaml
+requests:
+  - name: "your_request_name"
+    postprocessors:
+      - type: assert/json-schema
+        source: json_string
+        schema: '{ "type" : "array" }'
+```
+
+**Use json-schema located on the host:**
+
+**Important: specify the request scheme (http/https)**
+```yaml
+requests:
+  - name: "your_request_name"
+    postprocessors:
+      - type: assert/json-schema
+        source: url
+        schema: "https://examplehost.com/#validation_schema.json"
+```
+
 ### Scenarios
 
 The minimum fields for the script are name and list of requests