@apistudio/apim-cli/node_modules/@apic/wmgw-smith-inventory/test-with-ruleset.mjs

CLI for API Management Products

import setauthorization_ruleset from './src/resources/spectral-rulesets/setauthorization.ruleset.js';

// Test case with useIncoming as an empty object
const testWithEmptyUseIncoming = {
  apiVersion: "api.ibm.com/v1",
  kind: "SetAuthorization",
  metadata: {
    name: "test-setauthorization",
    version: "1.0.0"
  },
  spec: {
    basic: {
      useIncoming: {}
    }
  }
};

// Test case with static authorization
const testWithStaticAuth = {
  apiVersion: "api.ibm.com/v1",
  kind: "SetAuthorization",
  metadata: {
    name: "test-setauthorization",
    version: "1.0.0"
  },
  spec: {
    basic: {
      static: {
        username: "testuser",
        password: "testpass"
      }
    }
  }
};

// Test case with both (should fail)
const testWithBoth = {
  apiVersion: "api.ibm.com/v1",
  kind: "SetAuthorization",
  metadata: {
    name: "test-setauthorization",
    version: "1.0.0"
  },
  spec: {
    basic: {
      useIncoming: {},
      static: {
        username: "testuser",
        password: "testpass"
      }
    }
  }
};

// Test case with neither (should fail)
const testWithNeither = {
  apiVersion: "api.ibm.com/v1",
  kind: "SetAuthorization",
  metadata: {
    name: "test-setauthorization",
    version: "1.0.0"
  },
  spec: {
    basic: {}
  }
};

// Test case with useIncoming as a boolean (should fail)
const testWithInvalidUseIncoming = {
  apiVersion: "api.ibm.com/v1",
  kind: "SetAuthorization",
  metadata: {
    name: "test-setauthorization",
    version: "1.0.0"
  },
  spec: {
    basic: {
      useIncoming: true
    }
  }
};

// Extract the relevant rules from the ruleset
const relevantRules = {
  // Rule that validates the oneOf constraint for basic auth
  basicOneOfRule: setauthorization_ruleset.rules["spec-basic-oneOf"],
  
  // Rule that validates useIncoming is an object
  useIncomingTypeRule: setauthorization_ruleset.rules["spec-basic-useIncoming-type"],
  
  // Rule that validates useIncoming has no additional properties
  useIncomingNoAdditionalPropsRule: setauthorization_ruleset.rules["spec-basic-useIncoming-no-additional-properties"]
};

console.log("=== Examining SetAuthorization Ruleset ===\n");

// Print the relevant rules
console.log("1. Rule for basic oneOf validation:");
console.log(JSON.stringify(relevantRules.basicOneOfRule, null, 2));
console.log("\n2. Rule for useIncoming type validation:");
console.log(JSON.stringify(relevantRules.useIncomingTypeRule, null, 2));
console.log("\n3. Rule for useIncoming additionalProperties validation:");
console.log(JSON.stringify(relevantRules.useIncomingNoAdditionalPropsRule, null, 2));

// Manually check the test cases against the rules
console.log("\n=== Manual Validation Against Rules ===\n");

function checkBasicOneOf(testCase) {
  const spec = testCase.spec;
  if (!spec || !spec.basic) return false;
  
  const basic = spec.basic;
  const hasUseIncoming = basic.hasOwnProperty('useIncoming');
  const hasStatic = basic.hasOwnProperty('static');
  
  // Check if it matches one of the oneOf schemas
  const matchesUseIncomingSchema = hasUseIncoming && !hasStatic && 
    typeof basic.useIncoming === 'object' && basic.useIncoming !== null;
  
  const matchesStaticSchema = hasStatic && !hasUseIncoming && 
    typeof basic.static === 'object' && basic.static !== null &&
    basic.static.hasOwnProperty('username') && basic.static.hasOwnProperty('password');
  
  return matchesUseIncomingSchema || matchesStaticSchema;
}

function checkUseIncomingType(testCase) {
  const spec = testCase.spec;
  if (!spec || !spec.basic || !spec.basic.hasOwnProperty('useIncoming')) return true;
  
  return typeof spec.basic.useIncoming === 'object' && spec.basic.useIncoming !== null;
}

function runTest(testCase, description) {
  console.log(`Testing: ${description}`);
  
  const passesOneOf = checkBasicOneOf(testCase);
  const passesTypeCheck = checkUseIncomingType(testCase);
  
  console.log(`- OneOf validation: ${passesOneOf ? '✅ Pass' : '❌ Fail'}`);
  console.log(`- Type validation: ${passesTypeCheck ? '✅ Pass' : '❌ Fail'}`);
  console.log("");
}

// Run all tests
runTest(testWithEmptyUseIncoming, "useIncoming as an empty object (should pass both)");
runTest(testWithStaticAuth, "static authorization (should pass both)");
runTest(testWithBoth, "both useIncoming and static (should fail oneOf)");
runTest(testWithNeither, "neither useIncoming nor static (should fail oneOf)");
runTest(testWithInvalidUseIncoming, "useIncoming as a boolean (should fail type check)");

console.log("=== Test Complete ===");

// Made with Bob