vendor JSON schema to avoid network calls in tests (#1434)

Author: wbrowne

experimental/schemabuilder/reflector_test.go

@@ -1,6 +1,7 @@
 package schemabuilder
 
 import (
+	_ "embed"
 	"encoding/json"
 	"os"
 	"reflect"
@@ -9,13 +10,18 @@ import (
 	"github.com/go-openapi/loads"
 	"github.com/go-openapi/spec"
 	"github.com/go-openapi/strfmt"
+	"github.com/go-openapi/swag/loading"
 	"github.com/go-openapi/validate"
-	"github.com/grafana/grafana-plugin-sdk-go/data"
-	apisdata "github.com/grafana/grafana-plugin-sdk-go/experimental/apis/data/v0alpha1"
 	"github.com/invopop/jsonschema"
 	"github.com/stretchr/testify/require"
+
+	"github.com/grafana/grafana-plugin-sdk-go/data"
+	apisdata "github.com/grafana/grafana-plugin-sdk-go/experimental/apis/data/v0alpha1"
 )
 
+//go:embed testdata/draft-04-schema.json
+var draft04SchemaJSON []byte
+
 func TestWriteQuerySchema(t *testing.T) {
 	builder, err := NewSchemaBuilder(BuilderOptions{
 		PluginID: []string{"dummy"},
@@ -118,11 +124,28 @@ func validateOpenAPIv2Schema(t *testing.T, data []byte, file string) {
 	})
 	require.NoError(t, err, file)
 
-	// 2c. Load the spec structure using loads.Analyzed.
-	doc, err := loads.Analyzed(swaggerBytes, "2.0")
-	require.NoError(t, err)
+	localDocLoader := func(path string, opts ...loading.Option) (json.RawMessage, error) {
+		// Use vendored draft-04 schema to avoid network calls
+		if path == "https://json-schema.org/draft-04/schema#" || path == "https://json-schema.org/draft-04/schema" {
+			return draft04SchemaJSON, nil
+		}
+
+		// For other paths (local files or HTTP URLs), use the default loader
+		return loading.JSONDoc(path, opts...)
+	}
+
+	tmpFile, err := os.CreateTemp("", "swagger-*.json")
+	require.NoError(t, err, file)
+	defer os.Remove(tmpFile.Name())
+
+	_, err = tmpFile.Write(swaggerBytes)
+	require.NoError(t, err, file)
+	err = tmpFile.Close()
+	require.NoError(t, err, file)
+
+	doc, err := loads.Spec(tmpFile.Name(), loads.WithDocLoader(localDocLoader))
+	require.NoError(t, err, file)
 
-	// 2d. Validate the loaded document against the official OpenAPI 2.0 meta-schema.
 	err = validate.Spec(doc, strfmt.Default)
 	require.NoError(t, err, file)
 }

experimental/schemabuilder/testdata/draft-04-schema.json

@@ -0,0 +1,149 @@
+{
+    "id": "http://json-schema.org/draft-04/schema#",
+    "$schema": "http://json-schema.org/draft-04/schema#",
+    "description": "Core schema meta-schema",
+    "definitions": {
+        "schemaArray": {
+            "type": "array",
+            "minItems": 1,
+            "items": { "$ref": "#" }
+        },
+        "positiveInteger": {
+            "type": "integer",
+            "minimum": 0
+        },
+        "positiveIntegerDefault0": {
+            "allOf": [ { "$ref": "#/definitions/positiveInteger" }, { "default": 0 } ]
+        },
+        "simpleTypes": {
+            "enum": [ "array", "boolean", "integer", "null", "number", "object", "string" ]
+        },
+        "stringArray": {
+            "type": "array",
+            "items": { "type": "string" },
+            "minItems": 1,
+            "uniqueItems": true
+        }
+    },
+    "type": "object",
+    "properties": {
+        "id": {
+            "type": "string"
+        },
+        "$schema": {
+            "type": "string"
+        },
+        "title": {
+            "type": "string"
+        },
+        "description": {
+            "type": "string"
+        },
+        "default": {},
+        "multipleOf": {
+            "type": "number",
+            "minimum": 0,
+            "exclusiveMinimum": true
+        },
+        "maximum": {
+            "type": "number"
+        },
+        "exclusiveMaximum": {
+            "type": "boolean",
+            "default": false
+        },
+        "minimum": {
+            "type": "number"
+        },
+        "exclusiveMinimum": {
+            "type": "boolean",
+            "default": false
+        },
+        "maxLength": { "$ref": "#/definitions/positiveInteger" },
+        "minLength": { "$ref": "#/definitions/positiveIntegerDefault0" },
+        "pattern": {
+            "type": "string",
+            "format": "regex"
+        },
+        "additionalItems": {
+            "anyOf": [
+                { "type": "boolean" },
+                { "$ref": "#" }
+            ],
+            "default": {}
+        },
+        "items": {
+            "anyOf": [
+                { "$ref": "#" },
+                { "$ref": "#/definitions/schemaArray" }
+            ],
+            "default": {}
+        },
+        "maxItems": { "$ref": "#/definitions/positiveInteger" },
+        "minItems": { "$ref": "#/definitions/positiveIntegerDefault0" },
+        "uniqueItems": {
+            "type": "boolean",
+            "default": false
+        },
+        "maxProperties": { "$ref": "#/definitions/positiveInteger" },
+        "minProperties": { "$ref": "#/definitions/positiveIntegerDefault0" },
+        "required": { "$ref": "#/definitions/stringArray" },
+        "additionalProperties": {
+            "anyOf": [
+                { "type": "boolean" },
+                { "$ref": "#" }
+            ],
+            "default": {}
+        },
+        "definitions": {
+            "type": "object",
+            "additionalProperties": { "$ref": "#" },
+            "default": {}
+        },
+        "properties": {
+            "type": "object",
+            "additionalProperties": { "$ref": "#" },
+            "default": {}
+        },
+        "patternProperties": {
+            "type": "object",
+            "additionalProperties": { "$ref": "#" },
+            "default": {}
+        },
+        "dependencies": {
+            "type": "object",
+            "additionalProperties": {
+                "anyOf": [
+                    { "$ref": "#" },
+                    { "$ref": "#/definitions/stringArray" }
+                ]
+            }
+        },
+        "enum": {
+            "type": "array",
+            "minItems": 1,
+            "uniqueItems": true
+        },
+        "type": {
+            "anyOf": [
+                { "$ref": "#/definitions/simpleTypes" },
+                {
+                    "type": "array",
+                    "items": { "$ref": "#/definitions/simpleTypes" },
+                    "minItems": 1,
+                    "uniqueItems": true
+                }
+            ]
+        },
+        "format": { "type": "string" },
+        "allOf": { "$ref": "#/definitions/schemaArray" },
+        "anyOf": { "$ref": "#/definitions/schemaArray" },
+        "oneOf": { "$ref": "#/definitions/schemaArray" },
+        "not": { "$ref": "#" }
+    },
+    "dependencies": {
+        "exclusiveMaximum": [ "maximum" ],
+        "exclusiveMinimum": [ "minimum" ]
+    },
+    "default": {}
+}