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

package/dist/commands/media/__tests__/export.test.js

@@ -1,10 +1,11 @@
 import fs from 'node:fs/promises';
 import { runCommand } from '@oclif/test';
-import { getCliConfig, getGlobalCliClient } from '@sanity/cli-core';
 import { input, select } from '@sanity/cli-core/ux';
-import { testCommand } from '@sanity/cli-test';
+import { createTestToken, mockApi, testCommand } from '@sanity/cli-test';
 import { exportDataset } from '@sanity/export';
+import nock from 'nock';
 import { afterEach, describe, expect, test, vi } from 'vitest';
+import { MEDIA_LIBRARY_API_VERSION } from '../../../services/mediaLibraries.js';
 import { NO_PROJECT_ID } from '../../../util/errorMessages.js';
 import { MediaExportCommand } from '../export.js';
 vi.mock('@sanity/export', ()=>({
@@ -18,23 +19,6 @@ vi.mock('@sanity/cli-core/ux', async ()=>{
         select: vi.fn()
     };
 });
-vi.mock('../../../../../cli-core/src/config/findProjectRoot.js', ()=>({
-        findProjectRoot: vi.fn().mockResolvedValue({
-            directory: '/test/path',
-            root: '/test/path',
-            type: 'studio'
-        })
-    }));
-vi.mock('../../../../../cli-core/src/config/cli/getCliConfig.js', ()=>({
-        getCliConfig: vi.fn()
-    }));
-vi.mock('../../../../../cli-core/src/services/getCliToken.js', ()=>({
-        getCliToken: vi.fn().mockResolvedValue('test-token')
-    }));
-vi.mock('../../../../../cli-core/src/services/apiClient.js', ()=>({
-        getGlobalCliClient: vi.fn(),
-        getProjectCliClient: vi.fn()
-    }));
 vi.mock('node:fs/promises', ()=>({
         default: {
             mkdir: vi.fn().mockResolvedValue(undefined),
@@ -44,8 +28,6 @@ vi.mock('node:fs/promises', ()=>({
 const mockExportDataset = vi.mocked(exportDataset);
 const mockInput = vi.mocked(input);
 const mockSelect = vi.mocked(select);
-const mockGetCliConfig = vi.mocked(getCliConfig);
-const mockGetGlobalCliClient = vi.mocked(getGlobalCliClient);
 const mockFs = vi.mocked(fs);
 const TEST_CONFIG = {
     MEDIA_LIBRARY_ID: 'test-media-library',
@@ -64,6 +46,20 @@ const ERROR_MESSAGES = {
     NO_MEDIA_LIBRARIES: 'No active media libraries found',
     USE_OVERWRITE: '--overwrite'
 };
+const defaultMocks = {
+    cliConfig: {
+        api: {
+            projectId: TEST_CONFIG.PROJECT_ID
+        }
+    },
+    projectRoot: {
+        directory: '/test/path',
+        path: '/test/path/sanity.config.ts',
+        root: '/test/path',
+        type: 'studio'
+    },
+    token: 'test-token'
+};
 const createTestContext = (overrides = {})=>{
     const defaults = {
         fileExists: false,
@@ -86,23 +82,6 @@ const createTestContext = (overrides = {})=>{
         ...defaults,
         ...overrides
     };
-    // Setup CLI config
-    const apiConfig = {
-        projectId: context.projectId
-    };
-    mockGetCliConfig.mockResolvedValue({
-        api: apiConfig
-    });
-    // Setup client mock
-    const mockClient = {
-        config: ()=>({
-                projectId: context.projectId
-            }),
-        request: vi.fn().mockResolvedValue({
-            data: context.mediaLibraries
-        })
-    };
-    mockGetGlobalCliClient.mockResolvedValue(mockClient);
     // Setup fs.stat mock
     if (context.fileExists) {
         mockFs.stat.mockResolvedValue({
@@ -118,11 +97,26 @@ const createTestContext = (overrides = {})=>{
     if (context.selectValue) {
         mockSelect.mockResolvedValue(context.selectValue);
     }
-    return context;
+    // Return context with mocks for testCommand
+    return {
+        ...context,
+        mocks: {
+            ...defaultMocks,
+            cliConfig: {
+                api: {
+                    projectId: context.projectId
+                }
+            }
+        }
+    };
 };
 describe('#media:export', ()=>{
     afterEach(()=>{
         vi.clearAllMocks();
+        vi.unstubAllEnvs();
+        const pending = nock.pendingMocks();
+        nock.cleanAll();
+        expect(pending, 'pending mocks').toEqual([]);
     });
     test('should show help text correctly', async ()=>{
         const { stdout } = await runCommand([
@@ -166,12 +160,35 @@ describe('#media:export', ()=>{
     `);
     });
     test('should export with provided destination', async ()=>{
-        createTestContext({
-            selectValue: TEST_CONFIG.MEDIA_LIBRARY_ID
+        mockApi({
+            apiVersion: MEDIA_LIBRARY_API_VERSION,
+            method: 'get',
+            query: {
+                projectId: TEST_CONFIG.PROJECT_ID
+            },
+            uri: '/media-libraries'
+        }).reply(200, {
+            data: [
+                {
+                    id: TEST_CONFIG.MEDIA_LIBRARY_ID,
+                    organizationId: 'org-1',
+                    status: 'active'
+                },
+                {
+                    id: 'another-library',
+                    organizationId: 'org-1',
+                    status: 'active'
+                }
+            ]
         });
+        createTestToken('test-token');
+        mockSelect.mockResolvedValue(TEST_CONFIG.MEDIA_LIBRARY_ID);
+        const ctx = createTestContext();
         const { stderr, stdout } = await testCommand(MediaExportCommand, [
             TEST_OUTPUTS.TAR_GZ
-        ]);
+        ], {
+            mocks: ctx.mocks
+        });
         expect(stderr).toBe('');
         expect(stdout).toContain('Exporting from:');
         expect(stdout).toContain(TEST_CONFIG.PROJECT_ID);
@@ -185,12 +202,36 @@ describe('#media:export', ()=>{
         }));
     });
     test('should export with media library ID flag', async ()=>{
-        createTestContext();
+        mockApi({
+            apiVersion: MEDIA_LIBRARY_API_VERSION,
+            method: 'get',
+            query: {
+                projectId: TEST_CONFIG.PROJECT_ID
+            },
+            uri: '/media-libraries'
+        }).reply(200, {
+            data: [
+                {
+                    id: 'test-media-library',
+                    organizationId: 'org-1',
+                    status: 'active'
+                },
+                {
+                    id: 'another-library',
+                    organizationId: 'org-1',
+                    status: 'active'
+                }
+            ]
+        });
+        createTestToken('test-token');
+        const ctx = createTestContext();
         const { stderr, stdout } = await testCommand(MediaExportCommand, [
             TEST_OUTPUTS.TAR_GZ,
             '--media-library-id',
             TEST_CONFIG.MEDIA_LIBRARY_ID
-        ]);
+        ], {
+            mocks: ctx.mocks
+        });
         expect(stderr).toBe('');
         expect(stdout).toContain('Export finished');
         expect(mockSelect).not.toHaveBeenCalled();
@@ -199,70 +240,214 @@ describe('#media:export', ()=>{
         }));
     });
     test('should prompt for media library when not provided', async ()=>{
-        createTestContext({
+        mockApi({
+            apiVersion: MEDIA_LIBRARY_API_VERSION,
+            method: 'get',
+            query: {
+                projectId: TEST_CONFIG.PROJECT_ID
+            },
+            uri: '/media-libraries'
+        }).reply(200, {
+            data: [
+                {
+                    id: 'test-media-library',
+                    organizationId: 'org-1',
+                    status: 'active'
+                },
+                {
+                    id: 'another-library',
+                    organizationId: 'org-1',
+                    status: 'active'
+                }
+            ]
+        });
+        createTestToken('test-token');
+        const ctx = createTestContext({
             selectValue: TEST_CONFIG.MEDIA_LIBRARY_ID
         });
         await testCommand(MediaExportCommand, [
             TEST_OUTPUTS.TAR_GZ
-        ]);
+        ], {
+            mocks: ctx.mocks
+        });
         expect(mockSelect).toHaveBeenCalledWith(expect.objectContaining({
             message: 'Select media library:'
         }));
     });
     test('should prompt for destination when not provided', async ()=>{
-        createTestContext({
+        mockApi({
+            apiVersion: MEDIA_LIBRARY_API_VERSION,
+            method: 'get',
+            query: {
+                projectId: TEST_CONFIG.PROJECT_ID
+            },
+            uri: '/media-libraries'
+        }).reply(200, {
+            data: [
+                {
+                    id: 'test-media-library',
+                    organizationId: 'org-1',
+                    status: 'active'
+                },
+                {
+                    id: 'another-library',
+                    organizationId: 'org-1',
+                    status: 'active'
+                }
+            ]
+        });
+        createTestToken('test-token');
+        const ctx = createTestContext({
             inputValue: TEST_OUTPUTS.TAR_GZ,
             selectValue: TEST_CONFIG.MEDIA_LIBRARY_ID
         });
-        await testCommand(MediaExportCommand, []);
+        await testCommand(MediaExportCommand, [], {
+            mocks: ctx.mocks
+        });
         expect(mockInput).toHaveBeenCalledWith(expect.objectContaining({
             message: 'Output path:'
         }));
     });
     test('should error when file already exists without overwrite flag', async ()=>{
-        createTestContext({
+        mockApi({
+            apiVersion: MEDIA_LIBRARY_API_VERSION,
+            method: 'get',
+            query: {
+                projectId: TEST_CONFIG.PROJECT_ID
+            },
+            uri: '/media-libraries'
+        }).reply(200, {
+            data: [
+                {
+                    id: 'test-media-library',
+                    organizationId: 'org-1',
+                    status: 'active'
+                },
+                {
+                    id: 'another-library',
+                    organizationId: 'org-1',
+                    status: 'active'
+                }
+            ]
+        });
+        createTestToken('test-token');
+        const ctx = createTestContext({
             fileExists: true,
             selectValue: TEST_CONFIG.MEDIA_LIBRARY_ID
         });
         const { error } = await testCommand(MediaExportCommand, [
             TEST_OUTPUTS.EXISTING
-        ]);
+        ], {
+            mocks: ctx.mocks
+        });
         expect(error?.message).toContain(ERROR_MESSAGES.ALREADY_EXISTS);
         expect(error?.message).toContain(ERROR_MESSAGES.USE_OVERWRITE);
         expect(error?.oclif?.exit).toBe(1);
     });
     test('should overwrite file when overwrite flag is provided', async ()=>{
-        createTestContext({
+        mockApi({
+            apiVersion: MEDIA_LIBRARY_API_VERSION,
+            method: 'get',
+            query: {
+                projectId: TEST_CONFIG.PROJECT_ID
+            },
+            uri: '/media-libraries'
+        }).reply(200, {
+            data: [
+                {
+                    id: 'test-media-library',
+                    organizationId: 'org-1',
+                    status: 'active'
+                },
+                {
+                    id: 'another-library',
+                    organizationId: 'org-1',
+                    status: 'active'
+                }
+            ]
+        });
+        createTestToken('test-token');
+        const ctx = createTestContext({
             fileExists: true,
             selectValue: TEST_CONFIG.MEDIA_LIBRARY_ID
         });
         const { stderr, stdout } = await testCommand(MediaExportCommand, [
             TEST_OUTPUTS.EXISTING,
             '--overwrite'
-        ]);
+        ], {
+            mocks: ctx.mocks
+        });
         expect(stderr).toBe('');
         expect(stdout).toContain('Export finished');
     });
     test('should use directory and append default filename', async ()=>{
-        createTestContext({
+        mockApi({
+            apiVersion: MEDIA_LIBRARY_API_VERSION,
+            method: 'get',
+            query: {
+                projectId: TEST_CONFIG.PROJECT_ID
+            },
+            uri: '/media-libraries'
+        }).reply(200, {
+            data: [
+                {
+                    id: 'test-media-library',
+                    organizationId: 'org-1',
+                    status: 'active'
+                },
+                {
+                    id: 'another-library',
+                    organizationId: 'org-1',
+                    status: 'active'
+                }
+            ]
+        });
+        createTestToken('test-token');
+        const ctx = createTestContext({
             fileExists: true,
             isFile: false,
             selectValue: TEST_CONFIG.MEDIA_LIBRARY_ID
         });
         await testCommand(MediaExportCommand, [
             'some-directory'
-        ]);
+        ], {
+            mocks: ctx.mocks
+        });
         expect(mockExportDataset).toHaveBeenCalledWith(expect.objectContaining({
             outputPath: expect.stringContaining(`${TEST_CONFIG.MEDIA_LIBRARY_ID}-export.tar.gz`)
         }));
     });
     test('should export to stdout when destination is -', async ()=>{
-        createTestContext({
+        mockApi({
+            apiVersion: MEDIA_LIBRARY_API_VERSION,
+            method: 'get',
+            query: {
+                projectId: TEST_CONFIG.PROJECT_ID
+            },
+            uri: '/media-libraries'
+        }).reply(200, {
+            data: [
+                {
+                    id: 'test-media-library',
+                    organizationId: 'org-1',
+                    status: 'active'
+                },
+                {
+                    id: 'another-library',
+                    organizationId: 'org-1',
+                    status: 'active'
+                }
+            ]
+        });
+        createTestToken('test-token');
+        const ctx = createTestContext({
             selectValue: TEST_CONFIG.MEDIA_LIBRARY_ID
         });
         await testCommand(MediaExportCommand, [
             TEST_OUTPUTS.STDOUT
-        ]);
+        ], {
+            mocks: ctx.mocks
+        });
         expect(mockExportDataset).toHaveBeenCalledWith(expect.objectContaining({
             outputPath: process.stdout
         }));
@@ -300,8 +485,25 @@ describe('#media:export', ()=>{
             setup: {}
         }
     ])('should error when $scenario', async ({ additionalCheck, args, errorMessage, setup })=>{
-        createTestContext(setup);
-        const { error } = await testCommand(MediaExportCommand, args);
+        const ctx = createTestContext(setup);
+        // Set up mock for API calls (skip if no projectId)
+        if (ctx.projectId) {
+            createTestToken('test-token');
+            const data = ctx.mediaLibraries.filter((lib)=>lib.status === 'active');
+            mockApi({
+                apiVersion: MEDIA_LIBRARY_API_VERSION,
+                method: 'get',
+                query: {
+                    projectId: ctx.projectId
+                },
+                uri: '/media-libraries'
+            }).reply(200, {
+                data
+            });
+        }
+        const { error } = await testCommand(MediaExportCommand, args, {
+            mocks: ctx.mocks
+        });
         expect(error?.message).toContain(errorMessage);
         expect(error?.oclif?.exit).toBe(1);
         if (additionalCheck) {
@@ -329,40 +531,135 @@ describe('#media:export', ()=>{
             }
         }
     ])('should pass $description flag correctly', async ({ args, expected })=>{
-        createTestContext({
+        mockApi({
+            apiVersion: MEDIA_LIBRARY_API_VERSION,
+            method: 'get',
+            query: {
+                projectId: TEST_CONFIG.PROJECT_ID
+            },
+            uri: '/media-libraries'
+        }).reply(200, {
+            data: [
+                {
+                    id: 'test-media-library',
+                    organizationId: 'org-1',
+                    status: 'active'
+                },
+                {
+                    id: 'another-library',
+                    organizationId: 'org-1',
+                    status: 'active'
+                }
+            ]
+        });
+        createTestToken('test-token');
+        const ctx = createTestContext({
             selectValue: TEST_CONFIG.MEDIA_LIBRARY_ID
         });
         await testCommand(MediaExportCommand, [
             TEST_OUTPUTS.TAR_GZ,
             ...args
-        ]);
+        ], {
+            mocks: ctx.mocks
+        });
         expect(mockExportDataset).toHaveBeenCalledWith(expect.objectContaining(expected));
     });
     test('should handle export failure', async ()=>{
-        createTestContext({
+        mockApi({
+            apiVersion: MEDIA_LIBRARY_API_VERSION,
+            method: 'get',
+            query: {
+                projectId: TEST_CONFIG.PROJECT_ID
+            },
+            uri: '/media-libraries'
+        }).reply(200, {
+            data: [
+                {
+                    id: 'test-media-library',
+                    organizationId: 'org-1',
+                    status: 'active'
+                },
+                {
+                    id: 'another-library',
+                    organizationId: 'org-1',
+                    status: 'active'
+                }
+            ]
+        });
+        createTestToken('test-token');
+        const ctx = createTestContext({
             selectValue: TEST_CONFIG.MEDIA_LIBRARY_ID
         });
         mockExportDataset.mockRejectedValueOnce(new Error('Export operation failed'));
         const { error } = await testCommand(MediaExportCommand, [
             TEST_OUTPUTS.TAR_GZ
-        ]);
+        ], {
+            mocks: ctx.mocks
+        });
         expect(error?.message).toContain(ERROR_MESSAGES.EXPORT_FAILED);
         expect(error?.message).toContain('Export operation failed');
         expect(error?.oclif?.exit).toBe(1);
     });
     test('should create subdirectories if they do not exist', async ()=>{
-        createTestContext({
+        mockApi({
+            apiVersion: MEDIA_LIBRARY_API_VERSION,
+            method: 'get',
+            query: {
+                projectId: TEST_CONFIG.PROJECT_ID
+            },
+            uri: '/media-libraries'
+        }).reply(200, {
+            data: [
+                {
+                    id: 'test-media-library',
+                    organizationId: 'org-1',
+                    status: 'active'
+                },
+                {
+                    id: 'another-library',
+                    organizationId: 'org-1',
+                    status: 'active'
+                }
+            ]
+        });
+        createTestToken('test-token');
+        const ctx = createTestContext({
             selectValue: TEST_CONFIG.MEDIA_LIBRARY_ID
         });
         await testCommand(MediaExportCommand, [
             TEST_OUTPUTS.SUBDIR
-        ]);
+        ], {
+            mocks: ctx.mocks
+        });
         expect(mockFs.mkdir).toHaveBeenCalledWith(expect.stringContaining('subdir'), expect.objectContaining({
             recursive: true
         }));
     });
     test('should filter inactive media libraries', async ()=>{
-        createTestContext({
+        // Set up custom mock for this test with both active and inactive libraries
+        mockApi({
+            apiVersion: MEDIA_LIBRARY_API_VERSION,
+            method: 'get',
+            query: {
+                projectId: TEST_CONFIG.PROJECT_ID
+            },
+            uri: '/media-libraries'
+        }).reply(200, {
+            data: [
+                {
+                    id: 'active-library',
+                    organizationId: 'org-1',
+                    status: 'active'
+                },
+                {
+                    id: 'inactive-library',
+                    organizationId: 'org-1',
+                    status: 'inactive'
+                }
+            ]
+        });
+        createTestToken('test-token');
+        const ctx = createTestContext({
             mediaLibraries: [
                 {
                     id: 'active-library',
@@ -379,7 +676,9 @@ describe('#media:export', ()=>{
         });
         await testCommand(MediaExportCommand, [
             TEST_OUTPUTS.TAR_GZ
-        ]);
+        ], {
+            mocks: ctx.mocks
+        });
         expect(mockSelect).toHaveBeenCalledWith(expect.objectContaining({
             choices: expect.arrayContaining([
                 expect.objectContaining({