@adobe/aio-cli-plugin-api-mesh 1.0.1-beta → 1.0.4-beta

package/src/commands/api-mesh/__tests__/get.test.js

@@ -10,67 +10,327 @@ OF ANY KIND, either express or implied. See the License for the specific languag
 governing permissions and limitations under the License.
 */
 
-const mockConsoleCLIInstance = {};
+jest.mock('axios');
 jest.mock('@adobe/aio-lib-env');
 jest.mock('@adobe/aio-cli-lib-console');
-const orgs = [{ id: '1234', code: 'CODE1234@AdobeOrg', name: 'ORG01', type: 'entp' }];
-const selectedOrg = { id: '1234', code: 'CODE1234@AdobeOrg', name: 'ORG01', type: 'entp' };
+jest.mock('fs/promises');
+jest.mock('@adobe/aio-cli-lib-console', () => ({
+	init: jest.fn().mockResolvedValue(mockConsoleCLIInstance),
+	cleanStdOut: jest.fn(),
+}));
+jest.mock('@adobe/aio-lib-ims');
+jest.mock('../../../helpers', () => ({
+	initSdk: jest.fn().mockResolvedValue({}),
+	initRequestId: jest.fn().mockResolvedValue({}),
+}));
+jest.mock('../../../lib/devConsole');
 
-const projects = [{ id: '5678', title: 'Project01' }];
+const mockConsoleCLIInstance = {};
+const selectedOrg = { id: '1234', code: 'CODE1234@AdobeOrg', name: 'ORG01', type: 'entp' };
 const selectedProject = { id: '5678', title: 'Project01' };
-
-const workspaces = [{ id: '123456789', title: 'Workspace01' }];
 const selectedWorkspace = { id: '123456789', title: 'Workspace01' };
 
-function setDefaultMockConsoleCLI() {
-	mockConsoleCLIInstance.getToken = jest.fn().mockReturnValue('test_token');
-	mockConsoleCLIInstance.getCliEnv = jest.fn().mockReturnValue('prod');
+const { writeFile } = require('fs/promises');
+const { initSdk, initRequestId } = require('../../../helpers');
+const GetCommand = require('../get');
+const mockGetMeshConfig = require('../../__fixtures__/sample_mesh.json');
+const { getMeshId, getMesh } = require('../../../lib/devConsole');
 
-	mockConsoleCLIInstance.getOrganizations = jest.fn().mockResolvedValue(orgs);
-	mockConsoleCLIInstance.promptForSelectOrganization = jest.fn().mockResolvedValue(selectedOrg);
+let logSpy = null;
+let errorLogSpy = null;
 
-	mockConsoleCLIInstance.getProjects = jest.fn().mockResolvedValue(projects);
-	mockConsoleCLIInstance.promptForSelectProject = jest.fn().mockResolvedValue(selectedProject);
+let parseSpy = null;
 
-	mockConsoleCLIInstance.getWorkspaces = jest.fn().mockResolvedValue(workspaces);
-	mockConsoleCLIInstance.promptForSelectWorkspace = jest.fn().mockResolvedValue(selectedWorkspace);
-}
-
-jest.mock('@adobe/aio-cli-lib-console', () => ({
-	init: jest.fn().mockResolvedValue(mockConsoleCLIInstance),
-	cleanStdOut: jest.fn(),
-}));
-jest.mock('@adobe/aio-lib-ims');
-const GetCommand = require('../get');
-const { SchemaServiceClient } = require('../../../classes/SchemaServiceClient');
-const mockGetMesh = require('../../__fixtures__/sample_mesh.json');
+const mockIgnoreCacheFlag = Promise.resolve(true);
 
 describe('get command tests', () => {
 	beforeEach(() => {
-		setDefaultMockConsoleCLI();
+		initSdk.mockResolvedValue({
+			imsOrgId: selectedOrg.id,
+			projectId: selectedProject.id,
+			workspaceId: selectedWorkspace.id,
+		});
+
+		global.requestId = 'dummy_request_id';
+
+		logSpy = jest.spyOn(GetCommand.prototype, 'log');
+		errorLogSpy = jest.spyOn(GetCommand.prototype, 'error');
+
+		writeFile.mockResolvedValue(true);
+
+		getMeshId.mockResolvedValue('dummy_meshId');
+		getMesh.mockResolvedValue({
+			meshId: 'dummy_meshId',
+			mesh: mockGetMeshConfig,
+		});
+
+		parseSpy = jest.spyOn(GetCommand.prototype, 'parse');
+		parseSpy.mockResolvedValue({
+			args: { file: 'mesh.json' },
+			flags: {
+				ignoreCache: mockIgnoreCacheFlag,
+			},
+		});
 	});
+
 	afterEach(() => {
 		jest.restoreAllMocks();
 	});
 
-	test('get-mesh-missing-meshId', async () => {
-		const runResult = GetCommand.run([]);
+	test('snapshot get command', () => {
+		expect(GetCommand.description).toMatchInlineSnapshot(`"Get the config of a given mesh"`);
+		expect(GetCommand.args).toMatchInlineSnapshot(`
+		Array [
+		  Object {
+		    "name": "file",
+		  },
+		]
+	`);
+		expect(GetCommand.flags).toMatchInlineSnapshot(`
+		Object {
+		  "ignoreCache": Object {
+		    "allowNo": false,
+		    "char": "i",
+		    "default": false,
+		    "description": "Ignore cache and force manual org -> project -> workspace selection",
+		    "parse": [Function],
+		    "type": "boolean",
+		  },
+		}
+	`);
+		expect(GetCommand.aliases).toMatchInlineSnapshot(`Array []`);
+	});
+
+	test('should fail if mesh id is missing', async () => {
+		getMeshId.mockResolvedValue(null);
+		const runResult = GetCommand.run();
+
+		return runResult.catch(err => {
+			expect(err.message).toMatchInlineSnapshot(
+				`"Unable to get mesh config. No mesh found for Org(1234) -> Project(5678) -> Workspace(123456789). Please check the details and try again."`,
+			);
+			expect(logSpy.mock.calls).toMatchInlineSnapshot(`Array []`);
+			expect(errorLogSpy.mock.calls).toMatchInlineSnapshot(`
+			Array [
+			  Array [
+			    "Unable to get mesh config. No mesh found for Org(1234) -> Project(5678) -> Workspace(123456789). Please check the details and try again.",
+			  ],
+			]
+		`);
+		});
+	});
+
+	test('should fail if getMeshId failed', async () => {
+		getMeshId.mockRejectedValue(new Error('getMeshId failed'));
+		const runResult = GetCommand.run();
 
 		return runResult.catch(err => {
-			expect(err).toHaveProperty(
-				'message',
-				expect.stringMatching(
-					/^Unable to get mesh\. Please check the details and try again\. If the error persists please contact support\. RequestId: [a-z A-Z 0-9 -_]+/,
-				),
+			expect(err.message).toMatchInlineSnapshot(
+				`"Unable to get mesh ID. Please check the details and try again. RequestId: dummy_request_id"`,
 			);
+			expect(logSpy.mock.calls).toMatchInlineSnapshot(`Array []`);
+			expect(errorLogSpy.mock.calls).toMatchInlineSnapshot(`
+			Array [
+			  Array [
+			    "Unable to get mesh ID. Please check the details and try again. RequestId: dummy_request_id",
+			  ],
+			]
+		`);
+		});
+	});
+
+	test('should fail if mesh id is not found', async () => {
+		getMesh.mockResolvedValueOnce(null);
+
+		const runResult = await GetCommand.run();
+
+		expect(runResult).toMatchInlineSnapshot(`undefined`);
+		expect(logSpy.mock.calls).toMatchInlineSnapshot(`Array []`);
+		expect(errorLogSpy.mock.calls).toMatchInlineSnapshot(`
+		Array [
+		  Array [
+		    "Unable to get mesh with the ID dummy_meshId. Please check the mesh ID and try again. RequestId: dummy_request_id",
+		    Object {
+		      "exit": false,
+		    },
+		  ],
+		]
+	`);
+	});
+
+	test('should fail if get mesh method failed', async () => {
+		getMesh.mockRejectedValueOnce(new Error('get mesh failed'));
+
+		const runResult = GetCommand.run();
+
+		await expect(runResult).rejects.toEqual(
+			new Error(
+				'Unable to get mesh. Please check the details and try again. If the error persists please contact support. RequestId: dummy_request_id',
+			),
+		);
+		expect(logSpy.mock.calls).toMatchInlineSnapshot(`
+		Array [
+		  Array [
+		    "get mesh failed",
+		  ],
+		]
+	`);
+		expect(errorLogSpy.mock.calls).toMatchInlineSnapshot(`
+		Array [
+		  Array [
+		    "Unable to get mesh. Please check the details and try again. If the error persists please contact support. RequestId: dummy_request_id",
+		  ],
+		]
+	`);
+	});
+
+	test('should pass if mesh id is valid', async () => {
+		const meshId = 'dummy_meshId';
+		getMeshId.mockResolvedValueOnce(meshId);
+		const runResult = await GetCommand.run();
+
+		expect(initSdk).toHaveBeenCalledWith({
+			ignoreCache: true,
+		});
+		expect(initRequestId).toHaveBeenCalled();
+		expect(runResult).toEqual({ meshId: 'dummy_meshId', mesh: mockGetMeshConfig });
+		expect(logSpy.mock.calls).toMatchInlineSnapshot(`
+		Array [
+		  Array [
+		    "Successfully retrieved mesh %s",
+		    "{
+		  \\"meshId\\": \\"dummy_meshId\\",
+		  \\"mesh\\": {
+		    \\"meshConfig\\": {
+		      \\"sources\\": [
+		        {
+		          \\"name\\": \\"<api_name>\\",
+		          \\"handler\\": {
+		            \\"graphql\\": {
+		              \\"endpoint\\": \\"<gql_endpoint>\\"
+		            }
+		          }
+		        }
+		      ]
+		    }
+		  }
+		}",
+		  ],
+		  Array [
+		    "Successfully wrote mesh to file %s",
+		    "mesh.json",
+		  ],
+		]
+	`);
+		expect(errorLogSpy.mock.calls).toMatchInlineSnapshot(`Array []`);
+	});
+
+	test('should write to file if file argument is provided', async () => {
+		writeFile.mockResolvedValueOnce(true);
+
+		const file = './mesh.json';
+		parseSpy.mockResolvedValueOnce({
+			args: {
+				file,
+			},
+			flags: {
+				ignoreCache: mockIgnoreCacheFlag,
+			},
 		});
+
+		const runResult = await GetCommand.run();
+
+		expect(runResult).toEqual({ meshId: 'dummy_meshId', mesh: mockGetMeshConfig });
+		expect(writeFile.mock.calls).toMatchInlineSnapshot(`
+		Array [
+		  Array [
+		    "./mesh.json",
+		    "{}",
+		  ],
+		]
+	`);
+		expect(logSpy.mock.calls).toMatchInlineSnapshot(`
+		Array [
+		  Array [
+		    "Successfully retrieved mesh %s",
+		    "{
+		  \\"meshId\\": \\"dummy_meshId\\",
+		  \\"mesh\\": {
+		    \\"meshConfig\\": {
+		      \\"sources\\": [
+		        {
+		          \\"name\\": \\"<api_name>\\",
+		          \\"handler\\": {
+		            \\"graphql\\": {
+		              \\"endpoint\\": \\"<gql_endpoint>\\"
+		            }
+		          }
+		        }
+		      ]
+		    }
+		  }
+		}",
+		  ],
+		  Array [
+		    "Successfully wrote mesh to file %s",
+		    "./mesh.json",
+		  ],
+		]
+	`);
+		expect(errorLogSpy.mock.calls).toMatchInlineSnapshot(`Array []`);
 	});
 
-	test('get-mesh-with-meshId', async () => {
-		jest.spyOn(SchemaServiceClient.prototype, 'getMesh').mockImplementation(meshId => mockGetMesh);
-		expect.assertions(1);
-		const meshId = 'sample_merchant';
-		const runResult = GetCommand.run([meshId]);
-		await expect(runResult).resolves.toEqual(mockGetMesh);
+	test('should log error if failed to write to file', async () => {
+		writeFile.mockRejectedValueOnce(false);
+
+		const file = './mesh.json';
+		parseSpy.mockResolvedValueOnce({
+			args: {
+				file,
+			},
+			flags: {
+				ignoreCache: mockIgnoreCacheFlag,
+			},
+		});
+		const runResult = await GetCommand.run();
+
+		expect(runResult).toEqual({ meshId: 'dummy_meshId', mesh: mockGetMeshConfig });
+		expect(writeFile.mock.calls).toMatchInlineSnapshot(`
+		Array [
+		  Array [
+		    "./mesh.json",
+		    "{}",
+		  ],
+		]
+	`);
+		expect(logSpy.mock.calls).toMatchInlineSnapshot(`
+		Array [
+		  Array [
+		    "Successfully retrieved mesh %s",
+		    "{
+		  \\"meshId\\": \\"dummy_meshId\\",
+		  \\"mesh\\": {
+		    \\"meshConfig\\": {
+		      \\"sources\\": [
+		        {
+		          \\"name\\": \\"<api_name>\\",
+		          \\"handler\\": {
+		            \\"graphql\\": {
+		              \\"endpoint\\": \\"<gql_endpoint>\\"
+		            }
+		          }
+		        }
+		      ]
+		    }
+		  }
+		}",
+		  ],
+		  Array [
+		    "Unable to write mesh to file %s",
+		    "./mesh.json",
+		  ],
+		]
+	`);
+		expect(errorLogSpy.mock.calls).toMatchInlineSnapshot(`Array []`);
 	});
 });

package/src/commands/api-mesh/__tests__/update.test.js

@@ -10,68 +10,280 @@ OF ANY KIND, either express or implied. See the License for the specific languag
 governing permissions and limitations under the License.
 */
 
-const mockConsoleCLIInstance = {};
+jest.mock('axios');
+jest.mock('fs/promises');
 jest.mock('@adobe/aio-lib-env');
-const orgs = [{ id: '1234', code: 'CODE1234@AdobeOrg', name: 'ORG01', type: 'entp' }];
-const selectedOrg = { id: '1234', code: 'CODE1234@AdobeOrg', name: 'ORG01', type: 'entp' };
+jest.mock('../../../helpers', () => ({
+	initSdk: jest.fn().mockResolvedValue({}),
+	initRequestId: jest.fn().mockResolvedValue({}),
+	promptConfirm: jest.fn().mockResolvedValue(true),
+}));
+jest.mock('@adobe/aio-cli-lib-console', () => ({
+	init: jest.fn().mockResolvedValue(mockConsoleCLIInstance),
+	cleanStdOut: jest.fn(),
+}));
+jest.mock('@adobe/aio-lib-ims');
+jest.mock('../../../lib/devConsole');
 
-const projects = [{ id: '5678', title: 'Project01' }];
-const selectedProject = { id: '5678', title: 'Project01' };
+const mockConsoleCLIInstance = {};
 
-const workspaces = [{ id: '123456789', title: 'Workspace01' }];
+const selectedOrg = { id: '1234', code: 'CODE1234@AdobeOrg', name: 'ORG01', type: 'entp' };
+const selectedProject = { id: '5678', title: 'Project01' };
 const selectedWorkspace = { id: '123456789', title: 'Workspace01' };
 
-function setDefaultMockConsoleCLI() {
-	mockConsoleCLIInstance.getToken = jest.fn().mockReturnValue('test_token');
-	mockConsoleCLIInstance.getCliEnv = jest.fn().mockReturnValue('prod');
+const { readFile } = require('fs/promises');
 
-	mockConsoleCLIInstance.getOrganizations = jest.fn().mockResolvedValue(orgs);
-	mockConsoleCLIInstance.promptForSelectOrganization = jest.fn().mockResolvedValue(selectedOrg);
+const UpdateCommand = require('../update');
+const { initSdk, initRequestId, promptConfirm } = require('../../../helpers');
+const { getMeshId, updateMesh } = require('../../../lib/devConsole');
 
-	mockConsoleCLIInstance.getProjects = jest.fn().mockResolvedValue(projects);
-	mockConsoleCLIInstance.promptForSelectProject = jest.fn().mockResolvedValue(selectedProject);
+let logSpy = null;
+let errorLogSpy = null;
 
-	mockConsoleCLIInstance.getWorkspaces = jest.fn().mockResolvedValue(workspaces);
-	mockConsoleCLIInstance.promptForSelectWorkspace = jest.fn().mockResolvedValue(selectedWorkspace);
-}
+let parseSpy = null;
 
-jest.mock('@adobe/aio-cli-lib-console', () => ({
-	init: jest.fn().mockResolvedValue(mockConsoleCLIInstance),
-	cleanStdOut: jest.fn(),
-}));
-jest.mock('@adobe/aio-lib-ims');
-const UpdateCommand = require('../update');
-const { SchemaServiceClient } = require('../../../classes/SchemaServiceClient');
-const mockUpdateMesh = require('../../__fixtures__/sample_mesh.json');
+const mockIgnoreCacheFlag = Promise.resolve(true);
+const mockAutoApproveAction = Promise.resolve(false);
 
 describe('update command tests', () => {
 	beforeEach(() => {
-		setDefaultMockConsoleCLI();
-		const response = mockUpdateMesh;
-		jest.spyOn(SchemaServiceClient.prototype, 'updateMesh').mockImplementation(data => response);
+		initSdk.mockResolvedValue({
+			imsOrgId: selectedOrg.id,
+			projectId: selectedProject.id,
+			workspaceId: selectedWorkspace.id,
+		});
+
+		global.requestId = 'dummy_request_id';
+
+		logSpy = jest.spyOn(UpdateCommand.prototype, 'log');
+		errorLogSpy = jest.spyOn(UpdateCommand.prototype, 'error');
+
+		readFile.mockResolvedValue(true);
+
+		getMeshId.mockResolvedValue('mesh_id');
+		updateMesh.mockResolvedValue({ status: 'success' });
+
+		parseSpy = jest.spyOn(UpdateCommand.prototype, 'parse');
+		parseSpy.mockResolvedValue({
+			args: { file: 'valid_file_path' },
+			flags: {
+				ignoreCache: mockIgnoreCacheFlag,
+				autoConfirmAction: mockAutoApproveAction,
+			},
+		});
 	});
 
 	afterEach(() => {
 		jest.restoreAllMocks();
 	});
 
-	test('update-mesh-missing-meshId-file', async () => {
-		expect.assertions(2);
-		const runResult = UpdateCommand.run([]);
-		await expect(runResult instanceof Promise).toBeTruthy();
+	test('should fail if mesh id is missing', async () => {
+		getMeshId.mockResolvedValue(null);
+		const runResult = UpdateCommand.run();
+
+		await expect(runResult).rejects.toMatchInlineSnapshot(
+			`[Error: Unable to update. No mesh found for Org(1234) -> Project(5678) -> Workspace(123456789). Please check the details and try again.]`,
+		);
+		expect(logSpy.mock.calls).toMatchInlineSnapshot(`Array []`);
+		expect(errorLogSpy.mock.calls).toMatchInlineSnapshot(`
+		Array [
+		  Array [
+		    "Unable to update. No mesh found for Org(1234) -> Project(5678) -> Workspace(123456789). Please check the details and try again.",
+		  ],
+		]
+	`);
+	});
+
+	test('should fail if getMeshId api failed', async () => {
+		getMeshId.mockRejectedValue(new Error('getMeshId api failed'));
+		const runResult = UpdateCommand.run();
+
+		await expect(runResult).rejects.toMatchInlineSnapshot(
+			`[Error: Unable to get mesh ID. Please check the details and try again. RequestId: dummy_request_id]`,
+		);
+		expect(logSpy.mock.calls).toMatchInlineSnapshot(`Array []`);
+		expect(errorLogSpy.mock.calls).toMatchInlineSnapshot(`
+		Array [
+		  Array [
+		    "Unable to get mesh ID. Please check the details and try again. RequestId: dummy_request_id",
+		  ],
+		]
+	`);
+	});
+
+	test('should fail if update file path is missing', async () => {
+		parseSpy.mockResolvedValueOnce({
+			args: { file: null },
+			flags: {
+				ignoreCache: mockIgnoreCacheFlag,
+				autoConfirmAction: mockAutoApproveAction,
+			},
+		});
+		const runResult = UpdateCommand.run();
+
+		await expect(runResult).rejects.toEqual(
+			new Error('Missing required args. Run aio api-mesh update --help for more info.'),
+		);
+		expect(logSpy.mock.calls).toMatchInlineSnapshot(`Array []`);
+		expect(errorLogSpy.mock.calls).toMatchInlineSnapshot(`
+		Array [
+		  Array [
+		    "Missing required args. Run aio api-mesh update --help for more info.",
+		  ],
+		]
+	`);
+	});
+
+	test('should fail if dummy file path is provided', async () => {
+		readFile.mockRejectedValueOnce(new Error('File not found'));
+		const runResult = UpdateCommand.run();
+
 		await expect(runResult).rejects.toEqual(
 			new Error(
 				'Unable to read the mesh configuration file provided. Please check the file and try again.',
 			),
 		);
+		expect(logSpy.mock.calls).toMatchInlineSnapshot(`
+		Array [
+		  Array [
+		    "File not found",
+		  ],
+		]
+	`);
+		expect(errorLogSpy.mock.calls).toMatchInlineSnapshot(`
+		Array [
+		  Array [
+		    "Unable to read the mesh configuration file provided. Please check the file and try again.",
+		  ],
+		]
+	`);
+	});
+
+	test('should not update if user prompt returns false', async () => {
+		promptConfirm.mockResolvedValueOnce(false);
+
+		const runResult = await UpdateCommand.run();
+
+		expect(runResult).toMatchInlineSnapshot(`"Update cancelled"`);
+		expect(logSpy.mock.calls).toMatchInlineSnapshot(`
+		Array [
+		  Array [
+		    "Update cancelled",
+		  ],
+		]
+	`);
+		expect(errorLogSpy.mock.calls).toMatchInlineSnapshot(`Array []`);
+	});
+
+	test('should fail if updateMesh method failed', async () => {
+		updateMesh.mockRejectedValueOnce(new Error('dummy_error'));
+
+		const runResult = UpdateCommand.run();
+
+		await expect(runResult).rejects.toEqual(
+			new Error(
+				'Unable to update the mesh. Please check the mesh configuration file and try again. If the error persists please contact support. RequestId: dummy_request_id',
+			),
+		);
+		expect(logSpy.mock.calls).toMatchInlineSnapshot(`
+		Array [
+		  Array [
+		    "dummy_error",
+		  ],
+		]
+	`);
+		expect(errorLogSpy.mock.calls).toMatchInlineSnapshot(`
+		Array [
+		  Array [
+		    "Unable to update the mesh. Please check the mesh configuration file and try again. If the error persists please contact support. RequestId: dummy_request_id",
+		  ],
+		]
+	`);
+	});
+
+	test('should pass with valid args', async () => {
+		const runResult = await UpdateCommand.run();
+
+		expect(runResult).toMatchInlineSnapshot(`
+		Object {
+		  "status": "success",
+		}
+	`);
+		expect(initRequestId).toHaveBeenCalled();
+		expect(initSdk).toHaveBeenCalledWith({
+			ignoreCache: true,
+		});
+		expect(logSpy.mock.calls).toMatchInlineSnapshot(`
+		Array [
+		  Array [
+		    "Successfully updated the mesh with the id: %s",
+		    "mesh_id",
+		  ],
+		]
+	`);
+		expect(errorLogSpy.mock.calls).toMatchInlineSnapshot(`Array []`);
 	});
-	test('update-mesh-with-configuration', async () => {
-		expect.assertions(2);
-		const runResult = UpdateCommand.run([
-			'sample_merchant',
-			'src/commands/__fixtures__/sample_mesh.json',
-		]);
-		await expect(runResult instanceof Promise).toBeTruthy();
-		await expect(runResult).resolves.toEqual(mockUpdateMesh);
+
+	test('should pass with valid args and ignoreCache flag', async () => {
+		parseSpy.mockResolvedValueOnce({
+			args: { file: 'valid_file_name' },
+			flags: {
+				ignoreCache: Promise.resolve(true),
+				autoConfirmAction: mockAutoApproveAction,
+			},
+		});
+
+		const runResult = await UpdateCommand.run();
+
+		expect(runResult).toMatchInlineSnapshot(`
+		Object {
+		  "status": "success",
+		}
+	`);
+		expect(initRequestId).toHaveBeenCalled();
+		expect(initSdk).toHaveBeenCalledWith({
+			ignoreCache: true,
+		});
+		expect(logSpy.mock.calls).toMatchInlineSnapshot(`
+		Array [
+		  Array [
+		    "Successfully updated the mesh with the id: %s",
+		    "mesh_id",
+		  ],
+		]
+	`);
+		expect(errorLogSpy.mock.calls).toMatchInlineSnapshot(`Array []`);
+	});
+
+	test('should pass with valid args if autoConfirmAction flag is set', async () => {
+		parseSpy.mockResolvedValueOnce({
+			args: { file: 'valid_file_name' },
+			flags: {
+				ignoreCache: mockIgnoreCacheFlag,
+				autoConfirmAction: Promise.resolve(true),
+			},
+		});
+
+		const runResult = await UpdateCommand.run();
+
+		expect(runResult).toMatchInlineSnapshot(`
+		Object {
+		  "status": "success",
+		}
+	`);
+		expect(initRequestId).toHaveBeenCalled();
+		expect(promptConfirm).not.toHaveBeenCalled();
+		expect(initSdk).toHaveBeenCalledWith({
+			ignoreCache: true,
+		});
+		expect(logSpy.mock.calls).toMatchInlineSnapshot(`
+		Array [
+		  Array [
+		    "Successfully updated the mesh with the id: %s",
+		    "mesh_id",
+		  ],
+		]
+	`);
+		expect(errorLogSpy.mock.calls).toMatchInlineSnapshot(`Array []`);
 	});
 });