Repository: kubernetes-sigs/gcp-filestore-csi-driver
Pull request #254 (2022-04-22 23:45:44)

Multishare create/delete volume based on APIs
<!--  Thanks for sending a pull request!  Here are some tips for you:

1. If this is your first time, please read our contributor guidelines: https://git.k8s.io/community/contributors/guide#your-first-contribution and developer guide https://git.k8s.io/community/contributors/devel/development.md#development-guide
2. Follow the instructions for writing a release note: https://git.k8s.io/community/contributors/guide/release-notes.md
3. If the PR is unfinished, see how to mark it: https://git.k8s.io/community/contributors/guide/pull-requests.md#marking-unfinished-pull-requests
-->

**What type of PR is this?**
> Uncomment only one ` /kind <>` line, hit enter to put that in a new line, and remove leading whitespaces from that line:
>
> /kind api-change
> /kind bug
/kind cleanup
> /kind design
> /kind documentation
> /kind failing-test
> /kind feature
> /kind flake

**What this PR does / why we need it**:

**Which issue(s) this PR fixes**:
<!--
*Automatically closes linked issue when PR is merged.
Usage: `Fixes #<issue number>`, or `Fixes (paste link of issue)`.
_If PR is about `failing-tests or flakes`, please post the related issues/tests in a comment and do not use `Fixes`_*
-->
Fixes #

**Special notes for your reviewer**:

**Does this PR introduce a user-facing change?**:
<!--
If no, just write "NONE" in the release-note block below.
If yes, a release note is required:
Enter your extended release note in the block below. If the PR requires additional action from users switching to the new release, include the string "action required".
-->
```release-note
Multishare create/delete volume based on APIs
```


k8s-ci-robot: [APPROVALNOTIFIER] This PR is **APPROVED**

This pull-request has been approved by: *<a href="https://github.com/kubernetes-sigs/gcp-filestore-csi-driver/pull/254#" title="Author self-approved">saikat-royc</a>*

The full list of commands accepted by this bot can be found [here](https://go.k8s.io/bot-commands?repo=kubernetes-sigs%2Fgcp-filestore-csi-driver).

The pull request process is described [here](https://git.k8s.io/community/contributors/guide/owners.md#the-code-review-process)

<details >
Needs approval from an approver in each of these files:

- ~~[OWNERS](https://github.com/kubernetes-sigs/gcp-filestore-csi-driver/blob/master/OWNERS)~~ [saikat-royc]

Approvers can indicate their approval by writing `/approve` in a comment
Approvers can cancel approval by writing `/approve cancel` in a comment
</details>
<!-- META={"approvers":[]} -->
k8s-ci-robot: @saikat-royc: The following test **failed**, say `/retest` to rerun all failed tests or `/retest-required` to rerun all mandatory failed tests:

Test name | Commit | Details | Required | Rerun command
--- | --- | --- | --- | ---
pull-gcp-filestore-csi-driver-e2e | 86bf9a333d49847dc82378b4bdec6f9cc3475746 | [link](https://prow.k8s.io/view/gs/kubernetes-jenkins/pr-logs/pull/sigs.k8s.io_gcp-filestore-csi-driver/254/pull-gcp-filestore-csi-driver-e2e/1517652252959969280/) | true | `/test pull-gcp-filestore-csi-driver-e2e`

[Full PR test history](https://prow.k8s.io/pr-history?org=kubernetes-sigs&repo=gcp-filestore-csi-driver&pr=254). [Your PR dashboard](https://prow.k8s.io/pr?query=is%3Apr%20state%3Aopen%20author%3Asaikat-royc). Please help us cut down on flakes by [linking to](https://git.k8s.io/community/contributors/devel/sig-testing/flaky-tests.md#filing-issues-for-flaky-tests) an [open issue](https://github.com/kubernetes-sigs/gcp-filestore-csi-driver/issues?q=is:issue+is:open) when you hit one in your PR.

<details>

Instructions for interacting with me using PR comments are available [here](https://git.k8s.io/community/contributors/guide/pull-requests.md).  If you have questions or suggestions related to my behavior, please file an issue against the [kubernetes/test-infra](https://github.com/kubernetes/test-infra/issues/new?title=Prow%20issue:) repository. I understand the commands that are listed [here](https://go.k8s.io/bot-commands).
</details>
<!-- test report -->
k8s-ci-robot: @saikat-royc: The following test **failed**, say `/retest` to rerun all failed tests or `/retest-required` to rerun all mandatory failed tests:

Test name | Commit | Details | Required | Rerun command
--- | --- | --- | --- | ---
pull-gcp-filestore-csi-driver-e2e | d3138e4c5068a20a590effe2f5a3ae34791a48ea | [link](https://prow.k8s.io/view/gs/kubernetes-jenkins/pr-logs/pull/sigs.k8s.io_gcp-filestore-csi-driver/254/pull-gcp-filestore-csi-driver-e2e/1517747202347241472/) | true | `/test pull-gcp-filestore-csi-driver-e2e`

[Full PR test history](https://prow.k8s.io/pr-history?org=kubernetes-sigs&repo=gcp-filestore-csi-driver&pr=254). [Your PR dashboard](https://prow.k8s.io/pr?query=is%3Apr%20state%3Aopen%20author%3Asaikat-royc). Please help us cut down on flakes by [linking to](https://git.k8s.io/community/contributors/devel/sig-testing/flaky-tests.md#filing-issues-for-flaky-tests) an [open issue](https://github.com/kubernetes-sigs/gcp-filestore-csi-driver/issues?q=is:issue+is:open) when you hit one in your PR.

<details>

Instructions for interacting with me using PR comments are available [here](https://git.k8s.io/community/contributors/guide/pull-requests.md).  If you have questions or suggestions related to my behavior, please file an issue against the [kubernetes/test-infra](https://github.com/kubernetes/test-infra/issues/new?title=Prow%20issue:) repository. I understand the commands that are listed [here](https://go.k8s.io/bot-commands).
</details>
<!-- test report -->
k8s-ci-robot: @saikat-royc: The following test **failed**, say `/retest` to rerun all failed tests or `/retest-required` to rerun all mandatory failed tests:

Test name | Commit | Details | Required | Rerun command
--- | --- | --- | --- | ---
pull-gcp-filestore-csi-driver-e2e | af78aa3a7064c955f69bdbcc1793ddccc52f51a6 | [link](https://prow.k8s.io/view/gs/kubernetes-jenkins/pr-logs/pull/sigs.k8s.io_gcp-filestore-csi-driver/254/pull-gcp-filestore-csi-driver-e2e/1517748202026045440/) | true | `/test pull-gcp-filestore-csi-driver-e2e`

[Full PR test history](https://prow.k8s.io/pr-history?org=kubernetes-sigs&repo=gcp-filestore-csi-driver&pr=254). [Your PR dashboard](https://prow.k8s.io/pr?query=is%3Apr%20state%3Aopen%20author%3Asaikat-royc). Please help us cut down on flakes by [linking to](https://git.k8s.io/community/contributors/devel/sig-testing/flaky-tests.md#filing-issues-for-flaky-tests) an [open issue](https://github.com/kubernetes-sigs/gcp-filestore-csi-driver/issues?q=is:issue+is:open) when you hit one in your PR.

<details>

Instructions for interacting with me using PR comments are available [here](https://git.k8s.io/community/contributors/guide/pull-requests.md).  If you have questions or suggestions related to my behavior, please file an issue against the [kubernetes/test-infra](https://github.com/kubernetes/test-infra/issues/new?title=Prow%20issue:) repository. I understand the commands that are listed [here](https://go.k8s.io/bot-commands).
</details>
<!-- test report -->
k8s-ci-robot: @saikat-royc: The following test **failed**, say `/retest` to rerun all failed tests or `/retest-required` to rerun all mandatory failed tests:

Test name | Commit | Details | Required | Rerun command
--- | --- | --- | --- | ---
pull-gcp-filestore-csi-driver-e2e | d9a128eb43c79385ca9b2d5a1cac90c62f3689d3 | [link](https://prow.k8s.io/view/gs/kubernetes-jenkins/pr-logs/pull/sigs.k8s.io_gcp-filestore-csi-driver/254/pull-gcp-filestore-csi-driver-e2e/1518101835519365120/) | true | `/test pull-gcp-filestore-csi-driver-e2e`

[Full PR test history](https://prow.k8s.io/pr-history?org=kubernetes-sigs&repo=gcp-filestore-csi-driver&pr=254). [Your PR dashboard](https://prow.k8s.io/pr?query=is%3Apr%20state%3Aopen%20author%3Asaikat-royc). Please help us cut down on flakes by [linking to](https://git.k8s.io/community/contributors/devel/sig-testing/flaky-tests.md#filing-issues-for-flaky-tests) an [open issue](https://github.com/kubernetes-sigs/gcp-filestore-csi-driver/issues?q=is:issue+is:open) when you hit one in your PR.

<details>

Instructions for interacting with me using PR comments are available [here](https://git.k8s.io/community/contributors/guide/pull-requests.md).  If you have questions or suggestions related to my behavior, please file an issue against the [kubernetes/test-infra](https://github.com/kubernetes/test-infra/issues/new?title=Prow%20issue:) repository. I understand the commands that are listed [here](https://go.k8s.io/bot-commands).
</details>
<!-- test report -->

Patch:
diff --git a/pkg/cloud_provider/file/fake.go b/pkg/cloud_provider/file/fake.go
index 4c08c731..e8d73475 100644
--- a/pkg/cloud_provider/file/fake.go
+++ b/pkg/cloud_provider/file/fake.go
@@ -42,17 +42,39 @@ type fakeServiceManager struct {
 	backups                   map[string]*BackupInfo
 	createdMultishareInstance map[string]*MultishareInstance
 	createdMultishares        map[string]*Share
+	multishareops             []*filev1beta1multishare.Operation
 }
 
 var _ Service = &fakeServiceManager{}
 
 func NewFakeService() (Service, error) {
 	return &fakeServiceManager{
-		createdInstances: map[string]*ServiceInstance{},
-		backups:          map[string]*BackupInfo{},
+		createdInstances:          map[string]*ServiceInstance{},
+		backups:                   map[string]*BackupInfo{},
+		createdMultishareInstance: make(map[string]*MultishareInstance),
+		createdMultishares:        make(map[string]*Share),
 	}, nil
 }
 
+func NewFakeServiceForMultishare(instances []*MultishareInstance, shares []*Share, ops []*filev1beta1multishare.Operation) (Service, error) {
+	s := &fakeServiceManager{
+		createdInstances:          map[string]*ServiceInstance{},
+		backups:                   map[string]*BackupInfo{},
+		createdMultishareInstance: make(map[string]*MultishareInstance),
+		createdMultishares:        make(map[string]*Share),
+		multishareops:             make([]*filev1beta1multishare.Operation, 0),
+	}
+
+	for _, instance := range instances {
+		s.createdMultishareInstance[instance.Name] = instance
+	}
+	for _, share := range shares {
+		s.createdMultishares[share.Name] = share
+	}
+	s.multishareops = append(s.multishareops, ops...)
+	return s, nil
+}
+
 func (manager *fakeServiceManager) CreateInstance(ctx context.Context, obj *ServiceInstance) (*ServiceInstance, error) {
 	instance := &ServiceInstance{
 		Project:  defaultProject,
@@ -250,13 +272,24 @@ func (m *fakeBlockingServiceManager) HasOperations(ctx context.Context, obj *Ser
 func (manager *fakeServiceManager) GetMultishareInstance(ctx context.Context, obj *MultishareInstance) (*MultishareInstance, error) {
 	instance, ok := manager.createdMultishareInstance[obj.Name]
 	if !ok {
-		return nil, fmt.Errorf("notFound")
+		return nil, &googleapi.Error{
+			Code: int(code.Code_NOT_FOUND),
+			Errors: []googleapi.ErrorItem{
+				{
+					Reason: "notFound",
+				},
+			},
+		}
 	}
 	return instance, nil
 }
 
 func (manager *fakeServiceManager) ListMultishareInstances(ctx context.Context, filter *ListFilter) ([]*MultishareInstance, error) {
-	return nil, nil
+	var ilist []*MultishareInstance
+	for _, v := range manager.createdMultishareInstance {
+		ilist = append(ilist, v)
+	}
+	return ilist, nil
 }
 
 func (manager *fakeServiceManager) StartCreateMultishareInstanceOp(ctx context.Context, obj *MultishareInstance) (*filev1beta1multishare.Operation, error) {
@@ -268,17 +301,16 @@ func (manager *fakeServiceManager) StartCreateMultishareInstanceOp(ctx context.C
 		CapacityBytes: obj.CapacityBytes,
 		Network: Network{
 			Name:            obj.Network.Name,
-			Ip:              "1.1.1.1",
+			Ip:              obj.Network.Ip,
 			ReservedIpRange: obj.Network.ReservedIpRange,
 		},
 		Labels: obj.Labels,
 		State:  "READY",
 	}
-	manager.createdMultishareInstance[instance.Name] = instance
 	manager.createdMultishareInstance[obj.Name] = instance
 	meta := &filev1beta1multishare.OperationMetadata{
 		Target: fmt.Sprintf(instanceURIFmt, instance.Project, instance.Location, instance.Name),
-		Verb:   "CREATE",
+		Verb:   "create",
 	}
 	metaBytes, _ := json.Marshal(meta)
 	op := &filev1beta1multishare.Operation{
@@ -296,7 +328,17 @@ type Signal struct {
 }
 
 func (manager *fakeServiceManager) StartDeleteMultishareInstanceOp(ctx context.Context, obj *MultishareInstance) (*filev1beta1multishare.Operation, error) {
-	return nil, nil
+	delete(manager.createdMultishareInstance, obj.Name)
+	meta := &filev1beta1multishare.OperationMetadata{
+		Target: fmt.Sprintf(instanceURIFmt, obj.Project, obj.Location, obj.Name),
+		Verb:   "create",
+	}
+	metaBytes, _ := json.Marshal(meta)
+	op := &filev1beta1multishare.Operation{
+		Name:     "operation-" + uuid.New().String(),
+		Metadata: metaBytes,
+	}
+	return op, nil
 }
 
 func (manager *fakeServiceManager) StartResizeMultishareInstanceOp(ctx context.Context, obj *MultishareInstance) (*filev1beta1multishare.Operation, error) {
@@ -316,23 +358,25 @@ func (manager *fakeServiceManager) StartCreateShareOp(ctx context.Context, obj *
 		CapacityBytes: obj.CapacityBytes,
 		Network: Network{
 			Name:            obj.Parent.Network.Name,
-			Ip:              "1.1.1.1",
+			Ip:              obj.Parent.Network.Ip,
 			ReservedIpRange: obj.Parent.Network.ReservedIpRange,
 		},
 		Labels: obj.Parent.Labels,
 		State:  "READY",
 	}
 	share := &Share{
-		Name:          obj.Name,
-		Parent:        parent,
-		CapacityBytes: obj.CapacityBytes,
-		Labels:        obj.Labels,
+		Name:           obj.Name,
+		Parent:         parent,
+		CapacityBytes:  obj.CapacityBytes,
+		Labels:         obj.Labels,
+		MountPointName: obj.Name,
+		State:          "READY",
 	}
 	manager.createdMultishares[share.Name] = share
 
 	meta := &filev1beta1.OperationMetadata{
 		Target: fmt.Sprintf(shareURIFmt, share.Parent.Project, share.Parent.Location, share.Parent.Name, share.Name),
-		Verb:   "CREATE",
+		Verb:   "create",
 	}
 	metaBytes, _ := json.Marshal(meta)
 	op := &filev1beta1multishare.Operation{
@@ -388,19 +432,19 @@ func (manager *fakeServiceManager) GetShare(ctx context.Context, obj *Share) (*S
 }
 
 func (manager *fakeServiceManager) ListShares(ctx context.Context, filter *ListFilter) ([]*Share, error) {
-	var s []*Share
+	var slist []*Share
 	for _, v := range manager.createdMultishares {
-		if v.Parent.Project == filter.Project && v.Parent.Location == filter.Location && v.Parent.Name == filter.InstanceName {
-			s = append(s, v)
-		}
+		slist = append(slist, v)
 	}
+	return slist, nil
+}
 
-	return s, nil
+func (manager *fakeServiceManager) AddMultishareOps(ops []*filev1beta1multishare.Operation) {
+	manager.multishareops = append(manager.multishareops, ops...)
 }
 
 func (manager *fakeServiceManager) ListOps(ctx context.Context, resource *ListFilter) ([]*filev1beta1multishare.Operation, error) {
-	// TODO
-	return nil, nil
+	return manager.multishareops, nil
 }
 
 func NewFakeBlockingServiceForMultishare(unblocker chan chan Signal) (Service, error) {
@@ -421,14 +465,7 @@ func (manager *fakeBlockingServiceManager) GetMultishareInstance(ctx context.Con
 		return nil, fmt.Errorf("mock error")
 	}
 	if val.ReportNotFoundError {
-		return nil, &googleapi.Error{
-			Code: int(code.Code_NOT_FOUND),
-			Errors: []googleapi.ErrorItem{
-				{
-					Reason: "notFound",
-				},
-			},
-		}
+		return nil, notFoundError()
 	}
 	return manager.fakeServiceManager.GetMultishareInstance(ctx, instance)
 }
diff --git a/pkg/cloud_provider/file/file.go b/pkg/cloud_provider/file/file.go
index c903cd85..c2f84b0e 100644
--- a/pkg/cloud_provider/file/file.go
+++ b/pkg/cloud_provider/file/file.go
@@ -66,6 +66,10 @@ type MultishareInstance struct {
 	Description        string
 }
 
+func (i *MultishareInstance) String() string {
+	return fmt.Sprintf("%s/%s/%s", i.Project, i.Location, i.Name)
+}
+
 type ListFilter struct {
 	Project      string
 	Location     string
@@ -154,6 +158,11 @@ const (
 
 var _ Service = &gcfsServiceManager{}
 
+var (
+	instanceUriRegex = regexp.MustCompile(`^projects/([^/]+)/locations/([^/]+)/instances/([^/]+)$`)
+	shareUriRegex    = regexp.MustCompile(`^projects/([^/]+)/locations/([^/]+)/instances/([^/]+)/shares/([^/]+)$`)
+)
+
 func NewGCFSService(version string, client *http.Client, endpoint string) (Service, error) {
 	ctx := context.Background()
 	fileService, err := filev1beta1.NewService(ctx, option.WithHTTPClient(client))
@@ -674,7 +683,6 @@ func ApplyFilter(ops []*filev1beta1.Operation, uri string, opType string, done b
 
 // Multishare functions defined here
 func (manager *gcfsServiceManager) GetMultishareInstance(ctx context.Context, obj *MultishareInstance) (*MultishareInstance, error) {
-	// TODO: do not silence not found error.
 	instanceUri := instanceURI(obj.Project, obj.Location, obj.Name)
 	instance, err := manager.multishareInstancesService.Get(instanceUri).Context(ctx).Do()
 	if err != nil {
@@ -682,12 +690,7 @@ func (manager *gcfsServiceManager) GetMultishareInstance(ctx context.Context, ob
 		return nil, err
 	}
 
-	if instance != nil {
-		glog.V(4).Infof("GetInstance call fetched instance %+v", instance)
-		return cloudInstanceToMultishareInstance(instance)
-	}
-
-	return nil, nil
+	return cloudInstanceToMultishareInstance(instance)
 }
 
 func (manager *gcfsServiceManager) ListMultishareInstances(ctx context.Context, filter *ListFilter) ([]*MultishareInstance, error) {
@@ -702,6 +705,10 @@ func (manager *gcfsServiceManager) ListMultishareInstances(ctx context.Context,
 		}
 
 		for _, activeInstance := range instances.Instances {
+			if !activeInstance.MultiShareEnabled {
+				continue
+			}
+
 			instance, err := cloudInstanceToMultishareInstance(activeInstance)
 			if err != nil {
 				return nil, err
@@ -733,22 +740,21 @@ func (manager *gcfsServiceManager) StartCreateMultishareInstanceOp(ctx context.C
 		Description: instance.Description,
 	}
 
-	klog.V(4).Infof("Creating instance %q: project %q, location %q, tier %q, capacity %v, network %q, ipRange %q, connectMode %q, KmsKeyName %q, labels %v", instance.Name, instance.Project, instance.Location, targetinstance.Tier, targetinstance.CapacityGb, targetinstance.Networks[0].Network, targetinstance.Networks[0].ReservedIpRange, targetinstance.Networks[0].ConnectMode, targetinstance.KmsKeyName, targetinstance.Labels)
 	op, err := manager.multishareInstancesService.Create(locationURI(instance.Project, instance.Location), targetinstance).InstanceId(instance.Name).Context(ctx).Do()
 	if err != nil {
 		return nil, fmt.Errorf("CreateInstance operation failed: %v", err)
 	}
-
+	klog.Infof("Started create instance op %s, for instance %q project %q, location %q, tier %q, capacity %v, network %q, ipRange %q, connectMode %q, KmsKeyName %q, labels %v", op.Name, instance.Name, instance.Project, instance.Location, targetinstance.Tier, targetinstance.CapacityGb, targetinstance.Networks[0].Network, targetinstance.Networks[0].ReservedIpRange, targetinstance.Networks[0].ConnectMode, targetinstance.KmsKeyName, targetinstance.Labels)
 	return op, nil
 }
 
 func (manager *gcfsServiceManager) StartDeleteMultishareInstanceOp(ctx context.Context, instance *MultishareInstance) (*filev1beta1multishare.Operation, error) {
 	uri := instanceURI(instance.Project, instance.Location, instance.Name)
-	klog.V(4).Infof("Starting DeleteInstance cloud operation for instance %s", uri)
 	op, err := manager.multishareInstancesService.Delete(uri).Context(ctx).Do()
 	if err != nil {
 		return nil, fmt.Errorf("DeleteInstance operation failed: %v", err)
 	}
+	klog.Infof("Started Delete Instance op %s for instance uri %s", op.Name, uri)
 	return op, nil
 }
 
@@ -762,23 +768,24 @@ func (manager *gcfsServiceManager) StartCreateShareOp(ctx context.Context, share
 	targetshare := &filev1beta1multishare.Share{
 		CapacityGb: util.BytesToGb(share.CapacityBytes),
 		Labels:     share.Labels,
-		// TODO: check about mount_name
+		MountName:  share.MountPointName,
 	}
 
-	klog.V(4).Infof("Creating share %q: for instance %q, with capacity(GB) %v, Labels %v", share.Name, instanceuri, targetshare.CapacityGb, targetshare.Labels)
 	op, err := manager.multishareInstancesSharesService.Create(instanceuri, targetshare).ShareId(share.Name).Context(ctx).Do()
 	if err != nil {
 		return nil, fmt.Errorf("CreateShare operation failed: %v", err)
 	}
+	klog.Infof("Started Create Share op %s for share %q instance uri %q, with capacity(GB) %v, Labels %v", op.Name, share.Name, instanceuri, targetshare.CapacityGb, targetshare.Labels)
 	return op, nil
 }
 
 func (manager *gcfsServiceManager) StartDeleteShareOp(ctx context.Context, share *Share) (*filev1beta1multishare.Operation, error) {
-	shareuri := shareURI(share.Parent.Project, share.Parent.Location, share.Parent.Name, share.Name)
-	op, err := manager.multishareInstancesSharesService.Delete(shareuri).Context(ctx).Do()
+	uri := shareURI(share.Parent.Project, share.Parent.Location, share.Parent.Name, share.Name)
+	op, err := manager.multishareInstancesSharesService.Delete(uri).Context(ctx).Do()
 	if err != nil {
 		return nil, fmt.Errorf("DeleteShare operation failed: %v", err)
 	}
+	klog.Infof("Started Delete Share op %s for share uri %q ", op.Name, uri)
 	return op, nil
 }
 
@@ -806,34 +813,39 @@ func (manager *gcfsServiceManager) GetOp(ctx context.Context, op string) (*filev
 }
 
 func (manager *gcfsServiceManager) GetShare(ctx context.Context, obj *Share) (*Share, error) {
-	sobj, err := manager.multishareInstancesSharesService.Get(instanceURI(obj.Parent.Project, obj.Parent.Location, obj.Parent.Name)).Context(ctx).Do()
+	sobj, err := manager.multishareInstancesSharesService.Get(shareURI(obj.Parent.Project, obj.Parent.Location, obj.Parent.Name, obj.Name)).Context(ctx).Do()
+	if err != nil {
+		return nil, err
+	}
+
+	_, _, _, shareName, err := util.ParseShareURI(sobj.Name)
 	if err != nil {
 		return nil, err
 	}
-	project, location, instanceName, shareName, err := util.ParseShareURI(sobj.Name)
+	instance, err := manager.GetMultishareInstance(ctx, obj.Parent)
 	if err != nil {
 		return nil, err
 	}
+
 	return &Share{
-		Name: shareName,
-		Parent: &MultishareInstance{
-			Name:     instanceName,
-			Project:  project,
-			Location: location,
-		},
+		Name:           shareName,
+		Parent:         instance,
 		MountPointName: sobj.MountName,
 		CapacityBytes:  sobj.CapacityGb * util.Gb,
+		State:          sobj.State,
 	}, nil
 }
 
 func (manager *gcfsServiceManager) ListShares(ctx context.Context, filter *ListFilter) ([]*Share, error) {
-	lCall := manager.multishareInstancesSharesService.List(instanceURI(filter.Project, filter.Location, filter.InstanceName)).Context(ctx)
+	uri := instanceURI(filter.Project, filter.Location, filter.InstanceName)
+	lCall := manager.multishareInstancesSharesService.List(uri).Context(ctx)
 	nextPageToken := "pageToken"
 	var shares []*Share
 
 	for nextPageToken != "" {
 		resp, err := lCall.Do()
 		if err != nil {
+			klog.Errorf("list share error: %v", err)
 			return nil, err
 		}
 
@@ -940,6 +952,9 @@ func CompareShares(a, b *Share) error {
 }
 
 func cloudInstanceToMultishareInstance(instance *filev1beta1multishare.Instance) (*MultishareInstance, error) {
+	if instance == nil {
+		return nil, fmt.Errorf("nil instance")
+	}
 	project, location, name, err := getInstanceNameFromURI(instance.Name)
 	if err != nil {
 		return nil, err
@@ -991,3 +1006,35 @@ func (manager *gcfsServiceManager) ListOps(ctx context.Context, filter *ListFilt
 	}
 	return activeOperations, nil
 }
+
+func IsInstanceTarget(target string) bool {
+	return instanceUriRegex.MatchString(target)
+}
+
+func IsShareTarget(target string) bool {
+	return shareUriRegex.MatchString(target)
+}
+
+func GenerateMultishareInstanceURI(m *MultishareInstance) (string, error) {
+	if m == nil {
+		return "", fmt.Errorf("Null instance")
+	}
+
+	if m.Project == "" || m.Location == "" || m.Name == "" {
+		return "", fmt.Errorf("Missing parent, project or location in instance")
+	}
+
+	return fmt.Sprintf(instanceURIFmt, m.Project, m.Location, m.Name), nil
+}
+
+func GenerateShareURI(s *Share) (string, error) {
+	if s == nil || s.Parent == nil {
+		return "", fmt.Errorf("Missing share parent instance")
+	}
+
+	if s.Parent.Project == "" || s.Parent.Location == "" || s.Parent.Name == "" || s.Name == "" {
+		return "", fmt.Errorf("Missing parent, project or location in share parent")
+	}
+
+	return fmt.Sprintf(shareURIFmt, s.Parent.Project, s.Parent.Location, s.Parent.Name, s.Name), nil
+}
diff --git a/pkg/csi_driver/controller.go b/pkg/csi_driver/controller.go
index a41382a8..100bde0e 100644
--- a/pkg/csi_driver/controller.go
+++ b/pkg/csi_driver/controller.go
@@ -26,6 +26,7 @@ import (
 	"golang.org/x/net/context"
 	"google.golang.org/grpc/codes"
 	"google.golang.org/grpc/status"
+	"k8s.io/klog"
 	cloud "sigs.k8s.io/gcp-filestore-csi-driver/pkg/cloud_provider"
 	"sigs.k8s.io/gcp-filestore-csi-driver/pkg/cloud_provider/file"
 	"sigs.k8s.io/gcp-filestore-csi-driver/pkg/metrics"
@@ -117,6 +118,7 @@ func (s *controllerServer) CreateVolume(ctx context.Context, req *csi.CreateVolu
 		response, err := s.config.multiShareController.CreateVolume(ctx, req)
 		duration := time.Since(start)
 		s.config.metricsManager.RecordOperationMetrics(err, methodCreateVolume, modeMultishare, duration)
+		klog.Infof("CreateVolume request %+v, response %+v error %v", req, response, err)
 		return response, err
 	}
 
@@ -289,7 +291,7 @@ func (s *controllerServer) getCloudInstancesReservedIPRanges(ctx context.Context
 
 // DeleteVolume deletes a GCFS instance
 func (s *controllerServer) DeleteVolume(ctx context.Context, req *csi.DeleteVolumeRequest) (*csi.DeleteVolumeResponse, error) {
-	glog.V(4).Infof("DeleteVolume called with request %+v", req)
+	glog.Infof("DeleteVolume called with request %+v", req)
 	volumeID := req.GetVolumeId()
 	if volumeID == "" {
 		return nil, status.Error(codes.InvalidArgument, "volume id is empty")
@@ -303,6 +305,7 @@ func (s *controllerServer) DeleteVolume(ctx context.Context, req *csi.DeleteVolu
 		response, err := s.config.multiShareController.DeleteVolume(ctx, req)
 		duration := time.Since(start)
 		s.config.metricsManager.RecordOperationMetrics(err, methodDeleteVolume, modeMultishare, duration)
+		klog.Infof("CreateVolume request %+v, response %+v error %v", req, response, err)
 		return response, err
 	}
 
diff --git a/pkg/csi_driver/multishare_controller.go b/pkg/csi_driver/multishare_controller.go
index 85524f40..3798b591 100644
--- a/pkg/csi_driver/multishare_controller.go
+++ b/pkg/csi_driver/multishare_controller.go
@@ -60,10 +60,6 @@ func NewMultishareController(driver *GCFSDriver, fileService file.Service, cloud
 	}
 }
 
-func (m *MultishareController) Run() {
-	m.opsManager.Run()
-}
-
 func (m *MultishareController) CreateVolume(ctx context.Context, req *csi.CreateVolumeRequest) (*csi.CreateVolumeResponse, error) {
 	name := req.GetName()
 	if len(name) == 0 {
@@ -78,6 +74,7 @@ func (m *MultishareController) CreateVolume(ctx context.Context, req *csi.Create
 		return nil, status.Error(codes.InvalidArgument, err.Error())
 	}
 
+	klog.Infof("CreateVolume called for multishare with request %+v", req)
 	if acquired := m.volumeLocks.TryAcquire(name); !acquired {
 		return nil, status.Errorf(codes.Aborted, util.VolumeOperationAlreadyExistsFmt, name)
 	}
@@ -102,12 +99,13 @@ func (m *MultishareController) CreateVolume(ctx context.Context, req *csi.Create
 	if err != nil {
 		return nil, status.Errorf(codes.Internal, err.Error())
 	}
-	// cache lock released. poll for op.
+	// lock released. poll for op.
 	err = m.cloud.File.WaitForOpWithOpts(ctx, workflow.opName, file.PollOpts{Timeout: timeout, Interval: pollInterval})
 	if err != nil {
 		return nil, status.Errorf(codes.Internal, "Create Volume failed, operation %q poll error: %v", workflow.opName, err)
 	}
 
+	klog.Infof("Poll for operation %s (type %s) completed", workflow.opName, workflow.opType.String())
 	if workflow.opType == util.ShareCreate {
 		return m.getShareAndGenerateCSIResponse(ctx, instanceScPrefix, workflow.share)
 	}
@@ -115,7 +113,7 @@ func (m *MultishareController) CreateVolume(ctx context.Context, req *csi.Create
 	var shareCreateWorkflow *Workflow
 	var newShare *file.Share
 	switch workflow.opType {
-	case util.InstanceCreate, util.InstanceExpand:
+	case util.InstanceCreate, util.InstanceUpdate:
 		newShare, err = generateNewShare(util.ConvertVolToShareName(req.Name), workflow.instance, req)
 		if err != nil {
 			return nil, err
@@ -128,7 +126,7 @@ func (m *MultishareController) CreateVolume(ctx context.Context, req *csi.Create
 		return nil, status.Errorf(codes.Internal, "Create Volume failed, unknown workflow %v detected", workflow.opType)
 	}
 
-	// cache lock released. poll for share create op.
+	// lock released. poll for share create op.
 	shareCreatetimeout, shareCreatePollInterval, err := util.GetMultishareOpsTimeoutConfig(shareCreateWorkflow.opType)
 	if err != nil {
 		return nil, status.Errorf(codes.Internal, err.Error())
@@ -137,30 +135,33 @@ func (m *MultishareController) CreateVolume(ctx context.Context, req *csi.Create
 	if err != nil {
 		return nil, status.Errorf(codes.Internal, "operation %q poll error: %v", workflow.opName, err)
 	}
-
 	return m.getShareAndGenerateCSIResponse(ctx, instanceScPrefix, newShare)
 }
 
 func (m *MultishareController) getShareAndGenerateCSIResponse(ctx context.Context, instancePrefix string, s *file.Share) (*csi.CreateVolumeResponse, error) {
-	share, err := m.fileService.GetShare(ctx, s)
+	share, err := m.cloud.File.GetShare(ctx, s)
 	if err != nil {
 		return nil, status.Errorf(codes.Internal, err.Error())
 	}
 
-	// TODO: do we need any further validation here?
+	if share.State != "READY" {
+		return nil, status.Errorf(codes.Aborted, "share %s not ready, state %s", share.Name, share.State)
+	}
 	return generateCSICreateVolumeResponse(instancePrefix, share)
 }
 
 func (m *MultishareController) DeleteVolume(ctx context.Context, req *csi.DeleteVolumeRequest) (*csi.DeleteVolumeResponse, error) {
+	prefix, project, location, instanceName, shareName, err := parseMultishareVolId(req.VolumeId)
+	if err != nil {
+		return nil, status.Error(codes.InvalidArgument, err.Error())
+	}
+	klog.V(4).Infof("DeleteVolume called for multishare with request %+v", req)
+
 	if acquired := m.volumeLocks.TryAcquire(req.VolumeId); !acquired {
 		return nil, status.Errorf(codes.Aborted, util.VolumeOperationAlreadyExistsFmt, req.VolumeId)
 	}
 	defer m.volumeLocks.Release(req.VolumeId)
 
-	prefix, project, location, instanceName, shareName, err := parseMultishareVolId(req.VolumeId)
-	if err != nil {
-		return nil, status.Error(codes.InvalidArgument, err.Error())
-	}
 	share, err := m.cloud.File.GetShare(ctx, &file.Share{
 		Parent: &file.MultishareInstance{
 			Project:  project,
@@ -170,9 +171,15 @@ func (m *MultishareController) DeleteVolume(ctx context.Context, req *csi.Delete
 		Name: shareName,
 	})
 	if err != nil {
-		if !file.IsNotFoundErr(err) {
+		// If share not found, proceed to instance/shrink check.
+		if file.IsNotFoundErr(err) {
+			err = m.startAndWaitForInstanceDeleteOrShrink(ctx, req.VolumeId)
+			if err != nil {
+				return nil, err
+			}
 			return &csi.DeleteVolumeResponse{}, nil
 		}
+
 		return nil, status.Error(codes.Internal, err.Error())
 	}
 
@@ -181,26 +188,62 @@ func (m *MultishareController) DeleteVolume(ctx context.Context, req *csi.Delete
 		return nil, err
 	}
 
-	if workflow == nil {
-		return &csi.DeleteVolumeResponse{}, nil
+	// Poll for share delete to complete
+	if workflow != nil {
+		shareDeletetimeout, shareDeletePollInterval, err := util.GetMultishareOpsTimeoutConfig(workflow.opType)
+		if err != nil {
+			return nil, status.Errorf(codes.Internal, err.Error())
+		}
+		err = m.cloud.File.WaitForOpWithOpts(ctx, workflow.opName, file.PollOpts{Timeout: shareDeletetimeout, Interval: shareDeletePollInterval})
+		if err != nil {
+			return nil, status.Errorf(codes.Internal, "operation %q poll error: %v", workflow.opName, err)
+		}
 	}
 
-	shareDeletetimeout, shareDeletePollInterval, err := util.GetMultishareOpsTimeoutConfig(workflow.opType)
+	// Check whether instance can be shrinked or deleted.
+	err = m.startAndWaitForInstanceDeleteOrShrink(ctx, req.VolumeId)
 	if err != nil {
-		return nil, status.Errorf(codes.Internal, err.Error())
+		return nil, err
 	}
-	err = m.cloud.File.WaitForOpWithOpts(ctx, workflow.opName, file.PollOpts{Timeout: shareDeletetimeout, Interval: shareDeletePollInterval})
+	return &csi.DeleteVolumeResponse{}, nil
+}
+
+func (m *MultishareController) startAndWaitForInstanceDeleteOrShrink(ctx context.Context, csiVolId string) error {
+	_, project, location, instanceName, _, err := parseMultishareVolId(csiVolId)
 	if err != nil {
-		return nil, status.Errorf(codes.Internal, "operation %q poll error: %v", workflow.opName, err)
+		return status.Error(codes.InvalidArgument, err.Error())
 	}
 
-	return &csi.DeleteVolumeResponse{}, nil
+	// Check whether instance can be shrinked or deleted.
+	workflow, err := m.opsManager.checkAndStartInstanceDeleteOrShrinkWorkflow(ctx, &file.MultishareInstance{
+		Project:  project,
+		Location: location,
+		Name:     instanceName,
+	})
+	if err != nil {
+		return err
+	}
+
+	// return if no-op
+	if workflow == nil {
+		return nil
+	}
+	instanceOpTimeout, instanceOpPollInterval, err := util.GetMultishareOpsTimeoutConfig(workflow.opType)
+	if err != nil {
+		return status.Errorf(codes.Internal, err.Error())
+	}
+	err = m.cloud.File.WaitForOpWithOpts(ctx, workflow.opName, file.PollOpts{Timeout: instanceOpTimeout, Interval: instanceOpPollInterval})
+	if err != nil {
+		return status.Errorf(codes.Internal, "operation %q poll error: %v", workflow.opName, err)
+	}
+	return nil
 }
 
 func (m *MultishareController) ControllerExpandVolume(ctx context.Context, req *csi.CreateVolumeRequest) (*csi.CreateVolumeResponse, error) {
 	// Handle higher level csi params validation, try locks
 	// Initiate share workflow by calling Multishare OpsManager functions
 	// Prepare and return csi response
+	// TODO
 	return nil, status.Error(codes.Unimplemented, "ControllerExpandVolume unsupported for multi share instances")
 }
 
@@ -289,10 +332,11 @@ func generateNewShare(name string, parent *file.MultishareInstance, req *csi.Cre
 		return nil, status.Error(codes.InvalidArgument, err.Error())
 	}
 	return &file.Share{
-		Name:          name,
-		Parent:        parent,
-		CapacityBytes: targetSizeBytes,
-		Labels:        extractShareLabels(req.Parameters),
+		Name:           name,
+		Parent:         parent,
+		CapacityBytes:  targetSizeBytes,
+		Labels:         extractShareLabels(req.Parameters),
+		MountPointName: name,
 	}, nil
 }
 
@@ -421,6 +465,7 @@ func generateCSICreateVolumeResponse(instancePrefix string, s *file.Share) (*csi
 			},
 		},
 	}
+	klog.Infof("CreateVolume resp: %+v", resp)
 	return resp, nil
 }
 
diff --git a/pkg/csi_driver/multishare_ops_manager.go b/pkg/csi_driver/multishare_ops_manager.go
index 1c091d40..3a4fcd83 100644
--- a/pkg/csi_driver/multishare_ops_manager.go
+++ b/pkg/csi_driver/multishare_ops_manager.go
@@ -18,11 +18,14 @@ package driver
 
 import (
 	"context"
+	"encoding/json"
 	"fmt"
 	"math/rand"
+	"strings"
 	"sync"
 
 	"github.com/container-storage-interface/spec/lib/go/csi"
+	filev1beta1multishare "google.golang.org/api/file/v1beta1multishare"
 	"google.golang.org/grpc/codes"
 	"google.golang.org/grpc/status"
 	"k8s.io/klog"
@@ -31,7 +34,13 @@ import (
 	"sigs.k8s.io/gcp-filestore-csi-driver/pkg/util"
 )
 
-// A workflow is defined as a sequence of steps to safely (by checking the storage class cache) initiate instance or share operations.
+type OpInfo struct {
+	Id     string
+	Type   util.OperationType
+	Target string
+}
+
+// A workflow is defined as a sequence of steps to safely initiate instance or share operations.
 type Workflow struct {
 	instance *file.MultishareInstance
 	share    *file.Share
@@ -39,25 +48,18 @@ type Workflow struct {
 	opName   string
 }
 
-// MultishareOpsManager manages storage class cache, manages the lifecycle of all instance and share operations.
+// MultishareOpsManager manages the lifecycle of all instance and share operations.
 type MultishareOpsManager struct {
-	sync.Mutex // Lock to perform thread safe operations on the cache.
-	cache      *util.StorageClassInfoCache
+	sync.Mutex // Lock to perform thread safe multishare operations.
 	cloud      *cloud.Cloud
 }
 
 func NewMultishareOpsManager(cloud *cloud.Cloud) *MultishareOpsManager {
 	return &MultishareOpsManager{
-		cache: util.NewStorageClassInfoCache(),
 		cloud: cloud,
 	}
 }
 
-func (m *MultishareOpsManager) Run() {
-	// TODO: Start periodic cache hydration
-	// TODO: Start periodic instance inspection for delete and shrink
-}
-
 // setupEligibleInstanceAndStartWorkflow returns a workflow object (to indicate an instance or share level workflow is started), or a share object (if existing share already found), or error.
 func (m *MultishareOpsManager) setupEligibleInstanceAndStartWorkflow(ctx context.Context, req *csi.CreateVolumeRequest, instance *file.MultishareInstance) (*Workflow, *file.Share, error) {
 	m.Lock()
@@ -70,41 +72,30 @@ func (m *MultishareOpsManager) setupEligibleInstanceAndStartWorkflow(ctx context
 		return nil, nil, status.Error(codes.InvalidArgument, err.Error())
 	}
 
-	// Check if there is already a share create op in progress.
-	lastShareCreateOpInfo, opStatus, err := m.checkAndUpdateShareCreateOp(ctx, instanceScPrefix, shareName)
+	ops, err := m.listMultishareResourceRunningOps(ctx)
 	if err != nil {
-		return nil, nil, err
+		return nil, nil, status.Error(codes.Internal, err.Error())
 	}
-
-	if lastShareCreateOpInfo != nil {
-		switch opStatus {
-		case util.StatusRunning:
-			return nil, nil, status.Errorf(codes.Aborted, "Share create operation %q in progress", lastShareCreateOpInfo.OpName)
-		case util.StatusFailed:
-			return nil, nil, status.Errorf(codes.Internal, "Share create operation %q failed", lastShareCreateOpInfo.OpName)
-		case util.StatusSuccess:
-			share, err := m.validateShareExists(ctx, lastShareCreateOpInfo.InstanceHandle, shareName)
-			if err != nil {
-				return nil, nil, err
-			}
-			return nil, share, nil
-		default:
-			return nil, nil, status.Errorf(codes.Internal, "unknown op status %d for op %v", opStatus, lastShareCreateOpInfo.OpName)
-		}
+	createShareOp := containsOpWithShareName(shareName, util.ShareCreate, ops)
+	if createShareOp != nil {
+		msg := fmt.Sprintf("Share create op %s in progress", createShareOp.Id)
+		klog.Infof(msg)
+		return nil, nil, status.Error(codes.Aborted, msg)
 	}
 
 	// Check if share already part of an existing instance.
-	share, err := m.checkInstanceListForShare(ctx, instanceScPrefix, shareName)
+	shares, err := m.cloud.File.ListShares(ctx, &file.ListFilter{Project: m.cloud.Project, Location: "-", InstanceName: "-"})
 	if err != nil {
 		return nil, nil, err
 	}
-
-	if share != nil {
-		return nil, share, nil
+	for _, s := range shares {
+		if s.Name == shareName {
+			return nil, s, nil
+		}
 	}
 
 	// No share or running share create op fouund. Proceed to eligible instance check.
-	eligible, numIneligible, err := m.runEligibleInstanceCheck(ctx, instanceScPrefix)
+	eligible, numIneligible, err := m.runEligibleInstanceCheck(ctx, instanceScPrefix, ops)
 	if err != nil {
 		return nil, nil, status.Error(codes.InvalidArgument, err.Error())
 	}
@@ -112,6 +103,7 @@ func (m *MultishareOpsManager) setupEligibleInstanceAndStartWorkflow(ctx context
 	if len(eligible) > 0 {
 		// pick a random eligible instance
 		index := rand.Intn(len(eligible))
+		klog.V(5).Infof("For share %s, using instance %s as placeholder", shareName, eligible[index].String())
 		share, err := generateNewShare(shareName, eligible[index], req)
 		if err != nil {
 			return nil, nil, status.Error(codes.Internal, err.Error())
@@ -124,11 +116,11 @@ func (m *MultishareOpsManager) setupEligibleInstanceAndStartWorkflow(ctx context
 
 		if needExpand {
 			eligible[index].CapacityBytes = targetBytes
-			w, err := m.startInstanceWorkflow(ctx, instanceScPrefix, &Workflow{instance: eligible[index], opType: util.InstanceExpand})
+			w, err := m.startInstanceWorkflow(ctx, &Workflow{instance: eligible[index], opType: util.InstanceUpdate}, ops)
 			return w, nil, err
 		}
 
-		w, err := m.startShareCreateWorkflow(ctx, instanceScPrefix, share)
+		w, err := m.startShareWorkflow(ctx, &Workflow{share: share, opType: util.ShareCreate}, ops)
 		return w, nil, err
 	}
 
@@ -137,136 +129,89 @@ func (m *MultishareOpsManager) setupEligibleInstanceAndStartWorkflow(ctx context
 		return nil, nil, status.Errorf(codes.Aborted, " %d non-ready instances detected. No ready instance found", numIneligible)
 	}
 
-	w, err := m.startInstanceWorkflow(ctx, instanceScPrefix, &Workflow{instance: instance, opType: util.InstanceCreate})
+	w, err := m.startInstanceWorkflow(ctx, &Workflow{instance: instance, opType: util.InstanceCreate}, ops)
 	return w, nil, err
 }
 
-// checkAndUpdateShareCreateOp checks the share create op map, and evaluates the running status of the ops. If ops are detected as complete, they are removed as part of the check.
-func (m *MultishareOpsManager) checkAndUpdateShareCreateOp(ctx context.Context, instanceScPrefix, shareName string) (*util.ShareCreateOpInfo, util.OperationStatus, error) {
-	opInfo := m.cache.GetShareCreateOp(instanceScPrefix, shareName)
-	if opInfo == nil {
-		return nil, util.StatusUnknown, nil
-	}
-
-	op, err := m.cloud.File.GetOp(ctx, opInfo.OpName)
-	if err != nil && !file.IsNotFoundErr(err) {
-		return opInfo, util.StatusUnknown, status.Errorf(codes.Internal, "Failed to get operation %q", opInfo.OpName)
-	}
-
-	done, err := m.cloud.File.IsOpDone(op)
-	if err != nil {
-		// op completed with error.
-		// clear cache and return retry error to the caller.
-		m.cache.DeleteShareCreateOp(instanceScPrefix, shareName, opInfo.OpName)
-		return opInfo, util.StatusFailed, nil
-	}
-
-	if !done {
-		return opInfo, util.StatusRunning, nil
-	}
-
-	// Clear cache.
-	m.cache.DeleteShareCreateOp(instanceScPrefix, shareName, opInfo.OpName)
-	return opInfo, util.StatusSuccess, nil
-}
-
-// checkAndUpdateShareOp checks the share ops map, and evaluates the running status of the ops. If ops are detected as complete, they are removed as part of the check.
-func (m *MultishareOpsManager) checkAndUpdateShareOp(ctx context.Context, instanceScPrefix string, share *file.Share) (*util.OpInfo, util.OperationStatus, error) {
-	shareKey := util.CreateShareKey(share.Parent.Project, share.Parent.Location, share.Parent.Name, share.Name)
-	opInfo := m.cache.GetShareOp(instanceScPrefix, shareKey)
-	if opInfo == nil {
-		return nil, util.StatusUnknown, nil
-	}
-
-	op, err := m.cloud.File.GetOp(ctx, opInfo.Name)
-	if err != nil && !file.IsNotFoundErr(err) {
-		return opInfo, util.StatusUnknown, status.Errorf(codes.Internal, "Failed to get operation %q", opInfo.Name)
-	}
-
-	done, err := m.cloud.File.IsOpDone(op)
-	if err != nil {
-		// op completed with error.
-		// clear cache and return retry error to the caller.
-		m.cache.DeleteShareOp(instanceScPrefix, shareKey, opInfo.Name)
-		return opInfo, util.StatusFailed, nil
-	}
-
-	if !done {
-		return opInfo, util.StatusRunning, nil
-	}
-
-	// Clear cache.
-	m.cache.DeleteShareOp(instanceScPrefix, shareKey, opInfo.Name)
-	return opInfo, util.StatusSuccess, nil
-}
-
 func (m *MultishareOpsManager) startShareCreateWorkflowSafe(ctx context.Context, instanceSCPrefix string, share *file.Share) (*Workflow, error) {
 	m.Lock()
 	defer m.Unlock()
-	return m.startShareCreateWorkflow(ctx, instanceSCPrefix, share)
-}
+	ops, err := m.listMultishareResourceRunningOps(ctx)
+	if err != nil {
+		return nil, status.Error(codes.Internal, err.Error())
+	}
 
-func (m *MultishareOpsManager) startShareCreateWorkflow(ctx context.Context, instanceSCPrefix string, share *file.Share) (*Workflow, error) {
-	return m.startShareWorkflow(ctx, instanceSCPrefix, &Workflow{
-		share:  share,
-		opType: util.ShareCreate,
-	})
+	return m.startShareWorkflow(ctx, &Workflow{share: share, opType: util.ShareCreate}, ops)
 }
 
-func (m *MultishareOpsManager) startInstanceWorkflow(ctx context.Context, instanceSCPrefix string, w *Workflow) (*Workflow, error) {
-	// This function has 3 distinct steps:
-	// 1. verify no instance ops running for the given instance.
-	// 2. verify no running share ops for the shares hosted on the given instance.
-	// 3. Start the instance op.
+func (m *MultishareOpsManager) startInstanceWorkflow(ctx context.Context, w *Workflow, ops []*OpInfo) (*Workflow, error) {
+	// This function has 2 steps:
+	// 1. verify no instance ops or share (belonging to the instance) ops running for the given instance.
+	// 2. Start the instance op.
 	if w.instance == nil {
 		return nil, status.Errorf(codes.Internal, "instance not found in workflow object")
 	}
 
-	instanceReady, err := m.verifyNoRunningInstanceOps(ctx, instanceSCPrefix, w.instance)
+	err := m.verifyNoRunningInstanceOrShareOpsForInstance(w.instance, ops)
 	if err != nil {
-		return nil, status.Errorf(codes.Aborted, "Instance %q check error: %v", w.instance.Name, err)
-	}
-	if !instanceReady {
-		return nil, status.Errorf(codes.Aborted, "Instance %q not ready", w.instance.Name)
-	}
-
-	// Verify no ongoing share ops for the instance. Also clear finised ops from cache, while doing verification.
-	instanceReady, err = m.verifyNoRunningShareOpsForInstance(ctx, instanceSCPrefix, w.instance)
-	if err != nil {
-		return nil, status.Errorf(codes.Internal, "Failed to check share ops for Instance %q, error: %v", w.instance.Name, err)
-	}
-	if !instanceReady {
-		return nil, status.Errorf(codes.Aborted, "Instance %q not ready", w.instance.Name)
+		return nil, err
 	}
-
 	switch w.opType {
 	case util.InstanceCreate:
 		op, err := m.cloud.File.StartCreateMultishareInstanceOp(ctx, w.instance)
 		if err != nil {
-			return nil, status.Errorf(codes.Internal, err.Error())
+			return nil, err
 		}
 		w.opName = op.Name
-	case util.InstanceExpand:
+	case util.InstanceUpdate:
 		op, err := m.cloud.File.StartResizeMultishareInstanceOp(ctx, w.instance)
 		if err != nil {
-			return nil, status.Errorf(codes.Internal, err.Error())
+			return nil, err
 		}
 		w.opName = op.Name
 	case util.InstanceDelete:
 		op, err := m.cloud.File.StartDeleteMultishareInstanceOp(ctx, w.instance)
 		if err != nil {
-			return nil, status.Errorf(codes.Internal, err.Error())
+			return nil, err
 		}
 		w.opName = op.Name
 	default:
-		return nil, status.Errorf(codes.Internal, "for instance workflow, unknown op type %v", w.opType)
+		return nil, status.Errorf(codes.Internal, "for instance workflow, unknown op type %s", w.opType.String())
 	}
 
-	m.cache.AddInstanceOp(instanceSCPrefix, util.CreateInstanceKey(w.instance.Project, w.instance.Location, w.instance.Name), util.OpInfo{Name: w.opName, Type: w.opType})
 	return w, nil
 }
 
-func (m *MultishareOpsManager) startShareWorkflow(ctx context.Context, instanceSCPrefix string, w *Workflow) (*Workflow, error) {
+func (m *MultishareOpsManager) verifyNoRunningInstanceOps(instance *file.MultishareInstance, ops []*OpInfo) error {
+	instanceUri, err := file.GenerateMultishareInstanceURI(instance)
+	if err != nil {
+		return status.Errorf(codes.Internal, "failed to parse instance handle, err: %v", err)
+	}
+
+	for _, op := range ops {
+		if op.Target == instanceUri {
+			return status.Errorf(codes.Aborted, "Found running op %s type %s for target resource %s", op.Id, op.Type.String(), op.Target)
+		}
+	}
+
+	return nil
+}
+
+func (m *MultishareOpsManager) verifyNoRunningShareOps(share *file.Share, ops []*OpInfo) error {
+	shareUri, err := file.GenerateShareURI(share)
+	if err != nil {
+		return status.Errorf(codes.Internal, "failed to parse share handle, err: %v", err)
+	}
+	for _, op := range ops {
+		if op.Target == shareUri {
+			return status.Errorf(codes.Aborted, "Found running op %s type %s for target resource %s", op.Id, op.Type.String(), op.Target)
+		}
+	}
+
+	return nil
+}
+
+func (m *MultishareOpsManager) startShareWorkflow(ctx context.Context, w *Workflow, ops []*OpInfo) (*Workflow, error) {
 	// This function has 3 distinct steps:
 	// 1. verify no instance ops running for the instance hosting the given share.
 	// 2. verify no running ops for the given share.
@@ -280,73 +225,33 @@ func (m *MultishareOpsManager) startShareWorkflow(ctx context.Context, instanceS
 	}
 
 	// verify instance is ready.
-	instanceReady, err := m.verifyNoRunningInstanceOps(ctx, instanceSCPrefix, w.share.Parent)
+	err := m.verifyNoRunningInstanceOps(w.share.Parent, ops)
 	if err != nil {
-		return nil, status.Errorf(codes.Internal, "Instance %q check error: %v", w.share.Parent.Name, err)
-	}
-	if !instanceReady {
-		return nil, status.Errorf(codes.Aborted, "Instance %q not ready", w.share.Parent.Name)
+		return nil, err
 	}
-
 	// Verify share is ready.
-	shareReady, err := m.verifyNoRunningShareOp(ctx, instanceSCPrefix, w.share)
+	err = m.verifyNoRunningShareOps(w.share, ops)
 	if err != nil {
-		return nil, status.Errorf(codes.Internal, "Share %q check error: %v", w.share.Name, err)
-	}
-	if !shareReady {
-		return nil, status.Errorf(codes.Aborted, "Share %q not ready", w.share.Name)
+		return nil, err
 	}
-
 	switch w.opType {
 	case util.ShareCreate:
-		// validate no entry in cache for the share
-		item := m.cache.GetShareCreateOp(instanceSCPrefix, w.share.Name)
-		if item != nil {
-			return nil, status.Errorf(codes.Aborted, "Share %q not ready, found op %q", w.share.Name, item.OpName)
-		}
-
 		op, err := m.cloud.File.StartCreateShareOp(ctx, w.share)
 		if err != nil {
-			return nil, status.Errorf(codes.Internal, err.Error())
+			return nil, err
 		}
-
-		// Start op and update cache
-		instanceHandle, err := file.GetMultishareInstanceHandle(w.share.Parent)
-		if err != nil {
-			return nil, status.Errorf(codes.Internal, err.Error())
-		}
-		m.cache.AddShareCreateOp(instanceSCPrefix, w.share.Name, util.ShareCreateOpInfo{
-			InstanceHandle: instanceHandle,
-			OpName:         op.Name,
-		})
 		w.opName = op.Name
-	case util.ShareExpand:
-		// validate no entry in cache for the share
-		item := m.cache.GetShareOp(instanceSCPrefix, util.CreateShareKey(w.share.Parent.Project, w.share.Parent.Location, w.share.Parent.Name, w.share.Name))
-		if item != nil {
-			return nil, status.Errorf(codes.Aborted, "Share %q not ready, found op %q", w.share.Name, item.Name)
-		}
-
-		// Start op and update cache
+	case util.ShareUpdate:
 		op, err := m.cloud.File.StartResizeShareOp(ctx, w.share)
 		if err != nil {
-			return nil, status.Errorf(codes.Internal, err.Error())
+			return nil, err
 		}
-		m.cache.AddShareOp(instanceSCPrefix, util.CreateShareKey(w.share.Parent.Project, w.share.Parent.Location, w.share.Parent.Name, w.share.Name), util.OpInfo{Name: op.Name, Type: w.opType})
 		w.opName = op.Name
 	case util.ShareDelete:
-		// validate no entry in cache for the share
-		item := m.cache.GetShareOp(instanceSCPrefix, util.CreateShareKey(w.share.Parent.Project, w.share.Parent.Location, w.share.Parent.Name, w.share.Name))
-		if item != nil {
-			return nil, status.Errorf(codes.Aborted, "Share %q not ready, found op %q", w.share.Name, item.Name)
-		}
-
-		// Start op and update cache
 		op, err := m.cloud.File.StartDeleteShareOp(ctx, w.share)
 		if err != nil {
-			return nil, status.Errorf(codes.Internal, err.Error())
+			return nil, err
 		}
-		m.cache.AddShareOp(instanceSCPrefix, util.CreateShareKey(w.share.Parent.Project, w.share.Parent.Location, w.share.Parent.Name, w.share.Name), util.OpInfo{Name: op.Name, Type: w.opType})
 		w.opName = op.Name
 	default:
 		return nil, status.Errorf(codes.Internal, "for share workflow, unknown op type %v", w.opType)
@@ -354,253 +259,265 @@ func (m *MultishareOpsManager) startShareWorkflow(ctx context.Context, instanceS
 	return w, nil
 }
 
-func (m *MultishareOpsManager) verifyNoRunningInstanceOps(ctx context.Context, instanceSCPrefix string, instance *file.MultishareInstance) (bool, error) {
-	opInfo := m.cache.GetInstanceOp(instanceSCPrefix, util.CreateInstanceKey(instance.Project, instance.Location, instance.Name))
-	if opInfo == nil {
-		return true, nil
-	}
-	if opInfo.Name == "" {
-		return true, nil
-	}
-
-	op, err := m.cloud.File.GetOp(ctx, opInfo.Name)
-	if err != nil && !file.IsNotFoundErr(err) {
-		return false, err
-	}
-
-	// This method returns error if op completed with error. Instance is still considered ready since op completed.
-	done, _ := m.cloud.File.IsOpDone(op)
-	if done {
-		m.cache.DeleteInstanceOp(instanceSCPrefix, util.CreateInstanceKey(instance.Project, instance.Location, instance.Name), opInfo.Name)
-	}
-	return done, nil
-}
-
-func (m *MultishareOpsManager) verifyNoRunningShareOp(ctx context.Context, instanceScPrefix string, share *file.Share) (bool, error) {
-	shareCreateOpInfo, shareCreateOpStatus, err := m.checkAndUpdateShareCreateOp(ctx, instanceScPrefix, share.Name)
+func (m *MultishareOpsManager) verifyNoRunningInstanceOrShareOpsForInstance(instance *file.MultishareInstance, ops []*OpInfo) error {
+	instanceUri, err := file.GenerateMultishareInstanceURI(instance)
 	if err != nil {
-		return false, err
+		return status.Errorf(codes.Internal, "failed to parse instance handle, err: %v", err)
 	}
-	shareCreateopRunning := (shareCreateOpInfo != nil && shareCreateOpStatus == util.StatusRunning)
 
-	shareOpInfo, shareOpStatus, err := m.checkAndUpdateShareOp(ctx, instanceScPrefix, share)
-	if err != nil {
-		return false, err
+	// Check for instance prefix in op target.
+	for _, op := range ops {
+		if op.Target == instanceUri || strings.Contains(op.Target, instanceUri+"/") {
+			return status.Errorf(codes.Aborted, "Found running op %s, type %s, for target resource %s", op.Id, op.Type.String(), op.Target)
+		}
 	}
-
-	shareOpRunning := (shareOpInfo != nil && shareOpStatus == util.StatusRunning)
-	return (!shareCreateopRunning && !shareOpRunning), nil
+	return nil
 }
 
-func (m *MultishareOpsManager) verifyNoRunningShareOpsForInstance(ctx context.Context, instanceScPrefix string, instance *file.MultishareInstance) (bool, error) {
-	targetInstanceHandle, err := file.GetMultishareInstanceHandle(instance)
+// runEligibleInstanceCheck returns a list of ready and non-ready instances.
+func (m *MultishareOpsManager) runEligibleInstanceCheck(ctx context.Context, instanceScPrefix string, ops []*OpInfo) ([]*file.MultishareInstance, int, error) {
+	instances, err := m.listInstanceForStorageClassPrefix(ctx, instanceScPrefix)
 	if err != nil {
-		return false, err
+		return nil, 0, err
 	}
-	for _, item := range m.cache.GetShareCreateMap(instanceScPrefix).Items() {
-		if item.OpInfo.InstanceHandle != targetInstanceHandle {
-			continue
-		}
-		shareCreateOpInfo, shareCreateOpStatus, err := m.checkAndUpdateShareCreateOp(ctx, instanceScPrefix, item.Key)
+	var readyEligibleInstances []*file.MultishareInstance
+	nonReadyInstanceCount := 0
+	for _, instance := range instances {
+		op, err := containsOpWithInstanceTargetPrefix(instance, ops)
 		if err != nil {
-			return false, err
-		}
-		if shareCreateOpInfo != nil && shareCreateOpStatus == util.StatusRunning {
-			return false, nil
+			klog.Errorf("failed to check eligibility of instance %s", instance.Name)
+			continue
 		}
-	}
 
-	for _, item := range m.cache.GetShareOpsMap(instanceScPrefix).Items() {
-		shareHandle := item.Key
-		if !containsInstancePrefix(string(shareHandle), instance.Project, instance.Location, instance.Name) {
+		if op == nil {
+			shares, err := m.cloud.File.ListShares(ctx, &file.ListFilter{Project: instance.Project, Location: instance.Location, InstanceName: instance.Name})
+			if err != nil {
+				klog.Errorf("Failed to list shares of instance %s/%s/%s, err:%v", instance.Project, instance.Location, instance.Name, err)
+				continue
+			}
+			if len(shares) >= util.MaxSharesPerInstance {
+				continue
+			}
+
+			readyEligibleInstances = append(readyEligibleInstances, instance)
+			klog.Infof("Adding instance %s to eligible list", instance.String())
 			continue
 		}
 
-		_, _, _, shareName, err := util.ParseShareHandle(string(item.Key))
-		if err != nil {
-			return false, err
+		// instances whose delete is in progress should not be accounted as non-ready instances.
+		if op.Type == util.InstanceDelete {
+			continue
 		}
 
-		opInfo, status, err := m.checkAndUpdateShareOp(ctx, instanceScPrefix, &file.Share{Parent: instance, Name: shareName})
-		if err != nil {
-			return false, err
-		}
-		if opInfo != nil && status == util.StatusRunning {
-			return false, nil
+		if instance.State == "DELETING" {
+			continue
 		}
+		nonReadyInstanceCount += 1
+		// TODO: If we see > 1 instances with 0 shares (these could be possibly leaked instances where the driver hit timeout during creation op was in progress), should we trigger delete op for such instances? Possibly yes. Given that instance create/delete and share create/delete is serialized, maybe yes.
 	}
 
-	return true, nil
+	return readyEligibleInstances, nonReadyInstanceCount, nil
 }
 
-func (m *MultishareOpsManager) validateShareExists(ctx context.Context, instanceHandle, shareName string) (*file.Share, error) {
-	project, location, instanceName, err := util.ParseInstanceHandle(instanceHandle)
+func (m *MultishareOpsManager) instanceNeedsExpand(ctx context.Context, share *file.Share) (bool, int64, error) {
+	if share == nil {
+		return false, 0, fmt.Errorf("empty share")
+	}
+	if share.Parent == nil {
+		return false, 0, fmt.Errorf("Parent missing from share %q", share.Name)
+	}
+
+	shares, err := m.cloud.File.ListShares(ctx, &file.ListFilter{Project: share.Parent.Project, Location: share.Parent.Location, InstanceName: share.Parent.Name})
 	if err != nil {
-		return nil, status.Errorf(codes.Internal, "failed to parse instance handle %v", instanceHandle)
+		return false, 0, err
 	}
 
-	return m.cloud.File.GetShare(ctx, &file.Share{
-		Name: shareName,
-		Parent: &file.MultishareInstance{
-			Project:  project,
-			Location: location,
-			Name:     instanceName,
-		},
-	})
+	var sumShareBytes int64
+	for _, s := range shares {
+		sumShareBytes = sumShareBytes + s.CapacityBytes
+	}
+	// TODO: Check if we need to align the increment to step size.
+	var remainingBytes int64
+	remainingBytes = share.Parent.CapacityBytes - sumShareBytes
+	if remainingBytes < share.CapacityBytes {
+		return true, (share.CapacityBytes + sumShareBytes), nil
+	}
+	return false, 0, nil
 }
 
-func (m *MultishareOpsManager) checkInstanceListForShare(ctx context.Context, instanceScPrefix string, targetShareName string) (*file.Share, error) {
-	for _, item := range m.cache.GetInstanceMap(instanceScPrefix).Items() {
-		project, location, instanceName, err := util.ParseInstanceHandle(string(item.Key))
-		if err != nil {
-			return nil, status.Errorf(codes.Internal, "failed to parse instance key %q, err: %v", item.Key, err)
-		}
-
-		shares, err := m.cloud.File.ListShares(ctx, &file.ListFilter{Project: project, Location: location, InstanceName: instanceName})
-		// TODO: verify a list on a non existent instance would return not found error. or we need to check GET instance before listing shares.
-		if err != nil && !file.IsNotFoundErr(err) {
-			return nil, status.Errorf(codes.Internal, "failed to list shares for Instance %q, err: %v", item.Key, err)
-		}
+func (m *MultishareOpsManager) checkAndStartShareDeleteWorkflow(ctx context.Context, instanceScPrefix string, share *file.Share) (*Workflow, error) {
+	m.Lock()
+	defer m.Unlock()
 
-		for _, share := range shares {
-			_, _, _, shareName, err := file.ParseShare(share)
-			if err != nil {
-				return nil, status.Errorf(codes.Internal, "failed to parse share URI, err: %v", err)
-			}
+	ops, err := m.listMultishareResourceRunningOps(ctx)
+	if err != nil {
+		return nil, status.Error(codes.Internal, err.Error())
+	}
 
-			if shareName == targetShareName {
-				return share, nil
-			}
-		}
+	// If we find a running delete share op, poll for that to complete.
+	deleteshareop, err := containsOpWithShareTarget(share, util.ShareDelete, ops)
+	if err != nil {
+		return nil, err
+	}
+	if deleteshareop != nil {
+		return &Workflow{share: share, opName: deleteshareop.Id, opType: deleteshareop.Type}, nil
 	}
 
-	return nil, nil
+	return m.startShareWorkflow(ctx, &Workflow{share: share, opType: util.ShareDelete}, ops)
 }
 
-// runEligibleInstanceCheck returns a list of ready and non-ready instances.
-func (m *MultishareOpsManager) runEligibleInstanceCheck(ctx context.Context, instanceScPrefix string) ([]*file.MultishareInstance, int, error) {
-	var readyInstanceKeys []util.InstanceKey
-	nonReadyInstanceCount := 0
-	items := m.cache.GetInstanceMap(instanceScPrefix).Items()
-	for _, item := range items {
-		instanceKey := item.Key
-		opInfo := item.OpInfo
-		project, location, instanceName, err := util.ParseInstanceHandle(string(instanceKey))
-		if err != nil {
-			klog.Warningf("Failed to parse instance key %v", instanceKey)
-			continue
-		}
-		if opInfo.Name == "" {
-			readyInstanceKeys = append(readyInstanceKeys, instanceKey)
-			continue
-		}
+func (m *MultishareOpsManager) checkAndStartInstanceDeleteOrShrinkWorkflow(ctx context.Context, instance *file.MultishareInstance) (*Workflow, error) {
+	m.Lock()
+	defer m.Unlock()
 
-		// check and clear completed op
-		ready, err := m.verifyNoRunningInstanceOps(ctx, instanceScPrefix, &file.MultishareInstance{
-			Project:  project,
-			Location: location,
-			Name:     instanceName,
-		})
-		if err != nil {
-			klog.Warningf("Failed to check instance ready for instance key %v, err:%v", instanceKey, err)
-		}
+	ops, err := m.listMultishareResourceRunningOps(ctx)
+	if err != nil {
+		return nil, status.Error(codes.Internal, err.Error())
+	}
+
+	err = m.verifyNoRunningInstanceOrShareOpsForInstance(instance, ops)
+	if err != nil {
+		return nil, err
+	}
 
-		if !ready && opInfo.Type != util.InstanceDelete {
-			nonReadyInstanceCount = nonReadyInstanceCount + 1
+	// At this point no new share create or delete would be attempted since the driver has the lock.
+	// 1. GET instance . if not found its a no-op return success.
+	// 2. evaluate 0 shares.
+	// 3. else evaluate instance size with share size sum.
+	instance, err = m.cloud.File.GetMultishareInstance(ctx, instance)
+	if err != nil {
+		if file.IsNotFoundErr(err) {
+			return nil, nil
 		}
+		return nil, status.Error(codes.Internal, err.Error())
+	}
 
-		if ready {
-			readyInstanceKeys = append(readyInstanceKeys, instanceKey)
+	shares, err := m.cloud.File.ListShares(ctx, &file.ListFilter{Project: instance.Project, Location: instance.Location, InstanceName: instance.Name})
+	if err != nil {
+		if file.IsNotFoundErr(err) {
+			return nil, nil
 		}
+		return nil, status.Error(codes.Internal, err.Error())
 	}
 
-	var eligibleReadyInstances []*file.MultishareInstance
-	for _, instanceKey := range readyInstanceKeys {
-		project, location, instanceName, err := util.ParseInstanceHandle(string(instanceKey))
+	// Check for delete
+	if len(shares) == 0 {
+		w, err := m.startInstanceWorkflow(ctx, &Workflow{instance: instance, opType: util.InstanceDelete}, ops)
 		if err != nil {
-			klog.Warningf("Failed to parse instance key %v", instanceKey)
-			continue
+			if file.IsNotFoundErr(err) {
+				return nil, nil
+			}
+			return nil, status.Error(codes.Internal, err.Error())
 		}
+		return w, err
+	}
 
-		instance, err := m.cloud.File.GetMultishareInstance(ctx, &file.MultishareInstance{
-			Project:  project,
-			Location: location,
-			Name:     instanceName,
-		})
+	// check for shrink
+	var totalShareCap int64
+	for _, share := range shares {
+		totalShareCap += share.CapacityBytes
+	}
+	if totalShareCap < instance.CapacityBytes && instance.CapacityBytes > util.MinMultishareInstanceSizeBytes {
+		instance.CapacityBytes = util.Max(totalShareCap, util.MinMultishareInstanceSizeBytes)
+		w, err := m.startInstanceWorkflow(ctx, &Workflow{instance: instance, opType: util.InstanceUpdate}, ops)
 		if err != nil {
 			if file.IsNotFoundErr(err) {
-				klog.Infof("Instance %v not found, clear from map", instanceKey)
-				m.cache.DeleteInstance(instanceScPrefix, instanceKey)
-			} else {
-				klog.Warningf("Failed to GET for instance key %v, err:%v", instanceKey, err)
+				return nil, nil
 			}
+			return nil, status.Error(codes.Internal, err.Error())
+		}
+		return w, err
+	}
+
+	return nil, nil
+}
+
+// listMultishareOps reports all running ops related to multishare instances and share resources. The op target is of the form "projects/<>/locations/<>/instances/<>" or "projects/<>/locations/<>/instances/<>/shares/<>"
+func (m *MultishareOpsManager) listMultishareResourceRunningOps(ctx context.Context) ([]*OpInfo, error) {
+	ops, err := m.cloud.File.ListOps(ctx, &file.ListFilter{Project: m.cloud.Project, Location: "-"})
+	if err != nil {
+		return nil, err
+	}
+
+	var finalops []*OpInfo
+	for _, op := range ops {
+		if op.Done {
 			continue
 		}
 
-		shares, err := m.cloud.File.ListShares(ctx, &file.ListFilter{Project: project, Location: location, InstanceName: instanceName})
-		// TODO: verify what is the behavior for 0 share instance? i.e. len(shares)=0, err = nil?
-		if err != nil {
-			klog.Warningf("failed to list shares for Instance %q, err: %v", instanceKey, err)
+		if op.Metadata == nil {
 			continue
 		}
 
-		if len(shares) < util.MaxSharesPerInstance {
-			eligibleReadyInstances = append(eligibleReadyInstances, instance)
+		var meta filev1beta1multishare.OperationMetadata
+		if err := json.Unmarshal(op.Metadata, &meta); err != nil {
+			klog.Errorf("Failed to parse metadata for op %s", op.Name)
+			continue
 		}
-	}
 
-	return eligibleReadyInstances, nonReadyInstanceCount, nil
+		if file.IsInstanceTarget(meta.Target) {
+			finalops = append(finalops, &OpInfo{Id: op.Name, Target: meta.Target, Type: util.ConvertInstanceOpVerbToType(meta.Verb)})
+		} else if file.IsShareTarget(meta.Target) {
+			finalops = append(finalops, &OpInfo{Id: op.Name, Target: meta.Target, Type: util.ConvertShareOpVerbToType(meta.Verb)})
+		}
+		// TODO: Add other resource types if needed, when we support snapshot/backups.
+	}
+	return finalops, nil
 }
 
-func (m *MultishareOpsManager) instanceNeedsExpand(ctx context.Context, share *file.Share) (bool, int64, error) {
-	if share == nil {
-		return false, 0, fmt.Errorf("empty share")
-	}
-	if share.Parent == nil {
-		return false, 0, fmt.Errorf("Parent missing from share %q", share.Name)
+// Whether there is any op with target that is the given share name
+func containsOpWithShareName(shareName string, opType util.OperationType, ops []*OpInfo) *OpInfo {
+	for _, op := range ops {
+		// share names are expected to be unique in the cluster
+		if op.Type == opType && strings.Contains(op.Target, shareName) {
+			return op
+		}
 	}
 
-	shares, err := m.cloud.File.ListShares(ctx, &file.ListFilter{Project: share.Parent.Project, Location: share.Parent.Location, InstanceName: share.Parent.Name})
+	return nil
+}
+
+func containsOpWithShareTarget(share *file.Share, opType util.OperationType, ops []*OpInfo) (*OpInfo, error) {
+	shareUri, err := file.GenerateShareURI(share)
 	if err != nil {
-		return false, 0, err
+		return nil, status.Errorf(codes.Internal, "failed to parse share handle, err: %v", err)
 	}
 
-	var sumShareBytes int64
-	for _, s := range shares {
-		sumShareBytes = sumShareBytes + s.CapacityBytes
-	}
-	// TODO: Check if we need to align the increment to step size.
-	var remainingBytes int64
-	remainingBytes = share.Parent.CapacityBytes - sumShareBytes
-	if remainingBytes < share.CapacityBytes {
-		return true, share.Parent.CapacityBytes + (share.CapacityBytes - remainingBytes), nil
+	for _, op := range ops {
+		// share names are expected to be unique in the cluster
+		if op.Type == opType && op.Target == shareUri {
+			return op, nil
+		}
 	}
-	return false, 0, nil
-}
 
-func (m *MultishareOpsManager) startShareDeleteWorkflow(ctx context.Context, instanceScPrefix string, share *file.Share) (*Workflow, error) {
-	return m.startShareWorkflow(ctx, instanceScPrefix, &Workflow{
-		share:  share,
-		opType: util.ShareDelete,
-	})
+	return nil, nil
 }
 
-func (m *MultishareOpsManager) checkAndStartShareDeleteWorkflow(ctx context.Context, instanceScPrefix string, share *file.Share) (*Workflow, error) {
-	m.Lock()
-	defer m.Unlock()
-
-	// Check the status of the last known op (if any) for the given share in cache.
-	opInfo, opStatus, err := m.checkAndUpdateShareOp(ctx, instanceScPrefix, share)
+func containsOpWithInstanceTargetPrefix(instance *file.MultishareInstance, ops []*OpInfo) (*OpInfo, error) {
+	instanceUri, err := file.GenerateMultishareInstanceURI(instance)
 	if err != nil {
 		return nil, err
 	}
-	if opInfo != nil && opStatus == util.StatusRunning {
-		return nil, status.Errorf(codes.Aborted, "Share operation %q in progress", opInfo.Name)
+	for _, op := range ops {
+		// For share targets (e.g projects/<>/locations/<>/instances/<>/shares/<>), explicity check with a "/", to avoid false positives of instances with same prefix name.
+		if op.Target == instanceUri || strings.Contains(op.Target, instanceUri+"/") {
+			return op, nil
+		}
 	}
 
-	if opInfo.Type == util.ShareDelete && opStatus == util.StatusSuccess {
-		return nil, nil
-	}
+	return nil, nil
+}
 
-	return m.startShareDeleteWorkflow(ctx, instanceScPrefix, share)
+func (m *MultishareOpsManager) listInstanceForStorageClassPrefix(ctx context.Context, prefix string) ([]*file.MultishareInstance, error) {
+	instances, err := m.cloud.File.ListMultishareInstances(ctx, &file.ListFilter{Project: m.cloud.Project, Location: "-"})
+	if err != nil {
+		return nil, err
+	}
+	var finalInstances []*file.MultishareInstance
+	for _, i := range instances {
+		if val, ok := i.Labels[util.ParamMultishareInstanceScLabelKey]; ok && val == prefix {
+			finalInstances = append(finalInstances, i)
+		}
+	}
+	return finalInstances, nil
 }
diff --git a/pkg/csi_driver/volume_id.go b/pkg/csi_driver/volume_id.go
index 58ff9a71..8e1ab60f 100644
--- a/pkg/csi_driver/volume_id.go
+++ b/pkg/csi_driver/volume_id.go
@@ -78,12 +78,13 @@ func parseMultishareVolId(volId string) (string, string, string, string, string,
 		return "", "", "", "", "", fmt.Errorf("invalid volume id %v", volId)
 	}
 
-	prefix := tokens[0]
-	project := tokens[1]
-	location := tokens[2]
-	instanceName := tokens[3]
-	shareName := tokens[4]
-	if project == "" || location == "" || instanceName == "" || shareName == "" {
+	mode := tokens[0]
+	prefix := tokens[1]
+	project := tokens[2]
+	location := tokens[3]
+	instanceName := tokens[4]
+	shareName := tokens[5]
+	if mode != modeMultishare || project == "" || location == "" || instanceName == "" || shareName == "" {
 		return "", "", "", "", "", fmt.Errorf("invalid volume id %v", volId)
 	}
 	return prefix, project, location, instanceName, shareName, nil
diff --git a/pkg/util/cache.go b/pkg/util/cache.go
deleted file mode 100644
index 6ab12ba8..00000000
--- a/pkg/util/cache.go
+++ /dev/null
@@ -1,321 +0,0 @@
-/*
-Copyright 2022 The Kubernetes Authors.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-
-package util
-
-import (
-	"fmt"
-)
-
-type OpInfo struct {
-	Name string // Unique op identifier
-	Type OperationType
-}
-
-type ShareCreateOpInfo struct {
-	InstanceHandle string // Placeholder instance of the form project/location/instanceName
-	OpName         string // share create op
-}
-
-type ShareCreateMapItem struct {
-	Key    string
-	OpInfo ShareCreateOpInfo
-}
-
-type ShareOpsMapItem struct {
-	Key    ShareKey
-	OpInfo OpInfo
-}
-
-type InstanceMapItem struct {
-	Key    InstanceKey
-	OpInfo OpInfo
-}
-
-type InstanceKey string
-type ShareKey string
-
-func CreateInstanceKey(project, location, instanceName string) InstanceKey {
-	return InstanceKey(fmt.Sprintf("%s/%s/%s", project, location, instanceName))
-}
-
-func CreateShareKey(project, location, instanceName, shareName string) ShareKey {
-	return ShareKey(fmt.Sprintf("%s/%s/%s/%s", project, location, instanceName, shareName))
-}
-
-// This map serves two purpose. To capture any ongoing instance ops, and to keep track of list of known filestore instances that belong to a given storage class.
-type InstanceMap map[InstanceKey]OpInfo
-
-func (s InstanceMap) Get(key InstanceKey) *OpInfo {
-	k, ok := s[key]
-	if !ok {
-		return nil
-	}
-	return &k
-}
-
-func (s InstanceMap) Add(key InstanceKey, o OpInfo) {
-	s[key] = o
-}
-
-func (s InstanceMap) DeleteKey(key InstanceKey) {
-	delete(s, key)
-}
-
-func (s InstanceMap) DeleteValue(key InstanceKey, opName string) error {
-	k, ok := s[key]
-	if !ok {
-		return nil
-	}
-
-	if k.Name != opName {
-		return fmt.Errorf("For key %q, cannot clear op %q, cache already contains op %q", key, opName, k.Name)
-	}
-
-	s[key] = OpInfo{Name: "", Type: UnknownOp}
-	return nil
-}
-
-func (s InstanceMap) Keys() []InstanceKey {
-	keys := make([]InstanceKey, len(s))
-	for k := range s {
-		keys = append(keys, k)
-	}
-	return keys
-}
-
-func (s InstanceMap) Items() []InstanceMapItem {
-	var items []InstanceMapItem
-	for k, v := range s {
-		items = append(items, InstanceMapItem{Key: k, OpInfo: v})
-	}
-	return items
-}
-
-// Map of share name to last known share creation operation
-type ShareCreateMap map[string]ShareCreateOpInfo
-
-func (s ShareCreateMap) Get(key string) *ShareCreateOpInfo {
-	k, ok := s[key]
-	if !ok {
-		return nil
-	}
-	return &k
-}
-
-func (s ShareCreateMap) Add(key string, v ShareCreateOpInfo) {
-	s[key] = v
-}
-
-func (s ShareCreateMap) Delete(key string, opName string) error {
-	k, ok := s[key]
-	if !ok {
-		return nil
-	}
-
-	if k.OpName != opName {
-		return fmt.Errorf("For key %q, cannot clear op %q, cache already contains op %q", key, opName, k.OpName)
-	}
-	delete(s, key)
-	return nil
-}
-
-func (s ShareCreateMap) Keys() []string {
-	keys := make([]string, len(s))
-	for k := range s {
-		keys = append(keys, k)
-	}
-	return keys
-}
-
-func (s ShareCreateMap) Items() []ShareCreateMapItem {
-	var items []ShareCreateMapItem
-	for k, v := range s {
-		items = append(items, ShareCreateMapItem{Key: k, OpInfo: v})
-	}
-	return items
-}
-
-// Map of share handle to share operation details
-type ShareOpsMap map[ShareKey]OpInfo
-
-func (s ShareOpsMap) Get(key ShareKey) *OpInfo {
-	k, ok := s[key]
-	if !ok {
-		return nil
-	}
-	return &k
-}
-
-func (s ShareOpsMap) Add(key ShareKey, v OpInfo) {
-	s[key] = v
-}
-
-func (s ShareOpsMap) Delete(key ShareKey, opName string) error {
-	k, ok := s[key]
-	if !ok {
-		return nil
-	}
-
-	if k.Name != opName {
-		return fmt.Errorf("For key %q, cannot clear op %q, cache already contains op %q", key, opName, k.Name)
-	}
-
-	delete(s, key)
-	return nil
-}
-
-func (s ShareOpsMap) Keys() []ShareKey {
-	var keys []ShareKey
-	for k := range s {
-		keys = append(keys, k)
-	}
-	return keys
-}
-
-func (s ShareOpsMap) Items() []ShareOpsMapItem {
-	var items []ShareOpsMapItem
-	for k, v := range s {
-		items = append(items, ShareOpsMapItem{Key: k, OpInfo: v})
-	}
-	return items
-}
-
-type StorageClassInfo struct {
-	InstanceMap    InstanceMap    // Map of Filestore instance handle to last known Instance ops.
-	ShareCreateMap ShareCreateMap // Map of share name to last known ongoing share creation operation on a given placeholder Filestore instance.
-	ShareOpsMap    ShareOpsMap    // Map of share handle (project/location/instance/share) to share operation details
-}
-
-// Map of storageclass name to StorageClassInfo
-type StorageClassInfoCache struct {
-	ScInfoMap map[string]StorageClassInfo
-	Ready     bool
-}
-
-func NewStorageClassInfoCache() *StorageClassInfoCache {
-	return &StorageClassInfoCache{
-		ScInfoMap: make(map[string]StorageClassInfo),
-	}
-}
-
-func (m *StorageClassInfoCache) GetInstanceMap(scInfoMapKey string) InstanceMap {
-	v, ok := m.ScInfoMap[scInfoMapKey]
-	if !ok {
-		return nil
-	}
-	return v.InstanceMap
-}
-
-func (m *StorageClassInfoCache) AddInstanceOp(scInfoMapKey string, instanceKey InstanceKey, opInfo OpInfo) {
-	_, ok := m.ScInfoMap[scInfoMapKey]
-	if !ok {
-		m.ScInfoMap[scInfoMapKey] = StorageClassInfo{
-			InstanceMap:    make(InstanceMap),
-			ShareCreateMap: make(ShareCreateMap),
-			ShareOpsMap:    make(ShareOpsMap),
-		}
-	}
-	m.ScInfoMap[scInfoMapKey].InstanceMap.Add(instanceKey, opInfo)
-}
-
-func (m *StorageClassInfoCache) GetInstanceOp(scInfoMapKey string, instanceKey InstanceKey) *OpInfo {
-	v, ok := m.ScInfoMap[scInfoMapKey]
-	if !ok {
-		return nil
-	}
-	return v.InstanceMap.Get(instanceKey)
-}
-
-func (m *StorageClassInfoCache) DeleteInstanceOp(scInfoMapKey string, instanceKey InstanceKey, opName string) error {
-	v, ok := m.ScInfoMap[scInfoMapKey]
-	if !ok {
-		return nil
-	}
-	return v.InstanceMap.DeleteValue(instanceKey, opName)
-}
-
-func (m *StorageClassInfoCache) DeleteInstance(scInfoMapKey string, instanceKey InstanceKey) {
-	v, ok := m.ScInfoMap[scInfoMapKey]
-	if !ok {
-		return
-	}
-	v.InstanceMap.DeleteKey(instanceKey)
-}
-
-func (m *StorageClassInfoCache) GetShareCreateMap(scInfoMapKey string) ShareCreateMap {
-	v, ok := m.ScInfoMap[scInfoMapKey]
-	if !ok {
-		return nil
-	}
-	return v.ShareCreateMap
-}
-
-func (m *StorageClassInfoCache) GetShareOpsMap(scInfoMapKey string) ShareOpsMap {
-	v, ok := m.ScInfoMap[scInfoMapKey]
-	if !ok {
-		return nil
-	}
-	return v.ShareOpsMap
-}
-
-func (m *StorageClassInfoCache) AddShareCreateOp(scInfoMapKey string, shareName string, opInfo ShareCreateOpInfo) error {
-	if _, ok := m.ScInfoMap[scInfoMapKey]; !ok {
-		return fmt.Errorf("missing key %s", scInfoMapKey)
-	}
-	m.ScInfoMap[scInfoMapKey].ShareCreateMap.Add(shareName, opInfo)
-	return nil
-}
-
-func (m *StorageClassInfoCache) GetShareCreateOp(scInfoMapKey string, shareName string) *ShareCreateOpInfo {
-	v, ok := m.ScInfoMap[scInfoMapKey]
-	if !ok {
-		return nil
-	}
-	return v.ShareCreateMap.Get(shareName)
-}
-
-func (m *StorageClassInfoCache) DeleteShareCreateOp(scInfoMapKey string, shareName string, opName string) error {
-	v, ok := m.ScInfoMap[scInfoMapKey]
-	if !ok {
-		return nil
-	}
-	return v.ShareCreateMap.Delete(shareName, opName)
-}
-
-func (m *StorageClassInfoCache) AddShareOp(scInfoMapKey string, shareKey ShareKey, opInfo OpInfo) error {
-	if _, ok := m.ScInfoMap[scInfoMapKey]; !ok {
-		return fmt.Errorf("missing key %s", scInfoMapKey)
-	}
-	m.ScInfoMap[scInfoMapKey].ShareOpsMap.Add(shareKey, opInfo)
-	return nil
-}
-
-func (m *StorageClassInfoCache) GetShareOp(scInfoMapKey string, shareKey ShareKey) *OpInfo {
-	_, ok := m.ScInfoMap[scInfoMapKey]
-	if !ok {
-		return nil
-	}
-	return m.ScInfoMap[scInfoMapKey].ShareOpsMap.Get(shareKey)
-}
-
-func (m *StorageClassInfoCache) DeleteShareOp(scInfoMapKey string, shareKey ShareKey, opName string) error {
-	_, ok := m.ScInfoMap[scInfoMapKey]
-	if !ok {
-		return nil
-	}
-	return m.ScInfoMap[scInfoMapKey].ShareOpsMap.Delete(shareKey, opName)
-}
diff --git a/pkg/util/multishare_defs.go b/pkg/util/multishare_defs.go
index 8a33919c..66028a76 100644
--- a/pkg/util/multishare_defs.go
+++ b/pkg/util/multishare_defs.go
@@ -17,9 +17,7 @@ limitations under the License.
 package util
 
 const (
-	InstanceHandleSplitLen     = 3
 	InstanceURISplitLen        = 6
-	ShareHandleSplitLen        = 4
 	ShareURISplitLen           = 8
 	MultishareCSIVolIdSplitLen = 6
 
@@ -36,14 +34,32 @@ type OperationType int
 const (
 	InstanceCreate OperationType = iota
 	InstanceDelete
-	InstanceExpand
-	InstanceShrink
+	InstanceUpdate
 	ShareCreate
 	ShareDelete
-	ShareExpand
+	ShareUpdate
 	UnknownOp
 )
 
+func (o OperationType) String() string {
+	switch o {
+	case InstanceCreate:
+		return "instance" + OpVerbCreate
+	case InstanceDelete:
+		return "instance" + OpVerbDelete
+	case InstanceUpdate:
+		return "instance" + OpVerbUpdate
+	case ShareCreate:
+		return "share" + OpVerbCreate
+	case ShareDelete:
+		return "share" + OpVerbDelete
+	case ShareUpdate:
+		return "share" + OpVerbUpdate
+	default:
+		return "unknown"
+	}
+}
+
 type OperationStatus int
 
 const (
@@ -52,3 +68,35 @@ const (
 	StatusFailed
 	StatusUnknown
 )
+
+const (
+	OpVerbCreate = "create"
+	OpVerbDelete = "delete"
+	OpVerbUpdate = "update"
+)
+
+func ConvertInstanceOpVerbToType(v string) OperationType {
+	switch v {
+	case OpVerbCreate:
+		return InstanceCreate
+	case OpVerbDelete:
+		return InstanceDelete
+	case OpVerbUpdate:
+		return InstanceUpdate
+	default:
+		return UnknownOp
+	}
+}
+
+func ConvertShareOpVerbToType(v string) OperationType {
+	switch v {
+	case OpVerbCreate:
+		return ShareCreate
+	case OpVerbDelete:
+		return ShareDelete
+	case OpVerbUpdate:
+		return ShareUpdate
+	default:
+		return UnknownOp
+	}
+}
diff --git a/pkg/util/util.go b/pkg/util/util.go
index 9ce0f1bd..337be888 100644
--- a/pkg/util/util.go
+++ b/pkg/util/util.go
@@ -219,23 +219,6 @@ func CheckLabelValueRegex(value string) error {
 	return nil
 }
 
-func ParseInstanceHandle(instanceHandle string) (string, string, string, error) {
-	// Expected instance handle <project-name>/<location-name>/<instance-name>
-	splitStr := strings.Split(instanceHandle, "/")
-	if len(splitStr) != InstanceHandleSplitLen {
-		return "", "", "", fmt.Errorf("Unknown instance handle format %q", instanceHandle)
-	}
-
-	project := splitStr[0]
-	location := splitStr[1]
-	instanceName := splitStr[2]
-	if project == "" || location == "" || instanceName == "" {
-		return "", "", "", fmt.Errorf("Unknown instance handle format %q", instanceHandle)
-	}
-
-	return project, location, instanceName, nil
-}
-
 func ParseInstanceURI(instanceURI string) (string, string, string, error) {
 	// Expected instance URI projects/<project-name>/locations/<location-name>/instances/<instance-name>/shares/<share-name>
 	splitStr := strings.Split(instanceURI, "/")
@@ -253,24 +236,6 @@ func ParseInstanceURI(instanceURI string) (string, string, string, error) {
 	return project, location, instanceName, nil
 }
 
-func ParseShareHandle(shareHandle string) (string, string, string, string, error) {
-	// Expected share handle <project-name>/<location-name>/<instance-name>/<share-name>
-	splitStr := strings.Split(shareHandle, "/")
-	if len(splitStr) != ShareHandleSplitLen {
-		return "", "", "", "", fmt.Errorf("Unknown share handle format %q", shareHandle)
-	}
-
-	project := splitStr[0]
-	location := splitStr[1]
-	instanceName := splitStr[2]
-	shareName := splitStr[3]
-	if project == "" || location == "" || instanceName == "" || shareName == "" {
-		return "", "", "", "", fmt.Errorf("Unknown share handle format %q", shareHandle)
-	}
-
-	return project, location, instanceName, shareName, nil
-}
-
 func ParseShareURI(shareURI string) (string, string, string, string, error) {
 	// Expected share URI projects/<project-name>/locations/<location-name>/instances/<instance-name>/shares/<share-name>
 	splitStr := strings.Split(shareURI, "/")
@@ -291,9 +256,9 @@ func ParseShareURI(shareURI string) (string, string, string, string, error) {
 
 func GetMultishareOpsTimeoutConfig(opType OperationType) (time.Duration, time.Duration, error) {
 	switch opType {
-	case InstanceCreate, InstanceDelete, ShareDelete:
+	case InstanceCreate, ShareDelete:
 		return 1 * time.Hour, 5 * time.Second, nil
-	case InstanceExpand, InstanceShrink, ShareCreate, ShareExpand:
+	case InstanceDelete, InstanceUpdate, ShareCreate, ShareUpdate:
 		return 10 * time.Minute, 5 * time.Second, nil
 	default:
 		return 0, 0, fmt.Errorf("unknown op type %v", opType)


Test patch:
diff --git a/pkg/cloud_provider/file/file_test.go b/pkg/cloud_provider/file/file_test.go
index 80256cca..0c639d00 100644
--- a/pkg/cloud_provider/file/file_test.go
+++ b/pkg/cloud_provider/file/file_test.go
@@ -197,3 +197,226 @@ func TestGetInstanceNameFromURI(t *testing.T) {
 		}
 	}
 }
+
+func TestIsMultishareInstanceTarget(t *testing.T) {
+	tests := []struct {
+		name     string
+		inputuri string
+		match    bool
+	}{
+		{
+			name:     "empty",
+			inputuri: "",
+		},
+		{
+			name:     "invalid case 1",
+			inputuri: "projects/test-project/locations/us-central1/instances/test-instance/shares/test-share",
+		},
+		{
+			name:     "invalid case 2",
+			inputuri: "projectstest-project/locations/us-central1/instances/test-instance/shares/test-share",
+		},
+		{
+			name:     "invalid case 3",
+			inputuri: "projects/test-project/locations/us-central1/instances/test-instance/",
+		},
+		{
+			name:     "valid case 1",
+			inputuri: "projects/test-project/locations/us-central1/instances/test-instance",
+			match:    true,
+		},
+		{
+			name:     "valid case 2",
+			inputuri: "projects/test-project/locations/us-central1-c/instances/test-instance",
+			match:    true,
+		},
+	}
+	for _, tc := range tests {
+		t.Run(tc.name, func(t *testing.T) {
+			if IsInstanceTarget(tc.inputuri) != tc.match {
+				t.Errorf("unecpected error")
+			}
+		})
+	}
+}
+
+func TestIsMultishareShareTarget(t *testing.T) {
+	tests := []struct {
+		name     string
+		inputuri string
+		match    bool
+	}{
+		{
+			name:     "empty",
+			inputuri: "",
+		},
+		{
+			name:     "invalid case 1",
+			inputuri: "projects/test-project/locations/us-central1/instances/test-instance",
+		},
+		{
+			name:     "invalid case 2",
+			inputuri: "projectstest-project/locations/us-central1/instances/test-instance",
+		},
+		{
+			name:     "invalid case 3",
+			inputuri: "projects/test-project/locations/us-central1/instances/test-instance/shares/test-share/",
+		},
+		{
+			name:     "valid case 1",
+			inputuri: "projects/test-project/locations/us-central1/instances/test-instance/shares/test-share",
+			match:    true,
+		},
+		{
+			name:     "valid case 2",
+			inputuri: "projects/test-project/locations/us-central1-c/instances/test-instance/shares/test-share",
+			match:    true,
+		},
+	}
+	for _, tc := range tests {
+		t.Run(tc.name, func(t *testing.T) {
+			if IsShareTarget(tc.inputuri) != tc.match {
+				t.Errorf("unecpected error")
+			}
+		})
+	}
+}
+
+func TestGenerateMultishareInstanceURI(t *testing.T) {
+	tests := []struct {
+		name          string
+		input         *MultishareInstance
+		expectedUri   string
+		errorExpected bool
+	}{
+		{
+			name:          "nil instance",
+			errorExpected: true,
+		},
+		{
+			name: "empty project",
+			input: &MultishareInstance{
+				Location: "us-central1",
+				Name:     "test",
+			},
+			errorExpected: true,
+		},
+		{
+			name: "empty location",
+			input: &MultishareInstance{
+				Project: "test-project",
+				Name:    "test",
+			},
+			errorExpected: true,
+		},
+		{
+			name: "empty name",
+			input: &MultishareInstance{
+				Location: "us-central1",
+				Project:  "test-project",
+			},
+			errorExpected: true,
+		},
+		{
+			name: "valid input",
+			input: &MultishareInstance{
+				Location: "us-central1",
+				Project:  "test-project",
+				Name:     "test-instance",
+			},
+			expectedUri: "projects/test-project/locations/us-central1/instances/test-instance",
+		},
+	}
+	for _, tc := range tests {
+		t.Run(tc.name, func(t *testing.T) {
+			uri, err := GenerateMultishareInstanceURI(tc.input)
+			if err != nil && !tc.errorExpected {
+				t.Errorf("unexpected error")
+			}
+			if err == nil && tc.errorExpected {
+				t.Errorf("expected error got nil")
+			}
+			if tc.expectedUri != uri {
+				t.Errorf("got %s, want %s", uri, tc.expectedUri)
+			}
+		})
+	}
+}
+
+func TestGenerateShareURI(t *testing.T) {
+	tests := []struct {
+		name          string
+		input         *Share
+		expectedUri   string
+		errorExpected bool
+	}{
+		{
+			name:          "nil share",
+			errorExpected: true,
+		},
+		{
+			name:          "nil share parent",
+			errorExpected: true,
+			input: &Share{
+				Name: "test-share",
+			},
+		},
+		{
+			name: "empty project",
+			input: &Share{
+				Parent: &MultishareInstance{
+					Location: "us-central1",
+				},
+				Name: "test-share",
+			},
+			errorExpected: true,
+		},
+		{
+			name: "empty location",
+			input: &Share{
+				Parent: &MultishareInstance{
+					Project: "test-project",
+				},
+				Name: "test-share",
+			},
+			errorExpected: true,
+		},
+		{
+			name: "empty instance name",
+			input: &Share{
+				Parent: &MultishareInstance{
+					Project:  "test-project",
+					Location: "us-central1",
+				},
+				Name: "test-share",
+			},
+			errorExpected: true,
+		},
+		{
+			name: "valid input",
+			input: &Share{
+				Parent: &MultishareInstance{
+					Location: "us-central1",
+					Project:  "test-project",
+					Name:     "test-instance",
+				},
+				Name: "test-share",
+			},
+			expectedUri: "projects/test-project/locations/us-central1/instances/test-instance/shares/test-share",
+		},
+	}
+	for _, tc := range tests {
+		t.Run(tc.name, func(t *testing.T) {
+			uri, err := GenerateShareURI(tc.input)
+			if err != nil && !tc.errorExpected {
+				t.Errorf("unexpected error")
+			}
+			if err == nil && tc.errorExpected {
+				t.Errorf("expected error got nil")
+			}
+			if tc.expectedUri != uri {
+				t.Errorf("got %s, want %s", uri, tc.expectedUri)
+			}
+		})
+	}
+}
diff --git a/pkg/csi_driver/multishare_controller_test.go b/pkg/csi_driver/multishare_controller_test.go
index 3d0b521a..44e0c99e 100644
--- a/pkg/csi_driver/multishare_controller_test.go
+++ b/pkg/csi_driver/multishare_controller_test.go
@@ -17,11 +17,16 @@ limitations under the License.
 package driver
 
 import (
+	"context"
+	"encoding/json"
 	"fmt"
 	"reflect"
+	"strings"
 	"testing"
 
 	csi "github.com/container-storage-interface/spec/lib/go/csi"
+	filev1beta1multishare "google.golang.org/api/file/v1beta1multishare"
+	"k8s.io/apimachinery/pkg/util/uuid"
 	cloud "sigs.k8s.io/gcp-filestore-csi-driver/pkg/cloud_provider"
 	"sigs.k8s.io/gcp-filestore-csi-driver/pkg/cloud_provider/file"
 	"sigs.k8s.io/gcp-filestore-csi-driver/pkg/util"
@@ -33,6 +38,9 @@ const (
 	testPVCName              = "testPVC"
 	testPVCNamespace         = "testNamespace"
 	testPVName               = "testPV"
+	instanceUriFmt           = "projects/%s/locations/%s/instances/%s"
+	shareUriFmt              = "projects/%s/locations/%s/instances/%s/shares/%s"
+	multishareVolIdFmt       = modeMultishare + "/%s/%s/%s/%s/%s"
 )
 
 func initTestMultishareController(t *testing.T) *MultishareController {
@@ -580,3 +588,470 @@ func TestGenerateInstanceDescFromEcfsDesc(t *testing.T) {
 		})
 	}
 }
+
+func TestMultishareCreateVolume(t *testing.T) {
+	testVolName := "pvc-" + string(uuid.NewUUID())
+	testShareName := util.ConvertVolToShareName(testVolName)
+	testInstanceName1 := "fs-" + string(uuid.NewUUID())
+	testInstanceName2 := "fs-" + string(uuid.NewUUID())
+	type OpItem struct {
+		id     string
+		target string
+		verb   string
+		done   bool
+	}
+	tests := []struct {
+		name              string
+		prefix            string
+		ops               []OpItem
+		initInstances     []*file.MultishareInstance
+		initShares        []*file.Share
+		req               *csi.CreateVolumeRequest
+		resp              *csi.CreateVolumeResponse
+		errorExpected     bool
+		checkOnlyVolidFmt bool // for auto generated instance, the instance name is not known
+	}{
+		{
+			name: "no initial instances, create instance and share, success response",
+			req: &csi.CreateVolumeRequest{
+				Name: testVolName,
+				CapacityRange: &csi.CapacityRange{
+					RequiredBytes: 100 * util.Gb,
+				},
+				Parameters: map[string]string{
+					paramMultishareInstanceScLabel: testInstanceScPrefix,
+				},
+				VolumeCapabilities: []*csi.VolumeCapability{
+					{
+						AccessType: &csi.VolumeCapability_Mount{
+							Mount: &csi.VolumeCapability_MountVolume{},
+						},
+						AccessMode: &csi.VolumeCapability_AccessMode{
+							Mode: csi.VolumeCapability_AccessMode_SINGLE_NODE_WRITER,
+						},
+					},
+				},
+			},
+			checkOnlyVolidFmt: true,
+		},
+		{
+			name: "1 initial ready 1Tib instances with 0 shares, 1 busy instance, create 100Gib share and use the ready instance, success response",
+			initInstances: []*file.MultishareInstance{
+				{
+					Name:     testInstanceName1,
+					Location: "us-central1",
+					Project:  "test-project",
+					Labels: map[string]string{
+						util.ParamMultishareInstanceScLabelKey: testInstanceScPrefix,
+					},
+					CapacityBytes: 1 * util.Tb,
+					Tier:          "Enterprise",
+					Network: file.Network{
+						Ip: testIP,
+					},
+				},
+				{
+					Name:     testInstanceName2,
+					Location: "us-central1",
+					Project:  "test-project",
+					Labels: map[string]string{
+						util.ParamMultishareInstanceScLabelKey: testInstanceScPrefix,
+					},
+					CapacityBytes: 1 * util.Tb,
+					Tier:          "Enterprise",
+					Network: file.Network{
+						Ip: testIP,
+					},
+				},
+			},
+			ops: []OpItem{
+				{
+					id:     "op1",
+					target: fmt.Sprintf(instanceUriFmt, testProject, testRegion, testInstanceName2),
+					verb:   "create",
+				},
+			},
+			req: &csi.CreateVolumeRequest{
+				Name: testVolName,
+				CapacityRange: &csi.CapacityRange{
+					RequiredBytes: 100 * util.Gb,
+				},
+				Parameters: map[string]string{
+					paramMultishareInstanceScLabel: testInstanceScPrefix,
+				},
+				VolumeCapabilities: []*csi.VolumeCapability{
+					{
+						AccessType: &csi.VolumeCapability_Mount{
+							Mount: &csi.VolumeCapability_MountVolume{},
+						},
+						AccessMode: &csi.VolumeCapability_AccessMode{
+							Mode: csi.VolumeCapability_AccessMode_SINGLE_NODE_WRITER,
+						},
+					},
+				},
+			},
+			resp: &csi.CreateVolumeResponse{
+				Volume: &csi.Volume{
+					CapacityBytes: 100 * util.Gb,
+					VolumeId:      fmt.Sprintf(multishareVolIdFmt, testInstanceScPrefix, testProject, testRegion, testInstanceName1, testShareName),
+					VolumeContext: map[string]string{
+						attrIP: testIP,
+					},
+				},
+			},
+		},
+		{
+			name: "share op in progress found, return retry error to client",
+			initInstances: []*file.MultishareInstance{
+				{
+					Name:     testInstanceName1,
+					Location: "us-central1",
+					Project:  "test-project",
+					Labels: map[string]string{
+						util.ParamMultishareInstanceScLabelKey: testInstanceScPrefix,
+					},
+					CapacityBytes: 1 * util.Tb,
+					Tier:          "Enterprise",
+					Network: file.Network{
+						Ip: testIP,
+					},
+				},
+			},
+			ops: []OpItem{
+				{
+					id:     "op1",
+					target: fmt.Sprintf(shareUriFmt, testProject, testRegion, testInstanceName1, testShareName),
+					verb:   "create",
+				},
+			},
+			req: &csi.CreateVolumeRequest{
+				Name: testVolName,
+				CapacityRange: &csi.CapacityRange{
+					RequiredBytes: 100 * util.Gb,
+				},
+				Parameters: map[string]string{
+					paramMultishareInstanceScLabel: testInstanceScPrefix,
+				},
+				VolumeCapabilities: []*csi.VolumeCapability{
+					{
+						AccessType: &csi.VolumeCapability_Mount{
+							Mount: &csi.VolumeCapability_MountVolume{},
+						},
+						AccessMode: &csi.VolumeCapability_AccessMode{
+							Mode: csi.VolumeCapability_AccessMode_SINGLE_NODE_WRITER,
+						},
+					},
+				},
+			},
+			errorExpected: true,
+		},
+		{
+			name: "share already exists, return success",
+			initInstances: []*file.MultishareInstance{
+				{
+					Name:     testInstanceName1,
+					Location: "us-central1",
+					Project:  "test-project",
+					Labels: map[string]string{
+						util.ParamMultishareInstanceScLabelKey: testInstanceScPrefix,
+					},
+					CapacityBytes: 1 * util.Tb,
+					Tier:          "Enterprise",
+					Network: file.Network{
+						Ip: testIP,
+					},
+					State: "READY",
+				},
+			},
+			initShares: []*file.Share{
+				{
+					Name: testShareName,
+					Parent: &file.MultishareInstance{
+						Name:     testInstanceName1,
+						Location: "us-central1",
+						Project:  "test-project",
+						Labels: map[string]string{
+							util.ParamMultishareInstanceScLabelKey: testInstanceScPrefix,
+						},
+						CapacityBytes: 1 * util.Tb,
+						Tier:          "Enterprise",
+						Network: file.Network{
+							Ip: testIP,
+						},
+						State: "READY",
+					},
+					CapacityBytes:  100 * util.Gb,
+					MountPointName: testShareName,
+					State:          "READY",
+				},
+			},
+			req: &csi.CreateVolumeRequest{
+				Name: testVolName,
+				CapacityRange: &csi.CapacityRange{
+					RequiredBytes: 100 * util.Gb,
+				},
+				Parameters: map[string]string{
+					paramMultishareInstanceScLabel: testInstanceScPrefix,
+				},
+				VolumeCapabilities: []*csi.VolumeCapability{
+					{
+						AccessType: &csi.VolumeCapability_Mount{
+							Mount: &csi.VolumeCapability_MountVolume{},
+						},
+						AccessMode: &csi.VolumeCapability_AccessMode{
+							Mode: csi.VolumeCapability_AccessMode_SINGLE_NODE_WRITER,
+						},
+					},
+				},
+			},
+			resp: &csi.CreateVolumeResponse{
+				Volume: &csi.Volume{
+					CapacityBytes: 100 * util.Gb,
+					VolumeId:      fmt.Sprintf(multishareVolIdFmt, testInstanceScPrefix, testProject, testRegion, testInstanceName1, testShareName),
+					VolumeContext: map[string]string{
+						attrIP: testIP,
+					},
+				},
+			},
+		},
+		// TODO: Add test cases for instance resize
+	}
+	for _, tc := range tests {
+		t.Run(tc.name, func(t *testing.T) {
+			var v1beta1ops []*filev1beta1multishare.Operation
+			for _, item := range tc.ops {
+				var meta filev1beta1multishare.OperationMetadata
+				meta.Target = item.target
+				meta.Verb = item.verb
+				bytes, _ := json.Marshal(meta)
+				v1beta1ops = append(v1beta1ops, &filev1beta1multishare.Operation{
+					Name:     item.id,
+					Done:     item.done,
+					Metadata: bytes,
+				})
+			}
+
+			s, err := file.NewFakeServiceForMultishare(tc.initInstances, tc.initShares, v1beta1ops)
+			if err != nil {
+				t.Fatalf("failed to fake service: %v", err)
+			}
+			cloudProvider, err := cloud.NewFakeCloud()
+			cloudProvider.File = s
+			mcs := NewMultishareController(initTestDriver(t), s, cloudProvider, util.NewVolumeLocks(), "")
+			resp, err := mcs.CreateVolume(context.Background(), tc.req)
+			if tc.errorExpected && err == nil {
+				t.Errorf("expected error not found")
+			}
+			if !tc.errorExpected && err != nil {
+				t.Errorf("unexpected error")
+			}
+			if tc.checkOnlyVolidFmt {
+				if !strings.Contains(resp.Volume.VolumeId, modeMultishare) || !strings.Contains(resp.Volume.VolumeId, testShareName) {
+					t.Errorf("unexpected vol id %s", resp.Volume.VolumeId)
+				}
+			} else {
+				if tc.resp != nil && resp == nil {
+					t.Errorf("mismatch in response")
+				}
+				if tc.resp == nil && resp != nil {
+					t.Errorf("mismatch in response")
+				}
+				if !reflect.DeepEqual(resp, tc.resp) {
+					t.Errorf("got resp %+v, expected %+v", resp, tc.resp)
+				}
+			}
+		})
+	}
+}
+
+func TestMultishareDeleteVolume(t *testing.T) {
+	testVolName := "pvc-" + string(uuid.NewUUID())
+	testShareName := util.ConvertVolToShareName(testVolName)
+	testInstanceName1 := "fs-" + string(uuid.NewUUID())
+	testVolId := fmt.Sprintf("%s/%s/%s/%s/%s/%s", modeMultishare, testInstanceScPrefix, testProject, testRegion, testInstanceName1, testShareName)
+	type OpItem struct {
+		id     string
+		target string
+		verb   string
+		done   bool
+	}
+	tests := []struct {
+		name          string
+		ops           []OpItem
+		initInstance  []*file.MultishareInstance
+		initShares    []*file.Share
+		req           *csi.DeleteVolumeRequest
+		resp          *csi.DeleteVolumeResponse
+		errorExpected bool
+	}{
+		{
+			name: "share not found, instance ready, instance deleted, succes response",
+			req: &csi.DeleteVolumeRequest{
+				VolumeId: testVolId,
+			},
+			resp: &csi.DeleteVolumeResponse{},
+		},
+		{
+			name: "share not found, instance not ready (instance op in progress), error response",
+			req: &csi.DeleteVolumeRequest{
+				VolumeId: testVolId,
+			},
+			initInstance: []*file.MultishareInstance{
+				{
+					Name:     testInstanceName1,
+					Location: testRegion,
+					Project:  testProject,
+					Labels: map[string]string{
+						util.ParamMultishareInstanceScLabelKey: testInstanceScPrefix,
+					},
+					CapacityBytes: 1 * util.Tb,
+					Tier:          "Enterprise",
+					Network: file.Network{
+						Ip: testIP,
+					},
+				},
+			},
+			ops: []OpItem{
+				{
+					id:     "op1",
+					target: fmt.Sprintf(instanceUriFmt, testProject, testRegion, testInstanceName1),
+					verb:   "update",
+				},
+			},
+			errorExpected: true,
+		},
+		{
+			name: "share not found, instance not ready (share op in progress for the instance), error response",
+			req: &csi.DeleteVolumeRequest{
+				VolumeId: testVolId,
+			},
+			initInstance: []*file.MultishareInstance{
+				{
+					Name:     testInstanceName1,
+					Location: testRegion,
+					Project:  testProject,
+					Labels: map[string]string{
+						util.ParamMultishareInstanceScLabelKey: testInstanceScPrefix,
+					},
+					CapacityBytes: 1 * util.Tb,
+					Tier:          "Enterprise",
+					Network: file.Network{
+						Ip: testIP,
+					},
+				},
+			},
+			ops: []OpItem{
+				{
+					id:     "op1",
+					target: fmt.Sprintf(shareUriFmt, testProject, testRegion, testInstanceName1, testShareName),
+					verb:   "update",
+				},
+			},
+			errorExpected: true,
+		},
+		{
+			name: "share not found, instance ready with 0 shares, instance deleted, success response",
+			req: &csi.DeleteVolumeRequest{
+				VolumeId: testVolId,
+			},
+			initInstance: []*file.MultishareInstance{
+				{
+					Name:     testInstanceName1,
+					Location: testRegion,
+					Project:  testProject,
+					Labels: map[string]string{
+						util.ParamMultishareInstanceScLabelKey: testInstanceScPrefix,
+					},
+					CapacityBytes: 1 * util.Tb,
+					Tier:          "Enterprise",
+					Network: file.Network{
+						Ip: testIP,
+					},
+				},
+			},
+			resp: &csi.DeleteVolumeResponse{},
+		},
+		{
+			name: "share found, share deleted, instance ready with 0 shares, instance deleted, success response",
+			req: &csi.DeleteVolumeRequest{
+				VolumeId: testVolId,
+			},
+			initInstance: []*file.MultishareInstance{
+				{
+					Name:     testInstanceName1,
+					Location: testRegion,
+					Project:  testProject,
+					Labels: map[string]string{
+						util.ParamMultishareInstanceScLabelKey: testInstanceScPrefix,
+					},
+					CapacityBytes: 1 * util.Tb,
+					Tier:          "Enterprise",
+					Network: file.Network{
+						Ip: testIP,
+					},
+				},
+			},
+			initShares: []*file.Share{
+				{
+					Name: testShareName,
+					Parent: &file.MultishareInstance{
+						Project:  testProject,
+						Location: testRegion,
+						Name:     testInstanceName1,
+						Labels: map[string]string{
+							util.ParamMultishareInstanceScLabelKey: testInstanceScPrefix,
+						},
+						CapacityBytes: 1 * util.Tb,
+						Tier:          "Enterprise",
+						Network: file.Network{
+							Ip: testIP,
+						},
+					},
+					MountPointName: testShareName,
+				},
+			},
+			resp: &csi.DeleteVolumeResponse{},
+		},
+	}
+	for _, tc := range tests {
+		t.Run(tc.name, func(t *testing.T) {
+			var v1beta1ops []*filev1beta1multishare.Operation
+			for _, item := range tc.ops {
+				var meta filev1beta1multishare.OperationMetadata
+				meta.Target = item.target
+				meta.Verb = item.verb
+				bytes, _ := json.Marshal(meta)
+				v1beta1ops = append(v1beta1ops, &filev1beta1multishare.Operation{
+					Name:     item.id,
+					Done:     item.done,
+					Metadata: bytes,
+				})
+			}
+
+			s, err := file.NewFakeServiceForMultishare(tc.initInstance, tc.initShares, v1beta1ops)
+			if err != nil {
+				t.Fatalf("failed to fake service: %v", err)
+			}
+			cloudProvider, err := cloud.NewFakeCloud()
+			cloudProvider.File = s
+			mcs := NewMultishareController(initTestDriver(t), s, cloudProvider, util.NewVolumeLocks(), "")
+			resp, err := mcs.DeleteVolume(context.Background(), tc.req)
+			if tc.errorExpected && err == nil {
+				t.Errorf("expected error not found")
+			}
+			if !tc.errorExpected && err != nil {
+				t.Errorf("unexpected error")
+			}
+			if tc.resp != nil && resp == nil {
+				t.Errorf("mismatch in response")
+			}
+			if tc.resp == nil && resp != nil {
+				t.Errorf("mismatch in response")
+			}
+			if !reflect.DeepEqual(resp, tc.resp) {
+				t.Errorf("got resp %+v, expected %+v", resp, tc.resp)
+			}
+		})
+	}
+
+}
diff --git a/pkg/csi_driver/multishare_ops_manager_test.go b/pkg/csi_driver/multishare_ops_manager_test.go
index b8626fad..a3c5c984 100644
--- a/pkg/csi_driver/multishare_ops_manager_test.go
+++ b/pkg/csi_driver/multishare_ops_manager_test.go
@@ -17,10 +17,12 @@ limitations under the License.
 package driver
 
 import (
+	"encoding/json"
 	"fmt"
 	"testing"
 
 	"golang.org/x/net/context"
+	filev1beta1multishare "google.golang.org/api/file/v1beta1multishare"
 	cloud "sigs.k8s.io/gcp-filestore-csi-driver/pkg/cloud_provider"
 	"sigs.k8s.io/gcp-filestore-csi-driver/pkg/cloud_provider/file"
 	"sigs.k8s.io/gcp-filestore-csi-driver/pkg/util"
@@ -38,11 +40,7 @@ var (
 
 type Item struct {
 	scKey          string
-	instanceKey    util.InstanceKey
-	shareKey       util.ShareKey
 	shareCreateKey string
-	op             util.OpInfo
-	createOp       util.ShareCreateOpInfo
 }
 
 func initCloudProviderWithBlockingFileService(t *testing.T, opUnblocker chan chan file.Signal) *cloud.Cloud {
@@ -67,8 +65,6 @@ type MockOpStatus struct {
 
 type Response struct {
 	opStatus             util.OperationStatus
-	createOp             *util.ShareCreateOpInfo
-	shareOp              *util.OpInfo
 	verified             bool
 	readyInstances       []*file.MultishareInstance
 	numNonReadyInstances int
@@ -77,1655 +73,1476 @@ type Response struct {
 	err                  error
 }
 
-func TestCheckAndUpdateShareCreateOp(t *testing.T) {
+func TestInstanceNeedsExpand(t *testing.T) {
 	tests := []struct {
-		name                      string
-		scKey                     string
-		shareName                 string
-		initShareCreateOpMap      []Item
-		signalGetOp               bool
-		signalIsOpDone            bool
-		getOpStatus               *MockOpStatus
-		isOpDoneStatus            *MockOpStatus
-		expectedShareCreateOpInfo *util.ShareCreateOpInfo
-		expectedOpStaus           util.OperationStatus
-		shareKeyExpectedInCache   bool
+		name                    string
+		scKey                   string
+		initShares              []file.Share
+		targetShareToAccomodate *file.Share
+		expectedNeedsExpand     bool
+		targetBytes             int64
+		expectError             bool
 	}{
 		{
-			name:            "tc1 - no share create op in cache, unknown op status",
-			scKey:           testInstanceScPrefix,
-			shareName:       testShareName,
-			expectedOpStaus: util.StatusUnknown,
+			name:  "0 shares in 1 T instance,  new 100G share",
+			scKey: testInstanceScPrefix,
+			targetShareToAccomodate: &file.Share{
+				Name:          testShareName,
+				CapacityBytes: 100 * util.Gb,
+				Parent: &file.MultishareInstance{
+					Project:       testProject,
+					Location:      testRegion,
+					Name:          testInstanceName,
+					CapacityBytes: 1 * util.Tb,
+				},
+			},
 		},
 		{
-			name:      "tc2 - get share create op returns error, unknown op status, cache entry not cleared",
-			scKey:     testInstanceScPrefix,
-			shareName: testShareName,
-			initShareCreateOpMap: []Item{
-				{
-					scKey:          testInstanceScPrefix,
-					shareCreateKey: testShareName,
-					createOp: util.ShareCreateOpInfo{
-						InstanceHandle: testInstanceHandle,
-						OpName:         "op-1",
+			name:  "1 existing 100G share in 1 T instance,  new 100G share",
+			scKey: testInstanceScPrefix,
+			initShares: []file.Share{
+				{
+					Name:          testShareName + "1",
+					CapacityBytes: 100 * util.Gb,
+					Parent: &file.MultishareInstance{
+						Project:       testProject,
+						Location:      testRegion,
+						Name:          testInstanceName,
+						CapacityBytes: 1 * util.Tb,
 					},
 				},
 			},
-			signalGetOp: true,
-			getOpStatus: &MockOpStatus{
-				reportError: true,
-			},
-			expectedOpStaus: util.StatusUnknown,
-			expectedShareCreateOpInfo: &util.ShareCreateOpInfo{
-				InstanceHandle: testInstanceHandle,
-				OpName:         "op-1",
+			targetShareToAccomodate: &file.Share{
+				Name:          testShareName + "2",
+				CapacityBytes: 100 * util.Gb,
+				Parent: &file.MultishareInstance{
+					Project:       testProject,
+					Location:      testRegion,
+					Name:          testInstanceName,
+					CapacityBytes: 1 * util.Tb,
+				},
 			},
-			shareKeyExpectedInCache: true,
 		},
 		{
-			name:      "tc3 - IsOpDone returns error, return failed op status, cache entry cleared",
-			scKey:     testInstanceScPrefix,
-			shareName: testShareName,
-			initShareCreateOpMap: []Item{
-				{
-					scKey:          testInstanceScPrefix,
-					shareCreateKey: testShareName,
-					createOp: util.ShareCreateOpInfo{
-						InstanceHandle: testInstanceHandle,
-						OpName:         "op-1",
+			name:  "9 existing 100G share in 1 T instance, new 100G share",
+			scKey: testInstanceScPrefix,
+			initShares: []file.Share{
+				{
+					Name:          testShareName + "1",
+					CapacityBytes: 100 * util.Gb,
+					Parent: &file.MultishareInstance{
+						Project:       testProject,
+						Location:      testRegion,
+						Name:          testInstanceName,
+						CapacityBytes: 1 * util.Tb,
+					},
+				},
+				{
+					Name:          testShareName + "2",
+					CapacityBytes: 100 * util.Gb,
+					Parent: &file.MultishareInstance{
+						Project:       testProject,
+						Location:      testRegion,
+						Name:          testInstanceName,
+						CapacityBytes: 1 * util.Tb,
+					},
+				},
+				{
+					Name:          testShareName + "3",
+					CapacityBytes: 100 * util.Gb,
+					Parent: &file.MultishareInstance{
+						Project:       testProject,
+						Location:      testRegion,
+						Name:          testInstanceName,
+						CapacityBytes: 1 * util.Tb,
+					},
+				},
+				{
+					Name:          testShareName + "4",
+					CapacityBytes: 100 * util.Gb,
+					Parent: &file.MultishareInstance{
+						Project:       testProject,
+						Location:      testRegion,
+						Name:          testInstanceName,
+						CapacityBytes: 1 * util.Tb,
+					},
+				},
+				{
+					Name:          testShareName + "5",
+					CapacityBytes: 100 * util.Gb,
+					Parent: &file.MultishareInstance{
+						Project:       testProject,
+						Location:      testRegion,
+						Name:          testInstanceName,
+						CapacityBytes: 1 * util.Tb,
+					},
+				},
+				{
+					Name:          testShareName + "6",
+					CapacityBytes: 100 * util.Gb,
+					Parent: &file.MultishareInstance{
+						Project:       testProject,
+						Location:      testRegion,
+						Name:          testInstanceName,
+						CapacityBytes: 1 * util.Tb,
+					},
+				},
+				{
+					Name:          testShareName + "7",
+					CapacityBytes: 100 * util.Gb,
+					Parent: &file.MultishareInstance{
+						Project:       testProject,
+						Location:      testRegion,
+						Name:          testInstanceName,
+						CapacityBytes: 1 * util.Tb,
+					},
+				},
+				{
+					Name:          testShareName + "8",
+					CapacityBytes: 100 * util.Gb,
+					Parent: &file.MultishareInstance{
+						Project:       testProject,
+						Location:      testRegion,
+						Name:          testInstanceName,
+						CapacityBytes: 1 * util.Tb,
+					},
+				},
+				{
+					Name:          testShareName + "9",
+					CapacityBytes: 100 * util.Gb,
+					Parent: &file.MultishareInstance{
+						Project:       testProject,
+						Location:      testRegion,
+						Name:          testInstanceName,
+						CapacityBytes: 1 * util.Tb,
 					},
 				},
 			},
-			signalGetOp:    true,
-			signalIsOpDone: true,
-			isOpDoneStatus: &MockOpStatus{
-				reportError: true,
+			targetShareToAccomodate: &file.Share{
+				Name:          testShareName + "10",
+				CapacityBytes: 100 * util.Gb,
+				Parent: &file.MultishareInstance{
+					Project:       testProject,
+					Location:      testRegion,
+					Name:          testInstanceName,
+					CapacityBytes: 1 * util.Tb,
+				},
+			},
+		},
+		{
+			name:  "1 existing 100G share in 1 T instance,  new 1T share",
+			scKey: testInstanceScPrefix,
+			initShares: []file.Share{
+				{
+					Name:          testShareName + "1",
+					CapacityBytes: 100 * util.Gb,
+					Parent: &file.MultishareInstance{
+						Project:       testProject,
+						Location:      testRegion,
+						Name:          testInstanceName,
+						CapacityBytes: 1 * util.Tb,
+					},
+				},
 			},
-			expectedOpStaus: util.StatusFailed,
-			expectedShareCreateOpInfo: &util.ShareCreateOpInfo{
-				InstanceHandle: testInstanceHandle,
-				OpName:         "op-1",
+			targetShareToAccomodate: &file.Share{
+				Name:          testShareName + "2",
+				CapacityBytes: 1 * util.Tb,
+				Parent: &file.MultishareInstance{
+					Project:       testProject,
+					Location:      testRegion,
+					Name:          testInstanceName,
+					CapacityBytes: 1 * util.Tb,
+				},
 			},
+			expectedNeedsExpand: true,
+			targetBytes:         1*util.Tb + (1*util.Tb - (1*util.Tb - 100*util.Gb)),
 		},
 		{
-			name:      "tc4 - IsOpDone false, return running op status, cache entry not cleared",
-			scKey:     testInstanceScPrefix,
-			shareName: testShareName,
-			initShareCreateOpMap: []Item{
-				{
-					scKey:          testInstanceScPrefix,
-					shareCreateKey: testShareName,
-					createOp: util.ShareCreateOpInfo{
-						InstanceHandle: testInstanceHandle,
-						OpName:         "op-1",
+			name:  "2 existing 100G share in 1 T instance,  new 900G share",
+			scKey: testInstanceScPrefix,
+			initShares: []file.Share{
+				{
+					Name:          testShareName + "1",
+					CapacityBytes: 100 * util.Gb,
+					Parent: &file.MultishareInstance{
+						Project:       testProject,
+						Location:      testRegion,
+						Name:          testInstanceName,
+						CapacityBytes: 1 * util.Tb,
+					},
+				},
+				{
+					Name:          testShareName + "2",
+					CapacityBytes: 100 * util.Gb,
+					Parent: &file.MultishareInstance{
+						Project:       testProject,
+						Location:      testRegion,
+						Name:          testInstanceName,
+						CapacityBytes: 1 * util.Tb,
+					},
+				},
+				{
+					Name:          testShareName + "3",
+					CapacityBytes: 100 * util.Gb,
+					Parent: &file.MultishareInstance{
+						Project:       testProject,
+						Location:      testRegion,
+						Name:          testInstanceName,
+						CapacityBytes: 1 * util.Tb,
+					},
+				},
+				{
+					Name:          testShareName + "4",
+					CapacityBytes: 100 * util.Gb,
+					Parent: &file.MultishareInstance{
+						Project:       testProject,
+						Location:      testRegion,
+						Name:          testInstanceName,
+						CapacityBytes: 1 * util.Tb,
+					},
+				},
+				{
+					Name:          testShareName + "5",
+					CapacityBytes: 100 * util.Gb,
+					Parent: &file.MultishareInstance{
+						Project:       testProject,
+						Location:      testRegion,
+						Name:          testInstanceName,
+						CapacityBytes: 1 * util.Tb,
 					},
 				},
+				{
+					Name:          testShareName + "6",
+					CapacityBytes: 100 * util.Gb,
+					Parent: &file.MultishareInstance{
+						Project:       testProject,
+						Location:      testRegion,
+						Name:          testInstanceName,
+						CapacityBytes: 1 * util.Tb,
+					},
+				},
+				{
+					Name:          testShareName + "7",
+					CapacityBytes: 100 * util.Gb,
+					Parent: &file.MultishareInstance{
+						Project:       testProject,
+						Location:      testRegion,
+						Name:          testInstanceName,
+						CapacityBytes: 1 * util.Tb,
+					},
+				},
+				{
+					Name:          testShareName + "8",
+					CapacityBytes: 100 * util.Gb,
+					Parent: &file.MultishareInstance{
+						Project:       testProject,
+						Location:      testRegion,
+						Name:          testInstanceName,
+						CapacityBytes: 1 * util.Tb,
+					},
+				},
+				{
+					Name:          testShareName + "9",
+					CapacityBytes: 100 * util.Gb,
+					Parent: &file.MultishareInstance{
+						Project:       testProject,
+						Location:      testRegion,
+						Name:          testInstanceName,
+						CapacityBytes: 1 * util.Tb,
+					},
+				},
+			},
+			targetShareToAccomodate: &file.Share{
+				Name:          testShareName + "10",
+				CapacityBytes: 1 * util.Tb,
+				Parent: &file.MultishareInstance{
+					Project:       testProject,
+					Location:      testRegion,
+					Name:          testInstanceName,
+					CapacityBytes: 1 * util.Tb,
+				},
 			},
-			signalGetOp:    true,
-			signalIsOpDone: true,
-			isOpDoneStatus: &MockOpStatus{
-				reportRunning: true,
-			},
-			expectedOpStaus: util.StatusRunning,
-			expectedShareCreateOpInfo: &util.ShareCreateOpInfo{
-				InstanceHandle: testInstanceHandle,
-				OpName:         "op-1",
-			},
-			shareKeyExpectedInCache: true,
+			expectedNeedsExpand: true,
+			targetBytes:         1*util.Tb + (1*util.Tb - (1*util.Tb - 9*100*util.Gb)),
 		},
 		{
-			name:      "tc4 - IsOpDone true, return success op status, cache entry cleared",
-			scKey:     testInstanceScPrefix,
-			shareName: testShareName,
-			initShareCreateOpMap: []Item{
-				{
-					scKey:          testInstanceScPrefix,
-					shareCreateKey: testShareName,
-					createOp: util.ShareCreateOpInfo{
-						InstanceHandle: testInstanceHandle,
-						OpName:         "op-1",
+			name:  "9 existing 100G share in 1 T instance,  new 1T share",
+			scKey: testInstanceScPrefix,
+			initShares: []file.Share{
+				{
+					Name:          testShareName + "1",
+					CapacityBytes: 100 * util.Gb,
+					Parent: &file.MultishareInstance{
+						Project:       testProject,
+						Location:      testRegion,
+						Name:          testInstanceName,
+						CapacityBytes: 1 * util.Tb,
+					},
+				},
+				{
+					Name:          testShareName + "2",
+					CapacityBytes: 100 * util.Gb,
+					Parent: &file.MultishareInstance{
+						Project:       testProject,
+						Location:      testRegion,
+						Name:          testInstanceName,
+						CapacityBytes: 1 * util.Tb,
 					},
 				},
 			},
-			signalGetOp:     true,
-			signalIsOpDone:  true,
-			expectedOpStaus: util.StatusSuccess,
-			expectedShareCreateOpInfo: &util.ShareCreateOpInfo{
-				InstanceHandle: testInstanceHandle,
-				OpName:         "op-1",
+			targetShareToAccomodate: &file.Share{
+				Name:          testShareName + "3",
+				CapacityBytes: 900 * util.Gb,
+				Parent: &file.MultishareInstance{
+					Project:       testProject,
+					Location:      testRegion,
+					Name:          testInstanceName,
+					CapacityBytes: 1 * util.Tb,
+				},
 			},
+			expectedNeedsExpand: true,
+			targetBytes:         1*util.Tb + (900*util.Gb - (1*util.Tb - 2*100*util.Gb)),
 		},
 	}
 	for _, tc := range tests {
 		t.Run(tc.name, func(t *testing.T) {
-			opUnblocker := make(chan chan file.Signal)
+			opUnblocker := make(chan chan file.Signal, 1)
 			cloudProvider := initCloudProviderWithBlockingFileService(t, opUnblocker)
 			manager := NewMultishareOpsManager(cloudProvider)
 
-			runRequest := func(ctx context.Context, instanceSCPrefix, shareName string) <-chan Response {
+			runRequest := func(ctx context.Context, share *file.Share) <-chan Response {
 				responseChannel := make(chan Response)
 				go func() {
-					op, status, err := manager.checkAndUpdateShareCreateOp(ctx, instanceSCPrefix, shareName)
+					needsExpand, targetBytes, err := manager.instanceNeedsExpand(context.Background(), share)
 					responseChannel <- Response{
-						opStatus: status,
-						createOp: op,
-						err:      err,
+						instanceNeedsExpand: needsExpand,
+						targetBytes:         targetBytes,
+						err:                 err,
 					}
 				}()
 				return responseChannel
 			}
 
-			// Pre-populate the cache.
-			for _, v := range tc.initShareCreateOpMap {
-				if _, ok := manager.cache.ScInfoMap[v.scKey]; !ok {
-					manager.cache.ScInfoMap[v.scKey] = util.StorageClassInfo{
-						InstanceMap:    make(util.InstanceMap),
-						ShareCreateMap: make(util.ShareCreateMap),
-						ShareOpsMap:    make(util.ShareOpsMap),
-					}
-				}
-				err := manager.cache.AddShareCreateOp(v.scKey, v.shareCreateKey, v.createOp)
-				if err != nil {
-					t.Errorf("failed to add share create op")
-				}
-			}
-
-			respChannel := runRequest(context.Background(), tc.scKey, tc.shareName)
-
-			// Inject mock response
-			if tc.signalGetOp {
-				s := file.Signal{}
-				if tc.getOpStatus != nil {
-					s.ReportError = tc.getOpStatus.reportError
-					s.ReportOpWithErrorStatus = tc.getOpStatus.reportOpWithErrorStatus
-					s.ReportRunning = tc.getOpStatus.reportRunning
-				}
-				execute := <-opUnblocker
-				execute <- s
-			}
-
-			// Inject mock response
-			if tc.signalIsOpDone {
-				s := file.Signal{}
-				if tc.isOpDoneStatus != nil {
-					s.ReportError = tc.isOpDoneStatus.reportError
-					s.ReportOpWithErrorStatus = tc.isOpDoneStatus.reportOpWithErrorStatus
-					s.ReportRunning = tc.isOpDoneStatus.reportRunning
+			for _, share := range tc.initShares {
+				if share.Parent != nil {
+					manager.cloud.File.StartCreateMultishareInstanceOp(context.Background(), share.Parent)
 				}
-				execute := <-opUnblocker
-				execute <- s
+				manager.cloud.File.StartCreateShareOp(context.Background(), &share)
 			}
 
-			// Verify response
+			respChannel := runRequest(context.Background(), tc.targetShareToAccomodate)
 			response := <-respChannel
-			if response.opStatus != tc.expectedOpStaus {
-				t.Errorf("op status want %v, got %v", tc.expectedOpStaus, response.opStatus)
-			}
-			if tc.expectedShareCreateOpInfo == nil && response.createOp != nil {
-				t.Errorf("unexpected share create op found")
-			}
-
-			if tc.expectedShareCreateOpInfo != nil && response.createOp == nil {
-				t.Errorf("expected share create op not found")
+			if tc.expectError && response.err == nil {
+				t.Errorf("expected error")
 			}
-
-			if tc.expectedShareCreateOpInfo != nil && response.createOp != nil {
-				if tc.expectedShareCreateOpInfo.InstanceHandle != response.createOp.InstanceHandle {
-					t.Errorf("want %v, got %v", tc.expectedShareCreateOpInfo.InstanceHandle, response.createOp.InstanceHandle)
-				}
-				if tc.expectedShareCreateOpInfo.OpName != response.createOp.OpName {
-					t.Errorf("want %v, got %v", tc.expectedShareCreateOpInfo.OpName, response.createOp.OpName)
-				}
+			if !tc.expectError && response.err != nil {
+				t.Errorf("unexpectded error")
 			}
-
-			// Verify cache content
-			shareCreateOp := manager.cache.GetShareCreateOp(tc.scKey, tc.shareName)
-			if tc.shareKeyExpectedInCache && shareCreateOp == nil {
-				t.Errorf("expcted share key not found")
+			if tc.expectedNeedsExpand != response.instanceNeedsExpand {
+				t.Errorf("want %v, got %v", tc.expectedNeedsExpand, response.instanceNeedsExpand)
 			}
-			if !tc.shareKeyExpectedInCache && shareCreateOp != nil {
-				t.Errorf("unexpcted share key found")
+			if tc.targetBytes != response.targetBytes {
+				t.Errorf("want %v, got %v", tc.targetBytes, response.targetBytes)
 			}
 		})
 	}
 }
 
-func TestCheckAndUpdateShareOp(t *testing.T) {
-	testShare := &file.Share{
-		Name: testShareName,
-		Parent: &file.MultishareInstance{
-			Project:  testProject,
-			Location: testRegion,
-			Name:     testInstanceName,
-		},
+func TestListInstanceForStorageClassPrefix(t *testing.T) {
+	found := func(inputList []*file.MultishareInstance, i *file.MultishareInstance) bool {
+		for _, f := range inputList {
+			if f.Project == i.Project && f.Location == i.Location && f.Name == i.Name {
+				return true
+			}
+		}
+		return false
 	}
+
 	tests := []struct {
-		name                    string
-		scKey                   string
-		shareKey                util.ShareKey
-		share                   *file.Share
-		initShareOpMap          []Item
-		signalGetOp             bool
-		signalIsOpDone          bool
-		getOpStatus             *MockOpStatus
-		isOpDoneStatus          *MockOpStatus
-		expectedShareOpInfo     *util.OpInfo
-		expectedOpStaus         util.OperationStatus
-		shareKeyExpectedInCache bool
+		name             string
+		initInstanceList []*file.MultishareInstance
+		prefix           string
+		expectedList     []*file.MultishareInstance
 	}{
 		{
-			name:            "tc1 - no share op in cache, unknown op status",
-			scKey:           testInstanceScPrefix,
-			share:           testShare,
-			expectedOpStaus: util.StatusUnknown,
+			name:   "empty init inistance list",
+			prefix: "testprefix",
 		},
 		{
-			name:     "tc2 - get share op returns error, unknown op status, cache entry not cleared",
-			scKey:    testInstanceScPrefix,
-			share:    testShare,
-			shareKey: util.CreateShareKey(testProject, testRegion, testInstanceName, testShareName),
-			initShareOpMap: []Item{
-				{
-					scKey:    testInstanceScPrefix,
-					shareKey: util.CreateShareKey(testProject, testRegion, testInstanceName, testShareName),
-					op: util.OpInfo{
-						Name: "op-1",
-						Type: util.ShareDelete,
+			name:   "non-empty init inistance list",
+			prefix: "testprefix",
+			initInstanceList: []*file.MultishareInstance{
+				{
+					Name:     "test-instance",
+					Project:  "test-project",
+					Location: "us-central1",
+					Labels: map[string]string{
+						util.ParamMultishareInstanceScLabelKey: "testprefix",
 					},
 				},
 			},
-			signalGetOp: true,
-			getOpStatus: &MockOpStatus{
-				reportError: true,
-			},
-			expectedOpStaus: util.StatusUnknown,
-			expectedShareOpInfo: &util.OpInfo{
-				Name: "op-1",
-				Type: util.ShareDelete,
-			},
-			shareKeyExpectedInCache: true,
-		},
-		{
-			name:     "tc3 - IsOpDone returns error, return failed op status, cache entry cleared",
-			scKey:    testInstanceScPrefix,
-			share:    testShare,
-			shareKey: util.CreateShareKey(testProject, testRegion, testInstanceName, testShareName),
-			initShareOpMap: []Item{
-				{
-					scKey:    testInstanceScPrefix,
-					shareKey: util.CreateShareKey(testProject, testRegion, testInstanceName, testShareName),
-					op: util.OpInfo{
-						Name: "op-1",
-						Type: util.ShareDelete,
+			expectedList: []*file.MultishareInstance{
+				{
+					Name:     "test-instance",
+					Project:  "test-project",
+					Location: "us-central1",
+					Labels: map[string]string{
+						util.ParamMultishareInstanceScLabelKey: "testprefix",
 					},
 				},
 			},
-			signalGetOp:    true,
-			signalIsOpDone: true,
-			isOpDoneStatus: &MockOpStatus{
-				reportError: true,
-			},
-			expectedOpStaus: util.StatusFailed,
-			expectedShareOpInfo: &util.OpInfo{
-				Name: "op-1",
-				Type: util.ShareDelete,
-			},
 		},
 		{
-			name:     "tc4 - IsOpDone false, return running op status, cache entry not cleared",
-			scKey:    testInstanceScPrefix,
-			share:    testShare,
-			shareKey: util.CreateShareKey(testProject, testRegion, testInstanceName, testShareName),
-			initShareOpMap: []Item{
-				{
-					scKey:    testInstanceScPrefix,
-					shareKey: util.CreateShareKey(testProject, testRegion, testInstanceName, testShareName),
-					op: util.OpInfo{
-						Name: "op-1",
-						Type: util.ShareDelete,
+			name:   "non-empty init inistance list, 1 instance match",
+			prefix: "testprefix-1",
+			initInstanceList: []*file.MultishareInstance{
+				{
+					Name:     "test-instance-1",
+					Project:  "test-project",
+					Location: "us-central1",
+					Labels: map[string]string{
+						util.ParamMultishareInstanceScLabelKey: "testprefix-1",
 					},
 				},
-			},
-			signalGetOp:    true,
-			signalIsOpDone: true,
-			isOpDoneStatus: &MockOpStatus{
-				reportRunning: true,
-			},
-			expectedOpStaus: util.StatusRunning,
-			expectedShareOpInfo: &util.OpInfo{
-				Name: "op-1",
-				Type: util.ShareDelete,
-			},
-			shareKeyExpectedInCache: true,
-		},
-		{
-			name:     "tc4 - IsOpDone true, return success op status, cache entry cleared",
-			scKey:    testInstanceScPrefix,
-			share:    testShare,
-			shareKey: util.CreateShareKey(testProject, testRegion, testInstanceName, testShareName),
-			initShareOpMap: []Item{
-				{
-					scKey:    testInstanceScPrefix,
-					shareKey: util.CreateShareKey(testProject, testRegion, testInstanceName, testShareName),
-					op: util.OpInfo{
-						Name: "op-1",
-						Type: util.ShareDelete,
+				{
+					Name:     "test-instance-2",
+					Project:  "test-project",
+					Location: "us-central1",
+					Labels: map[string]string{
+						util.ParamMultishareInstanceScLabelKey: "testprefix-2",
 					},
 				},
 			},
-			signalGetOp:     true,
-			signalIsOpDone:  true,
-			expectedOpStaus: util.StatusSuccess,
-			expectedShareOpInfo: &util.OpInfo{
-				Name: "op-1",
-				Type: util.ShareDelete,
-			},
-		},
-	}
-	for _, tc := range tests {
-		t.Run(tc.name, func(t *testing.T) {
-			opUnblocker := make(chan chan file.Signal)
-			cloudProvider := initCloudProviderWithBlockingFileService(t, opUnblocker)
-			manager := NewMultishareOpsManager(cloudProvider)
-
-			runRequest := func(ctx context.Context, instanceSCPrefix string, share *file.Share) <-chan Response {
-				responseChannel := make(chan Response)
-				go func() {
-					op, status, err := manager.checkAndUpdateShareOp(ctx, instanceSCPrefix, share)
-					responseChannel <- Response{
-						opStatus: status,
-						shareOp:  op,
-						err:      err,
-					}
-				}()
-				return responseChannel
-			}
-
-			// Pre-populate the cache.
-			for _, v := range tc.initShareOpMap {
-				if _, ok := manager.cache.ScInfoMap[v.scKey]; !ok {
-					manager.cache.ScInfoMap[v.scKey] = util.StorageClassInfo{
-						InstanceMap:    make(util.InstanceMap),
-						ShareCreateMap: make(util.ShareCreateMap),
-						ShareOpsMap:    make(util.ShareOpsMap),
-					}
-				}
-				err := manager.cache.AddShareOp(v.scKey, v.shareKey, v.op)
-				if err != nil {
-					t.Errorf("failed to add share op to map")
-				}
-			}
-
-			respChannel := runRequest(context.Background(), tc.scKey, tc.share)
-
-			// Inject mock response
-			if tc.signalGetOp {
-				s := file.Signal{}
-				if tc.getOpStatus != nil {
-					s.ReportError = tc.getOpStatus.reportError
-					s.ReportOpWithErrorStatus = tc.getOpStatus.reportOpWithErrorStatus
-					s.ReportRunning = tc.getOpStatus.reportRunning
-				}
-				execute := <-opUnblocker
-				execute <- s
-			}
-
-			// Inject mock response
-			if tc.signalIsOpDone {
-				s := file.Signal{}
-				if tc.isOpDoneStatus != nil {
-					s.ReportError = tc.isOpDoneStatus.reportError
-					s.ReportOpWithErrorStatus = tc.isOpDoneStatus.reportOpWithErrorStatus
-					s.ReportRunning = tc.isOpDoneStatus.reportRunning
-				}
-				execute := <-opUnblocker
-				execute <- s
-			}
-
-			// Verify response
-			response := <-respChannel
-			if response.opStatus != tc.expectedOpStaus {
-				t.Errorf("op status want %v, got %v", tc.expectedOpStaus, response.opStatus)
-			}
-			if tc.expectedShareOpInfo == nil && response.shareOp != nil {
-				t.Errorf("unexpected share create op found")
-			}
-
-			if tc.expectedShareOpInfo != nil && response.shareOp == nil {
-				t.Errorf("expected share create op not found")
-			}
-
-			if tc.expectedShareOpInfo != nil && response.shareOp != nil {
-				if tc.expectedShareOpInfo.Name != response.shareOp.Name {
-					t.Errorf("want %v, got %v", tc.expectedShareOpInfo.Name, response.shareOp.Name)
-				}
-				if tc.expectedShareOpInfo.Type != response.shareOp.Type {
-					t.Errorf("want %v, got %v", tc.expectedShareOpInfo.Type, response.shareOp.Type)
-				}
-			}
-
-			// Verify cache content
-			shareOp := manager.cache.GetShareOp(tc.scKey, tc.shareKey)
-			if tc.shareKeyExpectedInCache && shareOp == nil {
-				t.Errorf("expcted share key not found")
-			}
-			if !tc.shareKeyExpectedInCache && shareOp != nil {
-				t.Errorf("unexpcted share key found")
-			}
-		})
-	}
-}
-
-func TestVerifyNoRunningInstanceOps(t *testing.T) {
-	tests := []struct {
-		name                       string
-		scKey                      string
-		instanceKey                util.InstanceKey
-		instance                   *file.MultishareInstance
-		initInstanceOpMap          []Item
-		signalGetOp                bool
-		signalIsOpDone             bool
-		getOpStatus                *MockOpStatus
-		isOpDoneStatus             *MockOpStatus
-		errorExpected              bool
-		expectedVerificationStaus  bool
-		instanceKeyExpectedInCache bool
-		emptyOpExpected            bool
-	}{
-		{
-			name:        "tc1 - no instance op in cache, verified",
-			scKey:       testInstanceScPrefix,
-			instanceKey: util.CreateInstanceKey(testProject, testRegion, testInstanceName),
-			instance: &file.MultishareInstance{
-				Project:  testProject,
-				Location: testRegion,
-				Name:     testInstanceName,
-			},
-			expectedVerificationStaus: true,
-		},
-		{
-			name:        "tc2 - get instance op returns empty op, verified",
-			scKey:       testInstanceScPrefix,
-			instanceKey: util.CreateInstanceKey(testProject, testRegion, testInstanceName),
-			instance: &file.MultishareInstance{
-				Project:  testProject,
-				Location: testRegion,
-				Name:     testInstanceName,
-			},
-			initInstanceOpMap: []Item{
+			expectedList: []*file.MultishareInstance{
 				{
-					scKey:       testInstanceScPrefix,
-					instanceKey: util.CreateInstanceKey(testProject, testRegion, testInstanceName),
-					op:          util.OpInfo{},
+					Name:     "test-instance-1",
+					Project:  "test-project",
+					Location: "us-central1",
+					Labels: map[string]string{
+						util.ParamMultishareInstanceScLabelKey: "testprefix-1",
+					},
 				},
 			},
-			instanceKeyExpectedInCache: true,
-			emptyOpExpected:            true,
-			expectedVerificationStaus:  true,
 		},
-
 		{
-			name:        "tc3 - get instance op returns error, status not verified",
-			scKey:       testInstanceScPrefix,
-			instanceKey: util.CreateInstanceKey(testProject, testRegion, testInstanceName),
-			instance: &file.MultishareInstance{
-				Project:  testProject,
-				Location: testRegion,
-				Name:     testInstanceName,
-			},
-			initInstanceOpMap: []Item{
+			name:   "non-empty init inistance list, 2 instances match",
+			prefix: "testprefix",
+			initInstanceList: []*file.MultishareInstance{
+				{
+					Name:     "test-instance-1",
+					Project:  "test-project",
+					Location: "us-central1",
+					Labels: map[string]string{
+						util.ParamMultishareInstanceScLabelKey: "testprefix",
+					},
+				},
 				{
-					scKey:       testInstanceScPrefix,
-					instanceKey: util.CreateInstanceKey(testProject, testRegion, testInstanceName),
-					op: util.OpInfo{
-						Name: "op-1",
-						Type: util.InstanceCreate,
+					Name:     "test-instance-2",
+					Project:  "test-project",
+					Location: "us-central1",
+					Labels: map[string]string{
+						util.ParamMultishareInstanceScLabelKey: "testprefix",
 					},
 				},
-			},
-			signalGetOp: true,
-			getOpStatus: &MockOpStatus{
-				reportError: true,
-			},
-			errorExpected:              true,
-			instanceKeyExpectedInCache: true,
-		},
-		{
-			name:        "tc4 - IsOpDone returns error for completeed op, status verified",
-			scKey:       testInstanceScPrefix,
-			instanceKey: util.CreateInstanceKey(testProject, testRegion, testInstanceName),
-			instance: &file.MultishareInstance{
-				Project:  testProject,
-				Location: testRegion,
-				Name:     testInstanceName,
-			},
-			initInstanceOpMap: []Item{
 				{
-					scKey:       testInstanceScPrefix,
-					instanceKey: util.CreateInstanceKey(testProject, testRegion, testInstanceName),
-					op: util.OpInfo{
-						Name: "op-1",
-						Type: util.InstanceCreate,
+					Name:     "test-instance-3",
+					Project:  "test-project",
+					Location: "us-central1",
+					Labels: map[string]string{
+						util.ParamMultishareInstanceScLabelKey: "testprefix-3",
 					},
 				},
 			},
-			signalGetOp:    true,
-			signalIsOpDone: true,
-			isOpDoneStatus: &MockOpStatus{
-				reportError: true,
-			},
-			instanceKeyExpectedInCache: true,
-			expectedVerificationStaus:  true,
-		},
-		{
-			name:        "tc5 - IsOpDone returns false, status not verified",
-			scKey:       testInstanceScPrefix,
-			instanceKey: util.CreateInstanceKey(testProject, testRegion, testInstanceName),
-			instance: &file.MultishareInstance{
-				Project:  testProject,
-				Location: testRegion,
-				Name:     testInstanceName,
-			},
-			initInstanceOpMap: []Item{
+			expectedList: []*file.MultishareInstance{
 				{
-					scKey:       testInstanceScPrefix,
-					instanceKey: util.CreateInstanceKey(testProject, testRegion, testInstanceName),
-					op: util.OpInfo{
-						Name: "op-1",
-						Type: util.InstanceCreate,
+					Name:     "test-instance-1",
+					Project:  "test-project",
+					Location: "us-central1",
+					Labels: map[string]string{
+						util.ParamMultishareInstanceScLabelKey: "testprefix",
 					},
 				},
-			},
-			signalGetOp:    true,
-			signalIsOpDone: true,
-			isOpDoneStatus: &MockOpStatus{
-				reportRunning: true,
-			},
-			instanceKeyExpectedInCache: true,
-			expectedVerificationStaus:  false,
-		},
-		{
-			name:        "tc5 - IsOpDone true, status verified",
-			scKey:       testInstanceScPrefix,
-			instanceKey: util.CreateInstanceKey(testProject, testRegion, testInstanceName),
-			instance: &file.MultishareInstance{
-				Project:  testProject,
-				Location: testRegion,
-				Name:     testInstanceName,
-			},
-			initInstanceOpMap: []Item{
 				{
-					scKey:       testInstanceScPrefix,
-					instanceKey: util.CreateInstanceKey(testProject, testRegion, testInstanceName),
-					op: util.OpInfo{
-						Name: "op-1",
-						Type: util.InstanceCreate,
+					Name:     "test-instance-2",
+					Project:  "test-project",
+					Location: "us-central1",
+					Labels: map[string]string{
+						util.ParamMultishareInstanceScLabelKey: "testprefix",
 					},
 				},
 			},
-			signalGetOp:    true,
-			signalIsOpDone: true,
-			isOpDoneStatus: &MockOpStatus{
-				reportRunning: true,
-			},
-			instanceKeyExpectedInCache: true,
-			expectedVerificationStaus:  false,
-		}}
+		},
+	}
 	for _, tc := range tests {
 		t.Run(tc.name, func(t *testing.T) {
-			opUnblocker := make(chan chan file.Signal)
-			cloudProvider := initCloudProviderWithBlockingFileService(t, opUnblocker)
-			manager := NewMultishareOpsManager(cloudProvider)
-
-			runRequest := func(ctx context.Context, instanceSCPrefix string, instance *file.MultishareInstance) <-chan Response {
-				responseChannel := make(chan Response)
-				go func() {
-					status, err := manager.verifyNoRunningInstanceOps(ctx, instanceSCPrefix, instance)
-					responseChannel <- Response{
-						verified: status,
-						err:      err,
-					}
-				}()
-				return responseChannel
-			}
-
-			// Pre-populate the cache.
-			for _, v := range tc.initInstanceOpMap {
-				manager.cache.AddInstanceOp(v.scKey, v.instanceKey, v.op)
+			cloudProvider, err := cloud.NewFakeCloud()
+			if err != nil {
+				t.Fatalf("failed to initialize Provider: %v", err)
 			}
 
-			respChannel := runRequest(context.Background(), tc.scKey, tc.instance)
-
-			// Inject mock response
-			if tc.signalGetOp {
-				s := file.Signal{}
-				if tc.getOpStatus != nil {
-					s.ReportError = tc.getOpStatus.reportError
-					s.ReportOpWithErrorStatus = tc.getOpStatus.reportOpWithErrorStatus
-					s.ReportRunning = tc.getOpStatus.reportRunning
-				}
-				execute := <-opUnblocker
-				execute <- s
+			for _, i := range tc.initInstanceList {
+				cloudProvider.File.StartCreateMultishareInstanceOp(context.Background(), i)
 			}
 
-			// Inject mock response
-			if tc.signalIsOpDone {
-				s := file.Signal{}
-				if tc.isOpDoneStatus != nil {
-					s.ReportError = tc.isOpDoneStatus.reportError
-					s.ReportOpWithErrorStatus = tc.isOpDoneStatus.reportOpWithErrorStatus
-					s.ReportRunning = tc.isOpDoneStatus.reportRunning
+			manager := NewMultishareOpsManager(cloudProvider)
+			filteredList, err := manager.listInstanceForStorageClassPrefix(context.Background(), tc.prefix)
+			for _, fi := range filteredList {
+				if !found(tc.expectedList, fi) {
+					t.Errorf("Failed to find instance")
 				}
-				execute := <-opUnblocker
-				execute <- s
-			}
-
-			// Verify response
-			response := <-respChannel
-			if response.verified != tc.expectedVerificationStaus {
-				t.Errorf("verify status want %v, got %v", tc.expectedVerificationStaus, response.verified)
-			}
-
-			if tc.errorExpected && response.err == nil {
-				t.Errorf("expected error not found")
-			}
-			if !tc.errorExpected && response.err != nil {
-				t.Errorf("unexpected error found")
-			}
-
-			// Verify cache content
-			instanceOp := manager.cache.GetInstanceOp(tc.scKey, tc.instanceKey)
-			if tc.instanceKeyExpectedInCache && instanceOp == nil {
-				t.Errorf("expcted instance key not found")
-			}
-			if !tc.instanceKeyExpectedInCache && instanceOp != nil {
-				t.Errorf("unexpcted instance key found")
-			}
-			if tc.emptyOpExpected && instanceOp.Name != "" {
-				t.Errorf("expcted empty op")
 			}
 		})
 	}
 }
 
-func TestVerifyNoRunningShareOp(t *testing.T) {
+func TestContainsOpWithInstanceTargetPrefix(t *testing.T) {
 	tests := []struct {
-		name                         string
-		scKey                        string
-		share                        *file.Share
-		initShareCreateOpMap         []Item
-		initShareOpMap               []Item
-		signalGetOpForShareCreate    bool
-		signalIsOpDoneForShareCreate bool
-		getOpStatusforShareCreate    *MockOpStatus
-		isOpDoneStatusForShareCreate *MockOpStatus
-		signalGetOpForShareOp        bool
-		signalIsOpDoneForShareOp     bool
-		getOpStatusforShareOp        *MockOpStatus
-		isOpDoneStatusForShareOp     *MockOpStatus
-
-		errorExpected             bool
-		expectedVerificationStaus bool
+		name          string
+		inputInstance *file.MultishareInstance
+		inputOps      []*OpInfo
+		opExpected    bool
+		errorExpected bool
 	}{
 		{
-			name:  "tc1 - no share create op in cache, no share op in cache",
-			scKey: testInstanceScPrefix,
-			share: &file.Share{
-				Name: testShareName,
-				Parent: &file.MultishareInstance{
-					Project:  testProject,
-					Location: testLocation,
-					Name:     testInstanceName,
-				},
+			name: "empty ops list",
+			inputInstance: &file.MultishareInstance{
+				Name:     "test-instance",
+				Project:  "test-project",
+				Location: "us-central1",
 			},
-			expectedVerificationStaus: true,
 		},
 		{
-			name:  "tc2 - check for share create op returns error, status not verified",
-			scKey: testInstanceScPrefix,
-			share: &file.Share{
-				Name: testShareName,
-				Parent: &file.MultishareInstance{
-					Project:  testProject,
-					Location: testLocation,
-					Name:     testInstanceName,
-				},
-			},
-			initShareCreateOpMap: []Item{
-				{
-					scKey:          testInstanceScPrefix,
-					shareCreateKey: testShareName,
-					createOp: util.ShareCreateOpInfo{
-						InstanceHandle: testInstanceHandle,
-						OpName:         "op-1",
-					},
-				},
+			name: "invalid instance, missing location",
+			inputInstance: &file.MultishareInstance{
+				Name:    "test-instance",
+				Project: "test-project",
 			},
-			signalGetOpForShareCreate: true,
-			getOpStatusforShareCreate: &MockOpStatus{
-				reportError: true,
+			errorExpected: true,
+		},
+		{
+			name: "invalid instance, missing project",
+			inputInstance: &file.MultishareInstance{
+				Name:     "test-instance",
+				Location: "us-central1",
 			},
-			expectedVerificationStaus: false,
-			errorExpected:             true,
+			errorExpected: true,
 		},
 		{
-			name:  "tc3 - check for share create op returns a stale op status complete in isOpDone, check for share op returns error in get op, status not verified",
-			scKey: testInstanceScPrefix,
-			share: &file.Share{
-				Name: testShareName,
-				Parent: &file.MultishareInstance{
-					Project:  testProject,
-					Location: testRegion,
-					Name:     testInstanceName,
-				},
+			name: "invalid instance, missing name",
+			inputInstance: &file.MultishareInstance{
+				Location: "us-central1",
+				Project:  "test-project",
 			},
-			initShareCreateOpMap: []Item{
-				{
-					scKey:          testInstanceScPrefix,
-					shareCreateKey: testShareName,
-					createOp: util.ShareCreateOpInfo{
-						InstanceHandle: testInstanceHandle,
-						OpName:         "op-1",
-					},
-				},
+			errorExpected: true,
+		},
+		{
+			name: "valid instance, no running instance prefixed op",
+			inputInstance: &file.MultishareInstance{
+				Location: "us-central1",
+				Project:  "test-project",
+				Name:     "test-instance",
 			},
-			initShareOpMap: []Item{
+			inputOps: []*OpInfo{
 				{
-					scKey:    testInstanceScPrefix,
-					shareKey: util.CreateShareKey(testProject, testRegion, testInstanceName, testShareName),
-					op: util.OpInfo{
-						Name: "op-1",
-						Type: util.ShareDelete,
-					},
+					Id:     "op1",
+					Type:   util.InstanceCreate,
+					Target: "projects/test-project/locations/us-central1/instances/test-instance1",
 				},
 			},
-			signalGetOpForShareCreate:    true,
-			signalIsOpDoneForShareCreate: true,
-			signalGetOpForShareOp:        true,
-			getOpStatusforShareOp: &MockOpStatus{
-				reportError: true,
-			},
-			expectedVerificationStaus: false,
-			errorExpected:             true,
 		},
 		{
-			name:  "tc4 - check for share create op returns nil, check for share op returns op fialed, status verified",
-			scKey: testInstanceScPrefix,
-			share: &file.Share{
-				Name: testShareName,
-				Parent: &file.MultishareInstance{
-					Project:  testProject,
-					Location: testRegion,
-					Name:     testInstanceName,
-				},
+			name: "valid instance, running instance op",
+			inputInstance: &file.MultishareInstance{
+				Location: "us-central1",
+				Project:  "test-project",
+				Name:     "test-instance",
 			},
-			initShareOpMap: []Item{
+			inputOps: []*OpInfo{
 				{
-					scKey:    testInstanceScPrefix,
-					shareKey: util.CreateShareKey(testProject, testRegion, testInstanceName, testShareName),
-					op: util.OpInfo{
-						Name: "op-1",
-						Type: util.ShareDelete,
-					},
+					Id:     "op1",
+					Type:   util.InstanceCreate,
+					Target: "projects/test-project/locations/us-central1/instances/test-instance",
 				},
 			},
-			signalGetOpForShareOp:    true,
-			signalIsOpDoneForShareOp: true,
-			isOpDoneStatusForShareOp: &MockOpStatus{
-				reportError: true,
-			},
-			expectedVerificationStaus: true,
-			errorExpected:             false,
+			opExpected: true,
 		},
 		{
-			name:  "tc4 - check for share create op returns nil, check for share op returns op success, status verified",
-			scKey: testInstanceScPrefix,
-			share: &file.Share{
-				Name: testShareName,
-				Parent: &file.MultishareInstance{
-					Project:  testProject,
-					Location: testRegion,
-					Name:     testInstanceName,
-				},
+			name: "valid instance, running share op",
+			inputInstance: &file.MultishareInstance{
+				Location: "us-central1",
+				Project:  "test-project",
+				Name:     "test-instance",
 			},
-			initShareOpMap: []Item{
+			inputOps: []*OpInfo{
 				{
-					scKey:    testInstanceScPrefix,
-					shareKey: util.CreateShareKey(testProject, testRegion, testInstanceName, testShareName),
-					op: util.OpInfo{
-						Name: "op-1",
-						Type: util.ShareDelete,
-					},
+					Id:     "op1",
+					Type:   util.InstanceCreate,
+					Target: "projects/test-project/locations/us-central1/instances/test-instance/shares/test-share",
 				},
 			},
-			signalGetOpForShareOp:     true,
-			signalIsOpDoneForShareOp:  true,
-			expectedVerificationStaus: true,
-			errorExpected:             false,
+			opExpected: true,
 		},
-	}
-	for _, tc := range tests {
-		t.Run(tc.name, func(t *testing.T) {
-			opUnblocker := make(chan chan file.Signal)
-			cloudProvider := initCloudProviderWithBlockingFileService(t, opUnblocker)
-			manager := NewMultishareOpsManager(cloudProvider)
-
-			runRequest := func(ctx context.Context, instanceSCPrefix string, share *file.Share) <-chan Response {
-				responseChannel := make(chan Response)
-				go func() {
-					status, err := manager.verifyNoRunningShareOp(ctx, instanceSCPrefix, share)
-					responseChannel <- Response{
-						verified: status,
-						err:      err,
-					}
-				}()
-				return responseChannel
-			}
-			// Pre-populate the share create op map
-			for _, v := range tc.initShareCreateOpMap {
-				if _, ok := manager.cache.ScInfoMap[v.scKey]; !ok {
-					manager.cache.ScInfoMap[v.scKey] = util.StorageClassInfo{
-						InstanceMap:    make(util.InstanceMap),
-						ShareCreateMap: make(util.ShareCreateMap),
-						ShareOpsMap:    make(util.ShareOpsMap),
-					}
-				}
-				manager.cache.AddShareCreateOp(v.scKey, v.shareCreateKey, v.createOp)
-			}
-
-			// Pre-populate the share op map
-			for _, v := range tc.initShareOpMap {
-				if _, ok := manager.cache.ScInfoMap[v.scKey]; !ok {
-					manager.cache.ScInfoMap[v.scKey] = util.StorageClassInfo{
-						InstanceMap:    make(util.InstanceMap),
-						ShareCreateMap: make(util.ShareCreateMap),
-						ShareOpsMap:    make(util.ShareOpsMap),
-					}
-				}
-				manager.cache.AddShareOp(v.scKey, v.shareKey, v.op)
-			}
-
-			respChannel := runRequest(context.Background(), tc.scKey, tc.share)
-
-			// Inject mock response
-			if tc.signalGetOpForShareCreate {
-				s := file.Signal{}
-				if tc.getOpStatusforShareCreate != nil {
-					s.ReportError = tc.getOpStatusforShareCreate.reportError
-					s.ReportOpWithErrorStatus = tc.getOpStatusforShareCreate.reportOpWithErrorStatus
-					s.ReportRunning = tc.getOpStatusforShareCreate.reportRunning
-				}
-				execute := <-opUnblocker
-				execute <- s
-			}
-
-			// Inject mock response
-			if tc.signalIsOpDoneForShareCreate {
-				s := file.Signal{}
-				if tc.isOpDoneStatusForShareCreate != nil {
-					s.ReportError = tc.isOpDoneStatusForShareCreate.reportError
-					s.ReportOpWithErrorStatus = tc.isOpDoneStatusForShareCreate.reportOpWithErrorStatus
-					s.ReportRunning = tc.isOpDoneStatusForShareCreate.reportRunning
-				}
-				execute := <-opUnblocker
-				execute <- s
+	}
+	for _, tc := range tests {
+		t.Run(tc.name, func(t *testing.T) {
+			op, err := containsOpWithInstanceTargetPrefix(tc.inputInstance, tc.inputOps)
+			if tc.errorExpected && err == nil {
+				t.Errorf("expected error, found none")
 			}
-
-			// Inject mock response
-			if tc.signalGetOpForShareOp {
-				s := file.Signal{}
-				if tc.getOpStatusforShareOp != nil {
-					s.ReportError = tc.getOpStatusforShareOp.reportError
-					s.ReportOpWithErrorStatus = tc.getOpStatusforShareOp.reportOpWithErrorStatus
-					s.ReportRunning = tc.getOpStatusforShareOp.reportRunning
-				}
-				execute := <-opUnblocker
-				execute <- s
+			if !tc.errorExpected && err != nil {
+				t.Errorf("unexpected error")
 			}
 
-			// Inject mock response
-			if tc.signalIsOpDoneForShareOp {
-				s := file.Signal{}
-				if tc.isOpDoneStatusForShareOp != nil {
-					s.ReportError = tc.isOpDoneStatusForShareOp.reportError
-					s.ReportOpWithErrorStatus = tc.isOpDoneStatusForShareOp.reportOpWithErrorStatus
-					s.ReportRunning = tc.isOpDoneStatusForShareOp.reportRunning
-				}
-				execute := <-opUnblocker
-				execute <- s
-			}
-			// Verify response
-			response := <-respChannel
-			if response.verified != tc.expectedVerificationStaus {
-				t.Errorf("op status want %v, got %v", tc.expectedVerificationStaus, response.verified)
-			}
-			if response.err != nil && !tc.errorExpected {
-				t.Errorf("got unexpected error")
+			if tc.opExpected && op == nil {
+				t.Errorf("expected op, found none")
 			}
-			if response.err == nil && tc.errorExpected {
-				t.Errorf("expected error")
+			if !tc.opExpected && op != nil {
+				t.Errorf("unexpected op")
 			}
 		})
 	}
 }
 
-func TestRunEligibleInstanceCheck(t *testing.T) {
+func TestContainsOpWithShareName(t *testing.T) {
 	tests := []struct {
-		name                              string
-		scKey                             string
-		initInstance                      []file.MultishareInstance
-		initShares                        []file.Share
-		initInstanceOpMap                 []Item
-		numSignalGetOpForInstance         int
-		numsignalIsOpDoneForInstance      int
-		isOpDoneStatusForInstance         []MockOpStatus
-		numSignalGetInstance              int
-		reportErrorForGetInstance         []bool
-		reportNotFoundErrorForGetInstance []bool
-		expectedNumReadyInstances         int
-		expectedNumNonReadyInstances      int
-		expectedError                     bool
+		name       string
+		shareName  string
+		opType     util.OperationType
+		inputops   []*OpInfo
+		opExpected bool
 	}{
 		{
-			name:  "tc1-empty instance map",
-			scKey: testInstanceScPrefix,
+			name:      "empty input ops",
+			shareName: "test-share",
 		},
 		{
-			name:  "single instance in map, failed to parse handle",
-			scKey: testInstanceScPrefix,
-			initInstanceOpMap: []Item{
+			name:      "share not found in input ops",
+			shareName: "test-share",
+			inputops: []*OpInfo{
 				{
-					instanceKey: util.InstanceKey("blah"),
-					op:          util.OpInfo{},
+					Id:     "op1",
+					Type:   util.InstanceCreate,
+					Target: "projects/test-project/locations/us-central1/instances/test-instance",
 				},
 			},
 		},
+	}
+	for _, tc := range tests {
+		t.Run(tc.name, func(t *testing.T) {
+			op := containsOpWithShareName(tc.shareName, tc.opType, tc.inputops)
+			if tc.opExpected && op == nil {
+				t.Errorf("expected op, found none")
+			}
+			if !tc.opExpected && op != nil {
+				t.Errorf("unexpected op")
+			}
+		})
+	}
+}
+
+func TestListMultishareResourceRunningOps(t *testing.T) {
+	found := func(inputList []*OpInfo, i *OpInfo) bool {
+		for _, f := range inputList {
+			if i.Id == f.Id && i.Target == f.Target && i.Type == f.Type {
+				return true
+			}
+		}
+		return false
+	}
+
+	type OpItem struct {
+		id     string
+		target string
+		verb   string
+		done   bool
+	}
+	tests := []struct {
+		name        string
+		initOps     []*OpItem
+		expectedOps []*OpInfo
+	}{
 		{
-			name:  "tc2-single ready instance in map, GET failed",
-			scKey: testInstanceScPrefix,
-			initInstanceOpMap: []Item{
+			name: "filter out done ops",
+			initOps: []*OpItem{
 				{
-					instanceKey: util.CreateInstanceKey(testProject, testRegion, testInstanceName),
-					op:          util.OpInfo{},
+					id:     "op1",
+					target: "projects/test-project/locations/us-central1/instances/test-instance",
+					verb:   "create",
+					done:   true,
 				},
-			},
-			numSignalGetInstance:              1,
-			reportErrorForGetInstance:         []bool{false},
-			reportNotFoundErrorForGetInstance: []bool{false},
-		},
-		{
-			name:  "tc3-single ready instance with 0 shares in map, GET success",
-			scKey: testInstanceScPrefix,
-			initInstanceOpMap: []Item{
 				{
-					instanceKey: util.CreateInstanceKey(testProject, testRegion, testInstanceName),
-					op:          util.OpInfo{},
+					id:     "op2",
+					target: "projects/test-project/locations/us-central1/instances/test-instance",
+					verb:   "update",
 				},
 			},
-			initInstance: []file.MultishareInstance{
+			expectedOps: []*OpInfo{
 				{
-					Name:     testInstanceName,
-					Project:  testProject,
-					Location: testRegion,
+					Id:     "op2",
+					Target: "projects/test-project/locations/us-central1/instances/test-instance",
+					Type:   util.InstanceUpdate,
 				},
 			},
-			numSignalGetInstance:              1,
-			reportErrorForGetInstance:         []bool{false},
-			reportNotFoundErrorForGetInstance: []bool{false},
-			expectedNumReadyInstances:         1,
 		},
 		{
-			name:  "tc4-two ready instance (no op in map) with 0 shares in map, GET success",
-			scKey: testInstanceScPrefix,
-			initInstanceOpMap: []Item{
+			name: "filter out done ops",
+			initOps: []*OpItem{
 				{
-					instanceKey: util.CreateInstanceKey(testProject, testRegion, testInstanceName+"1"),
-					op:          util.OpInfo{},
+					id:     "op1",
+					target: "projects/test-project/locations/us-central1/instances/test-instance",
+					verb:   "create",
+					done:   true,
 				},
 				{
-					instanceKey: util.CreateInstanceKey(testProject, testRegion, testInstanceName+"2"),
-					op:          util.OpInfo{},
+					id:     "op2",
+					target: "projects/test-project/locations/us-central1/instances/test-instance",
+					verb:   "update",
 				},
 			},
-			initInstance: []file.MultishareInstance{
-				{
-					Name:     testInstanceName + "1",
-					Project:  testProject,
-					Location: testRegion,
-				},
+			expectedOps: []*OpInfo{
 				{
-					Name:     testInstanceName + "2",
-					Project:  testProject,
-					Location: testRegion,
+					Id:     "op2",
+					Target: "projects/test-project/locations/us-central1/instances/test-instance",
+					Type:   util.InstanceUpdate,
 				},
 			},
-			numSignalGetInstance:              2,
-			reportErrorForGetInstance:         []bool{false, false},
-			reportNotFoundErrorForGetInstance: []bool{false, false},
-			expectedNumReadyInstances:         2,
 		},
 		{
-			name:  "tc5-two ready instance (op in map, that is complete) with 0 shares in map, GET success",
-			scKey: testInstanceScPrefix,
-			initInstanceOpMap: []Item{
+			name: "skip resources other than instance and shares",
+			initOps: []*OpItem{
 				{
-					instanceKey: util.CreateInstanceKey(testProject, testRegion, testInstanceName+"1"),
-					op: util.OpInfo{
-						Name: "op-1",
-						Type: util.InstanceCreate,
-					},
+					id:     "op1",
+					target: "projects/test-project/locations/us-central1/instances/test-instance-1",
+					verb:   "create",
 				},
 				{
-					instanceKey: util.CreateInstanceKey(testProject, testRegion, testInstanceName+"2"),
-					op: util.OpInfo{
-						Name: "op-2",
-						Type: util.InstanceCreate,
-					},
+					id:     "op2",
+					target: "projects/test-project/locations/us-central1/instances/test-instance-2",
+					verb:   "update",
 				},
-			},
-			initInstance: []file.MultishareInstance{
 				{
-					Name:     testInstanceName + "1",
-					Project:  testProject,
-					Location: testRegion,
+					id:     "op3",
+					target: "projects/test-project/locations/us-central1/backups/test-backup",
+					verb:   "create",
 				},
 				{
-					Name:     testInstanceName + "2",
-					Project:  testProject,
-					Location: testRegion,
+					id:     "op4",
+					target: "projects/test-project/locations/us-central1/snapshots/test-snapshot",
+					verb:   "create",
 				},
 			},
-			numSignalGetOpForInstance:    2,
-			numsignalIsOpDoneForInstance: 2,
-			isOpDoneStatusForInstance: []MockOpStatus{
+			expectedOps: []*OpInfo{
 				{
-					reportRunning:           false,
-					reportNotFoundError:     false,
-					reportOpWithErrorStatus: false,
+					Id:     "op1",
+					Target: "projects/test-project/locations/us-central1/instances/test-instance-1",
+					Type:   util.InstanceCreate,
 				},
 				{
-					reportRunning:           false,
-					reportNotFoundError:     false,
-					reportOpWithErrorStatus: false,
+					Id:     "op2",
+					Target: "projects/test-project/locations/us-central1/instances/test-instance-2",
+					Type:   util.InstanceUpdate,
 				},
 			},
-			numSignalGetInstance:              2,
-			reportErrorForGetInstance:         []bool{false, false},
-			reportNotFoundErrorForGetInstance: []bool{false, false},
-			expectedNumReadyInstances:         2,
 		},
+	}
+	for _, tc := range tests {
+		t.Run(tc.name, func(t *testing.T) {
+			var v1beta1ops []*filev1beta1multishare.Operation
+			for _, item := range tc.initOps {
+				var meta filev1beta1multishare.OperationMetadata
+				meta.Target = item.target
+				meta.Verb = item.verb
+				bytes, _ := json.Marshal(meta)
+				v1beta1ops = append(v1beta1ops, &filev1beta1multishare.Operation{
+					Name:     item.id,
+					Done:     item.done,
+					Metadata: bytes,
+				})
+			}
+
+			s, err := file.NewFakeServiceForMultishare(nil, nil, v1beta1ops)
+			if err != nil {
+				t.Fatalf("failed to fake service: %v", err)
+			}
+			cloudProvider, err := cloud.NewFakeCloud()
+			cloudProvider.File = s
+			manager := NewMultishareOpsManager(cloudProvider)
+			ops, err := manager.listMultishareResourceRunningOps(context.Background())
+			if err != nil {
+				t.Fatalf("failed to initialize GCFS service: %v", err)
+			}
+			for _, o := range ops {
+				if !found(tc.expectedOps, o) {
+					t.Errorf("unexpected op")
+				}
+			}
+		})
+	}
+}
+
+func TestVerifyNoRunningInstanceOps(t *testing.T) {
+	tests := []struct {
+		name          string
+		ops           []*OpInfo
+		instance      *file.MultishareInstance
+		errorExpected bool
+	}{
 		{
-			name:  "tc6-two instance (delete op in map, that is complete) with 0 shares in map",
-			scKey: testInstanceScPrefix,
-			initInstanceOpMap: []Item{
-				{
-					instanceKey: util.CreateInstanceKey(testProject, testRegion, testInstanceName+"1"),
-					op: util.OpInfo{
-						Name: "op-1",
-						Type: util.InstanceDelete,
-					},
-				},
+			name: "no error",
+			ops: []*OpInfo{
 				{
-					instanceKey: util.CreateInstanceKey(testProject, testRegion, testInstanceName+"2"),
-					op: util.OpInfo{
-						Name: "op-2",
-						Type: util.InstanceDelete,
-					},
+					Id:     "op1",
+					Target: "projects/test-project/locations/us-central1/instances/test-instance-1",
 				},
 			},
-			initInstance: []file.MultishareInstance{
-				{
-					Name:     testInstanceName + "1",
-					Project:  testProject,
-					Location: testRegion,
-				},
-				{
-					Name:     testInstanceName + "2",
-					Project:  testProject,
-					Location: testRegion,
-				},
+			instance: &file.MultishareInstance{
+				Name:     "test-instance-2",
+				Project:  "test-project",
+				Location: "us-central1",
 			},
-			numSignalGetOpForInstance:    2,
-			numsignalIsOpDoneForInstance: 2,
-			isOpDoneStatusForInstance: []MockOpStatus{
-				{
-					reportRunning:           false,
-					reportNotFoundError:     false,
-					reportOpWithErrorStatus: false,
-				},
-				{
-					reportRunning:           false,
-					reportNotFoundError:     false,
-					reportOpWithErrorStatus: false,
-				},
+		},
+		{
+			name: "invalid instance case1",
+			instance: &file.MultishareInstance{
+				Project:  "test-project",
+				Location: "us-central1",
 			},
-			numSignalGetInstance:              2,
-			reportErrorForGetInstance:         []bool{false, false},
-			reportNotFoundErrorForGetInstance: []bool{true, true},
+			errorExpected: true,
 		},
 		{
-			name:  "tc7-two instance (one ready, one not ready) with 0 shares in map",
-			scKey: testInstanceScPrefix,
-			initInstanceOpMap: []Item{
-				{
-					instanceKey: util.CreateInstanceKey(testProject, testRegion, testInstanceName+"1"),
-					op: util.OpInfo{
-						Name: "op-1",
-						Type: util.InstanceCreate,
-					},
-				},
-				{
-					instanceKey: util.CreateInstanceKey(testProject, testRegion, testInstanceName+"2"),
-					op: util.OpInfo{
-						Name: "op-2",
-						Type: util.InstanceExpand,
-					},
-				},
+			name: "invalid instance case2",
+			instance: &file.MultishareInstance{
+				Name:     "test-instance-2",
+				Location: "us-central1",
+			},
+			errorExpected: true,
+		},
+		{
+			name: "invalid instance case3",
+			instance: &file.MultishareInstance{
+				Name:    "test-instance-2",
+				Project: "test-project",
+			},
+			errorExpected: true,
+		},
+		{
+			name: "error found running op",
+			instance: &file.MultishareInstance{
+				Name:     "test-instance-1",
+				Project:  "test-project",
+				Location: "us-central1",
 			},
-			initInstance: []file.MultishareInstance{
+			ops: []*OpInfo{
 				{
-					Name:     testInstanceName + "1",
-					Project:  testProject,
-					Location: testRegion,
+					Id:     "op1",
+					Target: "projects/test-project/locations/us-central1/instances/test-instance-1",
 				},
+			},
+			errorExpected: true,
+		},
+		{
+			name: "no running op match",
+			instance: &file.MultishareInstance{
+				Name:     "test-instance-1",
+				Project:  "test-project",
+				Location: "us-central1",
+			},
+			ops: []*OpInfo{
 				{
-					Name:     testInstanceName + "2",
-					Project:  testProject,
-					Location: testRegion,
+					Id:     "op1",
+					Target: "projects/test-project/locations/us-central1/instances/test-instance-12",
 				},
 			},
-			numSignalGetOpForInstance:    2,
-			numsignalIsOpDoneForInstance: 2,
-			isOpDoneStatusForInstance: []MockOpStatus{
+		},
+	}
+	for _, tc := range tests {
+		t.Run(tc.name, func(t *testing.T) {
+			s, err := file.NewFakeServiceForMultishare(nil, nil, nil)
+			if err != nil {
+				t.Fatalf("failed to fake service: %v", err)
+			}
+			cloudProvider, err := cloud.NewFakeCloud()
+			cloudProvider.File = s
+			manager := NewMultishareOpsManager(cloudProvider)
+			err = manager.verifyNoRunningInstanceOps(tc.instance, tc.ops)
+			if tc.errorExpected && err == nil {
+				t.Errorf("expected error, found none")
+			}
+			if !tc.errorExpected && err != nil {
+				t.Errorf("unexpected error")
+			}
+		})
+	}
+}
+
+func TestVerifyNoRunningInstanceOrShareOpsForInstance(t *testing.T) {
+	tests := []struct {
+		name          string
+		ops           []*OpInfo
+		instance      *file.MultishareInstance
+		errorExpected bool
+	}{
+		{
+			name: "no error, no matching instance",
+			ops: []*OpInfo{
 				{
-					reportRunning:           false,
-					reportNotFoundError:     false,
-					reportOpWithErrorStatus: false,
+					Id:     "op1",
+					Target: "projects/test-project/locations/us-central1/instances/test-instance-12",
 				},
 				{
-					reportRunning:           true,
-					reportNotFoundError:     false,
-					reportOpWithErrorStatus: false,
+					Id:     "op2",
+					Target: "projects/test-project/locations/us-central1/instances/test-instance-12/shares/share-1",
 				},
 			},
-			numSignalGetInstance:              1,
-			reportErrorForGetInstance:         []bool{false},
-			reportNotFoundErrorForGetInstance: []bool{false},
-			expectedNumNonReadyInstances:      1,
-			expectedNumReadyInstances:         1,
+			instance: &file.MultishareInstance{
+				Name:     "test-instance-1",
+				Project:  "test-project",
+				Location: "us-central1",
+			},
 		},
 		{
-			name:  "tc8-one instance (delete op in progress) with 0 shares in map",
-			scKey: testInstanceScPrefix,
-			initInstanceOpMap: []Item{
-				{
-					instanceKey: util.CreateInstanceKey(testProject, testRegion, testInstanceName+"1"),
-					op: util.OpInfo{
-						Name: "op-1",
-						Type: util.InstanceDelete,
-					},
-				},
+			name: "invalid instance case1",
+			instance: &file.MultishareInstance{
+				Project:  "test-project",
+				Location: "us-central1",
+			},
+			errorExpected: true,
+		},
+		{
+			name: "invalid instance case2",
+			instance: &file.MultishareInstance{
+				Name:     "test-instance-2",
+				Location: "us-central1",
+			},
+			errorExpected: true,
+		},
+		{
+			name: "invalid instance case3",
+			instance: &file.MultishareInstance{
+				Name:    "test-instance-2",
+				Project: "test-project",
 			},
-			initInstance: []file.MultishareInstance{
+			errorExpected: true,
+		},
+		{
+			name: "error, matching instance op",
+			ops: []*OpInfo{
 				{
-					Name:     testInstanceName + "1",
-					Project:  testProject,
-					Location: testRegion,
+					Id:     "op1",
+					Target: "projects/test-project/locations/us-central1/instances/test-instance-1",
 				},
 			},
-			numSignalGetOpForInstance:    1,
-			numsignalIsOpDoneForInstance: 1,
-			isOpDoneStatusForInstance: []MockOpStatus{
+			instance: &file.MultishareInstance{
+				Name:     "test-instance-1",
+				Project:  "test-project",
+				Location: "us-central1",
+			},
+			errorExpected: true,
+		},
+		{
+			name: "error, matching share op with instance prefix",
+			ops: []*OpInfo{
 				{
-					reportRunning:           true,
-					reportNotFoundError:     false,
-					reportOpWithErrorStatus: false,
+					Id:     "op2",
+					Target: "projects/test-project/locations/us-central1/instances/test-instance-1/shares/share-1",
 				},
 			},
+			instance: &file.MultishareInstance{
+				Name:     "test-instance-1",
+				Project:  "test-project",
+				Location: "us-central1",
+			},
+			errorExpected: true,
 		},
 	}
 	for _, tc := range tests {
 		t.Run(tc.name, func(t *testing.T) {
-			opUnblocker := make(chan chan file.Signal, 1)
-			cloudProvider := initCloudProviderWithBlockingFileService(t, opUnblocker)
-			manager := NewMultishareOpsManager(cloudProvider)
-
-			runRequest := func(ctx context.Context, instanceSCPrefix string) <-chan Response {
-				responseChannel := make(chan Response)
-				go func() {
-					ready, numNonReady, err := manager.runEligibleInstanceCheck(ctx, instanceSCPrefix)
-					responseChannel <- Response{
-						readyInstances:       ready,
-						numNonReadyInstances: numNonReady,
-						err:                  err,
-					}
-				}()
-				return responseChannel
-			}
-			// Prepopulate known instances and shares
-			for _, instance := range tc.initInstance {
-				manager.cloud.File.StartCreateMultishareInstanceOp(context.Background(), &instance)
-			}
-			for _, share := range tc.initShares {
-				manager.cloud.File.StartCreateShareOp(context.Background(), &share)
-			}
-			for _, item := range tc.initInstanceOpMap {
-				manager.cache.AddInstanceOp(tc.scKey, item.instanceKey, item.op)
-			}
-
-			respChannel := runRequest(context.Background(), tc.scKey)
-			// Inject mock response for GetOp
-			for i := 0; i < tc.numSignalGetOpForInstance; i++ {
-				s := file.Signal{}
-				execute := <-opUnblocker
-				execute <- s
+			s, err := file.NewFakeServiceForMultishare(nil, nil, nil)
+			if err != nil {
+				t.Fatalf("failed to fake service: %v", err)
 			}
-
-			// Inject mock response for IsOpDone
-			for i := 0; i < tc.numsignalIsOpDoneForInstance; i++ {
-				s := file.Signal{}
-				s.ReportError = tc.isOpDoneStatusForInstance[i].reportError
-				s.ReportOpWithErrorStatus = tc.isOpDoneStatusForInstance[i].reportOpWithErrorStatus
-				s.ReportRunning = tc.isOpDoneStatusForInstance[i].reportRunning
-				execute := <-opUnblocker
-				execute <- s
-			}
-
-			for i := 0; i < tc.numSignalGetInstance; i++ {
-				s := file.Signal{}
-				s.ReportError = tc.reportErrorForGetInstance[i]
-				s.ReportNotFoundError = tc.reportNotFoundErrorForGetInstance[i]
-				execute := <-opUnblocker
-				execute <- s
-			}
-			// Verify response
-			response := <-respChannel
-			if response.numNonReadyInstances != tc.expectedNumNonReadyInstances {
-				t.Errorf("want %v, got %v", tc.expectedNumNonReadyInstances, response.numNonReadyInstances)
-			}
-			if len(response.readyInstances) != tc.expectedNumReadyInstances {
-				t.Errorf("unexpected instance %v", response.readyInstances)
+			cloudProvider, err := cloud.NewFakeCloud()
+			cloudProvider.File = s
+			manager := NewMultishareOpsManager(cloudProvider)
+			err = manager.verifyNoRunningInstanceOrShareOpsForInstance(tc.instance, tc.ops)
+			if tc.errorExpected && err == nil {
+				t.Errorf("expected error, found none")
 			}
-			if !tc.expectedError && response.err != nil {
+			if !tc.errorExpected && err != nil {
 				t.Errorf("unexpected error")
 			}
-			if tc.expectedError && response.err == nil {
-				t.Errorf("expecteded error")
-			}
 		})
 	}
 }
 
-func TestInstanceNeedsExpand(t *testing.T) {
+func TestVerifyNoRunningShareOps(t *testing.T) {
 	tests := []struct {
-		name                    string
-		scKey                   string
-		initShares              []file.Share
-		targetShareToAccomodate *file.Share
-		expectedNeedsExpand     bool
-		targetBytes             int64
-		expectError             bool
+		name          string
+		ops           []*OpInfo
+		share         *file.Share
+		errorExpected bool
 	}{
 		{
-			name:  "0 shares in 1 T instance,  new 100G share",
-			scKey: testInstanceScPrefix,
-			targetShareToAccomodate: &file.Share{
-				Name:          testShareName,
-				CapacityBytes: 100 * util.Gb,
+			name: "no error, no matching op",
+			ops: []*OpInfo{
+				{
+					Id:     "op1",
+					Target: "projects/test-project/locations/us-central1/instances/test-instance-12",
+				},
+				{
+					Id:     "op2",
+					Target: "projects/test-project/locations/us-central1/instances/test-instance-12/shares/share-1",
+				},
+			},
+			share: &file.Share{
 				Parent: &file.MultishareInstance{
-					Project:       testProject,
-					Location:      testRegion,
-					Name:          testInstanceName,
-					CapacityBytes: 1 * util.Tb,
+					Name:     "test-instance-1",
+					Project:  "test-project",
+					Location: "us-central1",
 				},
+				Name: "share-1",
 			},
 		},
 		{
-			name:  "1 existing 100G share in 1 T instance,  new 100G share",
-			scKey: testInstanceScPrefix,
-			initShares: []file.Share{
-				{
-					Name:          testShareName + "1",
-					CapacityBytes: 100 * util.Gb,
-					Parent: &file.MultishareInstance{
-						Project:       testProject,
-						Location:      testRegion,
-						Name:          testInstanceName,
-						CapacityBytes: 1 * util.Tb,
-					},
+			name: "invalid share case1",
+			share: &file.Share{
+				Parent: &file.MultishareInstance{
+					Name:     "test-instance-1",
+					Location: "us-central1",
 				},
+				Name: "share-1",
 			},
-			targetShareToAccomodate: &file.Share{
-				Name:          testShareName + "2",
-				CapacityBytes: 100 * util.Gb,
+			errorExpected: true,
+		},
+		{
+			name: "invalid share case2",
+			share: &file.Share{
 				Parent: &file.MultishareInstance{
-					Project:       testProject,
-					Location:      testRegion,
-					Name:          testInstanceName,
-					CapacityBytes: 1 * util.Tb,
+					Name:    "test-instance-1",
+					Project: "test-project",
 				},
+				Name: "share-1",
 			},
+			errorExpected: true,
 		},
 		{
-			name:  "9 existing 100G share in 1 T instance, new 100G share",
-			scKey: testInstanceScPrefix,
-			initShares: []file.Share{
+			name: "invalid share case3",
+			share: &file.Share{
+				Parent: &file.MultishareInstance{
+					Project:  "test-project",
+					Location: "us-central1",
+				},
+				Name: "share-1",
+			},
+			errorExpected: true,
+		},
+		{
+			name: "invalid share case3",
+			share: &file.Share{
+				Parent: &file.MultishareInstance{
+					Name:     "test-instance-1",
+					Project:  "test-project",
+					Location: "us-central1",
+				},
+			},
+			errorExpected: true,
+		},
+		{
+			name: "error, found matching share op",
+			ops: []*OpInfo{
 				{
-					Name:          testShareName + "1",
-					CapacityBytes: 100 * util.Gb,
-					Parent: &file.MultishareInstance{
-						Project:       testProject,
-						Location:      testRegion,
-						Name:          testInstanceName,
-						CapacityBytes: 1 * util.Tb,
+					Id:     "op1",
+					Target: "projects/test-project/locations/us-central1/instances/test-instance-1/shares/share-1",
+				},
+			},
+			share: &file.Share{
+				Parent: &file.MultishareInstance{
+					Name:     "test-instance-1",
+					Project:  "test-project",
+					Location: "us-central1",
+				},
+				Name: "share-1",
+			},
+			errorExpected: true,
+		},
+	}
+	for _, tc := range tests {
+		t.Run(tc.name, func(t *testing.T) {
+			s, err := file.NewFakeServiceForMultishare(nil, nil, nil)
+			if err != nil {
+				t.Fatalf("failed to fake service: %v", err)
+			}
+			cloudProvider, err := cloud.NewFakeCloud()
+			cloudProvider.File = s
+			manager := NewMultishareOpsManager(cloudProvider)
+			err = manager.verifyNoRunningShareOps(tc.share, tc.ops)
+			if tc.errorExpected && err == nil {
+				t.Errorf("expected error, found none")
+			}
+			if !tc.errorExpected && err != nil {
+				t.Errorf("unexpected error")
+			}
+		})
+	}
+}
+
+func TestRunEligibleInstanceCheck(t *testing.T) {
+	found := func(inputList []*file.MultishareInstance, i *file.MultishareInstance) bool {
+		for _, f := range inputList {
+			if f.Project == i.Project && f.Location == i.Location && f.Name == i.Name {
+				return true
+			}
+		}
+		return false
+	}
+	tests := []struct {
+		name                  string
+		prefix                string
+		ops                   []*OpInfo
+		initInstances         []*file.MultishareInstance
+		initShares            []*file.Share
+		expectedNonReadyCount int
+		expectedReadyInstance []*file.MultishareInstance
+	}{
+		{
+			name: "no instances",
+		},
+		{
+			name:   "all ready instances",
+			prefix: "testprefix",
+			initInstances: []*file.MultishareInstance{
+				{
+					Name:     "test-instance-1",
+					Location: "us-central1",
+					Project:  "test-project",
+					Labels: map[string]string{
+						util.ParamMultishareInstanceScLabelKey: "testprefix",
 					},
 				},
 				{
-					Name:          testShareName + "2",
-					CapacityBytes: 100 * util.Gb,
-					Parent: &file.MultishareInstance{
-						Project:       testProject,
-						Location:      testRegion,
-						Name:          testInstanceName,
-						CapacityBytes: 1 * util.Tb,
+					Name:     "test-instance-1",
+					Location: "us-central1",
+					Project:  "test-project",
+					Labels: map[string]string{
+						util.ParamMultishareInstanceScLabelKey: "testprefix",
 					},
 				},
+			},
+			expectedReadyInstance: []*file.MultishareInstance{
 				{
-					Name:          testShareName + "3",
-					CapacityBytes: 100 * util.Gb,
-					Parent: &file.MultishareInstance{
-						Project:       testProject,
-						Location:      testRegion,
-						Name:          testInstanceName,
-						CapacityBytes: 1 * util.Tb,
+					Name:     "test-instance-1",
+					Location: "us-central1",
+					Project:  "test-project",
+					Labels: map[string]string{
+						util.ParamMultishareInstanceScLabelKey: "testprefix",
 					},
 				},
 				{
-					Name:          testShareName + "4",
-					CapacityBytes: 100 * util.Gb,
-					Parent: &file.MultishareInstance{
-						Project:       testProject,
-						Location:      testRegion,
-						Name:          testInstanceName,
-						CapacityBytes: 1 * util.Tb,
+					Name:     "test-instance-2",
+					Location: "us-central1",
+					Project:  "test-project",
+					Labels: map[string]string{
+						util.ParamMultishareInstanceScLabelKey: "testprefix",
 					},
 				},
-				{
-					Name:          testShareName + "5",
-					CapacityBytes: 100 * util.Gb,
-					Parent: &file.MultishareInstance{
-						Project:       testProject,
-						Location:      testRegion,
-						Name:          testInstanceName,
-						CapacityBytes: 1 * util.Tb,
+			},
+		},
+		{
+			name:   "non-ready instances (instance update)",
+			prefix: "testprefix",
+			initInstances: []*file.MultishareInstance{
+				{
+					Name:     "instance-1",
+					Location: "us-central1",
+					Project:  "test-project",
+					Labels: map[string]string{
+						util.ParamMultishareInstanceScLabelKey: "testprefix",
 					},
 				},
+			},
+			expectedNonReadyCount: 1,
+			ops: []*OpInfo{
 				{
-					Name:          testShareName + "6",
-					CapacityBytes: 100 * util.Gb,
-					Parent: &file.MultishareInstance{
-						Project:       testProject,
-						Location:      testRegion,
-						Name:          testInstanceName,
-						CapacityBytes: 1 * util.Tb,
+					Id:     "op1",
+					Target: "projects/test-project/locations/us-central1/instances/instance-1",
+					Type:   util.InstanceUpdate,
+				},
+			},
+		},
+		{
+			name:   "non-ready instances (share create)",
+			prefix: "testprefix",
+			initInstances: []*file.MultishareInstance{
+				{
+					Name:     "instance-1",
+					Location: "us-central1",
+					Project:  "test-project",
+					Labels: map[string]string{
+						util.ParamMultishareInstanceScLabelKey: "testprefix",
 					},
 				},
+			},
+			expectedNonReadyCount: 1,
+			ops: []*OpInfo{
 				{
-					Name:          testShareName + "7",
-					CapacityBytes: 100 * util.Gb,
-					Parent: &file.MultishareInstance{
-						Project:       testProject,
-						Location:      testRegion,
-						Name:          testInstanceName,
-						CapacityBytes: 1 * util.Tb,
+					Id:     "op1",
+					Target: "projects/test-project/locations/us-central1/instances/instance-1/shares/share-1",
+					Type:   util.ShareCreate,
+				},
+			},
+		},
+		{
+			name:   "non-ready instances (share update)",
+			prefix: "testprefix",
+			initInstances: []*file.MultishareInstance{
+				{
+					Name:     "instance-1",
+					Location: "us-central1",
+					Project:  "test-project",
+					Labels: map[string]string{
+						util.ParamMultishareInstanceScLabelKey: "testprefix",
 					},
 				},
+			},
+			expectedNonReadyCount: 1,
+			ops: []*OpInfo{
 				{
-					Name:          testShareName + "8",
-					CapacityBytes: 100 * util.Gb,
-					Parent: &file.MultishareInstance{
-						Project:       testProject,
-						Location:      testRegion,
-						Name:          testInstanceName,
-						CapacityBytes: 1 * util.Tb,
+					Id:     "op1",
+					Target: "projects/test-project/locations/us-central1/instances/instance-1/shares/share-1",
+					Type:   util.ShareUpdate,
+				},
+			},
+		},
+		{
+			name:   "non-ready instances (share delete)",
+			prefix: "testprefix",
+			initInstances: []*file.MultishareInstance{
+				{
+					Name:     "instance-1",
+					Location: "us-central1",
+					Project:  "test-project",
+					Labels: map[string]string{
+						util.ParamMultishareInstanceScLabelKey: "testprefix",
 					},
 				},
+			},
+			expectedNonReadyCount: 1,
+			ops: []*OpInfo{
 				{
-					Name:          testShareName + "9",
-					CapacityBytes: 100 * util.Gb,
-					Parent: &file.MultishareInstance{
-						Project:       testProject,
-						Location:      testRegion,
-						Name:          testInstanceName,
-						CapacityBytes: 1 * util.Tb,
+					Id:     "op1",
+					Target: "projects/test-project/locations/us-central1/instances/instance-1/shares/share-1",
+					Type:   util.ShareDelete,
+				},
+			},
+		},
+		{
+			name:   "non-ready instances 0, instance delete not counted as ready",
+			prefix: "testprefix",
+			initInstances: []*file.MultishareInstance{
+				{
+					Name:     "instance-1",
+					Location: "us-central1",
+					Project:  "test-project",
+					Labels: map[string]string{
+						util.ParamMultishareInstanceScLabelKey: "testprefix",
 					},
 				},
 			},
-			targetShareToAccomodate: &file.Share{
-				Name:          testShareName + "10",
-				CapacityBytes: 100 * util.Gb,
-				Parent: &file.MultishareInstance{
-					Project:       testProject,
-					Location:      testRegion,
-					Name:          testInstanceName,
-					CapacityBytes: 1 * util.Tb,
+			ops: []*OpInfo{
+				{
+					Id:     "op1",
+					Target: "projects/test-project/locations/us-central1/instances/instance-1",
+					Type:   util.InstanceDelete,
 				},
 			},
 		},
 		{
-			name:  "1 existing 100G share in 1 T instance,  new 1T share",
-			scKey: testInstanceScPrefix,
-			initShares: []file.Share{
+			name:   "non-ready instances (share delete), ready instance",
+			prefix: "testprefix",
+			initInstances: []*file.MultishareInstance{
+				{
+					Name:     "instance-1",
+					Location: "us-central1",
+					Project:  "test-project",
+					Labels: map[string]string{
+						util.ParamMultishareInstanceScLabelKey: "testprefix",
+					},
+				},
 				{
-					Name:          testShareName + "1",
-					CapacityBytes: 100 * util.Gb,
-					Parent: &file.MultishareInstance{
-						Project:       testProject,
-						Location:      testRegion,
-						Name:          testInstanceName,
-						CapacityBytes: 1 * util.Tb,
+					Name:     "instance-2",
+					Location: "us-central1",
+					Project:  "test-project",
+					Labels: map[string]string{
+						util.ParamMultishareInstanceScLabelKey: "testprefix",
 					},
 				},
 			},
-			targetShareToAccomodate: &file.Share{
-				Name:          testShareName + "2",
-				CapacityBytes: 1 * util.Tb,
-				Parent: &file.MultishareInstance{
-					Project:       testProject,
-					Location:      testRegion,
-					Name:          testInstanceName,
-					CapacityBytes: 1 * util.Tb,
+			expectedReadyInstance: []*file.MultishareInstance{
+				{
+					Name:     "instance-2",
+					Location: "us-central1",
+					Project:  "test-project",
+					Labels: map[string]string{
+						util.ParamMultishareInstanceScLabelKey: "testprefix",
+					},
+				},
+			},
+			expectedNonReadyCount: 1,
+			ops: []*OpInfo{
+				{
+					Id:     "op1",
+					Target: "projects/test-project/locations/us-central1/instances/instance-1/shares/share-1",
+					Type:   util.ShareDelete,
 				},
 			},
-			expectedNeedsExpand: true,
-			targetBytes:         1*util.Tb + (1*util.Tb - (1*util.Tb - 100*util.Gb)),
 		},
 		{
-			name:  "2 existing 100G share in 1 T instance,  new 900G share",
-			scKey: testInstanceScPrefix,
-			initShares: []file.Share{
-				{
-					Name:          testShareName + "1",
-					CapacityBytes: 100 * util.Gb,
-					Parent: &file.MultishareInstance{
-						Project:       testProject,
-						Location:      testRegion,
-						Name:          testInstanceName,
-						CapacityBytes: 1 * util.Tb,
+			name:   "no ready instance, no non-ready instance, instance with 10 shares not eligible",
+			prefix: "testprefix",
+			initInstances: []*file.MultishareInstance{
+				{
+					Name:     "instance-1",
+					Location: "us-central1",
+					Project:  "test-project",
+					Labels: map[string]string{
+						util.ParamMultishareInstanceScLabelKey: "testprefix",
 					},
 				},
+			},
+			initShares: []*file.Share{
 				{
-					Name:          testShareName + "2",
-					CapacityBytes: 100 * util.Gb,
+					Name: "share-1",
 					Parent: &file.MultishareInstance{
-						Project:       testProject,
-						Location:      testRegion,
-						Name:          testInstanceName,
-						CapacityBytes: 1 * util.Tb,
+						Name:     "instance-1",
+						Project:  "test-project",
+						Location: "us-central1",
+						Labels: map[string]string{
+							util.ParamMultishareInstanceScLabelKey: "testprefix",
+						},
 					},
 				},
 				{
-					Name:          testShareName + "3",
-					CapacityBytes: 100 * util.Gb,
+					Name: "share-2",
 					Parent: &file.MultishareInstance{
-						Project:       testProject,
-						Location:      testRegion,
-						Name:          testInstanceName,
-						CapacityBytes: 1 * util.Tb,
+						Name:     "instance-1",
+						Project:  "test-project",
+						Location: "us-central1",
+						Labels: map[string]string{
+							util.ParamMultishareInstanceScLabelKey: "testprefix",
+						},
 					},
 				},
 				{
-					Name:          testShareName + "4",
-					CapacityBytes: 100 * util.Gb,
+					Name: "share-3",
 					Parent: &file.MultishareInstance{
-						Project:       testProject,
-						Location:      testRegion,
-						Name:          testInstanceName,
-						CapacityBytes: 1 * util.Tb,
+						Name:     "instance-1",
+						Project:  "test-project",
+						Location: "us-central1",
+						Labels: map[string]string{
+							util.ParamMultishareInstanceScLabelKey: "testprefix",
+						},
 					},
 				},
 				{
-					Name:          testShareName + "5",
-					CapacityBytes: 100 * util.Gb,
+					Name: "share-4",
 					Parent: &file.MultishareInstance{
-						Project:       testProject,
-						Location:      testRegion,
-						Name:          testInstanceName,
-						CapacityBytes: 1 * util.Tb,
+						Name:     "instance-1",
+						Project:  "test-project",
+						Location: "us-central1",
+						Labels: map[string]string{
+							util.ParamMultishareInstanceScLabelKey: "testprefix",
+						},
 					},
 				},
 				{
-					Name:          testShareName + "6",
-					CapacityBytes: 100 * util.Gb,
+					Name: "share-5",
 					Parent: &file.MultishareInstance{
-						Project:       testProject,
-						Location:      testRegion,
-						Name:          testInstanceName,
-						CapacityBytes: 1 * util.Tb,
+						Name:     "instance-1",
+						Project:  "test-project",
+						Location: "us-central1",
+						Labels: map[string]string{
+							util.ParamMultishareInstanceScLabelKey: "testprefix",
+						},
 					},
 				},
 				{
-					Name:          testShareName + "7",
-					CapacityBytes: 100 * util.Gb,
+					Name: "share-6",
 					Parent: &file.MultishareInstance{
-						Project:       testProject,
-						Location:      testRegion,
-						Name:          testInstanceName,
-						CapacityBytes: 1 * util.Tb,
+						Name:     "instance-1",
+						Project:  "test-project",
+						Location: "us-central1",
+						Labels: map[string]string{
+							util.ParamMultishareInstanceScLabelKey: "testprefix",
+						},
 					},
 				},
 				{
-					Name:          testShareName + "8",
-					CapacityBytes: 100 * util.Gb,
+					Name: "share-7",
 					Parent: &file.MultishareInstance{
-						Project:       testProject,
-						Location:      testRegion,
-						Name:          testInstanceName,
-						CapacityBytes: 1 * util.Tb,
+						Name:     "instance-1",
+						Project:  "test-project",
+						Location: "us-central1",
+						Labels: map[string]string{
+							util.ParamMultishareInstanceScLabelKey: "testprefix",
+						},
 					},
 				},
 				{
-					Name:          testShareName + "9",
-					CapacityBytes: 100 * util.Gb,
+					Name: "share-8",
 					Parent: &file.MultishareInstance{
-						Project:       testProject,
-						Location:      testRegion,
-						Name:          testInstanceName,
-						CapacityBytes: 1 * util.Tb,
+						Name:     "instance-1",
+						Project:  "test-project",
+						Location: "us-central1",
+						Labels: map[string]string{
+							util.ParamMultishareInstanceScLabelKey: "testprefix",
+						},
 					},
 				},
-			},
-			targetShareToAccomodate: &file.Share{
-				Name:          testShareName + "10",
-				CapacityBytes: 1 * util.Tb,
-				Parent: &file.MultishareInstance{
-					Project:       testProject,
-					Location:      testRegion,
-					Name:          testInstanceName,
-					CapacityBytes: 1 * util.Tb,
-				},
-			},
-			expectedNeedsExpand: true,
-			targetBytes:         1*util.Tb + (1*util.Tb - (1*util.Tb - 9*100*util.Gb)),
-		},
-		{
-			name:  "9 existing 100G share in 1 T instance,  new 1T share",
-			scKey: testInstanceScPrefix,
-			initShares: []file.Share{
 				{
-					Name:          testShareName + "1",
-					CapacityBytes: 100 * util.Gb,
+					Name: "share-9",
 					Parent: &file.MultishareInstance{
-						Project:       testProject,
-						Location:      testRegion,
-						Name:          testInstanceName,
-						CapacityBytes: 1 * util.Tb,
+						Name:     "instance-1",
+						Project:  "test-project",
+						Location: "us-central1",
+						Labels: map[string]string{
+							util.ParamMultishareInstanceScLabelKey: "testprefix",
+						},
 					},
 				},
 				{
-					Name:          testShareName + "2",
-					CapacityBytes: 100 * util.Gb,
+					Name: "share-10",
 					Parent: &file.MultishareInstance{
-						Project:       testProject,
-						Location:      testRegion,
-						Name:          testInstanceName,
-						CapacityBytes: 1 * util.Tb,
+						Name:     "instance-1",
+						Project:  "test-project",
+						Location: "us-central1",
+						Labels: map[string]string{
+							util.ParamMultishareInstanceScLabelKey: "testprefix",
+						},
 					},
 				},
 			},
-			targetShareToAccomodate: &file.Share{
-				Name:          testShareName + "3",
-				CapacityBytes: 900 * util.Gb,
-				Parent: &file.MultishareInstance{
-					Project:       testProject,
-					Location:      testRegion,
-					Name:          testInstanceName,
-					CapacityBytes: 1 * util.Tb,
-				},
-			},
-			expectedNeedsExpand: true,
-			targetBytes:         1*util.Tb + (900*util.Gb - (1*util.Tb - 2*100*util.Gb)),
 		},
 	}
 	for _, tc := range tests {
 		t.Run(tc.name, func(t *testing.T) {
-			opUnblocker := make(chan chan file.Signal, 1)
-			cloudProvider := initCloudProviderWithBlockingFileService(t, opUnblocker)
-			manager := NewMultishareOpsManager(cloudProvider)
-
-			runRequest := func(ctx context.Context, share *file.Share) <-chan Response {
-				responseChannel := make(chan Response)
-				go func() {
-					needsExpand, targetBytes, err := manager.instanceNeedsExpand(context.Background(), share)
-					responseChannel <- Response{
-						instanceNeedsExpand: needsExpand,
-						targetBytes:         targetBytes,
-						err:                 err,
-					}
-				}()
-				return responseChannel
-			}
-
-			for _, share := range tc.initShares {
-				if share.Parent != nil {
-					manager.cloud.File.StartCreateMultishareInstanceOp(context.Background(), share.Parent)
-				}
-				manager.cloud.File.StartCreateShareOp(context.Background(), &share)
-			}
-
-			respChannel := runRequest(context.Background(), tc.targetShareToAccomodate)
-			response := <-respChannel
-			if tc.expectError && response.err == nil {
-				t.Errorf("expected error")
+			s, err := file.NewFakeServiceForMultishare(tc.initInstances, tc.initShares, nil)
+			if err != nil {
+				t.Fatalf("failed to fake service: %v", err)
 			}
-			if !tc.expectError && response.err != nil {
-				t.Errorf("unexpectded error")
+			cloudProvider, err := cloud.NewFakeCloud()
+			cloudProvider.File = s
+			manager := NewMultishareOpsManager(cloudProvider)
+			ready, nonReady, err := manager.runEligibleInstanceCheck(context.Background(), tc.prefix, tc.ops)
+			if err != nil {
+				t.Errorf("unexpected error")
 			}
-			if tc.expectedNeedsExpand != response.instanceNeedsExpand {
-				t.Errorf("want %v, got %v", tc.expectedNeedsExpand, response.instanceNeedsExpand)
+			if nonReady != tc.expectedNonReadyCount {
+				t.Errorf("got %d, want %d", nonReady, tc.expectedNonReadyCount)
 			}
-			if tc.targetBytes != response.targetBytes {
-				t.Errorf("want %v, got %v", tc.targetBytes, response.targetBytes)
+			for _, r := range ready {
+				if !found(tc.expectedReadyInstance, r) {
+					t.Errorf("expected instance not ready")
+				}
 			}
 		})
 	}
diff --git a/pkg/util/cache_test.go b/pkg/util/cache_test.go
deleted file mode 100644
index 568cde96..00000000
--- a/pkg/util/cache_test.go
+++ /dev/null
@@ -1,1750 +0,0 @@
-/*
-Copyright 2022 The Kubernetes Authors.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-
-package util
-
-import (
-	"fmt"
-	"testing"
-)
-
-const (
-	testProject  = "test-project"
-	testLocation = "us-central1"
-	testInstance = "testInstance"
-	testShare    = "testShane"
-)
-
-type Item struct {
-	scKey          string
-	instanceKey    InstanceKey
-	shareKey       ShareKey
-	shareCreateKey string
-	op             OpInfo
-	createOp       ShareCreateOpInfo
-}
-
-type AddItem struct {
-	item          Item
-	skipInitSCKey bool
-	expectError   bool
-}
-
-type ClearItem struct {
-	item        Item
-	clearValue  bool
-	clearKey    bool
-	expectError bool
-}
-type OutputItem struct {
-	item             Item
-	expectEmpty      bool
-	expectEmptyValue bool
-}
-
-func TestInstanceMap(t *testing.T) {
-	tests := []struct {
-		name   string
-		add    []Item
-		clear  []ClearItem
-		output []OutputItem
-	}{
-		{
-			name: "tc1 - add ops for 1 storage class",
-			add: []Item{
-				{
-					scKey:       "sc-1",
-					instanceKey: InstanceKey(CreateInstanceKey(testProject, testLocation, testInstance+"1")),
-					op: OpInfo{
-						Name: "op-1",
-						Type: InstanceCreate,
-					},
-				},
-				{
-					scKey:       "sc-1",
-					instanceKey: InstanceKey(CreateInstanceKey(testProject, testLocation, testInstance+"2")),
-					op: OpInfo{
-						Name: "op-2",
-						Type: InstanceExpand,
-					},
-				},
-			},
-			output: []OutputItem{
-				{
-					item: Item{
-						scKey:       "sc-1",
-						instanceKey: InstanceKey(CreateInstanceKey(testProject, testLocation, testInstance+"1")),
-						op: OpInfo{
-							Name: "op-1",
-							Type: InstanceCreate,
-						},
-					},
-				},
-				{
-					item: Item{
-						scKey:       "sc-1",
-						instanceKey: InstanceKey(CreateInstanceKey(testProject, testLocation, testInstance+"2")),
-						op: OpInfo{
-							Name: "op-2",
-							Type: InstanceExpand,
-						},
-					},
-				},
-			},
-		},
-		{
-			name: "tc2 - add ops for 2 storage classes",
-			add: []Item{
-				{
-					scKey:       "sc-1",
-					instanceKey: InstanceKey(CreateInstanceKey(testProject, testLocation, testInstance+"1")),
-					op: OpInfo{
-						Name: "op-1",
-						Type: InstanceCreate,
-					},
-				},
-				{
-					scKey:       "sc-2",
-					instanceKey: InstanceKey(CreateInstanceKey(testProject, testLocation, testInstance+"2")),
-					op: OpInfo{
-						Name: "op-2",
-						Type: InstanceExpand,
-					},
-				},
-			},
-			output: []OutputItem{
-				{
-					item: Item{
-						scKey:       "sc-1",
-						instanceKey: InstanceKey(CreateInstanceKey(testProject, testLocation, testInstance+"1")),
-						op: OpInfo{
-							Name: "op-1",
-							Type: InstanceCreate,
-						},
-					},
-				},
-				{
-					item: Item{
-						scKey:       "sc-2",
-						instanceKey: InstanceKey(CreateInstanceKey(testProject, testLocation, testInstance+"2")),
-						op: OpInfo{
-							Name: "op-2",
-							Type: InstanceExpand,
-						},
-					},
-				},
-			},
-		},
-		{
-			name: "tc3 - add 2 ops, clear the ops for the instances",
-			add: []Item{
-				{
-					scKey:       "sc-1",
-					instanceKey: InstanceKey(CreateInstanceKey(testProject, testLocation, testInstance+"1")),
-					op: OpInfo{
-						Name: "op-1",
-						Type: InstanceCreate,
-					},
-				},
-				{
-					scKey:       "sc-2",
-					instanceKey: InstanceKey(CreateInstanceKey(testProject, testLocation, testInstance+"2")),
-					op: OpInfo{
-						Name: "op-2",
-						Type: InstanceExpand,
-					},
-				},
-			},
-			clear: []ClearItem{
-				{
-					item: Item{
-						scKey:       "sc-1",
-						instanceKey: InstanceKey(CreateInstanceKey(testProject, testLocation, testInstance+"1")),
-						op: OpInfo{
-							Name: "op-1",
-							Type: InstanceCreate,
-						},
-					},
-					clearValue: true,
-				},
-				{
-					item: Item{
-						scKey:       "sc-2",
-						instanceKey: InstanceKey(CreateInstanceKey(testProject, testLocation, testInstance+"2")),
-						op: OpInfo{
-							Name: "op-2",
-							Type: InstanceExpand,
-						},
-					},
-					clearValue: true,
-				},
-			},
-			output: []OutputItem{
-				{
-					item: Item{
-						scKey:       "sc-1",
-						instanceKey: InstanceKey(CreateInstanceKey(testProject, testLocation, testInstance+"1")),
-					},
-					expectEmptyValue: true,
-				},
-				{
-					item: Item{
-						scKey:       "sc-2",
-						instanceKey: InstanceKey(CreateInstanceKey(testProject, testLocation, testInstance+"2")),
-					},
-					expectEmptyValue: true,
-				},
-			},
-		},
-		{
-			name: "tc4 - add 2 ops, clear op value of one instance",
-			add: []Item{
-				{
-					scKey:       "sc-1",
-					instanceKey: InstanceKey(CreateInstanceKey(testProject, testLocation, testInstance+"1")),
-					op: OpInfo{
-						Name: "op-1",
-						Type: InstanceCreate,
-					},
-				},
-				{
-					scKey:       "sc-2",
-					instanceKey: InstanceKey(CreateInstanceKey(testProject, testLocation, testInstance+"2")),
-					op: OpInfo{
-						Name: "op-2",
-						Type: InstanceExpand,
-					},
-				},
-			},
-			clear: []ClearItem{
-				{
-					item: Item{
-						scKey:       "sc-2",
-						instanceKey: InstanceKey(CreateInstanceKey(testProject, testLocation, testInstance+"2")),
-						op: OpInfo{
-							Name: "op-2",
-							Type: InstanceExpand,
-						},
-					},
-					clearValue: true,
-				},
-			},
-			output: []OutputItem{
-				{
-					item: Item{
-						scKey:       "sc-1",
-						instanceKey: InstanceKey(CreateInstanceKey(testProject, testLocation, testInstance+"1")),
-						op: OpInfo{
-							Name: "op-1",
-							Type: InstanceCreate,
-						},
-					},
-				},
-				{
-					item: Item{
-						scKey:       "sc-2",
-						instanceKey: InstanceKey(CreateInstanceKey(testProject, testLocation, testInstance+"2")),
-						op: OpInfo{
-							Name: "op-2",
-							Type: InstanceExpand,
-						},
-					},
-					expectEmptyValue: true,
-				},
-			},
-		},
-		{
-			name: "tc5 - clear op attempt for non-existent sc",
-			add: []Item{
-				{
-					scKey:       "sc-1",
-					instanceKey: InstanceKey(CreateInstanceKey(testProject, testLocation, testInstance+"1")),
-					op: OpInfo{
-						Name: "op-1",
-						Type: InstanceCreate,
-					},
-				},
-				{
-					scKey:       "sc-2",
-					instanceKey: InstanceKey(CreateInstanceKey(testProject, testLocation, testInstance+"2")),
-					op: OpInfo{
-						Name: "op-2",
-						Type: InstanceExpand,
-					},
-				},
-			},
-			clear: []ClearItem{
-				{
-					item: Item{
-						scKey:       "sc-3",
-						instanceKey: InstanceKey(CreateInstanceKey(testProject, testLocation, testInstance+"2")),
-						op: OpInfo{
-							Name: "op-2",
-							Type: InstanceExpand,
-						},
-					},
-					clearValue: true,
-				},
-			},
-			output: []OutputItem{
-				{
-					item: Item{
-						scKey:       "sc-1",
-						instanceKey: InstanceKey(CreateInstanceKey(testProject, testLocation, testInstance+"1")),
-						op: OpInfo{
-							Name: "op-1",
-							Type: InstanceCreate,
-						},
-					},
-				},
-				{
-					item: Item{
-						scKey:       "sc-2",
-						instanceKey: InstanceKey(CreateInstanceKey(testProject, testLocation, testInstance+"2")),
-						op: OpInfo{
-							Name: "op-2",
-							Type: InstanceExpand,
-						},
-					},
-				},
-			},
-		},
-		{
-			name: "tc6 - clear op attempt for existing sc, error expected in clear",
-			add: []Item{
-				{
-					scKey:       "sc-1",
-					instanceKey: InstanceKey(CreateInstanceKey(testProject, testLocation, testInstance+"1")),
-					op: OpInfo{
-						Name: "op-1",
-						Type: InstanceCreate,
-					},
-				},
-				{
-					scKey:       "sc-2",
-					instanceKey: InstanceKey(CreateInstanceKey(testProject, testLocation, testInstance+"2")),
-					op: OpInfo{
-						Name: "op-2",
-						Type: InstanceExpand,
-					},
-				},
-			},
-			clear: []ClearItem{
-				{
-					item: Item{
-						scKey:       "sc-2",
-						instanceKey: InstanceKey(CreateInstanceKey(testProject, testLocation, testInstance+"2")),
-						op: OpInfo{
-							Name: "op-3",
-							Type: InstanceExpand,
-						},
-					},
-					expectError: true,
-					clearValue:  true,
-				},
-			},
-			output: []OutputItem{
-				{
-					item: Item{
-						scKey:       "sc-1",
-						instanceKey: InstanceKey(CreateInstanceKey(testProject, testLocation, testInstance+"1")),
-						op: OpInfo{
-							Name: "op-1",
-							Type: InstanceCreate,
-						},
-					},
-				},
-				{
-					item: Item{
-						scKey:       "sc-2",
-						instanceKey: InstanceKey(CreateInstanceKey(testProject, testLocation, testInstance+"2")),
-						op: OpInfo{
-							Name: "op-2",
-							Type: InstanceExpand,
-						},
-					},
-				},
-			},
-		},
-		{
-			name: "tc7 - clear non-existent instance key for existing sc",
-			add: []Item{
-				{
-					scKey:       "sc-1",
-					instanceKey: InstanceKey(CreateInstanceKey(testProject, testLocation, testInstance+"1")),
-					op: OpInfo{
-						Name: "op-1",
-						Type: InstanceCreate,
-					},
-				},
-				{
-					scKey:       "sc-2",
-					instanceKey: InstanceKey(CreateInstanceKey(testProject, testLocation, testInstance+"2")),
-					op: OpInfo{
-						Name: "op-2",
-						Type: InstanceExpand,
-					},
-				},
-			},
-			clear: []ClearItem{
-				{
-					item: Item{
-						scKey:       "sc-2",
-						instanceKey: InstanceKey(CreateInstanceKey(testProject, testLocation, testInstance+"3")),
-						op: OpInfo{
-							Name: "op-3",
-							Type: InstanceExpand,
-						},
-					},
-					clearValue: true,
-				},
-			},
-			output: []OutputItem{
-				{
-					item: Item{
-						scKey:       "sc-1",
-						instanceKey: InstanceKey(CreateInstanceKey(testProject, testLocation, testInstance+"1")),
-						op: OpInfo{
-							Name: "op-1",
-							Type: InstanceCreate,
-						},
-					},
-				},
-				{
-					item: Item{
-						scKey:       "sc-2",
-						instanceKey: InstanceKey(CreateInstanceKey(testProject, testLocation, testInstance+"2")),
-						op: OpInfo{
-							Name: "op-2",
-							Type: InstanceExpand,
-						},
-					},
-				},
-				{
-					item: Item{
-						scKey:       "sc-2",
-						instanceKey: InstanceKey(CreateInstanceKey(testProject, testLocation, testInstance+"3")),
-					},
-					expectEmpty: true,
-				},
-			},
-		},
-		{
-			name: "tc8 - add 2 ops, clear the keys for the instances",
-			add: []Item{
-				{
-					scKey:       "sc-1",
-					instanceKey: InstanceKey(CreateInstanceKey(testProject, testLocation, testInstance+"1")),
-					op: OpInfo{
-						Name: "op-1",
-						Type: InstanceCreate,
-					},
-				},
-				{
-					scKey:       "sc-2",
-					instanceKey: InstanceKey(CreateInstanceKey(testProject, testLocation, testInstance+"2")),
-					op: OpInfo{
-						Name: "op-2",
-						Type: InstanceExpand,
-					},
-				},
-			},
-			clear: []ClearItem{
-				{
-					item: Item{
-						scKey:       "sc-1",
-						instanceKey: InstanceKey(CreateInstanceKey(testProject, testLocation, testInstance+"1")),
-						op: OpInfo{
-							Name: "op-1",
-							Type: InstanceCreate,
-						},
-					},
-					clearKey: true,
-				},
-				{
-					item: Item{
-						scKey:       "sc-2",
-						instanceKey: InstanceKey(CreateInstanceKey(testProject, testLocation, testInstance+"2")),
-						op: OpInfo{
-							Name: "op-2",
-							Type: InstanceExpand,
-						},
-					},
-					clearKey: true,
-				},
-			},
-			output: []OutputItem{
-				{
-					item: Item{
-						scKey:       "sc-1",
-						instanceKey: InstanceKey(CreateInstanceKey(testProject, testLocation, testInstance+"1")),
-					},
-					expectEmpty: true,
-				},
-				{
-					item: Item{
-						scKey:       "sc-2",
-						instanceKey: InstanceKey(CreateInstanceKey(testProject, testLocation, testInstance+"2")),
-					},
-					expectEmpty: true,
-				},
-			},
-		},
-		{
-			name: "tc9 - add 2 ops, clear key of one instance",
-			add: []Item{
-				{
-					scKey:       "sc-1",
-					instanceKey: InstanceKey(CreateInstanceKey(testProject, testLocation, testInstance+"1")),
-					op: OpInfo{
-						Name: "op-1",
-						Type: InstanceCreate,
-					},
-				},
-				{
-					scKey:       "sc-2",
-					instanceKey: InstanceKey(CreateInstanceKey(testProject, testLocation, testInstance+"2")),
-					op: OpInfo{
-						Name: "op-2",
-						Type: InstanceExpand,
-					},
-				},
-			},
-			clear: []ClearItem{
-				{
-					item: Item{
-						scKey:       "sc-2",
-						instanceKey: InstanceKey(CreateInstanceKey(testProject, testLocation, testInstance+"2")),
-						op: OpInfo{
-							Name: "op-2",
-							Type: InstanceExpand,
-						},
-					},
-					clearKey: true,
-				},
-			},
-			output: []OutputItem{
-				{
-					item: Item{
-						scKey:       "sc-1",
-						instanceKey: InstanceKey(CreateInstanceKey(testProject, testLocation, testInstance+"1")),
-						op: OpInfo{
-							Name: "op-1",
-							Type: InstanceCreate,
-						},
-					},
-				},
-				{
-					item: Item{
-						scKey:       "sc-2",
-						instanceKey: InstanceKey(CreateInstanceKey(testProject, testLocation, testInstance+"2")),
-						op: OpInfo{
-							Name: "op-2",
-							Type: InstanceExpand,
-						},
-					},
-					expectEmpty: true,
-				},
-			},
-		},
-		{
-			name: "tc10 - clear key attempt for non-existent sc",
-			add: []Item{
-				{
-					scKey:       "sc-1",
-					instanceKey: InstanceKey(CreateInstanceKey(testProject, testLocation, testInstance+"1")),
-					op: OpInfo{
-						Name: "op-1",
-						Type: InstanceCreate,
-					},
-				},
-				{
-					scKey:       "sc-2",
-					instanceKey: InstanceKey(CreateInstanceKey(testProject, testLocation, testInstance+"2")),
-					op: OpInfo{
-						Name: "op-2",
-						Type: InstanceExpand,
-					},
-				},
-			},
-			clear: []ClearItem{
-				{
-					item: Item{
-						scKey:       "sc-3",
-						instanceKey: InstanceKey(CreateInstanceKey(testProject, testLocation, testInstance+"2")),
-						op: OpInfo{
-							Name: "op-2",
-							Type: InstanceExpand,
-						},
-					},
-					clearKey: true,
-				},
-			},
-			output: []OutputItem{
-				{
-					item: Item{
-						scKey:       "sc-1",
-						instanceKey: InstanceKey(CreateInstanceKey(testProject, testLocation, testInstance+"1")),
-						op: OpInfo{
-							Name: "op-1",
-							Type: InstanceCreate,
-						},
-					},
-				},
-				{
-					item: Item{
-						scKey:       "sc-2",
-						instanceKey: InstanceKey(CreateInstanceKey(testProject, testLocation, testInstance+"2")),
-						op: OpInfo{
-							Name: "op-2",
-							Type: InstanceExpand,
-						},
-					},
-				},
-			},
-		},
-		{
-			name: "tc11 - clear non-existent instance key for existing sc",
-			add: []Item{
-				{
-					scKey:       "sc-1",
-					instanceKey: InstanceKey(CreateInstanceKey(testProject, testLocation, testInstance+"1")),
-					op: OpInfo{
-						Name: "op-1",
-						Type: InstanceCreate,
-					},
-				},
-				{
-					scKey:       "sc-2",
-					instanceKey: InstanceKey(CreateInstanceKey(testProject, testLocation, testInstance+"2")),
-					op: OpInfo{
-						Name: "op-2",
-						Type: InstanceExpand,
-					},
-				},
-			},
-			clear: []ClearItem{
-				{
-					item: Item{
-						scKey:       "sc-2",
-						instanceKey: InstanceKey(CreateInstanceKey(testProject, testLocation, testInstance+"3")),
-						op: OpInfo{
-							Name: "op-3",
-							Type: InstanceExpand,
-						},
-					},
-					clearKey: true,
-				},
-			},
-			output: []OutputItem{
-				{
-					item: Item{
-						scKey:       "sc-1",
-						instanceKey: InstanceKey(CreateInstanceKey(testProject, testLocation, testInstance+"1")),
-						op: OpInfo{
-							Name: "op-1",
-							Type: InstanceCreate,
-						},
-					},
-				},
-				{
-					item: Item{
-						scKey:       "sc-2",
-						instanceKey: InstanceKey(CreateInstanceKey(testProject, testLocation, testInstance+"2")),
-						op: OpInfo{
-							Name: "op-2",
-							Type: InstanceExpand,
-						},
-					},
-				},
-				{
-					item: Item{
-						scKey:       "sc-2",
-						instanceKey: InstanceKey(CreateInstanceKey(testProject, testLocation, testInstance+"3")),
-					},
-					expectEmpty: true,
-				},
-			},
-		},
-	}
-	for _, tc := range tests {
-		t.Run(tc.name, func(t *testing.T) {
-			cache := NewStorageClassInfoCache()
-			for _, item := range tc.add {
-				cache.AddInstanceOp(item.scKey, item.instanceKey, item.op)
-			}
-			for _, item := range tc.clear {
-				if item.clearValue {
-					err := cache.DeleteInstanceOp(item.item.scKey, item.item.instanceKey, item.item.op.Name)
-					if item.expectError && err == nil {
-						t.Errorf("expected error")
-					}
-					if !item.expectError && err != nil {
-						t.Errorf("unexpected error")
-					}
-				}
-
-				if item.clearKey {
-					cache.DeleteInstance(item.item.scKey, item.item.instanceKey)
-				}
-			}
-
-			for _, item := range tc.output {
-				op := cache.GetInstanceOp(item.item.scKey, item.item.instanceKey)
-				if item.expectEmpty {
-					if op != nil {
-						t.Errorf("want nil, got %+v", op)
-					}
-					continue
-				}
-
-				if item.expectEmptyValue {
-					if op.Name != "" || op.Type != UnknownOp {
-						t.Errorf("want empty op, got %+v", op)
-					}
-					continue
-				}
-
-				if op.Name != item.item.op.Name || op.Type != item.item.op.Type {
-					t.Errorf("want %+v, got : %+v", item.item.op, op)
-				}
-			}
-		})
-	}
-}
-
-func TestShareOpsMap(t *testing.T) {
-	tests := []struct {
-		name   string
-		add    []AddItem
-		clear  []ClearItem
-		output []OutputItem
-	}{
-		{
-			name: "tc1 - add ops for 2 shares on same instance, for 1 storage class",
-			add: []AddItem{
-				{
-					item: Item{
-						scKey:    "sc-1",
-						shareKey: CreateShareKey(testProject, testLocation, testInstance, testShare+"1"),
-						op: OpInfo{
-							Name: "op-1",
-							Type: ShareExpand,
-						},
-					},
-				},
-				{
-					item: Item{
-						scKey:    "sc-1",
-						shareKey: CreateShareKey(testProject, testLocation, testInstance, testShare+"2"),
-						op: OpInfo{
-							Name: "op-2",
-							Type: ShareDelete,
-						},
-					},
-				},
-			},
-			output: []OutputItem{
-				{
-					item: Item{
-						scKey:    "sc-1",
-						shareKey: CreateShareKey(testProject, testLocation, testInstance, testShare+"1"),
-						op: OpInfo{
-							Name: "op-1",
-							Type: ShareExpand,
-						},
-					},
-				},
-				{
-					item: Item{
-						scKey:    "sc-1",
-						shareKey: CreateShareKey(testProject, testLocation, testInstance, testShare+"2"),
-						op: OpInfo{
-							Name: "op-2",
-							Type: ShareDelete,
-						},
-					},
-				},
-			},
-		},
-		{
-			name: "tc2 - add 2 share ops on different instances, for 2 storage classes",
-			add: []AddItem{
-				{
-					item: Item{
-						scKey:    "sc-1",
-						shareKey: CreateShareKey(testProject, testLocation, testInstance+"1", testShare+"1"),
-						op: OpInfo{
-							Name: "op-1",
-							Type: ShareDelete,
-						},
-					},
-				},
-				{
-					item: Item{
-						scKey:    "sc-2",
-						shareKey: CreateShareKey(testProject, testLocation, testInstance+"2", testShare+"2"),
-						op: OpInfo{
-							Name: "op-2",
-							Type: ShareExpand,
-						},
-					},
-				},
-			},
-			output: []OutputItem{
-				{
-					item: Item{
-						scKey:    "sc-1",
-						shareKey: CreateShareKey(testProject, testLocation, testInstance+"1", testShare+"1"),
-						op: OpInfo{
-							Name: "op-1",
-							Type: ShareDelete,
-						},
-					},
-				},
-				{
-					item: Item{
-						scKey:    "sc-2",
-						shareKey: CreateShareKey(testProject, testLocation, testInstance+"2", testShare+"2"),
-						op: OpInfo{
-							Name: "op-2",
-							Type: ShareExpand,
-						},
-					},
-				},
-			},
-		},
-		{
-			name: "tc3 - add 2 ops, clear 2 ops",
-			add: []AddItem{
-				{
-					item: Item{
-						scKey:    "sc-1",
-						shareKey: CreateShareKey(testProject, testLocation, testInstance+"1", testShare+"1"),
-						op: OpInfo{
-							Name: "op-1",
-							Type: ShareDelete,
-						},
-					},
-				},
-				{
-					item: Item{
-						scKey:    "sc-2",
-						shareKey: CreateShareKey(testProject, testLocation, testInstance+"2", testShare+"2"),
-						op: OpInfo{
-							Name: "op-2",
-							Type: ShareExpand,
-						},
-					},
-				},
-			},
-			clear: []ClearItem{
-				{
-					item: Item{
-						scKey:    "sc-1",
-						shareKey: CreateShareKey(testProject, testLocation, testInstance+"1", testShare+"1"),
-						op: OpInfo{
-							Name: "op-1",
-						},
-					},
-				},
-				{
-					item: Item{
-						scKey:    "sc-2",
-						shareKey: CreateShareKey(testProject, testLocation, testInstance+"2", testShare+"2"),
-						op: OpInfo{
-							Name: "op-2",
-						},
-					},
-				},
-			},
-		},
-		{
-			name: "tc4 - add 2 ops, clear 1 op",
-			add: []AddItem{
-				{
-					item: Item{
-						scKey:    "sc-1",
-						shareKey: CreateShareKey(testProject, testLocation, testInstance+"1", testShare+"1"),
-						op: OpInfo{
-							Name: "op-1",
-							Type: ShareDelete,
-						},
-					},
-				},
-				{
-					item: Item{
-						scKey:    "sc-2",
-						shareKey: CreateShareKey(testProject, testLocation, testInstance+"2", testShare+"2"),
-						op: OpInfo{
-							Name: "op-2",
-							Type: ShareExpand,
-						},
-					},
-				},
-			},
-			clear: []ClearItem{
-				{
-					item: Item{
-						scKey:    "sc-2",
-						shareKey: CreateShareKey(testProject, testLocation, testInstance+"2", testShare+"2"),
-						op: OpInfo{
-							Name: "op-2",
-						},
-					},
-				},
-			},
-			output: []OutputItem{
-				{
-					item: Item{
-						scKey:    "sc-1",
-						shareKey: CreateShareKey(testProject, testLocation, testInstance+"1", testShare+"1"),
-						op: OpInfo{
-							Name: "op-1",
-							Type: ShareDelete,
-						},
-					},
-				},
-				{
-					item: Item{
-						scKey:    "sc-2",
-						shareKey: CreateShareKey(testProject, testLocation, testInstance+"2", testShare+"2"),
-						op: OpInfo{
-							Name: "op-2",
-						},
-					},
-					expectEmpty: true,
-				},
-			},
-		},
-		{
-			name: "tc5 - clear non-existent op for non-existent sc",
-			add: []AddItem{
-				{
-					item: Item{
-						scKey:    "sc-1",
-						shareKey: CreateShareKey(testProject, testLocation, testInstance+"1", testShare+"1"),
-						op: OpInfo{
-							Name: "op-1",
-							Type: ShareDelete,
-						},
-					},
-				},
-				{
-					item: Item{
-						scKey:    "sc-2",
-						shareKey: CreateShareKey(testProject, testLocation, testInstance+"2", testShare+"2"),
-						op: OpInfo{
-							Name: "op-2",
-							Type: ShareExpand,
-						},
-					},
-				},
-			},
-			clear: []ClearItem{
-				{
-					item: Item{
-						scKey:    "sc-3",
-						shareKey: CreateShareKey(testProject, testLocation, testInstance+"2", testShare+"2"),
-						op: OpInfo{
-							Name: "op-3",
-						},
-					},
-				},
-			},
-			output: []OutputItem{
-				{
-					item: Item{
-						scKey:    "sc-1",
-						shareKey: CreateShareKey(testProject, testLocation, testInstance+"1", testShare+"1"),
-						op: OpInfo{
-							Name: "op-1",
-							Type: ShareDelete,
-						},
-					},
-				},
-				{
-					item: Item{
-						scKey:    "sc-2",
-						shareKey: CreateShareKey(testProject, testLocation, testInstance+"2", testShare+"2"),
-						op: OpInfo{
-							Name: "op-2",
-							Type: ShareExpand,
-						},
-					},
-				},
-			},
-		},
-		{
-			name: "tc6 - clear non-existent op for existing sc, error expected in clear",
-			add: []AddItem{
-				{
-					item: Item{
-						scKey:    "sc-1",
-						shareKey: CreateShareKey(testProject, testLocation, testInstance+"1", testShare+"1"),
-						op: OpInfo{
-							Name: "op-1",
-							Type: ShareDelete,
-						},
-					},
-				},
-				{
-					item: Item{
-						scKey:    "sc-2",
-						shareKey: CreateShareKey(testProject, testLocation, testInstance+"2", testShare+"2"),
-						op: OpInfo{
-							Name: "op-2",
-							Type: ShareExpand,
-						},
-					},
-				},
-			},
-			clear: []ClearItem{
-				{
-					item: Item{
-						scKey:    "sc-2",
-						shareKey: CreateShareKey(testProject, testLocation, testInstance+"2", testShare+"2"),
-						op: OpInfo{
-							Name: "op-3",
-						},
-					},
-					expectError: true,
-				},
-			},
-			output: []OutputItem{
-				{
-					item: Item{
-						scKey:    "sc-1",
-						shareKey: CreateShareKey(testProject, testLocation, testInstance+"1", testShare+"1"),
-						op: OpInfo{
-							Name: "op-1",
-							Type: ShareDelete,
-						},
-					},
-				},
-				{
-					item: Item{
-						scKey:    "sc-2",
-						shareKey: CreateShareKey(testProject, testLocation, testInstance+"2", testShare+"2"),
-						op: OpInfo{
-							Name: "op-2",
-							Type: ShareExpand,
-						},
-					},
-				},
-			},
-		},
-		{
-			name: "tc7 - clear non-existent share key (different share) for existing sc",
-			add: []AddItem{
-				{
-					item: Item{
-						scKey:    "sc-1",
-						shareKey: CreateShareKey(testProject, testLocation, testInstance+"1", testShare+"1"),
-						op: OpInfo{
-							Name: "op-1",
-							Type: ShareDelete,
-						},
-					},
-				},
-				{
-					item: Item{
-						scKey:    "sc-2",
-						shareKey: CreateShareKey(testProject, testLocation, testInstance+"2", testShare+"2"),
-						op: OpInfo{
-							Name: "op-2",
-							Type: ShareExpand,
-						},
-					},
-				},
-			},
-			clear: []ClearItem{
-				{
-					item: Item{
-						scKey:    "sc-2",
-						shareKey: CreateShareKey(testProject, testLocation, testInstance+"2", testShare+"3"),
-						op: OpInfo{
-							Name: "op-3",
-						},
-					},
-				},
-			},
-			output: []OutputItem{
-				{
-					item: Item{
-						scKey:    "sc-1",
-						shareKey: CreateShareKey(testProject, testLocation, testInstance+"1", testShare+"1"),
-						op: OpInfo{
-							Name: "op-1",
-							Type: ShareDelete,
-						},
-					},
-				},
-				{
-					item: Item{
-						scKey:    "sc-2",
-						shareKey: CreateShareKey(testProject, testLocation, testInstance+"2", testShare+"2"),
-						op: OpInfo{
-							Name: "op-2",
-							Type: ShareExpand,
-						},
-					},
-				},
-			},
-		},
-		{
-			name: "tc7 - clear non-existent share key (different instance) for existing sc",
-			add: []AddItem{
-				{
-					item: Item{
-						scKey:    "sc-1",
-						shareKey: CreateShareKey(testProject, testLocation, testInstance+"1", testShare+"1"),
-						op: OpInfo{
-							Name: "op-1",
-							Type: ShareDelete,
-						},
-					},
-				},
-				{
-					item: Item{
-						scKey:    "sc-2",
-						shareKey: CreateShareKey(testProject, testLocation, testInstance+"2", testShare+"2"),
-						op: OpInfo{
-							Name: "op-2",
-							Type: ShareExpand,
-						},
-					},
-				},
-			},
-			clear: []ClearItem{
-				{
-					item: Item{
-						scKey:    "sc-2",
-						shareKey: CreateShareKey(testProject, testLocation, testInstance+"3", testShare+"2"),
-						op: OpInfo{
-							Name: "op-3",
-						},
-					},
-				},
-			},
-			output: []OutputItem{
-				{
-					item: Item{
-						scKey:    "sc-1",
-						shareKey: CreateShareKey(testProject, testLocation, testInstance+"1", testShare+"1"),
-						op: OpInfo{
-							Name: "op-1",
-							Type: ShareDelete,
-						},
-					},
-				},
-				{
-					item: Item{
-						scKey:    "sc-2",
-						shareKey: CreateShareKey(testProject, testLocation, testInstance+"2", testShare+"2"),
-						op: OpInfo{
-							Name: "op-2",
-							Type: ShareExpand,
-						},
-					},
-				},
-			},
-		},
-		{
-			name: "tc8 - non-existent sc key, add op failure",
-			add: []AddItem{
-				{
-					item: Item{
-						scKey:    "sc-1",
-						shareKey: CreateShareKey(testProject, testLocation, testInstance+"1", testShare+"1"),
-						op: OpInfo{
-							Name: "op-1",
-							Type: ShareDelete,
-						},
-					},
-					skipInitSCKey: true,
-					expectError:   true,
-				},
-				{
-					item: Item{
-						scKey:    "sc-2",
-						shareKey: CreateShareKey(testProject, testLocation, testInstance+"2", testShare+"2"),
-						op: OpInfo{
-							Name: "op-2",
-							Type: ShareExpand,
-						},
-					},
-					skipInitSCKey: true,
-					expectError:   true,
-				},
-			},
-		},
-	}
-	for _, tc := range tests {
-		t.Run(tc.name, func(t *testing.T) {
-			cache := NewStorageClassInfoCache()
-			for _, item := range tc.add {
-				if !item.skipInitSCKey {
-					if _, ok := cache.ScInfoMap[item.item.scKey]; !ok {
-						cache.ScInfoMap[item.item.scKey] = StorageClassInfo{
-							InstanceMap:    make(InstanceMap),
-							ShareCreateMap: make(ShareCreateMap),
-							ShareOpsMap:    make(ShareOpsMap),
-						}
-					}
-				}
-				err := cache.AddShareOp(item.item.scKey, item.item.shareKey, item.item.op)
-				if !item.expectError && err != nil {
-					t.Errorf("unexpected error")
-				}
-				if item.expectError && err == nil {
-					t.Errorf("expected error not found")
-				}
-			}
-			for _, item := range tc.clear {
-				err := cache.DeleteShareOp(item.item.scKey, item.item.shareKey, item.item.op.Name)
-				if item.expectError && err == nil {
-					t.Errorf("expected error")
-				}
-				if !item.expectError && err != nil {
-					t.Errorf("unexpected error")
-				}
-			}
-
-			for _, item := range tc.output {
-				op := cache.GetShareOp(item.item.scKey, item.item.shareKey)
-				if item.expectEmpty {
-					if op != nil {
-						t.Errorf("want nil, got %+v", op)
-					}
-					return
-				}
-
-				if op.Name != item.item.op.Name || op.Type != item.item.op.Type {
-					t.Errorf("want %+v, got : %+v", item.item.op, op)
-				}
-			}
-		})
-	}
-
-}
-
-func createInstanceHandle(project, location, instance string) string {
-	return fmt.Sprintf("%s/%s/%s", project, location, instance)
-}
-
-func TestShareCreateOpMap(t *testing.T) {
-	tests := []struct {
-		name   string
-		add    []AddItem
-		clear  []ClearItem
-		output []OutputItem
-	}{
-		{
-			name: "tc1 - add ops for 2 shares on same instance, for 1 storage class",
-			add: []AddItem{
-				{
-					item: Item{
-						scKey:          "sc-1",
-						shareCreateKey: testShare + "1",
-						createOp: ShareCreateOpInfo{
-							InstanceHandle: createInstanceHandle(testProject, testLocation, testInstance),
-							OpName:         "op-1",
-						},
-					},
-				},
-				{
-					item: Item{
-						scKey:          "sc-1",
-						shareCreateKey: testShare + "2",
-						createOp: ShareCreateOpInfo{
-							InstanceHandle: createInstanceHandle(testProject, testLocation, testInstance),
-							OpName:         "op-2",
-						},
-					},
-				},
-			},
-			output: []OutputItem{
-				{
-					item: Item{
-						scKey:          "sc-1",
-						shareCreateKey: testShare + "1",
-						createOp: ShareCreateOpInfo{
-							InstanceHandle: createInstanceHandle(testProject, testLocation, testInstance),
-							OpName:         "op-1",
-						},
-					},
-				},
-				{
-					item: Item{
-						scKey:          "sc-1",
-						shareCreateKey: testShare + "2",
-						createOp: ShareCreateOpInfo{
-							InstanceHandle: createInstanceHandle(testProject, testLocation, testInstance),
-							OpName:         "op-2",
-						},
-					},
-				},
-			},
-		},
-		{
-			name: "tc2 - add 2 share ops on different instances, for 2 storage classes",
-			add: []AddItem{
-				{
-					item: Item{
-						scKey:          "sc-1",
-						shareCreateKey: testShare + "1",
-						createOp: ShareCreateOpInfo{
-							InstanceHandle: createInstanceHandle(testProject, testLocation, testInstance+"1"),
-							OpName:         "op-1",
-						},
-					},
-				},
-				{
-					item: Item{
-						scKey:          "sc-2",
-						shareCreateKey: testShare + "2",
-						createOp: ShareCreateOpInfo{
-							InstanceHandle: createInstanceHandle(testProject, testLocation, testInstance+"2"),
-							OpName:         "op-2",
-						},
-					},
-				},
-			},
-			output: []OutputItem{
-				{
-					item: Item{
-						scKey:          "sc-1",
-						shareCreateKey: testShare + "1",
-						createOp: ShareCreateOpInfo{
-							InstanceHandle: createInstanceHandle(testProject, testLocation, testInstance+"1"),
-							OpName:         "op-1",
-						},
-					},
-				},
-				{
-					item: Item{
-						scKey:          "sc-2",
-						shareCreateKey: testShare + "2",
-						createOp: ShareCreateOpInfo{
-							InstanceHandle: createInstanceHandle(testProject, testLocation, testInstance+"2"),
-							OpName:         "op-2",
-						},
-					},
-				},
-			},
-		},
-		{
-			name: "tc3 - add 2 share ops and 2 clear ops, for 2 storage classes",
-			add: []AddItem{
-				{
-					item: Item{
-						scKey:          "sc-1",
-						shareCreateKey: testShare + "1",
-						createOp: ShareCreateOpInfo{
-							InstanceHandle: createInstanceHandle(testProject, testLocation, testInstance+"1"),
-							OpName:         "op-1",
-						},
-					},
-				},
-				{
-					item: Item{
-						scKey:          "sc-2",
-						shareCreateKey: testShare + "2",
-						createOp: ShareCreateOpInfo{
-							InstanceHandle: createInstanceHandle(testProject, testLocation, testInstance+"2"),
-							OpName:         "op-2",
-						},
-					},
-				},
-			},
-			clear: []ClearItem{
-				{
-					item: Item{
-						scKey:          "sc-1",
-						shareCreateKey: testShare + "1",
-						createOp: ShareCreateOpInfo{
-							OpName: "op-1",
-						},
-					},
-				},
-				{
-					item: Item{
-						scKey:          "sc-2",
-						shareCreateKey: testShare + "2",
-						createOp: ShareCreateOpInfo{
-							OpName: "op-2",
-						},
-					},
-				},
-			},
-		},
-		{
-			name: "tc4 - add 2 share ops and 1 clear op, for 2 storage classes",
-			add: []AddItem{
-				{
-					item: Item{
-						scKey:          "sc-1",
-						shareCreateKey: testShare + "1",
-						createOp: ShareCreateOpInfo{
-							InstanceHandle: createInstanceHandle(testProject, testLocation, testInstance+"1"),
-							OpName:         "op-1",
-						},
-					},
-				},
-				{
-					item: Item{
-						scKey:          "sc-2",
-						shareCreateKey: testShare + "2",
-						createOp: ShareCreateOpInfo{
-							InstanceHandle: createInstanceHandle(testProject, testLocation, testInstance+"2"),
-							OpName:         "op-2",
-						},
-					},
-				},
-			},
-			clear: []ClearItem{
-				{
-					item: Item{
-						scKey:          "sc-2",
-						shareCreateKey: testShare + "2",
-						createOp: ShareCreateOpInfo{
-							OpName: "op-2",
-						},
-					},
-				},
-			},
-			output: []OutputItem{
-				{
-					item: Item{
-						scKey:          "sc-1",
-						shareCreateKey: testShare + "1",
-						createOp: ShareCreateOpInfo{
-							InstanceHandle: createInstanceHandle(testProject, testLocation, testInstance+"1"),
-							OpName:         "op-1",
-						},
-					},
-				},
-				{
-					item: Item{
-						scKey:          "sc-2",
-						shareCreateKey: testShare + "2",
-						createOp: ShareCreateOpInfo{
-							InstanceHandle: createInstanceHandle(testProject, testLocation, testInstance+"2"),
-							OpName:         "op-2",
-						},
-					},
-					expectEmpty: true,
-				},
-			},
-		},
-		{
-			name: "tc5 - clear non-existent sc",
-			add: []AddItem{
-				{
-					item: Item{
-						scKey:          "sc-1",
-						shareCreateKey: testShare + "1",
-						createOp: ShareCreateOpInfo{
-							InstanceHandle: createInstanceHandle(testProject, testLocation, testInstance+"1"),
-							OpName:         "op-1",
-						},
-					},
-				},
-				{
-					item: Item{
-						scKey:          "sc-2",
-						shareCreateKey: testShare + "2",
-						createOp: ShareCreateOpInfo{
-							InstanceHandle: createInstanceHandle(testProject, testLocation, testInstance+"2"),
-							OpName:         "op-2",
-						},
-					},
-				},
-			},
-			clear: []ClearItem{
-				{
-					item: Item{
-						scKey:          "sc-3",
-						shareCreateKey: testShare + "2",
-						createOp: ShareCreateOpInfo{
-							OpName: "op-2",
-						},
-					},
-				},
-			},
-			output: []OutputItem{
-				{
-					item: Item{
-						scKey:          "sc-1",
-						shareCreateKey: testShare + "1",
-						createOp: ShareCreateOpInfo{
-							InstanceHandle: createInstanceHandle(testProject, testLocation, testInstance+"1"),
-							OpName:         "op-1",
-						},
-					},
-				},
-				{
-					item: Item{
-						scKey:          "sc-2",
-						shareCreateKey: testShare + "2",
-						createOp: ShareCreateOpInfo{
-							InstanceHandle: createInstanceHandle(testProject, testLocation, testInstance+"2"),
-							OpName:         "op-2",
-						},
-					},
-				},
-			},
-		},
-		{
-			name: "tc6 - clear non-existent share key",
-			add: []AddItem{
-				{
-					item: Item{
-						scKey:          "sc-1",
-						shareCreateKey: testShare + "1",
-						createOp: ShareCreateOpInfo{
-							InstanceHandle: createInstanceHandle(testProject, testLocation, testInstance+"1"),
-							OpName:         "op-1",
-						},
-					},
-				},
-				{
-					item: Item{
-						scKey:          "sc-2",
-						shareCreateKey: testShare + "2",
-						createOp: ShareCreateOpInfo{
-							InstanceHandle: createInstanceHandle(testProject, testLocation, testInstance+"2"),
-							OpName:         "op-2",
-						},
-					},
-				},
-			},
-			clear: []ClearItem{
-				{
-					item: Item{
-						scKey:          "sc-1",
-						shareCreateKey: testShare + "3",
-						createOp: ShareCreateOpInfo{
-							OpName: "op-3",
-						},
-					},
-				},
-			},
-			output: []OutputItem{
-				{
-					item: Item{
-						scKey:          "sc-1",
-						shareCreateKey: testShare + "1",
-						createOp: ShareCreateOpInfo{
-							InstanceHandle: createInstanceHandle(testProject, testLocation, testInstance+"1"),
-							OpName:         "op-1",
-						},
-					},
-				},
-				{
-					item: Item{
-						scKey:          "sc-2",
-						shareCreateKey: testShare + "2",
-						createOp: ShareCreateOpInfo{
-							InstanceHandle: createInstanceHandle(testProject, testLocation, testInstance+"2"),
-							OpName:         "op-2",
-						},
-					},
-				},
-			},
-		},
-		{
-			name: "tc7 - clear mistched op for share key, error expected in clear",
-			add: []AddItem{
-				{
-					item: Item{
-						scKey:          "sc-1",
-						shareCreateKey: testShare + "1",
-						createOp: ShareCreateOpInfo{
-							InstanceHandle: createInstanceHandle(testProject, testLocation, testInstance+"1"),
-							OpName:         "op-1",
-						},
-					},
-				},
-				{
-					item: Item{
-						scKey:          "sc-2",
-						shareCreateKey: testShare + "2",
-						createOp: ShareCreateOpInfo{
-							InstanceHandle: createInstanceHandle(testProject, testLocation, testInstance+"2"),
-							OpName:         "op-2",
-						},
-					},
-				},
-			},
-			clear: []ClearItem{
-				{
-					item: Item{
-						scKey:          "sc-1",
-						shareCreateKey: testShare + "1",
-						createOp: ShareCreateOpInfo{
-							OpName: "op-3",
-						},
-					},
-					expectError: true,
-				},
-			},
-			output: []OutputItem{
-				{
-					item: Item{
-						scKey:          "sc-1",
-						shareCreateKey: testShare + "1",
-						createOp: ShareCreateOpInfo{
-							InstanceHandle: createInstanceHandle(testProject, testLocation, testInstance+"1"),
-							OpName:         "op-1",
-						},
-					},
-				},
-				{
-					item: Item{
-						scKey:          "sc-2",
-						shareCreateKey: testShare + "2",
-						createOp: ShareCreateOpInfo{
-							InstanceHandle: createInstanceHandle(testProject, testLocation, testInstance+"2"),
-							OpName:         "op-2",
-						},
-					},
-				},
-			},
-		},
-		{
-			name: "tc8 - missing sc key, add op failure",
-			add: []AddItem{
-				{
-					item: Item{
-						scKey:          "sc-1",
-						shareCreateKey: testShare + "1",
-						createOp: ShareCreateOpInfo{
-							InstanceHandle: createInstanceHandle(testProject, testLocation, testInstance+"1"),
-							OpName:         "op-1",
-						},
-					},
-					skipInitSCKey: true,
-					expectError:   true,
-				},
-				{
-					item: Item{
-						scKey:          "sc-2",
-						shareCreateKey: testShare + "2",
-						createOp: ShareCreateOpInfo{
-							InstanceHandle: createInstanceHandle(testProject, testLocation, testInstance+"2"),
-							OpName:         "op-2",
-						},
-					},
-					skipInitSCKey: true,
-					expectError:   true,
-				},
-			},
-		},
-	}
-	for _, tc := range tests {
-		t.Run(tc.name, func(t *testing.T) {
-			cache := NewStorageClassInfoCache()
-			for _, item := range tc.add {
-				if !item.skipInitSCKey {
-					if _, ok := cache.ScInfoMap[item.item.scKey]; !ok {
-						cache.ScInfoMap[item.item.scKey] = StorageClassInfo{
-							InstanceMap:    make(InstanceMap),
-							ShareCreateMap: make(ShareCreateMap),
-							ShareOpsMap:    make(ShareOpsMap),
-						}
-					}
-				}
-				err := cache.AddShareCreateOp(item.item.scKey, item.item.shareCreateKey, item.item.createOp)
-				if !item.expectError && err != nil {
-					t.Errorf("unexpected error")
-				}
-				if item.expectError && err == nil {
-					t.Errorf("expected error not found")
-				}
-			}
-			for _, item := range tc.clear {
-				err := cache.DeleteShareCreateOp(item.item.scKey, item.item.shareCreateKey, item.item.createOp.OpName)
-				if item.expectError && err == nil {
-					t.Errorf("expected error")
-				}
-				if !item.expectError && err != nil {
-					t.Errorf("unexpected error")
-				}
-			}
-
-			for _, item := range tc.output {
-				op := cache.GetShareCreateOp(item.item.scKey, item.item.shareCreateKey)
-				if item.expectEmpty {
-					if op != nil {
-						t.Errorf("want nil, got %+v", op)
-					}
-					return
-				}
-
-				if op.OpName != item.item.createOp.OpName || op.InstanceHandle != item.item.createOp.InstanceHandle {
-					t.Errorf("want %+v, got : %+v", item.item.createOp, op)
-				}
-			}
-		})
-	}
-
-}
-
-func TestCreateKey(t *testing.T) {
-	tests := []struct {
-		name                string
-		project             string
-		location            string
-		instance            string
-		share               string
-		expectedShareKey    string
-		expectedInstanceKey string
-	}{
-		{
-			name:             "tc1",
-			project:          testProject,
-			location:         testLocation,
-			instance:         testInstance,
-			share:            testShare,
-			expectedShareKey: fmt.Sprintf("%s/%s/%s/%s", testProject, testLocation, testInstance, testShare),
-		},
-		{
-			name:                "tc2",
-			project:             testProject,
-			location:            testLocation,
-			instance:            testInstance,
-			expectedInstanceKey: fmt.Sprintf("%s/%s/%s", testProject, testLocation, testInstance),
-		},
-	}
-	for _, tc := range tests {
-		t.Run(tc.name, func(t *testing.T) {
-			if tc.expectedShareKey != "" {
-				k := CreateShareKey(tc.project, tc.location, tc.instance, tc.share)
-				if string(k) != tc.expectedShareKey {
-					t.Errorf("want %v, got %v", tc.expectedShareKey, k)
-				}
-			}
-			if tc.expectedInstanceKey != "" {
-				k := CreateInstanceKey(tc.project, tc.location, tc.instance)
-				if string(k) != tc.expectedInstanceKey {
-					t.Errorf("want %v, got %v", tc.expectedInstanceKey, k)
-				}
-			}
-		})
-	}
-}
diff --git a/pkg/util/util_test.go b/pkg/util/util_test.go
index cc558d22..e15f9b53 100644
--- a/pkg/util/util_test.go
+++ b/pkg/util/util_test.go
@@ -28,6 +28,7 @@ const (
 	testRegion       = "us-central1"
 	testInstanceName = "testInstance"
 	testShareName    = "testShare"
+	testProject      = "test-project"
 )
 
 func TestRoundBytesToGb(t *testing.T) {
@@ -315,49 +316,6 @@ func TestConvertVolToShareName(t *testing.T) {
 
 }
 
-func TestParseInstanceHandle(t *testing.T) {
-	tests := []struct {
-		name           string
-		instanceHandle string
-		expectErr      bool
-		project        string
-		location       string
-		instancename   string
-	}{
-		{
-			name:           "invalid handle",
-			instanceHandle: "a/b/c/d",
-			expectErr:      true,
-		},
-		{
-			name:      "empty handle",
-			expectErr: true,
-		},
-		{
-			name:           "valid handle",
-			instanceHandle: testProject + "/" + testRegion + "/" + testInstanceName,
-			project:        testProject,
-			location:       testRegion,
-			instancename:   testInstanceName,
-		},
-	}
-	for _, tc := range tests {
-		t.Run(tc.name, func(t *testing.T) {
-			p, l, n, err := ParseInstanceHandle(tc.instanceHandle)
-			if !tc.expectErr && err != nil {
-				t.Error("unexpected error")
-			}
-			if tc.expectErr && err == nil {
-				t.Error("expected error, got none")
-			}
-			if p != tc.project || l != tc.location || n != tc.instancename {
-				t.Errorf("mismatch")
-			}
-		})
-	}
-
-}
-
 func TestParseInstanceURI(t *testing.T) {
 	tests := []struct {
 		name         string
@@ -405,50 +363,6 @@ func TestParseInstanceURI(t *testing.T) {
 	}
 }
 
-func TestParseShareHandle(t *testing.T) {
-	tests := []struct {
-		name         string
-		sharehandle  string
-		expectErr    bool
-		project      string
-		location     string
-		instancename string
-		sharename    string
-	}{
-		{
-			name:        "invalid handle",
-			sharehandle: "a/b/c/d/e",
-			expectErr:   true,
-		},
-		{
-			name:      "empty handle",
-			expectErr: true,
-		},
-		{
-			name:         "valid handle",
-			sharehandle:  testProject + "/" + testRegion + "/" + testInstanceName + "/" + testShareName,
-			project:      testProject,
-			location:     testRegion,
-			instancename: testInstanceName,
-			sharename:    testShareName,
-		},
-	}
-	for _, tc := range tests {
-		t.Run(tc.name, func(t *testing.T) {
-			p, l, n, s, err := ParseShareHandle(tc.sharehandle)
-			if !tc.expectErr && err != nil {
-				t.Error("unexpected error")
-			}
-			if tc.expectErr && err == nil {
-				t.Error("expected error, got none")
-			}
-			if p != tc.project || l != tc.location || n != tc.instancename || s != tc.sharename {
-				t.Errorf("mismatch")
-			}
-		})
-	}
-}
-
 func TestParseShareURI(t *testing.T) {
 	tests := []struct {
 		name         string