@sanity/cli 6.0.0-alpha.4 → 6.0.0-alpha.5

package/dist/commands/__tests__/deploy.test.js

@@ -1,5 +1,4 @@
 import { runCommand } from '@oclif/test';
-import { getCliConfig } from '@sanity/cli-core';
 import { confirm, input, select } from '@sanity/cli-core/ux';
 import { mockApi, testCommand } from '@sanity/cli-test';
 import nock from 'nock';
@@ -12,9 +11,6 @@ import { USER_APPLICATIONS_API_VERSION } from '../../services/userApplications.j
 import { dirIsEmptyOrNonExistent } from '../../util/dirIsEmptyOrNonExistent.js';
 import { readModuleVersion } from '../../util/readModuleVersion.js';
 import { DeployCommand } from '../deploy.js';
-vi.mock('../../../../cli-core/src/config/cli/getCliConfig.js', ()=>({
-        getCliConfig: vi.fn()
-    }));
 vi.mock('../../util/readModuleVersion.js', ()=>({
         readModuleVersion: vi.fn()
     }));
@@ -46,7 +42,6 @@ vi.mock('tar-fs', ()=>({
             };
         })
     }));
-const mockGetCliConfig = vi.mocked(getCliConfig);
 const mockSelect = vi.mocked(select);
 const mockConfirm = vi.mocked(confirm);
 const mockInput = vi.mocked(input);
@@ -55,6 +50,18 @@ const mockDirIsEmptyOrNonExistent = vi.mocked(dirIsEmptyOrNonExistent);
 const mockReadModuleVersion = vi.mocked(readModuleVersion);
 const mockBuildStudio = vi.mocked(buildStudio);
 const mockBuildApp = vi.mocked(buildApp);
+const appId = 'app-id';
+const organizationId = 'org-id';
+const defaultMocks = {
+    cliConfig: {
+        app: {
+            organizationId
+        },
+        deployment: {
+            appId
+        }
+    }
+};
 describe('#deploy', ()=>{
     beforeEach(async ()=>{
         // Set up default mocks
@@ -129,15 +136,6 @@ describe('#deploy', ()=>{
         process.cwd = ()=>cwd;
         mockConfirm.mockResolvedValue(true);
         mockDirIsEmptyOrNonExistent.mockResolvedValue(false);
-        const appId = 'app-id';
-        mockGetCliConfig.mockResolvedValue({
-            app: {
-                organizationId: 'org-id'
-            },
-            deployment: {
-                appId
-            }
-        });
         mockApi({
             apiVersion: USER_APPLICATIONS_API_VERSION,
             query: {
@@ -170,7 +168,8 @@ describe('#deploy', ()=>{
         ], {
             config: {
                 root: cwd
-            }
+            },
+            mocks: defaultMocks
         });
         expect(error).toBeUndefined();
         expect(mockConfirm).toHaveBeenCalledWith({
@@ -182,21 +181,13 @@ describe('#deploy', ()=>{
         const cwd = await testExample('basic-app');
         process.cwd = ()=>cwd;
         mockConfirm.mockResolvedValue(false);
-        const appId = 'app-id';
-        mockGetCliConfig.mockResolvedValue({
-            app: {
-                organizationId: 'org-id'
-            },
-            deployment: {
-                appId
-            }
-        });
         const { error } = await testCommand(DeployCommand, [
             'build'
         ], {
             config: {
                 root: cwd
-            }
+            },
+            mocks: defaultMocks
         });
         expect(error?.message).toContain('Cancelled.');
         expect(error?.oclif?.exit).toBe(1);
@@ -205,15 +196,6 @@ describe('#deploy', ()=>{
         test('should re-deploy app if it already exists', async ()=>{
             const cwd = await testExample('basic-app');
             process.cwd = ()=>cwd;
-            const appId = 'app-id';
-            mockGetCliConfig.mockResolvedValue({
-                app: {
-                    organizationId: 'org-id'
-                },
-                deployment: {
-                    appId
-                }
-            });
             mockApi({
                 apiVersion: USER_APPLICATIONS_API_VERSION,
                 query: {
@@ -244,7 +226,8 @@ describe('#deploy', ()=>{
             const { error, stderr, stdout } = await testCommand(DeployCommand, [], {
                 config: {
                     root: cwd
-                }
+                },
+                mocks: defaultMocks
             });
             expect(error).toBeUndefined();
             expect(stderr).toContain('Checking application info');
@@ -255,36 +238,21 @@ describe('#deploy', ()=>{
         test('should handle missing @sanity/sdk-react version', async ()=>{
             const cwd = await testExample('basic-app');
             process.cwd = ()=>cwd;
-            const appId = 'app-id';
-            const organizationId = 'org-id';
             mockReadModuleVersion.mockResolvedValue(null);
-            mockGetCliConfig.mockResolvedValue({
-                app: {
-                    organizationId
-                },
-                deployment: {
-                    appId
-                }
-            });
             const { error } = await testCommand(DeployCommand, [], {
                 config: {
                     root: cwd
-                }
+                },
+                mocks: defaultMocks
             });
             expect(error?.message).toContain('Failed to find installed @sanity/sdk-react version');
         });
         test('should create new user application if none exists', async ()=>{
             const cwd = await testExample('basic-app');
             process.cwd = ()=>cwd;
-            const organizationId = 'org-id';
             const newAppId = 'new-app-id';
             const deploymentId = 'deployment-id';
             mockInput.mockResolvedValue('Test App');
-            mockGetCliConfig.mockResolvedValue({
-                app: {
-                    organizationId
-                }
-            });
             mockApi({
                 apiVersion: USER_APPLICATIONS_API_VERSION,
                 query: {
@@ -325,6 +293,13 @@ describe('#deploy', ()=>{
             const { error, stdout } = await testCommand(DeployCommand, [], {
                 config: {
                     root: cwd
+                },
+                mocks: {
+                    cliConfig: {
+                        app: {
+                            organizationId
+                        }
+                    }
                 }
             });
             expect(error).toBeUndefined();
@@ -341,16 +316,7 @@ describe('#deploy', ()=>{
             const cwd = await testExample('basic-app');
             process.cwd = ()=>cwd;
             const existingAppId = 'existing-app-id';
-            const organizationId = 'org-id';
             const deploymentId = 'deployment-id';
-            mockGetCliConfig.mockResolvedValue({
-                app: {
-                    organizationId
-                },
-                deployment: {
-                    appId: existingAppId
-                }
-            });
             mockApi({
                 apiVersion: USER_APPLICATIONS_API_VERSION,
                 query: {
@@ -383,6 +349,14 @@ describe('#deploy', ()=>{
             ], {
                 config: {
                     root: cwd
+                },
+                mocks: {
+                    cliConfig: {
+                        ...defaultMocks.cliConfig,
+                        deployment: {
+                            appId: existingAppId
+                        }
+                    }
                 }
             });
             expect(error).toBeUndefined();
@@ -393,16 +367,7 @@ describe('#deploy', ()=>{
             const cwd = await testExample('basic-app');
             process.cwd = ()=>cwd;
             const existingAppId = 'existing-app-id';
-            const organizationId = 'org-id';
             mockCheckDir.mockRejectedValue(new Error('Directory check failed'));
-            mockGetCliConfig.mockResolvedValue({
-                app: {
-                    organizationId
-                },
-                deployment: {
-                    appId: existingAppId
-                }
-            });
             mockApi({
                 apiVersion: USER_APPLICATIONS_API_VERSION,
                 query: {
@@ -425,30 +390,31 @@ describe('#deploy', ()=>{
             ], {
                 config: {
                     root: cwd
+                },
+                mocks: {
+                    cliConfig: {
+                        ...defaultMocks.cliConfig,
+                        deployment: {
+                            appId: existingAppId
+                        }
+                    }
                 }
             });
             expect(error?.message).toContain('Error checking directory');
+            expect(error?.oclif?.exit).toBe(1);
         });
-        test('should error when fetching user applications if user doesn’t have org access', async ()=>{
+        test("should error when fetching user applications if user doesn't have org access", async ()=>{
             const cwd = await testExample('basic-app');
             process.cwd = ()=>cwd;
-            const appId = 'some-app-id';
-            const organizationId = 'org-without-access';
-            mockGetCliConfig.mockResolvedValue({
-                app: {
-                    organizationId
-                },
-                deployment: {
-                    appId
-                }
-            });
+            const anotherAppId = 'some-app-id';
+            const anotherOrganizationId = 'org-without-access';
             // Simulate API returning 403 Forbidden for the given org
             mockApi({
                 apiVersion: USER_APPLICATIONS_API_VERSION,
                 query: {
                     appType: 'coreApp'
                 },
-                uri: `/user-applications/${appId}`
+                uri: `/user-applications/${anotherAppId}`
             }).reply(403, {
                 error: 'Forbidden'
             });
@@ -457,23 +423,25 @@ describe('#deploy', ()=>{
             ], {
                 config: {
                     root: cwd
+                },
+                mocks: {
+                    cliConfig: {
+                        app: {
+                            organizationId: anotherOrganizationId
+                        },
+                        deployment: {
+                            appId: anotherAppId
+                        }
+                    }
                 }
             });
-            expect(error?.message).toContain(`You don’t have permission to view applications for the configured organization ID ("${organizationId}")`);
+            expect(error?.message).toContain(`You don’t have permission to view applications for the configured organization ID ("${anotherOrganizationId}")`);
+            expect(error?.oclif?.exit).toBe(1);
         });
         test('should handle user-applications endpoint errors', async ()=>{
             const cwd = await testExample('basic-app');
             process.cwd = ()=>cwd;
             const existingAppId = 'existing-app-id';
-            const organizationId = 'org-id';
-            mockGetCliConfig.mockResolvedValue({
-                app: {
-                    organizationId
-                },
-                deployment: {
-                    appId: existingAppId
-                }
-            });
             mockApi({
                 apiVersion: USER_APPLICATIONS_API_VERSION,
                 query: {
@@ -488,23 +456,23 @@ describe('#deploy', ()=>{
             ], {
                 config: {
                     root: cwd
+                },
+                mocks: {
+                    cliConfig: {
+                        ...defaultMocks.cliConfig,
+                        deployment: {
+                            appId: existingAppId
+                        }
+                    }
                 }
             });
             expect(error?.message).toContain('Error deploying application');
+            expect(error?.oclif?.exit).toBe(1);
         });
         test('should handle deployment API errors', async ()=>{
             const cwd = await testExample('basic-app');
             process.cwd = ()=>cwd;
             const existingAppId = 'existing-app-id';
-            const organizationId = 'org-id';
-            mockGetCliConfig.mockResolvedValue({
-                app: {
-                    organizationId
-                },
-                deployment: {
-                    appId: existingAppId
-                }
-            });
             mockApi({
                 apiVersion: USER_APPLICATIONS_API_VERSION,
                 query: {
@@ -537,23 +505,23 @@ describe('#deploy', ()=>{
             ], {
                 config: {
                     root: cwd
+                },
+                mocks: {
+                    cliConfig: {
+                        ...defaultMocks.cliConfig,
+                        deployment: {
+                            appId: existingAppId
+                        }
+                    }
                 }
             });
             expect(error?.message).toContain('Error deploying application');
+            expect(error?.oclif?.exit).toBe(1);
         });
         test('should show an error if deployment.appId is configured but the application does not exist', async ()=>{
             const cwd = await testExample('basic-app');
             process.cwd = ()=>cwd;
             const nonExistentAppId = 'non-existent-app-id';
-            const organizationId = 'org-id';
-            mockGetCliConfig.mockResolvedValue({
-                app: {
-                    organizationId
-                },
-                deployment: {
-                    appId: nonExistentAppId
-                }
-            });
             // Simulate API returning no user application for the given app.id
             mockApi({
                 apiVersion: USER_APPLICATIONS_API_VERSION,
@@ -569,49 +537,57 @@ describe('#deploy', ()=>{
             ], {
                 config: {
                     root: cwd
+                },
+                mocks: {
+                    cliConfig: {
+                        ...defaultMocks.cliConfig,
+                        deployment: {
+                            appId: nonExistentAppId
+                        }
+                    }
                 }
             });
             expect(error?.message).toContain('The `appId` provided in your configuration’s `deployment` object cannot be found in your organization');
+            expect(error?.oclif?.exit).toBe(1);
         });
         test('should show an error if deployment.appId and app.id (deprecated) are both in use', async ()=>{
             const cwd = await testExample('basic-app');
             process.cwd = ()=>cwd;
-            const appId = 'app-id';
-            const organizationId = 'org-id';
-            mockGetCliConfig.mockResolvedValue({
-                app: {
-                    id: appId,
-                    organizationId
-                },
-                deployment: {
-                    appId: appId
-                }
-            });
             const { error } = await testCommand(DeployCommand, [
                 '--no-build'
             ], {
                 config: {
                     root: cwd
+                },
+                mocks: {
+                    cliConfig: {
+                        ...defaultMocks.cliConfig,
+                        app: {
+                            id: appId,
+                            organizationId
+                        }
+                    }
                 }
             });
             expect(error?.message).toContain('Found both app.id (deprecated) and deployment.appId in your application configuration.\n\nPlease remove app.id from your sanity.cli.js or sanity.cli.ts file.');
+            expect(error?.oclif?.exit).toBe(1);
         });
         test('should show a warning if app.id (deprecated) is used', async ()=>{
             const cwd = await testExample('basic-app');
             process.cwd = ()=>cwd;
-            const appId = 'app-id';
-            const organizationId = 'org-id';
-            mockGetCliConfig.mockResolvedValue({
-                app: {
-                    id: appId,
-                    organizationId
-                }
-            });
             const { stderr } = await testCommand(DeployCommand, [
                 '--no-build'
             ], {
                 config: {
                     root: cwd
+                },
+                mocks: {
+                    cliConfig: {
+                        app: {
+                            id: appId,
+                            organizationId
+                        }
+                    }
                 }
             });
             expect(stderr).toContain('The `app.id` config has moved to `deployment.appId`.');
@@ -619,15 +595,9 @@ describe('#deploy', ()=>{
         test('should handle app creation with retry when host is taken', async ()=>{
             const cwd = await testExample('basic-app');
             process.cwd = ()=>cwd;
-            const organizationId = 'org-id';
             const newAppId = 'new-app-id';
             const deploymentId = 'deployment-id';
             mockInput.mockResolvedValue('Test App');
-            mockGetCliConfig.mockResolvedValue({
-                app: {
-                    organizationId
-                }
-            });
             mockApi({
                 apiVersion: USER_APPLICATIONS_API_VERSION,
                 query: {
@@ -680,6 +650,13 @@ describe('#deploy', ()=>{
             const { error, stdout } = await testCommand(DeployCommand, [], {
                 config: {
                     root: cwd
+                },
+                mocks: {
+                    cliConfig: {
+                        app: {
+                            organizationId
+                        }
+                    }
                 }
             });
             expect(error).toBeUndefined();
@@ -688,13 +665,7 @@ describe('#deploy', ()=>{
         test('should handle app creation failure with non-retryable error', async ()=>{
             const cwd = await testExample('basic-app');
             process.cwd = ()=>cwd;
-            const organizationId = 'org-id';
             mockInput.mockResolvedValue('Test App');
-            mockGetCliConfig.mockResolvedValue({
-                app: {
-                    organizationId
-                }
-            });
             mockApi({
                 apiVersion: USER_APPLICATIONS_API_VERSION,
                 query: {
@@ -718,6 +689,13 @@ describe('#deploy', ()=>{
             const { error } = await testCommand(DeployCommand, [], {
                 config: {
                     root: cwd
+                },
+                mocks: {
+                    cliConfig: {
+                        app: {
+                            organizationId
+                        }
+                    }
                 }
             });
             expect(error?.message).toContain('Error deploying application');
@@ -726,15 +704,6 @@ describe('#deploy', ()=>{
             const cwd = await testExample('basic-app');
             process.cwd = ()=>cwd;
             const existingAppId = 'existing-app-id';
-            const organizationId = 'org-id';
-            mockGetCliConfig.mockResolvedValue({
-                app: {
-                    organizationId
-                },
-                deployment: {
-                    appId: existingAppId
-                }
-            });
             mockApi({
                 apiVersion: USER_APPLICATIONS_API_VERSION,
                 query: {
@@ -749,6 +718,14 @@ describe('#deploy', ()=>{
             ], {
                 config: {
                     root: cwd
+                },
+                mocks: {
+                    cliConfig: {
+                        ...defaultMocks.cliConfig,
+                        deployment: {
+                            appId: existingAppId
+                        }
+                    }
                 }
             });
             expect(error?.message).toContain('Error deploying application');
@@ -757,15 +734,9 @@ describe('#deploy', ()=>{
         test('should test input validation for app title', async ()=>{
             const cwd = await testExample('basic-app');
             process.cwd = ()=>cwd;
-            const organizationId = 'org-id';
             const newAppId = 'new-app-id';
             const deploymentId = 'deployment-id';
             mockInput.mockResolvedValue('Valid App Title');
-            mockGetCliConfig.mockResolvedValue({
-                app: {
-                    organizationId
-                }
-            });
             mockApi({
                 apiVersion: USER_APPLICATIONS_API_VERSION,
                 query: {
@@ -806,6 +777,13 @@ describe('#deploy', ()=>{
             const { error } = await testCommand(DeployCommand, [], {
                 config: {
                     root: cwd
+                },
+                mocks: {
+                    cliConfig: {
+                        app: {
+                            organizationId
+                        }
+                    }
                 }
             });
             expect(error).toBeUndefined();
@@ -817,15 +795,9 @@ describe('#deploy', ()=>{
         test('should allow selecting from list of apps', async ()=>{
             const cwd = await testExample('basic-app');
             process.cwd = ()=>cwd;
-            const organizationId = 'org-id';
             const existingAppId1 = 'existing-app-id-1';
             const existingAppId2 = 'existing-app-id-2';
             const deploymentId = 'deployment-id';
-            mockGetCliConfig.mockResolvedValue({
-                app: {
-                    organizationId
-                }
-            });
             mockApi({
                 apiVersion: USER_APPLICATIONS_API_VERSION,
                 query: {
@@ -871,6 +843,13 @@ describe('#deploy', ()=>{
             const { error, stdout } = await testCommand(DeployCommand, [], {
                 config: {
                     root: cwd
+                },
+                mocks: {
+                    cliConfig: {
+                        app: {
+                            organizationId
+                        }
+                    }
                 }
             });
             expect(error).toBeUndefined();
@@ -882,16 +861,10 @@ describe('#deploy', ()=>{
         test('should allow creating a new app by selecting from list of apps', async ()=>{
             const cwd = await testExample('basic-app');
             process.cwd = ()=>cwd;
-            const organizationId = 'org-id';
             const existingAppId1 = 'existing-app-id-1';
             const existingAppId2 = 'existing-app-id-2';
             const newAppId = 'new-app-id';
             const deploymentId = 'deployment-id';
-            mockGetCliConfig.mockResolvedValue({
-                app: {
-                    organizationId
-                }
-            });
             mockApi({
                 apiVersion: USER_APPLICATIONS_API_VERSION,
                 query: {
@@ -956,6 +929,13 @@ describe('#deploy', ()=>{
             const { error, stdout } = await testCommand(DeployCommand, [], {
                 config: {
                     root: cwd
+                },
+                mocks: {
+                    cliConfig: {
+                        app: {
+                            organizationId
+                        }
+                    }
                 }
             });
             expect(error).toBeUndefined();
@@ -967,14 +947,16 @@ describe('#deploy', ()=>{
         test('should throw an error if organizationId is not set', async ()=>{
             const cwd = await testExample('basic-app');
             process.cwd = ()=>cwd;
-            mockGetCliConfig.mockResolvedValue({
-                app: {
-                    organizationId: undefined
-                }
-            });
             const { error } = await testCommand(DeployCommand, [], {
                 config: {
                     root: cwd
+                },
+                mocks: {
+                    cliConfig: {
+                        app: {
+                            organizationId: undefined
+                        }
+                    }
                 }
             });
             expect(error?.message).toContain('sanity.cli.ts does not contain an organization identifier ("app.organizationId"), which is required for the Sanity CLI to communicate with the Sanity API');
@@ -986,12 +968,14 @@ describe('#deploy', ()=>{
             const cwd = await testExample('basic-studio');
             process.cwd = ()=>cwd;
             mockReadModuleVersion.mockResolvedValue(null);
-            mockGetCliConfig.mockResolvedValue({
-                studioHost: 'existing-studio'
-            });
             const { error } = await testCommand(DeployCommand, [], {
                 config: {
                     root: cwd
+                },
+                mocks: {
+                    cliConfig: {
+                        studioHost: 'existing-studio'
+                    }
                 }
             });
             expect(error?.message).toContain('Failed to find installed sanity version');
@@ -1003,12 +987,6 @@ describe('#deploy', ()=>{
             const studioHost = 'existing-studio';
             const studioAppId = 'studio-app-id';
             mockCheckDir.mockRejectedValue(new Error('Directory check failed'));
-            mockGetCliConfig.mockResolvedValue({
-                api: {
-                    projectId
-                },
-                studioHost
-            });
             mockApi({
                 apiVersion: USER_APPLICATIONS_API_VERSION,
                 query: {
@@ -1031,6 +1009,14 @@ describe('#deploy', ()=>{
             ], {
                 config: {
                     root: cwd
+                },
+                mocks: {
+                    cliConfig: {
+                        api: {
+                            projectId
+                        },
+                        studioHost
+                    }
                 }
             });
             expect(error?.message).toContain('Error checking directory');
@@ -1042,12 +1028,6 @@ describe('#deploy', ()=>{
             const studioHost = 'existing-studio';
             const studioAppId = 'studio-app-id';
             const deploymentId = 'deployment-id';
-            mockGetCliConfig.mockResolvedValue({
-                api: {
-                    projectId
-                },
-                studioHost
-            });
             mockApi({
                 apiVersion: USER_APPLICATIONS_API_VERSION,
                 query: {
@@ -1078,6 +1058,14 @@ describe('#deploy', ()=>{
             const { error, stderr, stdout } = await testCommand(DeployCommand, [], {
                 config: {
                     root: cwd
+                },
+                mocks: {
+                    cliConfig: {
+                        api: {
+                            projectId
+                        },
+                        studioHost
+                    }
                 }
             });
             expect(error).toBeUndefined();
@@ -1089,12 +1077,6 @@ describe('#deploy', ()=>{
         test('should create new studio hostname when studioHost is provided but does not exist', async ()=>{
             const cwd = await testExample('basic-studio');
             process.cwd = ()=>cwd;
-            mockGetCliConfig.mockResolvedValue({
-                api: {
-                    projectId: 'test-project-id'
-                },
-                studioHost: 'new-studio-host'
-            });
             mockApi({
                 apiVersion: USER_APPLICATIONS_API_VERSION,
                 query: {
@@ -1135,6 +1117,14 @@ describe('#deploy', ()=>{
             const { error, stdout } = await testCommand(DeployCommand, [], {
                 config: {
                     root: cwd
+                },
+                mocks: {
+                    cliConfig: {
+                        api: {
+                            projectId: 'test-project-id'
+                        },
+                        studioHost: 'new-studio-host'
+                    }
                 }
             });
             expect(error).toBeUndefined();
@@ -1147,12 +1137,6 @@ describe('#deploy', ()=>{
             process.cwd = ()=>cwd;
             const projectId = 'test-project-id';
             const studioHost = 'taken-studio-host';
-            mockGetCliConfig.mockResolvedValue({
-                api: {
-                    projectId
-                },
-                studioHost
-            });
             mockApi({
                 apiVersion: USER_APPLICATIONS_API_VERSION,
                 query: {
@@ -1177,6 +1161,14 @@ describe('#deploy', ()=>{
             const { error } = await testCommand(DeployCommand, [], {
                 config: {
                     root: cwd
+                },
+                mocks: {
+                    cliConfig: {
+                        api: {
+                            projectId
+                        },
+                        studioHost
+                    }
                 }
             });
             expect(error?.message).toContain('Studio hostname already taken');
@@ -1186,11 +1178,6 @@ describe('#deploy', ()=>{
             const cwd = await testExample('basic-studio');
             process.cwd = ()=>cwd;
             const projectId = 'test-project-id';
-            mockGetCliConfig.mockResolvedValue({
-                api: {
-                    projectId
-                }
-            });
             const studioOneId = 'studio-one-id';
             const studioTwoId = 'studio-two-id';
             const deploymentId = 'deployment-id';
@@ -1237,6 +1224,13 @@ describe('#deploy', ()=>{
             const { error, stdout } = await testCommand(DeployCommand, [], {
                 config: {
                     root: cwd
+                },
+                mocks: {
+                    cliConfig: {
+                        api: {
+                            projectId
+                        }
+                    }
                 }
             });
             expect(error).toBeUndefined();
@@ -1267,11 +1261,6 @@ describe('#deploy', ()=>{
             const existingStudioId = 'existing-studio-id';
             const newStudioFromMenuId = 'new-studio-from-menu-id';
             const deploymentId = 'deployment-id';
-            mockGetCliConfig.mockResolvedValue({
-                api: {
-                    projectId
-                }
-            });
             mockApi({
                 apiVersion: USER_APPLICATIONS_API_VERSION,
                 query: {
@@ -1331,6 +1320,13 @@ describe('#deploy', ()=>{
             const { error, stdout } = await testCommand(DeployCommand, [], {
                 config: {
                     root: cwd
+                },
+                mocks: {
+                    cliConfig: {
+                        api: {
+                            projectId
+                        }
+                    }
                 }
             });
             expect(error).toBeUndefined();
@@ -1361,11 +1357,6 @@ describe('#deploy', ()=>{
                 promise.cancel = ()=>{};
                 return promise;
             });
-            mockGetCliConfig.mockResolvedValue({
-                api: {
-                    projectId
-                }
-            });
             mockApi({
                 apiVersion: USER_APPLICATIONS_API_VERSION,
                 query: {
@@ -1416,6 +1407,13 @@ describe('#deploy', ()=>{
             const { error, stdout } = await testCommand(DeployCommand, [], {
                 config: {
                     root: cwd
+                },
+                mocks: {
+                    cliConfig: {
+                        api: {
+                            projectId
+                        }
+                    }
                 }
             });
             expect(error).toBeUndefined();
@@ -1440,11 +1438,6 @@ describe('#deploy', ()=>{
                 promise.cancel = ()=>{};
                 return promise;
             });
-            mockGetCliConfig.mockResolvedValue({
-                api: {
-                    projectId
-                }
-            });
             mockApi({
                 apiVersion: USER_APPLICATIONS_API_VERSION,
                 query: {
@@ -1467,6 +1460,13 @@ describe('#deploy', ()=>{
             const { error } = await testCommand(DeployCommand, [], {
                 config: {
                     root: cwd
+                },
+                mocks: {
+                    cliConfig: {
+                        api: {
+                            projectId
+                        }
+                    }
                 }
             });
             expect(error?.message).toContain('Error creating user application');
@@ -1475,13 +1475,15 @@ describe('#deploy', ()=>{
         test('should throw error when no projectId is configured', async ()=>{
             const cwd = await testExample('basic-studio');
             process.cwd = ()=>cwd;
-            mockGetCliConfig.mockResolvedValue({
-                api: {},
-                studioHost: 'some-studio'
-            });
             const { error } = await testCommand(DeployCommand, [], {
                 config: {
                     root: cwd
+                },
+                mocks: {
+                    cliConfig: {
+                        api: {},
+                        studioHost: 'some-studio'
+                    }
                 }
             });
             expect(error?.message).toContain('sanity.cli.ts does not contain a project identifier ("api.projectId"), which is required for the Sanity CLI to communicate with the Sanity API');
@@ -1490,11 +1492,21 @@ describe('#deploy', ()=>{
         test('should log a warning if the deprecated auto-updates flag is used', async ()=>{
             const cwd = await testExample('basic-studio');
             process.cwd = ()=>cwd;
+            const projectId = 'test-project-id';
+            const studioHost = 'test-studio';
             const { stderr } = await testCommand(DeployCommand, [
                 '--auto-updates'
             ], {
                 config: {
                     root: cwd
+                },
+                mocks: {
+                    cliConfig: {
+                        api: {
+                            projectId
+                        },
+                        studioHost
+                    }
                 }
             });
             expect(stderr).toContain('Warning: The --auto-updates flag is deprecated');
@@ -1502,15 +1514,17 @@ describe('#deploy', ()=>{
         test('should throw an error when both the current and deprecated autoUpdates config are used', async ()=>{
             const cwd = await testExample('basic-studio');
             process.cwd = ()=>cwd;
-            mockGetCliConfig.mockResolvedValue({
-                autoUpdates: true,
-                deployment: {
-                    autoUpdates: true
-                }
-            });
             const { error } = await testCommand(DeployCommand, [], {
                 config: {
                     root: cwd
+                },
+                mocks: {
+                    cliConfig: {
+                        autoUpdates: true,
+                        deployment: {
+                            autoUpdates: true
+                        }
+                    }
                 }
             });
             expect(error?.message).toContain('Found both `autoUpdates` (deprecated) and `deployment.autoUpdates` in sanity.cli.');
@@ -1521,12 +1535,6 @@ describe('#deploy', ()=>{
             process.cwd = ()=>cwd;
             const projectId = 'test-project-id';
             const studioHost = 'existing-studio';
-            mockGetCliConfig.mockResolvedValue({
-                api: {
-                    projectId
-                },
-                studioHost
-            });
             mockApi({
                 apiVersion: USER_APPLICATIONS_API_VERSION,
                 query: {
@@ -1540,6 +1548,14 @@ describe('#deploy', ()=>{
             const { error } = await testCommand(DeployCommand, [], {
                 config: {
                     root: cwd
+                },
+                mocks: {
+                    cliConfig: {
+                        api: {
+                            projectId
+                        },
+                        studioHost
+                    }
                 }
             });
             expect(error?.message).toContain('Error finding user application');
@@ -1551,12 +1567,6 @@ describe('#deploy', ()=>{
             const projectId = 'test-project-id';
             const studioHost = 'existing-studio';
             const studioAppId = 'studio-app-id';
-            mockGetCliConfig.mockResolvedValue({
-                api: {
-                    projectId
-                },
-                studioHost
-            });
             mockApi({
                 apiVersion: USER_APPLICATIONS_API_VERSION,
                 query: {
@@ -1587,6 +1597,14 @@ describe('#deploy', ()=>{
             const { error } = await testCommand(DeployCommand, [], {
                 config: {
                     root: cwd
+                },
+                mocks: {
+                    cliConfig: {
+                        api: {
+                            projectId
+                        },
+                        studioHost
+                    }
                 }
             });
             expect(error?.message).toContain('Error deploying studio');
@@ -1597,12 +1615,6 @@ describe('#deploy', ()=>{
             process.cwd = ()=>cwd;
             const projectId = 'test-project-id';
             const studioHost = 'new-studio-host';
-            mockGetCliConfig.mockResolvedValue({
-                api: {
-                    projectId
-                },
-                studioHost
-            });
             mockApi({
                 apiVersion: USER_APPLICATIONS_API_VERSION,
                 query: {
@@ -1627,6 +1639,14 @@ describe('#deploy', ()=>{
             const { error } = await testCommand(DeployCommand, [], {
                 config: {
                     root: cwd
+                },
+                mocks: {
+                    cliConfig: {
+                        api: {
+                            projectId
+                        },
+                        studioHost
+                    }
                 }
             });
             expect(error?.message).toContain('Error creating user application from config');
@@ -1648,11 +1668,6 @@ describe('#deploy', ()=>{
                 promise.cancel = ()=>{};
                 return promise;
             });
-            mockGetCliConfig.mockResolvedValue({
-                api: {
-                    projectId
-                }
-            });
             mockApi({
                 apiVersion: USER_APPLICATIONS_API_VERSION,
                 query: {
@@ -1690,6 +1705,13 @@ describe('#deploy', ()=>{
             const { error, stdout } = await testCommand(DeployCommand, [], {
                 config: {
                     root: cwd
+                },
+                mocks: {
+                    cliConfig: {
+                        api: {
+                            projectId
+                        }
+                    }
                 }
             });
             expect(error).toBeUndefined();
@@ -1706,12 +1728,6 @@ describe('#deploy', ()=>{
             const studioHost = 'existing-studio';
             const studioAppId = 'studio-app-id';
             const deploymentId = 'deployment-id';
-            mockGetCliConfig.mockResolvedValue({
-                api: {
-                    projectId
-                },
-                studioHost
-            });
             mockApi({
                 apiVersion: USER_APPLICATIONS_API_VERSION,
                 query: {
@@ -1744,6 +1760,14 @@ describe('#deploy', ()=>{
             ], {
                 config: {
                     root: cwd
+                },
+                mocks: {
+                    cliConfig: {
+                        api: {
+                            projectId
+                        },
+                        studioHost
+                    }
                 }
             });
             expect(error).toBeUndefined();
@@ -1757,14 +1781,6 @@ describe('#deploy', ()=>{
             const studioAppId = 'studio-app-id';
             const appHost = 'my-studio';
             const deploymentId = 'deployment-id';
-            mockGetCliConfig.mockResolvedValue({
-                api: {
-                    projectId
-                },
-                deployment: {
-                    appId: studioAppId
-                }
-            });
             mockApi({
                 apiVersion: USER_APPLICATIONS_API_VERSION,
                 uri: `/projects/${projectId}/user-applications/${studioAppId}`
@@ -1792,6 +1808,16 @@ describe('#deploy', ()=>{
             const { error, stdout } = await testCommand(DeployCommand, [], {
                 config: {
                     root: cwd
+                },
+                mocks: {
+                    cliConfig: {
+                        api: {
+                            projectId
+                        },
+                        deployment: {
+                            appId: studioAppId
+                        }
+                    }
                 }
             });
             expect(error).toBeUndefined();
@@ -1804,15 +1830,6 @@ describe('#deploy', ()=>{
             const studioAppId = 'studio-app-id';
             const studioHost = 'my-studio-host';
             const deploymentId = 'deployment-id';
-            mockGetCliConfig.mockResolvedValue({
-                api: {
-                    projectId
-                },
-                deployment: {
-                    appId: studioAppId
-                },
-                studioHost
-            });
             // Should call by appId, NOT by appHost
             mockApi({
                 apiVersion: USER_APPLICATIONS_API_VERSION,
@@ -1841,6 +1858,17 @@ describe('#deploy', ()=>{
             const { error, stdout } = await testCommand(DeployCommand, [], {
                 config: {
                     root: cwd
+                },
+                mocks: {
+                    cliConfig: {
+                        api: {
+                            projectId
+                        },
+                        deployment: {
+                            appId: studioAppId
+                        },
+                        studioHost
+                    }
                 }
             });
             expect(error).toBeUndefined();
@@ -1851,14 +1879,6 @@ describe('#deploy', ()=>{
             process.cwd = ()=>cwd;
             const projectId = 'test-project-id';
             const studioAppId = 'non-existent-app-id';
-            mockGetCliConfig.mockResolvedValue({
-                api: {
-                    projectId
-                },
-                deployment: {
-                    appId: studioAppId
-                }
-            });
             mockApi({
                 apiVersion: USER_APPLICATIONS_API_VERSION,
                 uri: `/projects/${projectId}/user-applications/${studioAppId}`
@@ -1868,6 +1888,16 @@ describe('#deploy', ()=>{
             const { error } = await testCommand(DeployCommand, [], {
                 config: {
                     root: cwd
+                },
+                mocks: {
+                    cliConfig: {
+                        api: {
+                            projectId
+                        },
+                        deployment: {
+                            appId: studioAppId
+                        }
+                    }
                 }
             });
             expect(error?.message).toContain('Error finding user application');
@@ -1880,15 +1910,6 @@ describe('#deploy', ()=>{
             const projectId = 'test-project-id';
             const studioAppId = 'non-existent-app-id';
             const studioHost = 'valid-studio-host';
-            mockGetCliConfig.mockResolvedValue({
-                api: {
-                    projectId
-                },
-                deployment: {
-                    appId: studioAppId
-                },
-                studioHost
-            });
             // appId lookup fails
             mockApi({
                 apiVersion: USER_APPLICATIONS_API_VERSION,
@@ -1901,6 +1922,17 @@ describe('#deploy', ()=>{
             const { error } = await testCommand(DeployCommand, [], {
                 config: {
                     root: cwd
+                },
+                mocks: {
+                    cliConfig: {
+                        api: {
+                            projectId
+                        },
+                        deployment: {
+                            appId: studioAppId
+                        },
+                        studioHost
+                    }
                 }
             });
             expect(error?.message).toContain('Error finding user application');