Allow eager deserialization in tests

YAML can now be decoded only once and then the same test run multiple
times without having to re-deserialize. This is very useful to write
benchmarks that don't test yaml performance.

Author: Antoine Pelisse

internal/fixture/state.go

@@ -80,13 +80,11 @@ func (s *State) checkInit() error {
 	return nil
 }
 
-// Update the current state with the passed in object
-func (s *State) Update(obj typed.YAMLObject, version fieldpath.APIVersion, manager string) error {
-	obj = FixTabsOrDie(obj)
-	if err := s.checkInit(); err != nil {
+func (s *State) UpdateObject(tv *typed.TypedValue, version fieldpath.APIVersion, manager string) error {
+	err := s.checkInit()
+	if err != nil {
 		return err
 	}
-	tv, err := s.Parser.FromYAML(obj)
 	s.Live, err = s.Updater.Converter.Convert(s.Live, version)
 	if err != nil {
 		return err
@@ -101,13 +99,17 @@ func (s *State) Update(obj typed.YAMLObject, version fieldpath.APIVersion, manag
 	return nil
 }
 
-// Apply the passed in object to the current state
-func (s *State) Apply(obj typed.YAMLObject, version fieldpath.APIVersion, manager string, force bool) error {
-	obj = FixTabsOrDie(obj)
-	if err := s.checkInit(); err != nil {
+// Update the current state with the passed in object
+func (s *State) Update(obj typed.YAMLObject, version fieldpath.APIVersion, manager string) error {
+	tv, err := s.Parser.FromYAML(FixTabsOrDie(obj))
+	if err != nil {
 		return err
 	}
-	tv, err := s.Parser.FromYAML(obj)
+	return s.UpdateObject(tv, version, manager)
+}
+
+func (s *State) ApplyObject(tv *typed.TypedValue, version fieldpath.APIVersion, manager string, force bool) error {
+	err := s.checkInit()
 	if err != nil {
 		return err
 	}
@@ -125,6 +127,15 @@ func (s *State) Apply(obj typed.YAMLObject, version fieldpath.APIVersion, manage
 	return nil
 }
 
+// Apply the passed in object to the current state
+func (s *State) Apply(obj typed.YAMLObject, version fieldpath.APIVersion, manager string, force bool) error {
+	tv, err := s.Parser.FromYAML(FixTabsOrDie(obj))
+	if err != nil {
+		return err
+	}
+	return s.ApplyObject(tv, version, manager, force)
+}
+
 // CompareLive takes a YAML string and returns the comparison with the
 // current live object or an error.
 func (s *State) CompareLive(obj typed.YAMLObject) (*typed.Comparison, error) {
@@ -159,6 +170,7 @@ func (dummyConverter) IsMissingVersionError(err error) bool {
 // Operation is a step that will run when building a table-driven test.
 type Operation interface {
 	run(*State) error
+	preprocess(typed.ParseableType) (Operation, error)
 }
 
 func hasConflict(conflicts merge.Conflicts, conflict merge.Conflict) bool {
@@ -194,7 +206,37 @@ type Apply struct {
 var _ Operation = &Apply{}
 
 func (a Apply) run(state *State) error {
-	err := state.Apply(a.Object, a.APIVersion, a.Manager, false)
+	p, err := a.preprocess(state.Parser)
+	if err != nil {
+		return err
+	}
+	return p.run(state)
+}
+
+func (a Apply) preprocess(parser typed.ParseableType) (Operation, error) {
+	tv, err := parser.FromYAML(FixTabsOrDie(a.Object))
+	if err != nil {
+		return nil, err
+	}
+	return ApplyObject{
+		Manager:    a.Manager,
+		APIVersion: a.APIVersion,
+		Object:     tv,
+		Conflicts:  a.Conflicts,
+	}, nil
+}
+
+type ApplyObject struct {
+	Manager    string
+	APIVersion fieldpath.APIVersion
+	Object     *typed.TypedValue
+	Conflicts  merge.Conflicts
+}
+
+var _ Operation = &ApplyObject{}
+
+func (a ApplyObject) run(state *State) error {
+	err := state.ApplyObject(a.Object, a.APIVersion, a.Manager, false)
 	if err != nil {
 		if _, ok := err.(merge.Conflicts); !ok || a.Conflicts == nil {
 			return err
@@ -215,7 +257,10 @@ func (a Apply) run(state *State) error {
 		}
 	}
 	return nil
+}
 
+func (a ApplyObject) preprocess(parser typed.ParseableType) (Operation, error) {
+	return a, nil
 }
 
 // ForceApply is a type of operation. It is a forced-apply run by a
@@ -232,6 +277,36 @@ func (f ForceApply) run(state *State) error {
 	return state.Apply(f.Object, f.APIVersion, f.Manager, true)
 }
 
+func (f ForceApply) preprocess(parser typed.ParseableType) (Operation, error) {
+	tv, err := parser.FromYAML(FixTabsOrDie(f.Object))
+	if err != nil {
+		return nil, err
+	}
+	return ForceApplyObject{
+		Manager:    f.Manager,
+		APIVersion: f.APIVersion,
+		Object:     tv,
+	}, nil
+}
+
+// ForceApplyObject is a type of operation. It is a forced-apply run by
+// a manager with a given object. Any error will be returned.
+type ForceApplyObject struct {
+	Manager    string
+	APIVersion fieldpath.APIVersion
+	Object     *typed.TypedValue
+}
+
+var _ Operation = &ForceApplyObject{}
+
+func (f ForceApplyObject) run(state *State) error {
+	return state.ApplyObject(f.Object, f.APIVersion, f.Manager, true)
+}
+
+func (f ForceApplyObject) preprocess(parser typed.ParseableType) (Operation, error) {
+	return f, nil
+}
+
 // Update is a type of operation. It is a controller type of
 // update. Errors are passed along.
 type Update struct {
@@ -246,6 +321,36 @@ func (u Update) run(state *State) error {
 	return state.Update(u.Object, u.APIVersion, u.Manager)
 }
 
+func (u Update) preprocess(parser typed.ParseableType) (Operation, error) {
+	tv, err := parser.FromYAML(FixTabsOrDie(u.Object))
+	if err != nil {
+		return nil, err
+	}
+	return UpdateObject{
+		Manager:    u.Manager,
+		APIVersion: u.APIVersion,
+		Object:     tv,
+	}, nil
+}
+
+// UpdateObject is a type of operation. It is a controller type of
+// update. Errors are passed along.
+type UpdateObject struct {
+	Manager    string
+	APIVersion fieldpath.APIVersion
+	Object     *typed.TypedValue
+}
+
+var _ Operation = &Update{}
+
+func (u UpdateObject) run(state *State) error {
+	return state.UpdateObject(u.Object, u.APIVersion, u.Manager)
+}
+
+func (f UpdateObject) preprocess(parser typed.ParseableType) (Operation, error) {
+	return f, nil
+}
+
 // TestCase is the list of operations that need to be run, as well as
 // the object/managedfields as they are supposed to look like after all
 // the operations have been successfully performed. If Object/Managed is
@@ -276,6 +381,18 @@ func (tc TestCase) Bench(parser typed.ParseableType) error {
 	return tc.BenchWithConverter(parser, &dummyConverter{})
 }
 
+// Preprocess all the operations by parsing the yaml before-hand.
+func (tc TestCase) PreprocessOperations(parser typed.ParseableType) error {
+	for i := range tc.Ops {
+		op, err := tc.Ops[i].preprocess(parser)
+		if err != nil {
+			return err
+		}
+		tc.Ops[i] = op
+	}
+	return nil
+}
+
 // BenchWithConverter runs the test-case using the given parser and converter,
 // but doesn't do any comparison operations aftewards; you should probably run
 // TestWithConverter once and reset the benchmark, to make sure the test case

merge/deduced_test.go

@@ -603,6 +603,8 @@ func BenchmarkDeducedSimple(b *testing.B) {
 		b.Fatal(err)
 	}
 
+	test.PreprocessOperations(typed.DeducedParseableType)
+
 	b.ReportAllocs()
 	b.ResetTimer()
 	for n := 0; n < b.N; n++ {
@@ -712,6 +714,8 @@ func BenchmarkDeducedNested(b *testing.B) {
 		b.Fatal(err)
 	}
 
+	test.PreprocessOperations(typed.DeducedParseableType)
+
 	b.ReportAllocs()
 	b.ResetTimer()
 	for n := 0; n < b.N; n++ {
@@ -821,6 +825,8 @@ func BenchmarkDeducedNestedAcrossVersion(b *testing.B) {
 		b.Fatal(err)
 	}
 
+	test.PreprocessOperations(typed.DeducedParseableType)
+
 	b.ReportAllocs()
 	b.ResetTimer()
 	for n := 0; n < b.N; n++ {

merge/leaf_test.go

@@ -536,6 +536,8 @@ func BenchmarkLeafConflictAcrossVersion(b *testing.B) {
 		b.Fatal(err)
 	}
 
+	test.PreprocessOperations(leafFieldsParser)
+
 	b.ReportAllocs()
 	b.ResetTimer()
 	for n := 0; n < b.N; n++ {

merge/multiple_appliers_test.go

@@ -1108,6 +1108,8 @@ func BenchmarkMultipleApplierRecursiveRealConversion(b *testing.B) {
 		b.Fatal(err)
 	}
 
+	test.PreprocessOperations(nestedTypeParser)
+
 	b.ReportAllocs()
 	b.ResetTimer()
 	for n := 0; n < b.N; n++ {