@adobe/aio-cli-plugin-api-mesh 3.7.0 → 3.8.0-alpha.1

package/src/commands/__fixtures__/sample_mesh_with_files_array.json

@@ -1,29 +1,29 @@
 {
-    "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\":\"dummyContent\"}"
-        }
-      ]
-    }
-  }
+	"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\":\"dummyContent\"}"
+			}
+		]
+	}
+}

package/src/commands/__fixtures__/sample_secrets_mesh.json

@@ -15,4 +15,4 @@
 			}
 		]
 	}
-}
+}

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

@@ -0,0 +1,253 @@
+const fs = require('fs');
+const path = require('path');
+const GetBulkLogCommand = require('../log-get-bulk');
+const { initRequestId, initSdk, promptConfirm } = require('../../../helpers');
+const { getMeshId, getPresignedUrls } = require('../../../lib/devConsole');
+const { suggestCorrectedDateFormat } = require('../../../utils');
+
+jest.mock('fs');
+jest.mock('axios');
+jest.mock('../../../helpers', () => ({
+	initSdk: jest.fn().mockResolvedValue({}),
+	initRequestId: jest.fn().mockResolvedValue({}),
+	promptConfirm: jest.fn().mockResolvedValue(true),
+}));
+jest.mock('../../../lib/devConsole');
+jest.mock('../../../classes/logger');
+
+describe('GetBulkLogCommand', () => {
+	let parseSpy;
+
+	beforeEach(() => {
+		// Setup spies and mock functions
+		parseSpy = jest.spyOn(GetBulkLogCommand.prototype, 'parse').mockResolvedValue({
+			flags: {
+				startTime: '2024-08-29T12:00:00Z',
+				endTime: '2024-08-29T12:30:00Z',
+				filename: 'test.csv',
+				ignoreCache: false,
+			},
+		});
+
+		// initRequestId.mockResolvedValue();
+		initSdk.mockResolvedValue({
+			imsOrgId: 'orgId',
+			imsOrgCode: 'orgCode',
+			projectId: 'projectId',
+			workspaceId: 'workspaceId',
+			workspaceName: 'workspaceName',
+		});
+		getMeshId.mockResolvedValue('meshId');
+		getPresignedUrls.mockResolvedValue({
+			presignedUrls: [{ key: 'log1.csv', url: 'http://example.com/someHash' }],
+			totalSize: 2048,
+		});
+		promptConfirm.mockResolvedValue(true);
+		global.requestId = 'dummy_request_id';
+	});
+
+	afterEach(() => {
+		jest.clearAllMocks();
+	});
+
+	test('throws an error if the time difference between startTime and endTime is greater than 30 minutes', async () => {
+		// Mock the file system checks even if they are not the focus of this test
+		fs.existsSync.mockReturnValue(true); // Assume the file exists
+		fs.statSync.mockReturnValue({ size: 0 }); // Assume the file is empty
+
+		// Get the current date and time
+		const now = new Date();
+
+		// Create dynamic startTime and endTime
+		const startTime = new Date(now);
+		const endTime = new Date(now);
+		endTime.setMinutes(startTime.getMinutes() + 45); // Set endTime to 45 minutes after startTime
+
+		const formattedStartTime = startTime.toISOString().slice(0, 19) + 'Z';
+		const formattedEndTime = endTime.toISOString().slice(0, 19) + 'Z';
+
+		parseSpy.mockResolvedValueOnce({
+			flags: {
+				startTime: formattedStartTime,
+				endTime: formattedEndTime,
+				filename: 'test.csv',
+				ignoreCache: false,
+			},
+		});
+
+		const command = new GetBulkLogCommand([], {});
+		await expect(command.run()).rejects.toThrow(
+			'Max duration between startTime and endTime should be 30 minutes. Current duration is 0 hours 45 minutes and 0 seconds.',
+		);
+	});
+
+	test('throws an error if startTime format is invalid', async () => {
+		parseSpy.mockResolvedValueOnce({
+			flags: {
+				// startTime: '20240809123456',
+				startTime: '20241213223832',
+				endTime: '2024-08-29T12:30:00Z',
+				filename: 'test.csv',
+			},
+		});
+
+		const command = new GetBulkLogCommand([], {});
+
+		// Assuming your suggestCorrectedDateFormat function corrects the format to "2024-08-09T09:08:33Z"
+		const correctedStartTime = '2024-12-13T22:38:32Z'; // Use an appropriate correction - 2024-08-09T12:34:56Z
+
+		await expect(command.run()).rejects.toThrow(
+			`Use the format YYYY-MM-DDTHH:MM:SSZ for startTime. Did you mean ${correctedStartTime}?`,
+		);
+	});
+
+	test('throws an error if endTime format is invalid', async () => {
+		parseSpy.mockResolvedValueOnce({
+			flags: {
+				startTime: '2024-08-29T12:00:00Z',
+				endTime: '2024-08-29:23:45:56Z',
+				filename: 'test.csv',
+			},
+		});
+
+		const command = new GetBulkLogCommand([], {});
+
+		// Assuming your suggestCorrectedDateFormat function corrects the format to "2024-08-09T09:08:33Z"
+		const correctedStartTime = '2024-08-29T23:45:56Z'; // Use an appropriate correction
+		await expect(command.run()).rejects.toThrow(
+			`Use the format YYYY-MM-DDTHH:MM:SSZ for endTime. Did you mean ${correctedStartTime}?`,
+		);
+	});
+
+	// Test for totalSize being 0
+	test('throws an error if totalSize is 0', async () => {
+		// Mock the file system checks even if they are not the focus of this test
+		fs.existsSync.mockReturnValue(true); // Assume the file exists
+		fs.statSync.mockReturnValue({ size: 0 }); // Assume the file is empty
+		// Mock getPresignedUrls to return totalSize as 0
+		getPresignedUrls.mockResolvedValueOnce({
+			presignedUrls: [{ key: 'log1', url: 'http://example.com/log1' }],
+			totalSize: 0, // totalSize is 0
+		});
+
+		const command = new GetBulkLogCommand([], {});
+		await expect(command.run()).rejects.toThrow('No logs available to download');
+	});
+
+	test('throws an error if logs are requested for a date older than 30 days', async () => {
+		const today = new Date();
+		const thirtyDaysAgo = new Date(today);
+		thirtyDaysAgo.setUTCDate(today.getUTCDate() - 30);
+
+		const startTime = new Date(thirtyDaysAgo);
+		startTime.setUTCDate(thirtyDaysAgo.getUTCDate() - 1);
+		const formattedStartTime = startTime.toISOString().slice(0, 19) + 'Z';
+
+		parseSpy.mockResolvedValueOnce({
+			flags: {
+				startTime: formattedStartTime,
+				endTime: '2024-08-30T12:30:00Z',
+				filename: 'test.csv',
+			},
+		});
+
+		const command = new GetBulkLogCommand([], {});
+		await expect(command.run()).rejects.toThrow(
+			'Cannot get logs more than 30 days old. Adjust your time range.',
+		);
+	});
+
+	// Test for file creation and emptiness check
+	test('creates file if it does not exist and checks if file is empty before proceeding', async () => {
+		fs.existsSync.mockReturnValue(false); // Mock file does not exist
+		fs.statSync.mockReturnValue({ size: 0 }); // Mock file is empty
+
+		const mockWriteStream = {
+			write: jest.fn(),
+			end: jest.fn(),
+			on: jest.fn((event, callback) => {
+				if (event === 'finish') {
+					callback();
+				}
+			}),
+		};
+		fs.createWriteStream.mockReturnValue(mockWriteStream);
+
+		const command = new GetBulkLogCommand([], {});
+		await command.run();
+
+		expect(fs.existsSync).toHaveBeenCalledWith(path.resolve(process.cwd(), 'test.csv'));
+		expect(fs.writeFileSync).toHaveBeenCalledWith(path.resolve(process.cwd(), 'test.csv'), ''); // Ensures file is created if not exists
+		expect(mockWriteStream.write).toHaveBeenCalled(); // Writes content to file
+	});
+
+	test('throws an error if the file is not empty', async () => {
+		fs.existsSync.mockReturnValue(true);
+		fs.statSync.mockReturnValue({ size: 1024 });
+
+		const command = new GetBulkLogCommand([], {});
+		await expect(command.run()).rejects.toThrow('Make sure the file: test.csv is empty');
+	});
+
+	test('downloads logs if all conditions are met', async () => {
+		fs.existsSync.mockReturnValue(true);
+		fs.statSync.mockReturnValue({ size: 0 });
+
+		const mockWriteStream = {
+			write: jest.fn(),
+			end: jest.fn(),
+			on: jest.fn((event, callback) => {
+				if (event === 'finish') {
+					callback();
+				}
+			}),
+		};
+		fs.createWriteStream.mockReturnValue(mockWriteStream);
+
+		const command = new GetBulkLogCommand([], {});
+		await command.run();
+
+		expect(initRequestId).toHaveBeenCalled();
+		expect(initSdk).toHaveBeenCalled();
+		expect(getMeshId).toHaveBeenCalledWith('orgId', 'projectId', 'workspaceId', 'workspaceName');
+		expect(getPresignedUrls).toHaveBeenCalledWith(
+			'orgCode',
+			'projectId',
+			'workspaceId',
+			'meshId',
+			expect.any(String),
+			expect.any(String),
+		);
+		expect(fs.createWriteStream).toHaveBeenCalledWith(path.resolve(process.cwd(), 'test.csv'), {
+			flags: 'a',
+		});
+		expect(mockWriteStream.write).toHaveBeenCalled();
+		expect(mockWriteStream.end).toHaveBeenCalled();
+	});
+});
+describe('GetBulkLogCommand startTime and endTime validation', () => {
+	// Define the test cases as an array of [inputDate, expectedOutput] pairs
+	const testCases = [
+		// Invalid formats that should be corrected
+		['2024-0812T123445', '2024-08-12T12:34:45Z'],
+		['2024:08:12-09-08-36Z', '2024-08-12T09:08:36Z'],
+		['20241223T234556Z', '2024-12-23T23:45:56Z'],
+		['20241213223832', '2024-12-13T22:38:32Z'],
+		['2024-12-13T223832Z', '2024-12-13T22:38:32Z'],
+		['2024-11-23T21:34:45', '2024-11-23T21:34:45Z'],
+
+		// Invalid date components that should not be corrected, but return null which lets the user know the date is invalid
+		['20240834123456Z', null], // Invalid day (34)
+		['2024-12-34T23:34:45Z', null], // Invalid day (34)
+		['2024-13-23:21:34:45', null], // Invalid month (13)
+		['2024-11-63T21:34:45', null], // Invalid day (13) and missing Z
+	];
+
+	test.each(testCases)(
+		'suggestCorrectedDateFormat("%s") should return "%s"',
+		(inputDate, expectedOutput) => {
+			const correctedDate = suggestCorrectedDateFormat(inputDate);
+			expect(correctedDate).toBe(expectedOutput);
+		},
+	);
+});

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

@@ -0,0 +1,234 @@
+/*
+Copyright 2021 Adobe. All rights reserved.
+This file is licensed to you under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License. You may obtain a copy
+of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under
+the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+OF ANY KIND, either express or implied. See the License for the specific language
+governing permissions and limitations under the License.
+*/
+
+jest.mock('axios');
+jest.mock('@adobe/aio-lib-env');
+jest.mock('@adobe/aio-cli-lib-console');
+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 mockConsoleCLIInstance = {};
+const selectedOrg = { id: '1234', code: 'CODE1234@AdobeOrg', name: 'ORG01', type: 'entp' };
+const selectedProject = { id: '5678', title: 'Project01' };
+const selectedWorkspace = { id: '123456789', title: 'Workspace01' };
+
+const { writeFile } = require('fs/promises');
+const { initSdk } = require('../../../helpers');
+const FetchLogsCommand = require('../log-get');
+const { getLogsByRayId, getMeshId } = require('../../../lib/devConsole');
+const os = require('os');
+let logSpy = null;
+let errorLogSpy = null;
+let parseSpy = null;
+let platformSpy = null;
+
+const mockIgnoreCacheFlag = Promise.resolve(true);
+
+describe('FetchLogsCommand tests', () => {
+	beforeEach(() => {
+		initSdk.mockResolvedValue({
+			imsOrgId: selectedOrg.id,
+			projectId: selectedProject.id,
+			workspaceId: selectedWorkspace.id,
+			workspaceName: selectedWorkspace.title,
+		});
+
+		global.requestId = 'dummy_request_id';
+
+		logSpy = jest.spyOn(FetchLogsCommand.prototype, 'log');
+		errorLogSpy = jest.spyOn(FetchLogsCommand.prototype, 'error');
+		platformSpy = jest.spyOn(os, 'platform');
+
+		writeFile.mockResolvedValue(true);
+
+		parseSpy = jest.spyOn(FetchLogsCommand.prototype, 'parse');
+		parseSpy.mockResolvedValue({
+			args: { rayId: 'ray1' },
+			flags: {
+				ignoreCache: mockIgnoreCacheFlag,
+			},
+		});
+		getMeshId.mockResolvedValue('12345');
+		getLogsByRayId.mockResolvedValue({
+			'EventTimestampMs': 123456789,
+			'Exceptions': 'None',
+			'Logs': 'Log data',
+			'Outcome': 'Success',
+			'meshId': 'mesh1',
+			'rayId': 'ray1',
+			'URL': 'http://example.com',
+			'Request Method': 'GET',
+			'Response Status': 200,
+		});
+	});
+
+	afterEach(() => {
+		platformSpy.mockRestore();
+	});
+
+	test('snapshot FetchLogsCommand', () => {
+		expect(FetchLogsCommand.description).toMatchInlineSnapshot(
+			`"Get the Log of a given mesh by RayId"`,
+		);
+		expect(FetchLogsCommand.args).toMatchInlineSnapshot(`
+		[
+		  {
+		    "description": "Fetch a single log by rayID",
+		    "name": "rayId",
+		    "required": true,
+		  },
+		]
+	`);
+		expect(FetchLogsCommand.flags).toMatchInlineSnapshot(`
+		                {
+		                  "ignoreCache": {
+		                    "allowNo": false,
+		                    "char": "i",
+		                    "default": false,
+		                    "description": "Ignore cache and force manual org -> project -> workspace selection",
+		                    "parse": [Function],
+		                    "type": "boolean",
+		                  },
+		                }
+	        `);
+		expect(FetchLogsCommand.aliases).toMatchInlineSnapshot(`[]`);
+	});
+
+	test('should handle log not found error', async () => {
+		getLogsByRayId.mockRejectedValue(new Error('LogNotFound'));
+
+		const runResult = FetchLogsCommand.run();
+
+		return runResult.catch(err => {
+			expect(err.message).toMatchInlineSnapshot(`
+			"No logs found for RayID ray1. Check the RayID and try again. RequestId: dummy_request_id. Alternatively, you can use the following command to get all logs for a 30 minute time period: 
+			aio api-mesh log-get-bulk --startTime YYYY-MM-DDTHH:MM:SSZ --endTime YYYY-MM-DDTHH:MM:SSZ --filename mesh_logs.csv"
+		`);
+			expect(logSpy.mock.calls).toMatchInlineSnapshot(`[]`);
+			expect(errorLogSpy.mock.calls).toMatchInlineSnapshot(`
+			[
+			  [
+			    "No logs found for RayID ray1. Check the RayID and try again. RequestId: dummy_request_id. Alternatively, you can use the following command to get all logs for a 30 minute time period: 
+			aio api-mesh log-get-bulk --startTime YYYY-MM-DDTHH:MM:SSZ --endTime YYYY-MM-DDTHH:MM:SSZ --filename mesh_logs.csv",
+			  ],
+			]
+		`);
+		});
+	});
+
+	test('should handle server error', async () => {
+		getLogsByRayId.mockRejectedValue(new Error('ServerError'));
+
+		const runResult = FetchLogsCommand.run();
+
+		return runResult.catch(err => {
+			expect(err.message).toMatchInlineSnapshot(
+				`"Server error while fetching logs for RayId ray1. Please try again later. RequestId: dummy_request_id"`,
+			);
+			expect(logSpy.mock.calls).toMatchInlineSnapshot(`[]`);
+			expect(errorLogSpy.mock.calls).toMatchInlineSnapshot(`
+					[
+					  [
+					    "Server error while fetching logs for RayId ray1. Please try again later. RequestId: dummy_request_id",
+					  ],
+					]
+			`);
+		});
+	});
+
+	test('should handle generic error', async () => {
+		getLogsByRayId.mockRejectedValue({
+			response: { status: 503, statusText: 'Service Unavailable' },
+		});
+
+		const runResult = FetchLogsCommand.run();
+
+		return runResult.catch(err => {
+			expect(err.message).toMatchInlineSnapshot(
+				`"Unable to get mesh logs. Please check the details and try again. If the error persists please contact support. RequestId: dummy_request_id"`,
+			);
+			expect(logSpy.mock.calls).toMatchInlineSnapshot(`[]`);
+			expect(errorLogSpy.mock.calls).toMatchInlineSnapshot(`
+			[
+			  [
+			    "Unable to get mesh logs. Please check the details and try again. If the error persists please contact support. RequestId: dummy_request_id",
+			  ],
+			]
+		`);
+		});
+	});
+
+	test('should handle mesh ID not found error', async () => {
+		getMeshId.mockResolvedValue(null);
+
+		const runResult = FetchLogsCommand.run();
+
+		return runResult.catch(err => {
+			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(`[]`);
+			expect(errorLogSpy.mock.calls).toMatchInlineSnapshot(`
+					[
+					  [
+					    "Unable to get mesh ID. Please check the details and try again. RequestId: dummy_request_id",
+					  ],
+					]
+			`);
+		});
+	});
+	test('should fetch logs successfully', async () => {
+		getMeshId.mockResolvedValue('mesh1');
+		getLogsByRayId.mockResolvedValue({
+			eventTimestampMs: 1724660420904,
+			exceptions: '[]',
+			logs:
+				'[{\'Level\': \'log\', \'Message\': [\'[object Object]\'], \'TimestampMs\': 1724660422580}, {\'Level\': \'log\', \'Message\': [\'{"sources":[{"name":"venia","handler":{"graphql":{"useGETForQueries":true,"endpoint":"https://venia.magento.com/graphql","operationHeaders":{"x-test-header":"{context.headers[\\\'x-test-header\\\']}"}}}}],"responseConfig":{"includeHTTPDetails":true},"additionalResolvers":[],"plugins":[{"httpDetailsExtensions":{}}]}\'], \'TimestampMs\': 1724660422580}]',
+			outcome: 'ok',
+			meshId: 'mesh1',
+			rayId: 'ray1',
+			url: 'https://edge-dev1-graph.adobe.io/api/REDACTED/graphql',
+			requestMethod: 'POST',
+			responseStatus: 200,
+			level: 'log',
+		});
+
+		const command = new FetchLogsCommand(['ray1']);
+		await command.run();
+
+		expect(logSpy).toHaveBeenCalledWith('Event Timestamp : %s', 1724660420904);
+		expect(logSpy).toHaveBeenCalledWith('Exceptions : %s', '[]');
+		expect(logSpy).toHaveBeenCalledWith(
+			'Logs : %s',
+			'[{\'Level\': \'log\', \'Message\': [\'[object Object]\'], \'TimestampMs\': 1724660422580}, {\'Level\': \'log\', \'Message\': [\'{"sources":[{"name":"venia","handler":{"graphql":{"useGETForQueries":true,"endpoint":"https://venia.magento.com/graphql","operationHeaders":{"x-test-header":"{context.headers[\\\'x-test-header\\\']}"}}}}],"responseConfig":{"includeHTTPDetails":true},"additionalResolvers":[],"plugins":[{"httpDetailsExtensions":{}}]}\'], \'TimestampMs\': 1724660422580}]',
+		);
+		expect(logSpy).toHaveBeenCalledWith('Outcome : %s', 'ok');
+		expect(logSpy).toHaveBeenCalledWith('Mesh ID : %s', 'mesh1');
+		expect(logSpy).toHaveBeenCalledWith('RayId : %s', 'ray1');
+		expect(logSpy).toHaveBeenCalledWith(
+			'Mesh URL : %s',
+			'https://edge-dev1-graph.adobe.io/api/REDACTED/graphql',
+		);
+		expect(logSpy).toHaveBeenCalledWith('Request Method : %s', 'POST');
+		expect(logSpy).toHaveBeenCalledWith('Request Status : %s', 200);
+	});
+});