NewListFunc:               func() runtime.Object { return &storageapi.CSINodeList{} },
		DefaultQualifiedResource:  storageapi.Resource("csinodes"),
		SingularQualifiedResource: storageapi.Resource("csinode"),

		CreateStrategy:      csinode.Strategy,
		UpdateStrategy:      csinode.Strategy,
		DeleteStrategy:      csinode.Strategy,
		ReturnDeletedObject: true,

		t.Run(test.test, func(t *testing.T) {
			node, csiNode := getNodeWithPodAndVolumeLimits(test.limitSource, test.existingPods, test.maxVols, test.driverNames...)
			if csiNode != nil {
				enableMigrationOnNode(csiNode, csilibplugins.AWSEBSInTreePluginName)
			}
			csiTranslator := csitrans.New()
			p := &CSILimits{
				csiNodeLister:        getFakeCSINodeLister(csiNode),

		migratedPlugins map[string](func() bool)
		existingNode    *storage.CSINode
		expectedNode    *storage.CSINode
		expectModified  bool
	}{
		{
			name: "nil migrated plugins",
			existingNode: &storage.CSINode{
				ObjectMeta: metav1.ObjectMeta{
					Name: "node1",
				},
			},
			expectedNode: &storage.CSINode{
				ObjectMeta: metav1.ObjectMeta{
					Name: "node1",
				},
			},
		},

}

func (csiNodeStrategy) Validate(ctx context.Context, obj runtime.Object) field.ErrorList {
	csiNode := obj.(*storage.CSINode)
	validateOptions := validation.CSINodeValidationOptions{
		AllowLongNodeID: true,
	}

	errs := validation.ValidateCSINode(csiNode, validateOptions)

	return errs
}

// WarningsOnCreate returns warnings for the creation of the given object.

		translator:           csiTranslator,
	}, nil
}

func getVolumeLimits(nodeInfo *framework.NodeInfo, csiNode *storagev1.CSINode) map[v1.ResourceName]int64 {
	// TODO: stop getting values from Node object in v1.18
	nodeVolumeLimits := volumeLimits(nodeInfo)
	if csiNode != nil {
		for i := range csiNode.Spec.Drivers {
			d := csiNode.Spec.Drivers[i]
			if d.Allocatable != nil && d.Allocatable.Count != nil {

	}
}

// InstallCSIDriver updates the node ID annotation in the Node object and CSIDrivers field in the
// CSINode object. If the CSINode object doesn't yet exist, it will be created.
// If multiple calls to InstallCSIDriver() are made in parallel, some calls might receive Node or
// CSINode update conflicts, which causes the function to retry the corresponding update.

		return nil
	}

	node := nodeInfo.Node()

	var csiNode *storage.CSINode
	var err error
	if pl.csiNodeLister != nil {
		csiNode, err = pl.csiNodeLister.Get(node.Name)
		if err != nil {
			// we don't fail here because the CSINode object is only necessary
			// for determining whether the migration is enabled or not
			logger.V(5).Info("Could not get a CSINode object for the node", "node", klog.KObj(node), "err", err)
		}

        "deletecollection",
        "get",
        "list",
        "patch",
        "update",
        "watch"
      ]
    },
    {
      "kind": "CSINode",
      "name": "csinodes",
      "namespaced": false,
      "singularName": "csinode",
      "storageVersionHash": "Pe62DkZtjuo=",
      "verbs": [
        "create",
        "delete",
        "deletecollection",
        "get",
        "list",

See the License for the specific language governing permissions and
limitations under the License.
*/

// Package csinode provides Registry interface and its REST
// implementation for storing csinode api objects.

	csiNode := &storagev1.CSINode{
		ObjectMeta: metav1.ObjectMeta{Name: f.nodeName},
		Spec: storagev1.CSINodeSpec{
			Drivers: []storagev1.CSINodeDriver{},
		},
	}
	enableMigrationOnNode(csiNode, csilibplugins.GCEPDInTreePluginName)
	return getFakeCSINodeLister(csiNode)
}

func enableMigrationOnNode(csiNode *storagev1.CSINode, pluginName string) {