addressed coverage

Author: daveshanley

parameters/validate_parameter_test.go

@@ -1,6 +1,8 @@
 package parameters
 
 import (
+	"github.com/pb33f/libopenapi-validator/helpers"
+	lowv3 "github.com/pb33f/libopenapi/datamodel/low/v3"
 	"net/http"
 	"testing"
 
@@ -192,3 +194,86 @@ func TestHeaderSchemaNoType_AllPoly(t *testing.T) {
 	assert.Equal(t, "schema 'apiKey' is defined as an boolean and a integer, however it failed to pass a schema validation", valErrs[0].Reason)
 	assert.Len(t, valErrs[0].SchemaValidationErrors, 3)
 }
+
+func TestHeaderSchemaStringNoJSON(t *testing.T) {
+	bytes := []byte(`{
+  "openapi": "3.0.0",
+  "info": {
+    "title": "API Spec With Mandatory Header",
+    "version": "1.0.0"
+  },
+  "paths": {
+    "/api-endpoint": {
+      "get": {
+        "summary": "Restricted API Endpoint",
+        
+        "responses": {
+          "200": {
+            "description": "Successful response",
+             "headers": { 
+               "chicken-nuggets": {
+				"required": true,
+				"schema": {
+				  "oneOf": [
+					{
+					  "type": "boolean"
+					},
+					{
+					  "type": "integer"
+					}
+				  ],
+				}
+			  }
+			},
+          }
+        }
+      }
+    }
+  },
+  "components": {
+    "securitySchemes": {
+      "ApiKeyHeader": {
+        "type": "apiKey",
+        "name": "apiKey",
+        "in": "header"
+      }
+    }
+  },
+  "security": [
+    {
+      "ApiKeyHeader": []
+    }
+  ]
+}`)
+
+	doc, err := libopenapi.NewDocument(bytes)
+	if err != nil {
+		t.Fatalf("error while creating open api spec document: %v", err)
+	}
+
+	req, err := http.NewRequest("GET", "/api-endpoint", nil)
+	if err != nil {
+		t.Fatalf("error while creating request: %v", err)
+	}
+
+	req.Header.Set("Content-Type", "application/json")
+	req.Header.Set("apiKey", "headerValue")
+
+	v3Model, errs := doc.BuildV3Model()
+	if len(errs) > 0 {
+		t.Fatalf("error while building v3 model: %v", errs)
+	}
+
+	v3Model.Model.Servers = nil
+	// render the document back to bytes and reload the model.
+	_, _, v3Model, _ = doc.RenderAndReload()
+
+	headers := v3Model.Model.Paths.PathItems.GetOrZero("/api-endpoint").Get.Responses.Codes.GetOrZero("200").Headers
+	headerSchema := headers.GetOrZero("chicken-nuggets").Schema.Schema()
+
+	headerErrors := ValidateParameterSchema(headerSchema, nil, "bubbles", "header",
+		"response header", "chicken-nuggets", helpers.ResponseBodyValidation, lowv3.HeadersLabel, nil)
+
+	assert.Len(t, headerErrors, 1)
+	assert.Equal(t, "response header 'chicken-nuggets' is defined as an boolean or integer, however it failed to pass a schema validation", headerErrors[0].Reason)
+}

responses/validate_headers_test.go

@@ -83,3 +83,50 @@ paths:
 	assert.Equal(t, errors[0].Message, "header 'chicken-nuggets' failed to validate")
 	assert.Equal(t, errors[0].Reason, "response header 'chicken-nuggets' is defined as an integer, however it failed to pass a schema validation")
 }
+
+func TestValidateResponseHeaders_Valid(t *testing.T) {
+	spec := `openapi: "3.0.0"
+info:
+  title: Healthcheck
+  version: '0.1.0'
+paths:
+  /health:
+    get:
+      responses:
+        '200':
+          headers:
+            chicken-nuggets:
+              description: chicken nuggets response
+              required: false
+              schema:
+                type: integer
+          description: pet response`
+
+	doc, _ := libopenapi.NewDocument([]byte(spec))
+
+	m, _ := doc.BuildV3Model()
+
+	// build a request
+	request, _ := http.NewRequest(http.MethodGet, "https://things.com/health", nil)
+
+	// simulate a request/response
+	res := httptest.NewRecorder()
+	handler := func(w http.ResponseWriter, r *http.Request) {
+		w.Header().Set("Chicken-Cakes", "I should fail")
+		w.WriteHeader(http.StatusOK)
+		_, _ = w.Write(nil)
+	}
+
+	// fire the request
+	handler(res, request)
+
+	response := res.Result()
+
+	headers := m.Model.Paths.PathItems.GetOrZero("/health").Get.Responses.Codes.GetOrZero("200").Headers
+
+	// validate!
+	valid, errors := ValidateResponseHeaders(request, response, headers)
+
+	assert.True(t, valid)
+	assert.Len(t, errors, 0)
+}