Use Swagger#MarshalNext where possible

pkg/aggregator/aggregator_test.go

@@ -35,7 +35,7 @@ type DebugSpec struct {
 }
 
 func (d DebugSpec) String() string {
-	bytes, err := json.MarshalIndent(d.Swagger, "", " ")
+	bytes, err := d.Swagger.MarshalNext()
 	if err != nil {
 		return fmt.Sprintf("DebugSpec.String failed: %s", err)
 	}
@@ -1762,7 +1762,7 @@ func BenchmarkMergeSpecsIgnorePathConflictsWithKubeSpec(b *testing.B) {
 			}
 		}
 
-		specBytes, _ := json.Marshal(sp)
+		specBytes, _ := sp.MarshalNext()
 		handler.ToProtoBinary(specBytes)
 
 		b.StopTimer()
@@ -2003,7 +2003,7 @@ func TestCloneSpec(t *testing.T) {
 }
 
 func cloneSpec(source *spec.Swagger) (*spec.Swagger, error) {
-	bytes, err := json.Marshal(source)
+	bytes, err := source.MarshalNext()
 	if err != nil {
 		return nil, err
 	}

pkg/builder/openapi_test.go

@@ -26,6 +26,7 @@ import (
 	"github.com/emicklei/go-restful/v3"
 	"github.com/stretchr/testify/assert"
 	openapi "k8s.io/kube-openapi/pkg/common"
+	"k8s.io/kube-openapi/pkg/util/jsontesting"
 	"k8s.io/kube-openapi/pkg/validation/spec"
 )
 
@@ -467,15 +468,17 @@ func TestBuildOpenAPISpec(t *testing.T) {
 	if !assert.NoError(err) {
 		return
 	}
-	expected_json, err := json.Marshal(expected)
+	expected_json, err := expected.MarshalNext()
 	if !assert.NoError(err) {
 		return
 	}
-	actual_json, err := json.Marshal(swagger)
+	actual_json, err := swagger.MarshalNext()
 	if !assert.NoError(err) {
 		return
 	}
-	assert.Equal(string(expected_json), string(actual_json))
+	if err := jsontesting.JsonCompare(expected_json, actual_json); err != nil {
+		t.Error(err)
+	}
 }
 
 func TestBuildOpenAPIDefinitionsForResource(t *testing.T) {

pkg/handler/handler.go

@@ -20,7 +20,6 @@ import (
 	"bytes"
 	"compress/gzip"
 	"crypto/sha512"
-	"encoding/json"
 	"fmt"
 	"mime"
 	"net/http"
@@ -117,7 +116,7 @@ func (o *OpenAPIService) UpdateSpec(openapiSpec *spec.Swagger) (err error) {
 	o.rwMutex.Lock()
 	defer o.rwMutex.Unlock()
 	o.jsonCache = o.jsonCache.New(func() ([]byte, error) {
-		return json.Marshal(openapiSpec)
+		return openapiSpec.MarshalNext()
 	})
 	o.protoCache = o.protoCache.New(func() ([]byte, error) {
 		json, err := o.jsonCache.Get()

pkg/handler/handler_test.go

@@ -25,7 +25,7 @@ func TestRegisterOpenAPIVersionedService(t *testing.T) {
 		t.Errorf("Unexpected error in unmarshalling SwaggerJSON: %v", err)
 	}
 
-	returnedJSON, err := json.Marshal(s)
+	returnedJSON, err := s.MarshalNext()
 	if err != nil {
 		t.Errorf("Unexpected error in preparing returnedJSON: %v", err)
 	}

pkg/openapiconv/convert_test.go

@@ -24,6 +24,7 @@ import (
 	"testing"
 
 	"k8s.io/kube-openapi/pkg/spec3"
+	"k8s.io/kube-openapi/pkg/util/jsontesting"
 	"k8s.io/kube-openapi/pkg/validation/spec"
 )
 
@@ -51,19 +52,19 @@ func TestConvert(t *testing.T) {
 			t.Fatal(err)
 		}
 
-		openAPIV2JSONBeforeConversion, err := json.Marshal(swaggerSpec)
+		openAPIV2JSONBeforeConversion, err := swaggerSpec.MarshalNext()
 		if err != nil {
 			t.Fatal(err)
 		}
 
 		convertedV3Spec := ConvertV2ToV3(&swaggerSpec)
 
-		openAPIV2JSONAfterConversion, err := json.Marshal(swaggerSpec)
+		openAPIV2JSONAfterConversion, err := swaggerSpec.MarshalNext()
 		if err != nil {
 			t.Fatal(err)
 		}
-		if !reflect.DeepEqual(openAPIV2JSONBeforeConversion, openAPIV2JSONAfterConversion) {
-			t.Errorf("Expected OpenAPI V2 to be untouched before and after conversion")
+		if err := jsontesting.JsonCompare(openAPIV2JSONBeforeConversion, openAPIV2JSONAfterConversion); err != nil {
+			t.Errorf("Expected OpenAPI V2 to be untouched before and after conversion: %v", err)
 		}
 
 		spec3JSON, err := ioutil.ReadFile(filepath.Join("testdata_generated_from_k8s/v3_" + tc.groupVersion + ".json"))

pkg/schemamutation/walker_test.go

@@ -220,7 +220,7 @@ func TestReplaceReferences(t *testing.T) {
 			}
 
 			// find refs
-			bs, err := json.Marshal(s)
+			bs, err := s.MarshalNext()
 			if err != nil {
 				t.Fatalf("failed to marshal swagger: %v", err)
 			}
@@ -244,7 +244,7 @@ func TestReplaceReferences(t *testing.T) {
 				}
 			}
 
-			origString, err := json.Marshal(s)
+			origString, err := s.MarshalNext()
 			if err != nil {
 				t.Fatalf("failed to marshal swagger: %v", err)
 			}
@@ -390,13 +390,13 @@ func TestReplaceSchema(t *testing.T) {
 }
 
 func cloneSwagger(orig *spec.Swagger) (*spec.Swagger, error) {
-	bs, err := json.Marshal(orig)
+	bs, err := orig.MarshalNext()
 	if err != nil {
-		return nil, err
+		return nil, fmt.Errorf("error marshaling: %v", err)
 	}
 	s := &spec.Swagger{}
 	if err := json.Unmarshal(bs, s); err != nil {
-		return nil, err
+		return nil, fmt.Errorf("error unmarshaling: %v", err)
 	}
 	return s, nil
 }

pkg/validation/spec/gnostic_test.go

@@ -31,6 +31,7 @@ import (
 	"github.com/stretchr/testify/require"
 	"google.golang.org/protobuf/proto"
 	"gopkg.in/yaml.v3"
+	jsontesting "k8s.io/kube-openapi/pkg/util/jsontesting"
 	. "k8s.io/kube-openapi/pkg/validation/spec"
 )
 
@@ -43,7 +44,7 @@ func gnosticCommonTest(t testing.TB, fuzzer *fuzz.Fuzzer) {
 	fuzzer.Fuzz(&expected)
 
 	// Convert to gnostic via JSON to compare
-	jsonBytes, err := json.Marshal(expected)
+	jsonBytes, err := expected.MarshalNext()
 	require.NoError(t, err)
 
 	t.Log("Specimen", string(jsonBytes))
@@ -59,10 +60,10 @@ func gnosticCommonTest(t testing.TB, fuzzer *fuzz.Fuzzer) {
 		t.Fatal(cmp.Diff(expected, actual, SwaggerDiffOptions...))
 	}
 
-	newJsonBytes, err := json.Marshal(actual)
+	newJsonBytes, err := actual.MarshalNext()
 	require.NoError(t, err)
-	if !reflect.DeepEqual(jsonBytes, newJsonBytes) {
-		t.Fatal(cmp.Diff(string(jsonBytes), string(newJsonBytes), SwaggerDiffOptions...))
+	if err := jsontesting.JsonCompare(jsonBytes, newJsonBytes); err != nil {
+		t.Fatal(err)
 	}
 }
 
@@ -518,19 +519,19 @@ func TestCommonDataLoss(t *testing.T) {
 
 			// Make sure that they were exactly the same, except for the data loss
 			//	by checking JSON encodes the some
-			badConvertedJSON, err := json.Marshal(badConverted)
+			badConvertedJSON, err := badConverted.MarshalNext()
 			if err != nil {
 				t.Error(err)
 				return
 			}
 
-			fixedConvertedJSON, err := json.Marshal(fixedConverted)
+			fixedConvertedJSON, err := fixedConverted.MarshalNext()
 			if err != nil {
 				t.Error(err)
 				return
 			}
 
-			fixedDirectJSON, err := json.Marshal(fixedDirect)
+			fixedDirectJSON, err := fixedDirect.MarshalNext()
 			if err != nil {
 				t.Error(err)
 				return
@@ -580,13 +581,13 @@ func TestBadStatusCode(t *testing.T) {
 
 	// Make sure that they were exactly the same, except for the data loss
 	//	by checking JSON encodes the some
-	badConvertedJSON, err := json.Marshal(badConverted)
+	badConvertedJSON, err := badConverted.MarshalNext()
 	if err != nil {
 		t.Error(err)
 		return
 	}
 
-	droppedConvertedJSON, err := json.Marshal(droppedConverted)
+	droppedConvertedJSON, err := droppedConverted.MarshalNext()
 	if err != nil {
 		t.Error(err)
 		return

pkg/validation/spec/swagger_test.go

@@ -119,7 +119,7 @@ const specJSON = `{
 func TestSwaggerSpec_Serialize(t *testing.T) {
 	expected := make(map[string]interface{})
 	_ = json.Unmarshal([]byte(specJSON), &expected)
-	b, err := json.MarshalIndent(spec, "", "  ")
+	b, err := spec.MarshalNext()
 	if assert.NoError(t, err) {
 		var actual map[string]interface{}
 		err := json.Unmarshal(b, &actual)
@@ -220,7 +220,7 @@ func TestSwaggerSpec_ExperimentalUnmarshal(t *testing.T) {
 	internal.UseOptimizedJSONUnmarshaling = true
 
 	// Serialize into JSON again
-	jsonBytesV2, err := json.Marshal(expected)
+	jsonBytesV2, err := expected.MarshalNext()
 	require.NoError(t, err)
 
 	t.Log("Specimen V2", string(jsonBytes))