@sanity/cli 5.1.1-next.6 → 6.0.0-alpha.3

package/dist/commands/media/__tests__/deploy-aspect.test.js

@@ -0,0 +1,632 @@
+import { runCommand } from '@oclif/test';
+import { getCliConfig } from '@sanity/cli-core';
+import { select } from '@sanity/cli-core/ux';
+import { mockApi, testCommand } from '@sanity/cli-test';
+import { MEDIA_LIBRARY_ASSET_ASPECT_TYPE_NAME } from '@sanity/types';
+import nock from 'nock';
+import { afterEach, beforeEach, describe, expect, test, vi } from 'vitest';
+import { MEDIA_LIBRARY_API_VERSION } from '../../../services/mediaLibraries.js';
+import { NO_MEDIA_LIBRARY_ASPECTS_PATH, NO_PROJECT_ID } from '../../../util/errorMessages.js';
+import { MediaDeployAspectCommand } from '../deploy-aspect.js';
+// Create hoisted mock functions
+const mockFsAccess = vi.hoisted(()=>vi.fn());
+const mockFsReaddir = vi.hoisted(()=>vi.fn());
+const mockTsImport = vi.hoisted(()=>vi.fn());
+const mockGetTsconfig = vi.hoisted(()=>vi.fn());
+vi.mock('node:fs/promises', ()=>({
+        access: mockFsAccess,
+        readdir: mockFsReaddir
+    }));
+vi.mock('tsx/esm/api', ()=>({
+        tsImport: mockTsImport
+    }));
+vi.mock('get-tsconfig', ()=>({
+        getTsconfig: mockGetTsconfig
+    }));
+vi.mock('@sanity/cli-core/ux', async ()=>{
+    const actual = await vi.importActual('@sanity/cli-core/ux');
+    return {
+        ...actual,
+        select: vi.fn()
+    };
+});
+vi.mock('../../../../../cli-core/src/config/findProjectRoot.js', ()=>({
+        findProjectRoot: vi.fn().mockResolvedValue({
+            directory: '/test/project',
+            root: '/test/project',
+            type: 'studio'
+        })
+    }));
+vi.mock('../../../../../cli-core/src/config/cli/getCliConfig.js', ()=>({
+        getCliConfig: vi.fn().mockResolvedValue({
+            api: {
+                projectId: 'test-project-id'
+            },
+            mediaLibrary: {
+                aspectsPath: '/test/project/aspects'
+            }
+        })
+    }));
+vi.mock('../../../../../cli-core/src/services/getCliToken.js', ()=>({
+        getCliToken: vi.fn().mockResolvedValue('test-token')
+    }));
+const mockSelect = vi.mocked(select);
+const mockGetCliConfig = vi.mocked(getCliConfig);
+/**
+ * Helper to create a mock aspect definition with valid schema
+ */ function createMockAspect(id) {
+    return {
+        _createdAt: new Date().toISOString(),
+        _id: id,
+        _rev: 'mock-revision',
+        _type: MEDIA_LIBRARY_ASSET_ASPECT_TYPE_NAME,
+        _updatedAt: new Date().toISOString(),
+        definition: {
+            fields: [
+                {
+                    name: 'testField',
+                    title: 'Test Field',
+                    type: 'string'
+                }
+            ],
+            name: id,
+            title: id,
+            type: 'object'
+        }
+    };
+}
+/**
+ * Helper to create an invalid aspect definition
+ * Uses unsupported field types (image/file) which are not allowed in aspects
+ */ function createInvalidMockAspect(id) {
+    return {
+        _createdAt: new Date().toISOString(),
+        _id: id,
+        _rev: 'mock-revision',
+        _type: MEDIA_LIBRARY_ASSET_ASPECT_TYPE_NAME,
+        _updatedAt: new Date().toISOString(),
+        definition: {
+            fields: [
+                {
+                    name: 'invalidImageField',
+                    title: 'Invalid Image Field',
+                    type: 'image'
+                }
+            ],
+            name: id,
+            title: id,
+            type: 'object'
+        }
+    };
+}
+/**
+ * Helper to setup filesystem mocks for aspect files
+ */ function setupFileSystemMock(files) {
+    mockFsAccess.mockResolvedValue(undefined);
+    mockFsReaddir.mockResolvedValue(files.map((file)=>({
+            isFile: ()=>file.isFile,
+            name: file.filename
+        })));
+}
+/**
+ * Helper to setup tsImport mock to return aspect definitions
+ */ function setupTsImportMock(imports) {
+    mockTsImport.mockImplementation(async (filePath)=>{
+        const filename = filePath.split('/').pop() || '';
+        const importConfig = imports[filename];
+        if (!importConfig) {
+            throw new Error(`No mock configured for ${filename}`);
+        }
+        if (importConfig.shouldFail) {
+            throw new Error(importConfig.errorMessage || 'Import failed');
+        }
+        return {
+            default: importConfig.aspect
+        };
+    });
+}
+/**
+ * Setup default mocks for a successful test scenario
+ */ function setupDefaultMocks() {
+    mockFsAccess.mockResolvedValue(undefined);
+    mockFsReaddir.mockResolvedValue([]);
+    mockGetTsconfig.mockReturnValue({
+        path: '/test/tsconfig.json'
+    });
+}
+describe('#media:deploy-aspect', ()=>{
+    beforeEach(()=>{
+        vi.clearAllMocks();
+        setupDefaultMocks();
+        // Reset getCliConfig mock to default
+        mockGetCliConfig.mockResolvedValue({
+            api: {
+                projectId: 'test-project-id'
+            },
+            mediaLibrary: {
+                aspectsPath: '/test/project/aspects'
+            }
+        });
+    });
+    afterEach(()=>{
+        const pending = nock.pendingMocks();
+        nock.cleanAll();
+        expect(pending, 'pending mocks').toEqual([]);
+    });
+    test('should show help text correctly', async ()=>{
+        const { stdout } = await runCommand([
+            'media deploy-aspect --help'
+        ]);
+        expect(stdout).toMatchInlineSnapshot(`
+      "Deploy an aspect
+
+      USAGE
+        $ sanity media deploy-aspect [ASPECTNAME] [--all] [--media-library-id <value>]
+
+      ARGUMENTS
+        [ASPECTNAME]  Name of the aspect to deploy
+
+      FLAGS
+        --all                       Deploy all aspects
+        --media-library-id=<value>  The id of the target media library
+
+      DESCRIPTION
+        Deploy an aspect
+
+      EXAMPLES
+        Deploy the aspect named "someAspect"
+
+          $ sanity media deploy-aspect someAspect
+
+        Deploy all aspects
+
+          $ sanity media deploy-aspect --all
+
+      "
+    `);
+    });
+    test.each([
+        {
+            args: [],
+            description: 'neither aspect name nor --all flag is provided',
+            expectedError: 'Specify an aspect name, or use the `--all` option to deploy all aspect definitions.'
+        },
+        {
+            args: [
+                'myAspect',
+                '--all'
+            ],
+            description: 'both aspect name and --all flag are provided',
+            expectedError: 'Specified both an aspect name and `--all`.'
+        }
+    ])('should error if $description', async ({ args, expectedError })=>{
+        const { error } = await testCommand(MediaDeployAspectCommand, args);
+        expect(error?.message).toContain(expectedError);
+        expect(error?.oclif?.exit).toBe(1);
+    });
+    test.each([
+        {
+            config: {
+                mediaLibrary: {
+                    aspectsPath: '/test/project/aspects'
+                }
+            },
+            description: 'project ID is not configured',
+            expectedError: NO_PROJECT_ID
+        },
+        {
+            config: {
+                api: {
+                    projectId: 'test-project-id'
+                }
+            },
+            description: 'media library aspects path is not configured',
+            expectedError: NO_MEDIA_LIBRARY_ASPECTS_PATH
+        }
+    ])('should error if $description', async ({ config, expectedError })=>{
+        mockGetCliConfig.mockResolvedValue(config);
+        const { error } = await testCommand(MediaDeployAspectCommand, [
+            'myAspect'
+        ]);
+        expect(error?.message).toContain(expectedError);
+        expect(error?.oclif?.exit).toBe(1);
+    });
+    test('should successfully deploy a single aspect', async ()=>{
+        // Setup filesystem to return a single aspect file
+        setupFileSystemMock([
+            {
+                filename: 'myAspect.ts',
+                isFile: true
+            }
+        ]);
+        // Setup tsImport to return the aspect definition
+        setupTsImportMock({
+            'myAspect.ts': {
+                aspect: createMockAspect('myAspect')
+            }
+        });
+        // Mock the media libraries API call
+        mockApi({
+            apiVersion: MEDIA_LIBRARY_API_VERSION,
+            method: 'get',
+            query: {
+                projectId: 'test-project-id'
+            },
+            uri: '/media-libraries'
+        }).reply(200, {
+            data: [
+                {
+                    id: 'test-library-id',
+                    organizationId: 'test-org-id',
+                    status: 'active'
+                }
+            ]
+        });
+        mockSelect.mockResolvedValue('test-library-id');
+        // Mock deploy API call
+        mockApi({
+            apiVersion: MEDIA_LIBRARY_API_VERSION,
+            method: 'post',
+            uri: '/media-libraries/test-library-id/mutate'
+        }).reply(200, {
+            results: [
+                {
+                    id: 'myAspect',
+                    operation: 'created'
+                }
+            ]
+        });
+        const { stdout } = await testCommand(MediaDeployAspectCommand, [
+            'myAspect'
+        ]);
+        expect(mockFsReaddir).toHaveBeenCalledWith('/test/project/aspects', {
+            withFileTypes: true
+        });
+        expect(mockTsImport).toHaveBeenCalled();
+        expect(stdout).toContain('✓');
+        expect(stdout).toContain('Deployed 1 aspect');
+        expect(stdout).toContain('myAspect');
+    });
+    test('should deploy all aspects with --all flag', async ()=>{
+        // Setup filesystem to return multiple aspect files
+        setupFileSystemMock([
+            {
+                filename: 'aspect1.ts',
+                isFile: true
+            },
+            {
+                filename: 'aspect2.ts',
+                isFile: true
+            }
+        ]);
+        // Setup tsImport to return aspect definitions for both files
+        setupTsImportMock({
+            'aspect1.ts': {
+                aspect: createMockAspect('aspect1')
+            },
+            'aspect2.ts': {
+                aspect: createMockAspect('aspect2')
+            }
+        });
+        // Mock the media libraries API call
+        mockApi({
+            apiVersion: MEDIA_LIBRARY_API_VERSION,
+            method: 'get',
+            query: {
+                projectId: 'test-project-id'
+            },
+            uri: '/media-libraries'
+        }).reply(200, {
+            data: [
+                {
+                    id: 'test-library-id',
+                    organizationId: 'test-org-id',
+                    status: 'active'
+                }
+            ]
+        });
+        mockSelect.mockResolvedValue('test-library-id');
+        // Mock deploy API call
+        mockApi({
+            apiVersion: MEDIA_LIBRARY_API_VERSION,
+            method: 'post',
+            uri: '/media-libraries/test-library-id/mutate'
+        }).reply(200, {
+            results: [
+                {
+                    id: 'aspect1',
+                    operation: 'created'
+                },
+                {
+                    id: 'aspect2',
+                    operation: 'created'
+                }
+            ]
+        });
+        const { stdout } = await testCommand(MediaDeployAspectCommand, [
+            '--all'
+        ]);
+        expect(stdout).toContain('✓');
+        expect(stdout).toContain('Deployed 2 aspects');
+        expect(stdout).toContain('aspect1');
+        expect(stdout).toContain('aspect2');
+    });
+    test('should use --media-library-id flag when provided', async ()=>{
+        // Setup filesystem to return a single aspect file
+        setupFileSystemMock([
+            {
+                filename: 'myAspect.ts',
+                isFile: true
+            }
+        ]);
+        // Setup tsImport to return the aspect definition
+        setupTsImportMock({
+            'myAspect.ts': {
+                aspect: createMockAspect('myAspect')
+            }
+        });
+        // Mock deploy API call
+        mockApi({
+            apiVersion: MEDIA_LIBRARY_API_VERSION,
+            method: 'post',
+            uri: '/media-libraries/custom-library-id/mutate'
+        }).reply(200, {
+            results: [
+                {
+                    id: 'myAspect',
+                    operation: 'created'
+                }
+            ]
+        });
+        await testCommand(MediaDeployAspectCommand, [
+            'myAspect',
+            '--media-library-id',
+            'custom-library-id'
+        ]);
+        expect(mockSelect).not.toHaveBeenCalled();
+    });
+    test('should error if aspect is not found', async ()=>{
+        // Setup filesystem with aspect files that don't match the requested name
+        setupFileSystemMock([
+            {
+                filename: 'someOtherAspect.ts',
+                isFile: true
+            },
+            {
+                filename: 'anotherAspect.ts',
+                isFile: true
+            }
+        ]);
+        // Setup tsImport to return aspects with different IDs
+        setupTsImportMock({
+            'anotherAspect.ts': {
+                aspect: createMockAspect('anotherAspect')
+            },
+            'someOtherAspect.ts': {
+                aspect: createMockAspect('someOtherAspect')
+            }
+        });
+        // Mock the media libraries API call
+        mockApi({
+            apiVersion: MEDIA_LIBRARY_API_VERSION,
+            method: 'get',
+            query: {
+                projectId: 'test-project-id'
+            },
+            uri: '/media-libraries'
+        }).reply(200, {
+            data: [
+                {
+                    id: 'test-library-id',
+                    organizationId: 'test-org-id',
+                    status: 'active'
+                }
+            ]
+        });
+        mockSelect.mockResolvedValue('test-library-id');
+        const { error } = await testCommand(MediaDeployAspectCommand, [
+            'nonExistentAspect'
+        ]);
+        expect(error?.message).toContain('Could not find aspect');
+        expect(error?.message).toContain('nonExistentAspect');
+        expect(error?.oclif?.exit).toBe(1);
+    });
+    test('should skip invalid aspects and deploy only valid ones', async ()=>{
+        // Setup filesystem with both valid and invalid aspect files
+        setupFileSystemMock([
+            {
+                filename: 'invalidAspect.ts',
+                isFile: true
+            },
+            {
+                filename: 'validAspect.ts',
+                isFile: true
+            }
+        ]);
+        // Setup tsImport to return aspect definitions (one invalid, one valid)
+        setupTsImportMock({
+            'invalidAspect.ts': {
+                aspect: createInvalidMockAspect('invalidAspect')
+            },
+            'validAspect.ts': {
+                aspect: createMockAspect('validAspect')
+            }
+        });
+        // Mock the media libraries API call
+        mockApi({
+            apiVersion: MEDIA_LIBRARY_API_VERSION,
+            method: 'get',
+            query: {
+                projectId: 'test-project-id'
+            },
+            uri: '/media-libraries'
+        }).reply(200, {
+            data: [
+                {
+                    id: 'test-library-id',
+                    organizationId: 'test-org-id',
+                    status: 'active'
+                }
+            ]
+        });
+        mockSelect.mockResolvedValue('test-library-id');
+        // Mock deploy API call
+        mockApi({
+            apiVersion: MEDIA_LIBRARY_API_VERSION,
+            method: 'post',
+            uri: '/media-libraries/test-library-id/mutate'
+        }).reply(200, {
+            results: [
+                {
+                    id: 'validAspect',
+                    operation: 'created'
+                }
+            ]
+        });
+        const { stderr, stdout } = await testCommand(MediaDeployAspectCommand, [
+            '--all'
+        ]);
+        expect(stderr).toContain('Skipped 1 invalid aspect');
+        expect(stderr).toContain('invalidAspect');
+        expect(stdout).toContain('Deployed 1 aspect');
+        expect(stdout).toContain('validAspect');
+    });
+    test('should warn if no valid aspects to deploy', async ()=>{
+        // Setup filesystem with only invalid aspect files
+        setupFileSystemMock([
+            {
+                filename: 'invalidAspect.ts',
+                isFile: true
+            }
+        ]);
+        // Setup tsImport to return an invalid aspect definition
+        setupTsImportMock({
+            'invalidAspect.ts': {
+                aspect: createInvalidMockAspect('invalidAspect')
+            }
+        });
+        // Mock the media libraries API call
+        mockApi({
+            apiVersion: MEDIA_LIBRARY_API_VERSION,
+            method: 'get',
+            query: {
+                projectId: 'test-project-id'
+            },
+            uri: '/media-libraries'
+        }).reply(200, {
+            data: [
+                {
+                    id: 'test-library-id',
+                    organizationId: 'test-org-id',
+                    status: 'active'
+                }
+            ]
+        });
+        mockSelect.mockResolvedValue('test-library-id');
+        const { stderr } = await testCommand(MediaDeployAspectCommand, [
+            '--all'
+        ]);
+        expect(stderr).toContain('Skipped 1 invalid aspect');
+        expect(stderr).toContain('No valid aspects to deploy');
+    });
+    test('should handle API errors gracefully', async ()=>{
+        // Setup filesystem to return a single aspect file
+        setupFileSystemMock([
+            {
+                filename: 'myAspect.ts',
+                isFile: true
+            }
+        ]);
+        // Setup tsImport to return the aspect definition
+        setupTsImportMock({
+            'myAspect.ts': {
+                aspect: createMockAspect('myAspect')
+            }
+        });
+        // Mock the media libraries API call
+        mockApi({
+            apiVersion: MEDIA_LIBRARY_API_VERSION,
+            method: 'get',
+            query: {
+                projectId: 'test-project-id'
+            },
+            uri: '/media-libraries'
+        }).reply(200, {
+            data: [
+                {
+                    id: 'test-library-id',
+                    organizationId: 'test-org-id',
+                    status: 'active'
+                }
+            ]
+        });
+        mockSelect.mockResolvedValue('test-library-id');
+        // Mock deploy API call to fail
+        mockApi({
+            apiVersion: MEDIA_LIBRARY_API_VERSION,
+            method: 'post',
+            uri: '/media-libraries/test-library-id/mutate'
+        }).reply(500, {
+            message: 'Internal server error'
+        });
+        const { error } = await testCommand(MediaDeployAspectCommand, [
+            'myAspect'
+        ]);
+        expect(error?.message).toContain('Failed to deploy aspects');
+        expect(error?.oclif?.exit).toBe(1);
+    });
+    test('should fetch and present media libraries for selection', async ()=>{
+        // Setup filesystem to return a single aspect file
+        setupFileSystemMock([
+            {
+                filename: 'myAspect.ts',
+                isFile: true
+            }
+        ]);
+        // Setup tsImport to return the aspect definition
+        setupTsImportMock({
+            'myAspect.ts': {
+                aspect: createMockAspect('myAspect')
+            }
+        });
+        // Mock the media libraries API call
+        mockApi({
+            apiVersion: MEDIA_LIBRARY_API_VERSION,
+            method: 'get',
+            query: {
+                projectId: 'test-project-id'
+            },
+            uri: '/media-libraries'
+        }).reply(200, {
+            data: [
+                {
+                    id: 'selected-library-id',
+                    organizationId: 'test-org-id',
+                    status: 'active'
+                }
+            ]
+        });
+        mockSelect.mockResolvedValue('selected-library-id');
+        // Mock deploy API call
+        mockApi({
+            apiVersion: MEDIA_LIBRARY_API_VERSION,
+            method: 'post',
+            uri: '/media-libraries/selected-library-id/mutate'
+        }).reply(200, {
+            results: [
+                {
+                    id: 'myAspect',
+                    operation: 'created'
+                }
+            ]
+        });
+        await testCommand(MediaDeployAspectCommand, [
+            'myAspect'
+        ]);
+        expect(mockSelect).toHaveBeenCalledWith(expect.objectContaining({
+            message: 'Select media library'
+        }));
+    });
+});
+
+//# sourceMappingURL=deploy-aspect.test.js.map