@adobe/aio-cli-plugin-api-mesh 2.0.0 → 2.2.0-beta.1

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

@@ -17,6 +17,7 @@ jest.mock('../../../helpers', () => ({
 	initSdk: jest.fn().mockResolvedValue({}),
 	initRequestId: jest.fn().mockResolvedValue({}),
 	promptConfirm: jest.fn().mockResolvedValue(true),
+	importFiles: jest.fn().mockResolvedValue(),
 }));
 jest.mock('@adobe/aio-cli-lib-console', () => ({
 	init: jest.fn().mockResolvedValue(mockConsoleCLIInstance),
@@ -34,7 +35,7 @@ const selectedWorkspace = { id: '123456789', title: 'Workspace01' };
 const { readFile } = require('fs/promises');
 
 const UpdateCommand = require('../update');
-const { initSdk, initRequestId, promptConfirm } = require('../../../helpers');
+const { initSdk, initRequestId, promptConfirm, importFiles } = require('../../../helpers');
 const { getMeshId, updateMesh } = require('../../../lib/devConsole');
 
 let logSpy = null;
@@ -58,7 +59,7 @@ describe('update command tests', () => {
 		logSpy = jest.spyOn(UpdateCommand.prototype, 'log');
 		errorLogSpy = jest.spyOn(UpdateCommand.prototype, 'error');
 
-		readFile.mockResolvedValue(true);
+		readFile.mockResolvedValue('{}');
 
 		getMeshId.mockResolvedValue('mesh_id');
 		updateMesh.mockResolvedValue({ status: 'success' });
@@ -73,11 +74,209 @@ describe('update command tests', () => {
 		});
 	});
 
-	afterEach(() => {
-		jest.restoreAllMocks();
+	test('should pass with valid args', async () => {
+		let sampleMesh = {
+			meshConfig: {
+				sources: [
+					{
+						name: '<api_name>',
+						handler: {
+							graphql: {
+								endpoint: '<gql_endpoint>',
+							},
+						},
+					},
+				],
+			},
+		};
+		readFile.mockResolvedValue(JSON.stringify(sampleMesh));
+
+		parseSpy.mockResolvedValueOnce({
+			args: { file: 'src/commands/__fixtures__/sample_mesh.json' },
+			flags: {
+				ignoreCache: mockIgnoreCacheFlag,
+				autoConfirmAction: mockAutoApproveAction,
+			},
+		});
+
+		const runResult = await UpdateCommand.run();
+
+		expect(runResult).toMatchInlineSnapshot(`
+		{
+		  "status": "success",
+		}
+	`);
+		expect(initRequestId).toHaveBeenCalled();
+		expect(initSdk).toHaveBeenCalledWith({
+			ignoreCache: true,
+		});
+		expect(logSpy.mock.calls).toMatchInlineSnapshot(`
+		[
+		  [
+		    "******************************************************************************************************",
+		  ],
+		  [
+		    "Your mesh is being provisioned. Wait a few minutes before checking the status of your mesh %s",
+		    "mesh_id",
+		  ],
+		  [
+		    "To check the status of your mesh, run:",
+		  ],
+		  [
+		    "aio api-mesh:status",
+		  ],
+		  [
+		    "******************************************************************************************************",
+		  ],
+		]
+	`);
+		expect(errorLogSpy.mock.calls).toMatchInlineSnapshot(`[]`);
+	});
+
+	test('should pass with valid args and ignoreCache flag', async () => {
+		let sampleMesh = {
+			meshConfig: {
+				sources: [
+					{
+						name: '<api_name>',
+						handler: {
+							graphql: {
+								endpoint: '<gql_endpoint>',
+							},
+						},
+					},
+				],
+			},
+		};
+		readFile.mockResolvedValue(JSON.stringify(sampleMesh));
+
+		parseSpy.mockResolvedValueOnce({
+			args: { file: 'src/commands/__fixtures__/sample_mesh.json' },
+			flags: {
+				ignoreCache: Promise.resolve(true),
+				autoConfirmAction: mockAutoApproveAction,
+			},
+		});
+
+		const runResult = await UpdateCommand.run();
+
+		expect(runResult).toMatchInlineSnapshot(`
+		{
+		  "status": "success",
+		}
+	`);
+		expect(initRequestId).toHaveBeenCalled();
+		expect(initSdk).toHaveBeenCalledWith({
+			ignoreCache: true,
+		});
+		expect(logSpy.mock.calls).toMatchInlineSnapshot(`
+		[
+		  [
+		    "******************************************************************************************************",
+		  ],
+		  [
+		    "Your mesh is being provisioned. Wait a few minutes before checking the status of your mesh %s",
+		    "mesh_id",
+		  ],
+		  [
+		    "To check the status of your mesh, run:",
+		  ],
+		  [
+		    "aio api-mesh:status",
+		  ],
+		  [
+		    "******************************************************************************************************",
+		  ],
+		]
+	`);
+		expect(errorLogSpy.mock.calls).toMatchInlineSnapshot(`[]`);
+	});
+
+	test('should pass with valid args if autoConfirmAction flag is set', async () => {
+		let sampleMesh = {
+			meshConfig: {
+				sources: [
+					{
+						name: '<api_name>',
+						handler: {
+							graphql: {
+								endpoint: '<gql_endpoint>',
+							},
+						},
+					},
+				],
+			},
+		};
+		readFile.mockResolvedValue(JSON.stringify(sampleMesh));
+
+		parseSpy.mockResolvedValueOnce({
+			args: { file: 'src/commands/__fixtures__/sample_mesh.json' },
+			flags: {
+				ignoreCache: mockIgnoreCacheFlag,
+				autoConfirmAction: Promise.resolve(true),
+			},
+		});
+
+		const runResult = await UpdateCommand.run();
+
+		expect(runResult).toMatchInlineSnapshot(`
+		{
+		  "status": "success",
+		}
+	`);
+		expect(initRequestId).toHaveBeenCalled();
+		expect(promptConfirm).not.toHaveBeenCalled();
+		expect(initSdk).toHaveBeenCalledWith({
+			ignoreCache: true,
+		});
+		expect(logSpy.mock.calls).toMatchInlineSnapshot(`
+		[
+		  [
+		    "******************************************************************************************************",
+		  ],
+		  [
+		    "Your mesh is being provisioned. Wait a few minutes before checking the status of your mesh %s",
+		    "mesh_id",
+		  ],
+		  [
+		    "To check the status of your mesh, run:",
+		  ],
+		  [
+		    "aio api-mesh:status",
+		  ],
+		  [
+		    "******************************************************************************************************",
+		  ],
+		]
+	`);
+		expect(errorLogSpy.mock.calls).toMatchInlineSnapshot(`[]`);
 	});
 
 	test('should fail if mesh id is missing', async () => {
+		let sampleMesh = {
+			meshConfig: {
+				sources: [
+					{
+						name: '<api_name>',
+						handler: {
+							graphql: {
+								endpoint: '<gql_endpoint>',
+							},
+						},
+					},
+				],
+			},
+		};
+		readFile.mockResolvedValue(JSON.stringify(sampleMesh));
+
+		parseSpy.mockResolvedValueOnce({
+			args: { file: 'src/commands/__fixtures__/sample_mesh.json' },
+			flags: {
+				ignoreCache: mockIgnoreCacheFlag,
+				autoConfirmAction: mockAutoApproveAction,
+			},
+		});
+
 		getMeshId.mockResolvedValue(null);
 		const runResult = UpdateCommand.run();
 
@@ -95,6 +294,30 @@ describe('update command tests', () => {
 	});
 
 	test('should fail if getMeshId api failed', async () => {
+		let sampleMesh = {
+			meshConfig: {
+				sources: [
+					{
+						name: '<api_name>',
+						handler: {
+							graphql: {
+								endpoint: '<gql_endpoint>',
+							},
+						},
+					},
+				],
+			},
+		};
+		readFile.mockResolvedValue(JSON.stringify(sampleMesh));
+
+		parseSpy.mockResolvedValueOnce({
+			args: { file: 'src/commands/__fixtures__/sample_mesh.json' },
+			flags: {
+				ignoreCache: mockIgnoreCacheFlag,
+				autoConfirmAction: mockAutoApproveAction,
+			},
+		});
+
 		getMeshId.mockRejectedValue(new Error('getMeshId api failed'));
 		const runResult = UpdateCommand.run();
 
@@ -111,6 +334,60 @@ describe('update command tests', () => {
 	`);
 	});
 
+	test('should fail if updateMesh method failed', async () => {
+		let sampleMesh = {
+			meshConfig: {
+				sources: [
+					{
+						name: '<api_name>',
+						handler: {
+							graphql: {
+								endpoint: '<gql_endpoint>',
+							},
+						},
+					},
+				],
+			},
+		};
+		readFile.mockResolvedValue(JSON.stringify(sampleMesh));
+
+		parseSpy.mockResolvedValueOnce({
+			args: { file: 'src/commands/__fixtures__/sample_mesh.json' },
+			flags: {
+				ignoreCache: mockIgnoreCacheFlag,
+				autoConfirmAction: mockAutoApproveAction,
+			},
+		});
+
+		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',
+		// 	),
+		// );
+
+		await expect(runResult).rejects.toMatchInlineSnapshot(
+			`[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(`
+		[
+		  [
+		    "dummy_error",
+		  ],
+		]
+	`);
+		expect(errorLogSpy.mock.calls).toMatchInlineSnapshot(`
+		[
+		  [
+		    "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 fail if update file path is missing', async () => {
 		parseSpy.mockResolvedValueOnce({
 			args: { file: null },
@@ -160,6 +437,30 @@ describe('update command tests', () => {
 	});
 
 	test('should not update if user prompt returns false', async () => {
+		let sampleMesh = {
+			meshConfig: {
+				sources: [
+					{
+						name: '<api_name>',
+						handler: {
+							graphql: {
+								endpoint: '<gql_endpoint>',
+							},
+						},
+					},
+				],
+			},
+		};
+		readFile.mockResolvedValue(JSON.stringify(sampleMesh));
+
+		parseSpy.mockResolvedValueOnce({
+			args: { file: 'src/commands/__fixtures__/sample_mesh.json' },
+			flags: {
+				ignoreCache: mockIgnoreCacheFlag,
+				autoConfirmAction: mockAutoApproveAction,
+			},
+		});
+
 		promptConfirm.mockResolvedValueOnce(false);
 
 		const runResult = await UpdateCommand.run();
@@ -175,151 +476,265 @@ describe('update command tests', () => {
 		expect(errorLogSpy.mock.calls).toMatchInlineSnapshot(`[]`);
 	});
 
-	test('should fail if updateMesh method failed', async () => {
-		updateMesh.mockRejectedValueOnce(new Error('dummy_error'));
+	test('should pass if there are local files in meshConfig i.e., the file is appended in files array', async () => {
+		let sampleMesh = {
+			meshConfig: {
+				sources: [
+					{
+						name: '<json_source_name>',
+						handler: {
+							JsonSchema: {
+								baseUrl: '<json_source__baseurl>',
+								operations: [
+									{
+										type: 'Query',
+										field: '<query>',
+										path: '<query_path>',
+										method: 'POST',
+										requestSchema: './requestParams.json',
+									},
+								],
+							},
+						},
+					},
+				],
+			},
+		};
+		readFile.mockResolvedValue(JSON.stringify(sampleMesh));
+
+		let meshConfig = {
+			sources: [
+				{
+					name: '<json_source_name>',
+					handler: {
+						JsonSchema: {
+							baseUrl: '<json_source__baseurl>',
+							operations: [
+								{
+									type: 'Query',
+									field: '<query>',
+									path: '<query_path>',
+									method: 'POST',
+									requestSchema: './requestParams.json',
+								},
+							],
+						},
+					},
+				},
+			],
+			files: [
+				{
+					path: './requestParams.json',
+					content: '{"type":"updatedContent"}',
+				},
+			],
+		};
+
+		updateMesh.mockResolvedValue({
+			meshId: 'dummy_mesh_id',
+			meshConfig: meshConfig,
+		});
 
-		const runResult = UpdateCommand.run();
+		parseSpy.mockResolvedValue({
+			args: { file: 'src/commands/__fixtures__/sample_mesh_files.json' },
+			flags: {
+				autoConfirmAction: mockAutoApproveAction,
+			},
+		});
 
-		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(`
-		[
-		  [
-		    "dummy_error",
-		  ],
-		]
-	`);
-		expect(errorLogSpy.mock.calls).toMatchInlineSnapshot(`
+		importFiles.mockResolvedValueOnce({
+			meshConfig,
+		});
+
+		const output = await UpdateCommand.run();
+
+		expect(initRequestId).toHaveBeenCalled();
+		expect(updateMesh.mock.calls[0]).toMatchInlineSnapshot(`
 		[
-		  [
-		    "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",
-		  ],
+		  "1234",
+		  "5678",
+		  "123456789",
+		  "mesh_id",
+		  {
+		    "meshConfig": {
+		      "files": [
+		        {
+		          "content": "{"type":"updatedContent"}",
+		          "path": "./requestParams.json",
+		        },
+		      ],
+		      "sources": [
+		        {
+		          "handler": {
+		            "JsonSchema": {
+		              "baseUrl": "<json_source__baseurl>",
+		              "operations": [
+		                {
+		                  "field": "<query>",
+		                  "method": "POST",
+		                  "path": "<query_path>",
+		                  "requestSchema": "./requestParams.json",
+		                  "type": "Query",
+		                },
+		              ],
+		            },
+		          },
+		          "name": "<json_source_name>",
+		        },
+		      ],
+		    },
+		  },
 		]
 	`);
-	});
 
-	test('should pass with valid args', async () => {
-		const runResult = await UpdateCommand.run();
-
-		expect(runResult).toMatchInlineSnapshot(`
+		expect(output).toMatchInlineSnapshot(`
 		{
-		  "status": "success",
+		  "meshConfig": {
+		    "files": [
+		      {
+		        "content": "{"type":"updatedContent"}",
+		        "path": "./requestParams.json",
+		      },
+		    ],
+		    "sources": [
+		      {
+		        "handler": {
+		          "JsonSchema": {
+		            "baseUrl": "<json_source__baseurl>",
+		            "operations": [
+		              {
+		                "field": "<query>",
+		                "method": "POST",
+		                "path": "<query_path>",
+		                "requestSchema": "./requestParams.json",
+		                "type": "Query",
+		              },
+		            ],
+		          },
+		        },
+		        "name": "<json_source_name>",
+		      },
+		    ],
+		  },
+		  "meshId": "dummy_mesh_id",
 		}
 	`);
-		expect(initRequestId).toHaveBeenCalled();
-		expect(initSdk).toHaveBeenCalledWith({
-			ignoreCache: true,
-		});
-		expect(logSpy.mock.calls).toMatchInlineSnapshot(`
-		[
-		  [
-		    "******************************************************************************************************",
-		  ],
-		  [
-		    "Your mesh is being provisioned. Wait a few minutes before checking the status of your mesh %s",
-		    "mesh_id",
-		  ],
-		  [
-		    "To check the status of your mesh, run:",
-		  ],
-		  [
-		    "aio api-mesh:status",
-		  ],
-		  [
-		    "******************************************************************************************************",
-		  ],
-		]
-	`);
-		expect(errorLogSpy.mock.calls).toMatchInlineSnapshot(`[]`);
 	});
 
-	test('should pass with valid args and ignoreCache flag', async () => {
-		parseSpy.mockResolvedValueOnce({
-			args: { file: 'valid_file_name' },
+	test('should fail if the input mesh config file is inavlid i.e., file name has more than 25 characters', async () => {
+		let sampleMesh = {
+			meshConfig: {
+				sources: [
+					{
+						name: '<json_source_name>',
+						handler: {
+							JsonSchema: {
+								baseUrl: '<json_source__baseurl>',
+								operations: [
+									{
+										type: 'Query',
+										field: '<query>',
+										path: '<query_path>',
+										method: 'POST',
+										requestSchema: './requestJSONParameters.json',
+									},
+								],
+							},
+						},
+					},
+				],
+			},
+		};
+		readFile.mockResolvedValue(JSON.stringify(sampleMesh));
+
+		parseSpy.mockResolvedValue({
+			args: { file: 'src/commands/__fixtures__/sample_mesh_invalid_file_name.json' },
 			flags: {
-				ignoreCache: Promise.resolve(true),
+				ignoreCache: mockIgnoreCacheFlag,
 				autoConfirmAction: mockAutoApproveAction,
 			},
 		});
 
-		const runResult = await UpdateCommand.run();
+		const output = UpdateCommand.run();
+
+		await expect(output).rejects.toEqual(new Error('Input mesh config is not valid.'));
 
-		expect(runResult).toMatchInlineSnapshot(`
-		{
-		  "status": "success",
-		}
-	`);
-		expect(initRequestId).toHaveBeenCalled();
-		expect(initSdk).toHaveBeenCalledWith({
-			ignoreCache: true,
-		});
 		expect(logSpy.mock.calls).toMatchInlineSnapshot(`
 		[
 		  [
-		    "******************************************************************************************************",
-		  ],
-		  [
-		    "Your mesh is being provisioned. Wait a few minutes before checking the status of your mesh %s",
-		    "mesh_id",
-		  ],
-		  [
-		    "To check the status of your mesh, run:",
-		  ],
-		  [
-		    "aio api-mesh:status",
+		    "Mesh file names must be less than 25 characters. The following file(s) are invalid: requestJSONParameters.json.",
 		  ],
+		]
+	`);
+
+		expect(errorLogSpy.mock.calls).toMatchInlineSnapshot(`
+		[
 		  [
-		    "******************************************************************************************************",
+		    "Input mesh config is not valid.",
 		  ],
 		]
 	`);
-		expect(errorLogSpy.mock.calls).toMatchInlineSnapshot(`[]`);
 	});
 
-	test('should pass with valid args if autoConfirmAction flag is set', async () => {
-		parseSpy.mockResolvedValueOnce({
-			args: { file: 'valid_file_name' },
+	test('should fail if the import files function fails', async () => {
+		let sampleMesh = {
+			meshConfig: {
+				sources: [
+					{
+						name: '<json_source_name>',
+						handler: {
+							JsonSchema: {
+								baseUrl: '<json_source__baseurl>',
+								operations: [
+									{
+										type: 'Query',
+										field: '<query>',
+										path: '<query_path>',
+										method: 'POST',
+										requestSchema: './requestParams.json',
+									},
+								],
+							},
+						},
+					},
+				],
+			},
+		};
+		readFile.mockResolvedValue(JSON.stringify(sampleMesh));
+
+		parseSpy.mockResolvedValue({
+			args: { file: 'src/commands/__fixtures__/sample_mesh_files.json' },
 			flags: {
 				ignoreCache: mockIgnoreCacheFlag,
-				autoConfirmAction: Promise.resolve(true),
+				autoConfirmAction: mockAutoApproveAction,
 			},
 		});
 
-		const runResult = await UpdateCommand.run();
-
-		expect(runResult).toMatchInlineSnapshot(`
-		{
-		  "status": "success",
-		}
-	`);
-		expect(initRequestId).toHaveBeenCalled();
-		expect(promptConfirm).not.toHaveBeenCalled();
-		expect(initSdk).toHaveBeenCalledWith({
-			ignoreCache: true,
+		importFiles.mockImplementation(() => {
+			throw new Error('Error reading the file.');
 		});
+
+		const output = UpdateCommand.run();
+		await expect(output).rejects.toEqual(
+			new Error(
+				'Unable to import the files in the mesh config. Please check the file and try again.',
+			),
+		);
+
 		expect(logSpy.mock.calls).toMatchInlineSnapshot(`
 		[
 		  [
-		    "******************************************************************************************************",
-		  ],
-		  [
-		    "Your mesh is being provisioned. Wait a few minutes before checking the status of your mesh %s",
-		    "mesh_id",
-		  ],
-		  [
-		    "To check the status of your mesh, run:",
-		  ],
-		  [
-		    "aio api-mesh:status",
+		    "Error reading the file.",
 		  ],
+		]
+	`);
+
+		expect(errorLogSpy.mock.calls).toMatchInlineSnapshot(`
+		[
 		  [
-		    "******************************************************************************************************",
+		    "Unable to import the files in the mesh config. Please check the file and try again.",
 		  ],
 		]
 	`);
-		expect(errorLogSpy.mock.calls).toMatchInlineSnapshot(`[]`);
 	});
 });