@apistudio/apim-cli/node_modules/@apic/studio-client-model/src/apic-mode/models/test/apic-assets.model.test.js

CLI for API Management Products

/**
 * Copyright IBM Corp. 2024, 2025
 */

describe('APICAssets', () => {
  it('should define all required asset collections', () => {
    const assets = {
      apis: [],
      api_spec: [],
      policies: [],
      globalPolicies: [],
      scopedPolicies: [],
      policySequences: [],
      tests: [],
      environment: [],
      assertions: [],
      mockResponses: [],
      mockEndpoints: [],
      otherFiles: [],
      packages: [],
      product: [],
      plans: [],
      requestLimits: [],
      mcpTools: [],
      mcpServer: [],
      quota: [],
    };

    // Verify all required properties exist
    expect(assets).toHaveProperty('apis');
    expect(assets).toHaveProperty('api_spec');
    expect(assets).toHaveProperty('policies');
    expect(assets).toHaveProperty('globalPolicies');
    expect(assets).toHaveProperty('scopedPolicies');
    expect(assets).toHaveProperty('policySequences');
    expect(assets).toHaveProperty('tests');
    expect(assets).toHaveProperty('environment');
    expect(assets).toHaveProperty('assertions');
    expect(assets).toHaveProperty('mockResponses');
    expect(assets).toHaveProperty('mockEndpoints');
    expect(assets).toHaveProperty('otherFiles');
    expect(assets).toHaveProperty('packages');
    expect(assets).toHaveProperty('product');
    expect(assets).toHaveProperty('plans');
    expect(assets).toHaveProperty('requestLimits');
    expect(assets).toHaveProperty('mcpTools');
    expect(assets).toHaveProperty('mcpServer');
    expect(assets).toHaveProperty('quota');
  });

  it('should be able to add assets to collections', () => {
    // Create a default APICAssets object
    const assets = {
      apis: [],
      api_spec: [],
      assertions: [],
      globalPolicies: [],
      otherFiles: [],
      policies: [],
      policySequences: [],
      scopedPolicies: [],
      environment: [],
      tests: [],
      mockEndpoints: [],
      mockResponses: [],
      packages: [],
      product: [],
      plans: [],
      requestLimits: [],
      mcpTools: [],
      mcpServer: [],
      quota: [],
    };

    const fileInfo = {
      isModified: false,
      path: '/path/to/file',
      fileUrl: 'https://example.com/file',
      orgId: 'org123',
    };

    const apiAsset = {
      name: 'Test API',
      nameSpace: 'test-namespace',
      version: '1.0.0',
      fileInfo,
      kind: 'api',
    };

    const policyAsset = {
      name: 'Test Policy',
      nameSpace: 'test-namespace',
      version: '1.0.0',
      fileInfo,
      kind: 'policy',
    };

    // Add assets to collections
    assets.apis.push(apiAsset);
    assets.policies.push(policyAsset);

    expect(assets.apis.length).toBe(1);
    expect(assets.apis[0].name).toBe('Test API');
    expect(assets.policies.length).toBe(1);
    expect(assets.policies[0].name).toBe('Test Policy');
  });
});

describe('getNewDefaultAPICAssets', () => {
  it('should return a new APICAssets object with empty arrays', () => {
    // Create a default APICAssets object
    const assets = {
      apis: [],
      api_spec: [],
      assertions: [],
      globalPolicies: [],
      otherFiles: [],
      policies: [],
      policySequences: [],
      scopedPolicies: [],
      environment: [],
      tests: [],
      mockEndpoints: [],
      mockResponses: [],
      packages: [],
      product: [],
      plans: [],
      requestLimits: [],
      mcpTools: [],
      mcpServer: [],
      quota: [],
    };

    // Check that all properties are empty arrays
    expect(assets.apis).toEqual([]);
    expect(assets.api_spec).toEqual([]);
    expect(assets.policies).toEqual([]);
    expect(assets.globalPolicies).toEqual([]);
    expect(assets.scopedPolicies).toEqual([]);
    expect(assets.policySequences).toEqual([]);
    expect(assets.tests).toEqual([]);
    expect(assets.environment).toEqual([]);
    expect(assets.assertions).toEqual([]);
    expect(assets.mockResponses).toEqual([]);
    expect(assets.mockEndpoints).toEqual([]);
    expect(assets.otherFiles).toEqual([]);
    expect(assets.packages).toEqual([]);
    expect(assets.product).toEqual([]);
    expect(assets.plans).toEqual([]);
    expect(assets.requestLimits).toEqual([]);
    expect(assets.mcpTools).toEqual([]);
    expect(assets.mcpServer).toEqual([]);
    expect(assets.quota).toEqual([]);
  });

  it('should return a new instance each time it is called', () => {
    // Create two default APICAssets objects
    const assets1 = {
      apis: [],
      api_spec: [],
      assertions: [],
      globalPolicies: [],
      otherFiles: [],
      policies: [],
      policySequences: [],
      scopedPolicies: [],
      environment: [],
      tests: [],
      mockEndpoints: [],
      mockResponses: [],
      packages: [],
      product: [],
      plans: [],
      requestLimits: [],
      mcpTools: [],
      mcpServer: [],
      quota: [],
    };

    const assets2 = {
      apis: [],
      api_spec: [],
      assertions: [],
      globalPolicies: [],
      otherFiles: [],
      policies: [],
      policySequences: [],
      scopedPolicies: [],
      environment: [],
      tests: [],
      mockEndpoints: [],
      mockResponses: [],
      packages: [],
      product: [],
      plans: [],
      requestLimits: [],
      mcpTools: [],
      mcpServer: [],
      quota: [],
    };

    // Verify they are different instances
    expect(assets1).not.toBe(assets2);

    // Modify one instance and verify the other is not affected
    assets1.apis.push({
      name: 'Test API',
      nameSpace: 'test-namespace',
      version: '1.0.0',
      fileInfo: {
        isModified: false,
        path: '/path/to/file',
        fileUrl: 'https://example.com/file',
        orgId: 'org123',
      },
      kind: 'api',
    });

    expect(assets1.apis.length).toBe(1);
    expect(assets2.apis.length).toBe(0);
  });
});