@lcap/nasl-parser/tests/unambiguous-grammar/ai-test-cst.spec.ts

Take Nasl text to Nasl AST with the help of generalized parsing.

import { Parser, Grammar } from "nearley";
import grammar from "../../ts/nasl";

const testStr1 =`
// 这是一段注释
@(
    title = "标题",
    description = "",
    triggerType = "",
    cron = "",
    overridable = false,
)
logic logic1(list: List<Integer>) => result {
    let userDeptMapList: List<app::dataSources::defaultDS::entities::LCAPUserDeptMapping>;
    result = null;
    if (list.length == 0) {
        result = null;
    } else {
        result = ListSum(list) / list.length;
    }
}
`

const testStr2 =`
// test
@(
    description = "获取所有的角色名称",
    triggerType = "",
    cron = "",
    transactional = false,
)
logic LCAPGetRoleNameList(roleName: String) => result {
    let search;

    if (HasValue(search)) {
        result = ListTransform(search, { item => item.lCAPRole.name });
    } else {
        result = [] : List<Integer>;
    }

    result = ListTransform(result, { item => ToLower(item) });
    if (HasValue(roleName)) {
        if (Contains(result, ToLower(roleName))) {
            Add(result, roleName);
        } else {
        }
    } else {
    }
    ListDistinct(result);
    end;
}
`

const testStr3 =`
namespace app {
    namespace structures {
        struct LCAPGetPermissionResult() { }
    }

    namespace dataSources {
        namespace defaultDS {
            namespace entities {
                entity LCAPPermission() { }
            }
        }
    }
}

using app::structures;
using app::dataSources::defaultDS::entities;

@(
    description = "查询功能权限列表",
    triggerType = "",
    cron = "",
    transactional = false,
)
logic LCAPLoadPermissionManagementTableView(filter: app::dataSources::defaultDS::entities::LCAPPermission, page: Integer, size: Integer) => result {
    let search;
    let perAndRoleMap;
    let permissionList;

    if (HasValue(search)) {
        result = CreateListPage(ListTransform(permissionList.list, { item => app::structures::LCAPGetPermissionResult(
                permission=item.lCAPPermission,
                roleList=ListTransform(MapGet(perAndRoleMap, item.lCAPPermission.name), { item1 => item1.lCAPRole }),
            )}), permissionList.total);
    } else {
        result = CreateListPage([]: List<app::structures::LCAPGetPermissionResult>, search.length);
    };
    end;
}
`

describe('AI test suits', () => {
    test('test 1', async () => {
        const parser = new Parser(Grammar.fromCompiled(grammar));
        parser.feed(testStr1);
        expect(parser.results.length).toBe(1);
    });

    test('test 2: array lit with type syntax', async () => {
        const parser = new Parser(Grammar.fromCompiled(grammar));
        parser.feed(testStr2);
        expect(parser.results.length).toBe(1);
    });

    test('test 3: namespace, struct constructor', async () => {
        const parser = new Parser(Grammar.fromCompiled(grammar));
        parser.feed(testStr3);
        expect(parser.results.length).toBe(1);
    });
});