ScanTest.test.ts

import { CxWrapper } from '../main/wrapper/CxWrapper';
import { CxCommandOutput } from "../main/wrapper/CxCommandOutput";
import { CxParamType } from "../main/wrapper/CxParamType";
import { BaseTest } from "./BaseTest";
import {OssPackage} from "./data/ossTypes";
import CxIacResult from "../main/iacRealtime/CxIac";
import CxContainerRealtimeResult from "../main/containersRealtime/CxContainerRealtime";
import CxAsca from '../main/asca/CxAsca';

describe("ScanCreate cases", () => {
    const cxScanConfig = new BaseTest();
    it('ScanList Successful case', async () => {
        const auth = new CxWrapper(cxScanConfig);
        const cxCommandOutput: CxCommandOutput = await auth.scanList("");
        console.log(" Json object from scanList successful case: " + JSON.stringify(cxCommandOutput));
        expect(cxCommandOutput.payload.length).toBeGreaterThan(1);
        expect(cxCommandOutput.exitCode).toBe(0);
    });

    it('ScanCreate Successful case wait mode', async () => {
        const params = new Map();
        params.set(CxParamType.PROJECT_NAME, "ast-cli-javascript-integration-success");
        params.set(CxParamType.S, "./src");
        params.set(CxParamType.FILTER, "*.ts,!**/node_modules/**/*");
        params.set(CxParamType.BRANCH, "master");
        params.set(CxParamType.SCAN_TYPES,"kics");
        const auth = new CxWrapper(cxScanConfig);
        const cxCommandOutput: CxCommandOutput = await auth.scanCreate(params);
        const scanObject = cxCommandOutput.payload.pop();
        const scanShowObject = await auth.scanShow(scanObject.id);
        console.log(" Json object from successful wait mode case: " + JSON.stringify(scanShowObject));
        expect(scanShowObject.payload.pop().status).toEqual("Completed");
    })

    it('ScanCreate Failure case', async () => {
        const params = new Map();
        params.set(CxParamType.PROJECT_NAME, "ast-cli-javascript-integration-failure");
        params.set(CxParamType.S, "./src");
        params.set(CxParamType.SAST_PRESET_NAME, "Checkmarx Default Fake");
        params.set(CxParamType.BRANCH, "master");
        params.set(CxParamType.SCAN_TYPES, "sast");
        const auth = new CxWrapper(cxScanConfig);
        const cxCommandOutput: CxCommandOutput = await auth.scanCreate(params);
        const scanObject = cxCommandOutput.payload.pop();
        const scanShowObject = await auth.scanShow(scanObject.id);
        console.log(" Json object from failure case: " + JSON.stringify(scanShowObject));
        expect(scanShowObject.payload.pop().status).toEqual("Failed");
    })

    it('ScanCreate Successful case with Branch', async () => {
        const params = new Map();
        params.set(CxParamType.PROJECT_NAME, "ast-cli-javascript-integration-success-branch");
        params.set(CxParamType.S, "./src");
        params.set(CxParamType.FILTER, "*.ts,!**/node_modules/**/*");
        params.set(CxParamType.BRANCH, "master");
        params.set(CxParamType.ADDITIONAL_PARAMETERS, "--scan-types sast");
        const auth = new CxWrapper(cxScanConfig);
        const cxCommandOutput: CxCommandOutput = await auth.scanCreate(params);
        const scanObject = cxCommandOutput.payload.pop();
        const scanShowObject = await auth.scanShow(scanObject.id);
        console.log(" Json object from successful wait mode case with branch: " + JSON.stringify(scanShowObject));
        expect(scanShowObject.payload.pop().status).toEqual("Completed");

    })

    it('ScanCreate Successful case no wait mode', async () => {
        const params = new Map();
        params.set(CxParamType.PROJECT_NAME, "ast-cli-javascript-integration-nowait");
        params.set(CxParamType.S, "./src");
        params.set(CxParamType.SAST_PRESET_NAME, "Checkmarx Default Fake");
        params.set(CxParamType.ADDITIONAL_PARAMETERS, "--async");
        params.set(CxParamType.BRANCH, "master");
        const auth = new CxWrapper(cxScanConfig);
        const cxCommandOutput: CxCommandOutput = await auth.scanCreate(params);
        const scanObject = cxCommandOutput.payload.pop();
        const scanShowObject = await auth.scanShow(scanObject.id);
        console.log(" Json object from successful no wait mode case: " + JSON.stringify(scanShowObject));
        expect(scanShowObject.payload.pop().status).toEqual("Running");
    })

    it('ScanCancel Successful case', async () => {
        const params = new Map();
        params.set(CxParamType.PROJECT_NAME, "ast-cli-javascript-integration-cancel");
        params.set(CxParamType.S, "./src");
        params.set(CxParamType.BRANCH, "master");
        params.set(CxParamType.FILTER, "*.ts,!**/node_modules/**/*");
        params.set(CxParamType.ADDITIONAL_PARAMETERS, "--async");
        const auth = new CxWrapper(cxScanConfig);
        const cxCommandOutput: CxCommandOutput = await auth.scanCreate(params);
        const scanObject = cxCommandOutput.payload.pop();
        await auth.scanCancel(scanObject.id)
        const scanShowObject = await auth.scanShow(scanObject.id);
        expect(scanShowObject.exitCode).toEqual(0);
    })

    it('KicsRealtime Successful case ', async () => {
        const auth = new CxWrapper(cxScanConfig);
        const [outputProcess,pid] = await auth.kicsRealtimeScan("dist/tests/data/Dockerfile","docker","-v");
        const cxCommandOutput: CxCommandOutput = await outputProcess;
        console.log(" Json object from successful no wait mode case: " + JSON.stringify( cxCommandOutput.payload));
        const scanObject = cxCommandOutput.payload.pop();
        console.log(" Json object from successful no wait mode case: " + JSON.stringify(scanObject));
        expect(scanObject.results.length).toBeGreaterThan(0);
        expect(pid).toBeDefined();
    })

    it('ScaRealtime Successful case', async () => {
        const wrapper = new CxWrapper(cxScanConfig);
        const cxCommandOutput: CxCommandOutput = await wrapper.runScaRealtimeScan(process.cwd());
        if(cxCommandOutput.exitCode == 1) {
            expect(cxCommandOutput.payload).toBeUndefined();
        } else {
            const scanObject = cxCommandOutput.payload.pop();
            expect(scanObject.results).toBeDefined();
        }
    })

    it("Should check if scan create is possible", async() => {
        const cxScanConfig = new BaseTest();
        const auth = new CxWrapper(cxScanConfig);
        const tenantSettings: boolean = await auth.ideScansEnabled();
        expect(tenantSettings).toBeDefined();
    })

    it("Should check if AI guided remediation is active", async() => {
        const cxScanConfig = new BaseTest();
        const auth = new CxWrapper(cxScanConfig);
        const aiEnabled: boolean = await auth.guidedRemediationEnabled();
        expect(aiEnabled).toBeDefined();
    })

    it("Should check if AI MCP server is active", async () => {
    const cxScanConfig = new BaseTest();
    const auth = new CxWrapper(cxScanConfig);
    const aiMcpEnabled: boolean = await auth.aiMcpServerEnabled();
    expect(typeof aiMcpEnabled).toBe("boolean");
});

    it('ScanAsca fail case Without extensions', async () => {
        const auth = new CxWrapper(cxScanConfig);
        const cxCommandOutput: CxCommandOutput = await auth.scanAsca("tsc/tests/data/python-file");
        console.log(" Json object from failure case: " + JSON.stringify(cxCommandOutput));

        expect(cxCommandOutput.payload[0].error.description).toEqual("The file name must have an extension.");
        expect(cxCommandOutput.exitCode).toBe(0);
        expect(cxCommandOutput.payload[0].status).toBeUndefined();
    });

    it('ScanAsca Successful case', async () => {
        const auth = new CxWrapper(cxScanConfig);
        const cxCommandOutput: CxCommandOutput = await auth.scanAsca("tsc/tests/data/python-vul-file.py");
        console.log("Json object from scanAsca successful case: " + JSON.stringify(cxCommandOutput));
        const scanObject = cxCommandOutput.payload.pop();
        expect(cxCommandOutput.payload).toBeDefined();
        expect(cxCommandOutput.exitCode).toBe(0);
        expect(scanObject.status).toEqual(true);
    });

    it('ScanAsca with complex name Successful case', async () => {
        const auth = new CxWrapper(cxScanConfig);
        const cxCommandOutput: CxCommandOutput = await auth.scanAsca("tsc/tests/data/var express = require('express';.js");
        console.log("Json object from scanAsca successful case: " + JSON.stringify(cxCommandOutput));
        const scanObject = cxCommandOutput.payload.pop();
        expect(cxCommandOutput.payload).toBeDefined();
        expect(cxCommandOutput.exitCode).toBe(0);
        expect(scanObject.status).toEqual(true);
    });

    it('ScanAsca Successful case with update version', async () => {
        const auth = new CxWrapper(cxScanConfig);
        const cxCommandOutput: CxCommandOutput = await auth.scanAsca("tsc/tests/data/python-vul-file.py", true);
        console.log("Json object from scanAsca successful case with update version: " + JSON.stringify(cxCommandOutput));
        const scanObject = cxCommandOutput.payload.pop();
        expect(cxCommandOutput.payload).toBeDefined();
        expect(cxCommandOutput.exitCode).toBe(0);
        expect(scanObject.status).toEqual(true);
        expect(Number.isInteger(scanObject.scanDetails[0].line)).toBe(true);
        expect(typeof scanObject.scanDetails[0].description).toBe('string');
    });

    it('ScanOss Successful case', async () => {
        const wrapper = new CxWrapper(cxScanConfig);
        const cxCommandOutput: CxCommandOutput = await wrapper.ossScanResults("tsc/tests/data/package.json","");
        console.log("Json object from scanOSS successful case: " + JSON.stringify(cxCommandOutput));
        expect(cxCommandOutput.payload).toBeDefined();
        expect(cxCommandOutput.exitCode).toBe(0);
    });

    it('ScanOss with ignored package should filter results', async () => {
    const wrapper = new CxWrapper(cxScanConfig);
    const sourceFile = "tsc/tests/data/package.json";
    const ignoredFile = "tsc/tests/data/checkmarxIgnoredTempFile.json";

    const cxCommandOutput: CxCommandOutput = await wrapper.ossScanResults(sourceFile, ignoredFile);

    expect(cxCommandOutput.exitCode).toBe(0);
    expect(cxCommandOutput.payload).toBeDefined();

    const results = cxCommandOutput.payload as OssPackage[];

    console.log("Filtered OSS packages:", results);

    expect(results.length).toBe(1);

    const hasCOA = results.some(pkg =>
        pkg.PackageManager === "coa" && pkg.PackageVersion === "3.1.3"
    );
    expect(hasCOA).toBe(false);
});

    it('ScanSecrets Successful case', async () => {
        const wrapper = new CxWrapper(cxScanConfig);
        const cxCommandOutput: CxCommandOutput = await wrapper.secretsScanResults("src/tests/data/secret-exposed.txt","");
        console.log("Json object from scanOSS successful case: " + JSON.stringify(cxCommandOutput));
        expect(cxCommandOutput.payload).toBeDefined();
        expect(cxCommandOutput.exitCode).toBe(0);
    });

    it('ScanSecrets with ignore file filters the result', async () => {
    const wrapper = new CxWrapper(cxScanConfig);
    const cxCommandOutput: CxCommandOutput = await wrapper.secretsScanResults(
        "src/tests/data/secret-exposed.txt",
        "src/tests/data/ignoreFileSecrets.json"
    );

    console.log("Json object from scanSecrets with ignore file: " + JSON.stringify(cxCommandOutput));
    expect(cxCommandOutput.payload).toBeDefined();
    expect(Array.isArray(cxCommandOutput.payload)).toBe(true);
    expect(cxCommandOutput.payload.pop().length).toBe(0);
    expect(cxCommandOutput.exitCode).toBe(0);
});

    it('ScanContainersRealtime Successful case', async () => {
        const wrapper = new CxWrapper(cxScanConfig);
        const cxCommandOutput: CxCommandOutput = await wrapper.containersRealtimeScanResults("src/tests/data/Dockerfile", "");
        console.log("Json object from scanContainersRealtime successful case: " + JSON.stringify(cxCommandOutput));
        expect(cxCommandOutput.payload).toBeDefined();
        expect(cxCommandOutput.exitCode).toBe(0);
    });

    it.skip('ScanIacRealtime Successful case', async () => {
        const wrapper = new CxWrapper(cxScanConfig);
        const cxCommandOutput: CxCommandOutput = await wrapper.iacRealtimeScanResults("src/tests/data/Dockerfile", "docker","");
        console.log("Json object from scanIacRealtime successful case: " + JSON.stringify(cxCommandOutput));
        expect(cxCommandOutput.payload).toBeDefined();
        expect(cxCommandOutput.exitCode).toBe(0);
    });



    it.skip('ScanIacRealtime with ignore file should filter results', async () => {
    const wrapper = new CxWrapper(cxScanConfig);
    const sourceFile = "src/tests/data/Dockerfile";
    const ignoredFile = "src/tests/data/ignoredIacContainersAsca";

    const cxCommandOutput: CxCommandOutput = await wrapper.iacRealtimeScanResults(sourceFile, "docker", ignoredFile);

    expect(cxCommandOutput.exitCode).toBe(0);
    expect(cxCommandOutput.payload).toBeDefined();

    const findings = CxIacResult.parseResult(cxCommandOutput.payload);

    console.log("Filtered IAC findings:", findings);

    expect(findings.length).toBe(3);
});


it.skip('ScanContainersRealtime with ignored image should filter result', async () => {
    const wrapper = new CxWrapper(cxScanConfig);
    const sourceFile = "tsc/tests/data/Dockerfile";
    const ignoredFile = "tsc/tests/data/ignoredIacContainersAsca.json";

    const cxCommandOutput: CxCommandOutput = await wrapper.containersRealtimeScanResults(sourceFile, ignoredFile);

    expect(cxCommandOutput.exitCode).toBe(0);
    expect(cxCommandOutput.payload).toBeDefined();

    const parsedResults = CxContainerRealtimeResult.parseResult(cxCommandOutput.payload[0]);

    console.log("Filtered container results:", parsedResults);

    expect(parsedResults.length).toBe(0);
});

it.skip('ScanAsca with ignore file should filter one result', async () => {
    const wrapper = new CxWrapper(cxScanConfig);

    const sourcePath = "tsc/tests/data/python-vul-file.py";
    const ignoreFile = "tsc/tests/data/ignoredIacContainersAsca.json";

    const cxCommandOutput: CxCommandOutput = await wrapper.scanAsca(
        sourcePath,
        false,
        ignoreFile
    );

    expect(cxCommandOutput.exitCode).toBe(0);
    expect(cxCommandOutput.payload).toBeDefined();

    const parsed = CxAsca.parseScan(cxCommandOutput.payload[0]);
    console.log("Filtered ASCA results:", parsed.scanDetails);

    expect(parsed.status).toBe(true);
    expect(Array.isArray(parsed.scanDetails)).toBe(true);


    expect(parsed.scanDetails.length).toBe(5);
});



});