func TestSortEncodedManagedFields(t *testing.T) {
	tests := []struct {
		name          string
		managedFields []metav1.ManagedFieldsEntry
		expected      []metav1.ManagedFieldsEntry
	}{
		{
			name:          "empty",
			managedFields: []metav1.ManagedFieldsEntry{},
			expected:      []metav1.ManagedFieldsEntry{},
		},
		{
			name:          "nil",
			managedFields: nil,
			expected:      nil,
		},
		{

func TestTransformingManagedFieldsToParent(t *testing.T) {
	tests := []struct {
		desc        string
		parent      []metav1.ManagedFieldsEntry
		subresource []metav1.ManagedFieldsEntry
		expected    []metav1.ManagedFieldsEntry
	}{
		{
			desc: "different-managers: apply -> update",
			parent: []metav1.ManagedFieldsEntry{
				{
					Manager:    "test",
					Operation:  metav1.ManagedFieldsOperationApply,
					APIVersion: "apps/v1",

		}
		b, err := s.ToJSON()
		if err != nil {
			panic(fmt.Sprintf("error building ManagedFieldsEntry for test: %v", err))
		}
		return &metav1.FieldsV1{Raw: b}
	}

	entry := func(name string, version string, order int, fields *metav1.FieldsV1) metav1.ManagedFieldsEntry {
		return metav1.ManagedFieldsEntry{
			Manager:    name,
			APIVersion: version,
			Operation:  "Update",
			FieldsType: "FieldsV1",

			managedFields.APIVersion = ""
			return managedFields, true
		},
		"invalid Operation": func(managedFields metav1.ManagedFieldsEntry) (metav1.ManagedFieldsEntry, bool) {
			managedFields.Operation = "invalid operation"
			return managedFields, true
		},
		"invalid fieldsType": func(managedFields metav1.ManagedFieldsEntry) (metav1.ManagedFieldsEntry, bool) {
			managedFields.FieldsType = "invalid fieldsType"

		}
		managed.times[manager] = encodedVersionedSet.Time
	}
	return &managed, nil
}

// BuildManagerIdentifier creates a manager identifier string from a ManagedFieldsEntry
func BuildManagerIdentifier(encodedManager *metav1.ManagedFieldsEntry) (manager string, err error) {
	encodedManagerCopy := *encodedManager

	// Never include fields type in the manager identifier
	encodedManagerCopy.FieldsType = ""

// resource and the scale subresource
type ScaleHandler struct {
	parentEntries []metav1.ManagedFieldsEntry
	groupVersion  schema.GroupVersion
	mappings      ResourcePathMappings
}

// NewScaleHandler creates a new ScaleHandler
func NewScaleHandler(parentEntries []metav1.ManagedFieldsEntry, groupVersion schema.GroupVersion, mappings ResourcePathMappings) *ScaleHandler {
	return &ScaleHandler{

			"name": "configmap"
		},
		"data": {
			"key_b": "value"
		}
	}`))
	if err != nil {
		t.Fatal(err)
	}
	previousManagedFields := f.ManagedFields()
	previousEntries := map[string]v1.ManagedFieldsEntry{}
	for _, entry := range previousManagedFields {
		previousEntries[entry.Manager] = entry
	}

	time.Sleep(time.Second)

	err = updateObject(f, "fieldmanager_a_test", []byte(`{
		"apiVersion": "v1",

	if managedFields == nil {
		RemoveNestedField(u.Object, "metadata", "managedFields")
		return
	}
	items := []interface{}{}
	for _, managedFieldsEntry := range managedFields {
		out, err := runtime.DefaultUnstructuredConverter.ToUnstructured(&managedFieldsEntry)
		if err != nil {
			utilruntime.HandleError(fmt.Errorf("unable to set managedFields for object: %v", err))
			return
		}

		t.Run(fmt.Sprintf("%#v", test), func(t *testing.T) {
			errs := ValidateManagedFields([]metav1.ManagedFieldsEntry{test}, field.NewPath("managedFields"))
			if len(errs) == 0 {
				t.Errorf("Validation should have failed")
			}
		})
	}
}

func TestValidateMangedFieldsValid(t *testing.T) {
	tests := []metav1.ManagedFieldsEntry{{
		Operation:  metav1.ManagedFieldsOperationUpdate,
		APIVersion: "v1",

				ObjectMeta: metav1.ObjectMeta{
					Namespace:   "foo",
					Name:        "bar",
					Labels:      map[string]string{"a": "b"},
					Annotations: map[string]string{"c": "d"},
					ManagedFields: []metav1.ManagedFieldsEntry{
						{
							Manager: "whatever",
						},
					},
				},
			},
			want: &corev1.Pod{
				ObjectMeta: metav1.ObjectMeta{
					Namespace:   "foo",
					Name:        "bar",