generated tests

Author: igor-pythagora

pythagora_tests/unit/src/commands/export/runExport.test.js

@@ -0,0 +1,169 @@
+const { runExport } = require('../../../../../src/commands/export.js')
+const api = require('../../../../../src/helpers/api.js')
+const starting = require('../../../../../src/helpers/starting.js')
+const exportsHelpers = require('../../../../../src/helpers/exports.js')
+const common = require('../../../../../src/utils/common.js')
+const cmdPrint = require('../../../../../src/utils/cmdPrint.js')
+const legacy = require('../../../../../src/utils/legacy.js')
+
+const fs = require('fs')
+const getArgsMock = jest.fn();
+jest.mock('fs')
+
+const axios = require('axios')
+jest.mock('axios')
+
+jest.mock('../../../../../src/utils/getArgs', () => jest.fn({}))
+
+describe('runExport', () => {
+  afterEach(() => {
+    jest.resetAllMocks()
+  })
+
+  test('testId exists and test already generated', async () => {
+    const apiKey = 'testKey'
+    const testId = 'test1'
+    getArgsMock.mockReturnValueOnce({
+      pythagora_api_key: apiKey,
+      test_id: testId
+    });
+    // jest.mock('../../../../../src/utils/getArgs', () => ({
+    //   pythagora_api_key: apiKey,
+    //   test_id: testId
+    // }))
+    fs.readdirSync.mockReturnValue([])
+    fs.readFileSync.mockReturnValue(JSON.stringify({ [testId]: { testName: 'testName.test.js' } }))
+    exportsHelpers.testExists.mockReturnValue(true)
+
+    await runExport()
+
+    expect(cmdPrint.logAndExit).toHaveBeenCalledWith(`Test with id ${testId} already generated, you can find it here: ./${'./tests/generated/testName.test.js'}. If you want to generate it again delete old one first.`)
+  })
+
+  test('testId exists but test not found', async () => {
+    const apiKey = 'testKey'
+    const testId = 'notfound'
+    getArgsMock.mockReturnValueOnce({
+      pythagora_api_key: apiKey,
+      test_id: testId
+    });
+    // jest.mock('../../../../../src/utils/getArgs', () => ({
+    //   pythagora_api_key: apiKey,
+    //   test_id: testId
+    // }))
+    fs.readdirSync.mockReturnValue([])
+    fs.readFileSync.mockReturnValue('{}')
+    exportsHelpers.testExists.mockReturnValue(false)
+    common.getAllGeneratedTests.mockReturnValue([])
+
+    await expect(runExport()).rejects.toThrow(`Test with id ${testId} not found`)
+  })
+
+  test('testId not provided, OPTIONS method', async () => {
+    const apiKey = 'testKey'
+    const testId = undefined
+    getArgsMock.mockReturnValueOnce({
+      pythagora_api_key: apiKey,
+      test_id: testId
+    });
+    // jest.mock('../../../../../src/utils/getArgs', () => ({
+    //   pythagora_api_key: apiKey,
+    //   test_id: testId
+    // }))
+    fs.readdirSync.mockReturnValue([])
+    fs.readFileSync.mockReturnValue('{}')
+    common.getAllGeneratedTests.mockReturnValue([{ method: 'OPTIONS', id: 'test1' }])
+
+    await runExport()
+
+    expect(exportsHelpers.testExists).not.toHaveBeenCalled()
+    expect(legacy.convertOldTestForGPT).not.toHaveBeenCalled()
+    expect(api.isEligibleForExport).not.toHaveBeenCalled()
+    expect(exportsHelpers.exportTest).not.toHaveBeenCalled()
+    expect(cmdPrint.testEligibleForExportLog).not.toHaveBeenCalled()
+  })
+
+  test('testId not provided, test already generated', async () => {
+    const apiKey = 'testKey'
+    const testId = undefined
+    getArgsMock.mockReturnValueOnce({
+      pythagora_api_key: apiKey,
+      test_id: testId
+    });
+    // jest.mock('../../../../../src/utils/getArgs', () => ({
+    //   pythagora_api_key: apiKey,
+    //   test_id: testId
+    // }))
+    fs.readdirSync.mockReturnValue([])
+    fs.readFileSync.mockReturnValue(JSON.stringify({ test1: { testName: 'testName.test.js' } }))
+    common.getAllGeneratedTests.mockReturnValue([{ method: 'GET', id: 'test1', endpoint: '/example' }])
+    exportsHelpers.testExists.mockReturnValue(true)
+
+    await runExport()
+
+    expect(exportsHelpers.testExists).toHaveBeenCalledWith({ testName: 'testName.test.js' }, 'test1')
+    expect(legacy.convertOldTestForGPT).not.toHaveBeenCalled()
+    expect(api.isEligibleForExport).not.toHaveBeenCalled()
+    expect(exportsHelpers.exportTest).not.toHaveBeenCalled()
+    expect(cmdPrint.testEligibleForExportLog).not.toHaveBeenCalled()
+    expect(console.log).toHaveBeenCalledWith(`Test with id test1 already generated, you can find it here: ./${'./tests/generated/testName.test.js'}.`)
+  })
+
+  test('testId not provided, test not eligible for export', async () => {
+    const apiKey = 'testKey'
+    const testId = undefined
+    const originalTest = { method: 'GET', id: 'test1', endpoint: '/example' }
+    const convertedTest = { ...originalTest, testId: 'test1' }
+    getArgsMock.mockReturnValueOnce({
+      pythagora_api_key: apiKey,
+      test_id: testId
+    });
+    // jest.mock('../../../../../src/utils/getArgs', () => ({
+    //   pythagora_api_key: apiKey,
+    //   test_id: testId
+    // }))
+    fs.readdirSync.mockReturnValue([])
+    fs.readFileSync.mockReturnValue('{}')
+    common.getAllGeneratedTests.mockReturnValue([originalTest])
+    exportsHelpers.testExists.mockReturnValue(false)
+    legacy.convertOldTestForGPT.mockReturnValue(convertedTest)
+    api.isEligibleForExport.mockResolvedValue(false)
+
+    await runExport()
+
+    expect(exportsHelpers.testExists).toHaveBeenCalledWith({}, 'test1')
+    expect(legacy.convertOldTestForGPT).toHaveBeenCalledWith(originalTest)
+    expect(api.isEligibleForExport).toHaveBeenCalledWith(convertedTest)
+    expect(exportsHelpers.exportTest).not.toHaveBeenCalled()
+    expect(cmdPrint.testEligibleForExportLog).toHaveBeenCalledWith('/example', 'test1', false)
+  })
+
+  test('testId not provided, test eligible for export', async () => {
+    const apiKey = 'testKey'
+    const testId = undefined
+    const originalTest = { method: 'GET', id: 'test1', endpoint: '/example' }
+    const convertedTest = { ...originalTest, testId: 'test1' }
+    getArgsMock.mockReturnValueOnce({
+      pythagora_api_key: apiKey,
+      test_id: testId
+    });
+    // jest.mock('../../../../../src/utils/getArgs', () => ({
+    //   pythagora_api_key: apiKey,
+    //   test_id: testId
+    // }))
+    fs.readdirSync.mockReturnValue([])
+    fs.readFileSync.mockReturnValue('{}')
+    common.getAllGeneratedTests.mockReturnValue([originalTest])
+    exportsHelpers.testExists.mockReturnValue(false)
+    legacy.convertOldTestForGPT.mockReturnValue(convertedTest)
+    api.isEligibleForExport.mockResolvedValue(true)
+    exportsHelpers.exportTest.mockResolvedValue()
+
+    await runExport()
+
+    expect(exportsHelpers.testExists).toHaveBeenCalledWith({}, 'test1')
+    expect(legacy.convertOldTestForGPT).toHaveBeenCalledWith(originalTest)
+    expect(api.isEligibleForExport).toHaveBeenCalledWith(convertedTest)
+    expect(exportsHelpers.exportTest).toHaveBeenCalledWith(originalTest, {})
+  })
+})

pythagora_tests/unit/src/helpers/exports/cleanupDataFolder.test.js

@@ -0,0 +1,40 @@
+describe('cleanupDataFolder', () => {
+  const fs = require('fs');
+  const path = require('path');
+  const { cleanupDataFolder } = require('../../../../../src/helpers/exports.js');
+  const { EXPORTED_TESTS_DIR, EXPORTED_TESTS_DATA_DIR } = require('../../../../../src/const/common');
+
+  test('should delete file from data folder if not existing in pythagora_tests folder', () => {
+    jest.spyOn(fs, 'readdirSync').mockReturnValueOnce(['file1.json']);
+    jest.spyOn(fs, 'existsSync').mockReturnValueOnce(false);
+    const unlinkSyncSpy = jest.spyOn(fs, 'unlinkSync').mockImplementationOnce(jest.fn());
+
+    cleanupDataFolder();
+
+    expect(unlinkSyncSpy).toHaveBeenCalledWith(path.join(`./${EXPORTED_TESTS_DATA_DIR}`, 'file1.json'));
+  });
+
+  test('should not delete file from data folder if existing in pythagora_tests folder', () => {
+    jest.spyOn(fs, 'readdirSync').mockReturnValueOnce(['file2.json']);
+    jest.spyOn(fs, 'existsSync').mockReturnValueOnce(true);
+    const unlinkSyncSpy = jest.spyOn(fs, 'unlinkSync').mockImplementationOnce(jest.fn());
+
+    cleanupDataFolder();
+
+    expect(unlinkSyncSpy).not.toHaveBeenCalled();
+  });
+
+  test('should not throw error if readdirSync fails', () => {
+    jest.spyOn(fs, 'readdirSync').mockImplementationOnce(() => { throw new Error() });
+    jest.spyOn(fs, 'existsSync');
+    const unlinkSyncSpy = jest.spyOn(fs, 'unlinkSync');
+
+    expect(() => cleanupDataFolder()).not.toThrow();
+
+    expect(unlinkSyncSpy).not.toHaveBeenCalled();
+  });
+
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+});

pythagora_tests/unit/src/helpers/exports/configureAuthFile.test.js

@@ -0,0 +1,85 @@
+describe('configureAuthFile tests', () => {
+  const { configureAuthFile } = require('../../../../../src/helpers/exports.js');
+  const { updateMetadata } = require('../../../../../src/utils/common.js');
+  const fs = require('fs');
+  const originalExit = process.exit;
+  const originalConsoleLog = console.log;
+  const originalWriteFileSync = fs.writeFileSync;
+
+  afterEach(() => {
+    process.exit = originalExit;
+    console.log = originalConsoleLog;
+    fs.writeFileSync = originalWriteFileSync;
+  });
+
+  test('configureAuthFile with valid loginPath and loginRequestBody, loginMongoQueries', async () => {
+    const generatedTests = [
+      {
+        endpoint: '/test_login_path',
+        method: 'POST',
+        body: { key: 'value' },
+        intermediateData: [{ type: 'mongodb' }]
+      }
+    ];
+
+    const mockExit = jest.fn();
+    process.exit = mockExit;
+
+    const mockConsoleLog = jest.fn();
+    console.log = mockConsoleLog;
+
+    const mockWriteFileSync = jest.fn();
+    fs.writeFileSync = mockWriteFileSync;
+
+    jest.mock('../../../../../src/helpers/api.js', () => ({
+      getJestAuthFunction: () => Promise.resolve('mocked_gpt_response\n```\n\nmocked_gpt_response\n```')
+    }));
+
+    jest.mock('../../../../../src/utils/common.js', () => ({
+      ...jest.requireActual('../../../../../src/utils/common.js'),
+      updateMetadata: jest.fn()
+    }));
+
+    await configureAuthFile(generatedTests);
+
+    expect(updateMetadata).toHaveBeenCalled();
+    expect(mockExit).not.toHaveBeenCalled();
+    expect(mockConsoleLog).not.toHaveBeenCalledWith(expect.stringContaining('To export test to Jest, Pythagora needs a captured test'));
+    expect(mockWriteFileSync).toHaveBeenCalledWith(expect.stringMatching(/\/auth\.js$/), 'mocked_gpt_response');
+  });
+
+  test('configureAuthFile without loginPath in metadata', async () => {
+    const generatedTests = [];
+
+    const mockExit = jest.fn();
+    process.exit = mockExit;
+
+    const mockConsoleLog = jest.fn();
+    console.log = mockConsoleLog;
+
+    await configureAuthFile(generatedTests);
+
+    expect(mockConsoleLog).toHaveBeenCalledWith(expect.stringContaining('Login endpoint path not found'));
+    expect(mockExit).toHaveBeenCalledWith(1);
+  });
+
+  test('configureAuthFile with loginPath but missing loginRequestBody or loginMongoQueries', async () => {
+    const generatedTests = [
+      {
+        endpoint: '/missing_login_test',
+        method: 'POST',
+      }
+    ];
+
+    const mockExit = jest.fn();
+    process.exit = mockExit;
+
+    const mockConsoleLog = jest.fn();
+    console.log = mockConsoleLog;
+
+    await configureAuthFile(generatedTests);
+
+    expect(mockConsoleLog).toHaveBeenCalledWith(expect.stringContaining('To export test to Jest, Pythagora needs a captured test'));
+    expect(mockExit).toHaveBeenCalledWith(1);
+  });
+});

pythagora_tests/unit/src/helpers/exports/createDefaultFiles.test.js

@@ -0,0 +1,63 @@
+describe('Create Default Files', () => {
+  const fs = require('fs');
+  const path = require('path');
+  const { createDefaultFiles } = require('../../../../../src/helpers/exports.js');
+  const args = ['--globalSetup', '../../jest-global-setup.js'];
+  let generatedTests;
+  beforeEach(() => {
+    jest.resetModules();
+
+    const templatePath = path.join(__dirname, '../templates/jest-global-setup.js');
+    const fsMock = {
+      [src]: 'jest.config.js',
+      [dst]: '',
+    };
+
+    fs.readlink.mockImplementation((src, type) => {
+      return fsMock[src];
+    });
+
+    generatedTests = [
+      {
+        endpoint: '/api/login',
+        method: 'POST',
+        intermediateData: [],
+        body: {},
+      },
+    ];
+  });
+
+  afterEach(() => {
+    jest.clearAllMocks();
+  });
+
+  test('Create jest-global-setup.js on first run', async () => {
+    expect.assertions(1);
+    fs.existsSync.mockReturnValue(false);
+    await createDefaultFiles(generatedTests);
+    expect(fs.copyFileSync).toHaveBeenCalledTimes(1);
+  });
+
+  test('Skips copying default files on subsequent runs', async () => {
+    expect.assertions(1);
+    fs.existsSync.mockReturnValue(true);
+    await createDefaultFiles(generatedTests);
+    expect(fs.copyFileSync).toHaveBeenCalledTimes(0);
+  });
+
+  test('Create jest.config.js if it does not exist', async () => {
+    expect.assertions(2);
+    fs.existsSync.mockReturnValue(false);
+    await createDefaultFiles(generatedTests);
+    expect(fs.copyFileSync).toHaveBeenCalledTimes(1);
+    expect(fs.copyFileSync).toHaveBeenCalledWith(expect.any(String), './jest.config.js');
+  });
+
+  test('Skips copying jest.config.js on subsequent runs', async () => {
+    expect.assertions(2);
+    fs.existsSync.mockReturnValue(true);
+    await createDefaultFiles(generatedTests);
+    expect(fs.copyFileSync).toHaveBeenCalledTimes(0);
+  });
+
+});