JavaScript中比较信任策略时忽略Service数组元素顺序的实现

先修正原代码里的变量名错误（trustPolicy应为obtainedPolicy，ExpectedPolicy应为ExpectedTrustPolicy），同时注意iam.getRole返回的结构中，AssumeRolePolicyDocument嵌套在Role对象下。针对Service数组顺序问题，以下是两种可行解决方式：

方案一：排序后进行深度比较 #

将预期和实际的Service数组统一排序，再用deepStrictEqual比较，即可忽略原始顺序：

const compareTrustPolicy = (RoleName) => {
    const ExpectedTrustPolicy = {
        "Version": "2012-10-17",
        "Statement": [
            {
                "Effect": "Allow",
                "Principal": {
                    "Service": ["service1", "service2"]
                },
                "Action": "sts:AssumeRole"
            }
        ]
    };

    return iam.getRole(RoleName).promise()
        .then((roleData) => {
            const obtainedPolicy = JSON.parse(decodeURIComponent(roleData.Role.AssumeRolePolicyDocument));
            
            // 复制数组并排序，避免修改原对象
            const sortedExpectedServices = [...ExpectedTrustPolicy.Statement[0].Principal.Service].sort();
            const sortedObtainedServices = [...obtainedPolicy.Statement[0].Principal.Service].sort();
            
            // 替换原数组为排序后的版本
            ExpectedTrustPolicy.Statement[0].Principal.Service = sortedExpectedServices;
            obtainedPolicy.Statement[0].Principal.Service = sortedObtainedServices;
            
            assert.deepStrictEqual(obtainedPolicy, ExpectedTrustPolicy, '信任策略不匹配');
        });
};

方案二：自定义验证逻辑（不修改原数组） #

如果不想改动原数组顺序，可以单独验证Service数组的元素一致性，同时检查其他固定字段：

const compareTrustPolicy = (RoleName) => {
    const ExpectedTrustPolicy = {
        "Version": "2012-10-17",
        "Statement": [
            {
                "Effect": "Allow",
                "Principal": {
                    "Service": ["service1", "service2"]
                },
                "Action": "sts:AssumeRole"
            }
        ]
    };

    return iam.getRole(RoleName).promise()
        .then((roleData) => {
            const obtainedPolicy = JSON.parse(decodeURIComponent(roleData.Role.AssumeRolePolicyDocument));
            const expectedStmt = ExpectedTrustPolicy.Statement[0];
            const obtainedStmt = obtainedPolicy.Statement[0];

            // 验证基础字段一致性
            assert.strictEqual(obtainedPolicy.Version, ExpectedTrustPolicy.Version, 'Version不匹配');
            assert.strictEqual(obtainedStmt.Effect, expectedStmt.Effect, 'Effect不匹配');
            assert.strictEqual(obtainedStmt.Action, expectedStmt.Action, 'Action不匹配');
            
            // 验证Service数组元素完全一致（忽略顺序）
            const expectedServices = new Set(expectedStmt.Principal.Service);
            const obtainedServices = new Set(obtainedStmt.Principal.Service);
            
            assert.strictEqual(expectedServices.size, obtainedServices.size, 'Service数组长度不一致');
            for (const service of expectedServices) {
                assert.ok(obtainedServices.has(service), `缺失Service: ${service}`);
            }
        });
};

说明 #

• 方案一操作简单，适合结构固定的信任策略验证；
• 方案二更灵活，能精准控制每个字段的校验逻辑，适合复杂结构的场景。

内容的提问来源于stack exchange，提问作者raosa