@aws-mdaa/dataops-job-l3-construct 1.5.0 → 1.6.0

package/node_modules/@aws-mdaa/config/test/config-nt.test.js

@@ -0,0 +1,129 @@
+"use strict";
+/*!
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const aws_cdk_lib_1 = require("aws-cdk-lib");
+const lib_1 = require("../lib");
+/**
+ * These tests cover all logic not directly related to the Transformers
+ */
+jest.mock('aws-cdk-lib', () => ({
+    CfnParameter: jest.fn().mockImplementation(() => ({
+        valueAsString: 'string-value',
+        valueAsNumber: 123,
+        valueAsList: ['item1', 'item2'],
+    })),
+    Stack: {
+        of: jest.fn().mockReturnValue({
+            partition: 'aws',
+            region: 'us-east-1',
+            account: '123456789012',
+        }),
+    },
+}));
+describe('Test createParamUsingTypeLabels', () => {
+    class TestConfigTransformer extends lib_1.MdaaConfigParamRefValueTransformer {
+        constructor(props) {
+            props =
+                props ||
+                    {
+                        scope: {
+                            node: {},
+                        },
+                    };
+            super(props);
+            this.scope = props.scope;
+        }
+        testCreateParamUsingTypeLabels(paramBase, paramName, paramProps) {
+            return this.createParamUsingTypeLabels(paramBase, paramName, paramProps);
+        }
+    }
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+    test('throws error when scope is not defined', () => {
+        const testClass = new TestConfigTransformer({});
+        // Act & Assert
+        expect(() => {
+            testClass.testCreateParamUsingTypeLabels('string:test', 'TestParam', {});
+        }).toThrow('Unable to create params outside of a Construct');
+    });
+    test('creates string parameter when paramBase starts with "string:"', () => {
+        // Arrange
+        const paramProps = { default: 'default-value' };
+        const testClass = new TestConfigTransformer();
+        // Act
+        const result = testClass.testCreateParamUsingTypeLabels('string:test', 'TestParam', paramProps);
+        // Assert
+        expect(aws_cdk_lib_1.CfnParameter).toHaveBeenCalledWith(testClass.scope, 'TestParam', { ...paramProps, type: 'String' });
+        expect(result).toBe('string-value');
+    });
+    test('creates number parameter when paramBase starts with "number"', () => {
+        // Arrange
+        const paramProps = { default: 42 };
+        const testClass = new TestConfigTransformer();
+        // Act
+        const result = testClass.testCreateParamUsingTypeLabels('number:test', 'TestParam', paramProps);
+        // Assert
+        expect(aws_cdk_lib_1.CfnParameter).toHaveBeenCalledWith(testClass.scope, 'TestParam', { ...paramProps, type: 'Number' });
+        expect(result).toBe(123);
+    });
+    test('creates list parameter when paramBase starts with "list"', () => {
+        const mockScope = {
+            node: {},
+        };
+        const testClass = new TestConfigTransformer({ scope: mockScope });
+        // Arrange
+        const paramProps = { default: 'item1,item2' };
+        // Act
+        const result = testClass.testCreateParamUsingTypeLabels('list:test', 'TestParam', paramProps);
+        // Assert
+        expect(aws_cdk_lib_1.CfnParameter).toHaveBeenCalledWith(testClass.scope, 'TestParam', {
+            ...paramProps,
+            type: 'CommaDelimitedList',
+        });
+        expect(result).toBe('item1,item2');
+    });
+    test('creates default string parameter when no type prefix is provided', () => {
+        const testClass = new TestConfigTransformer();
+        // Arrange
+        const paramProps = { default: 'default-value' };
+        // Act
+        const result = testClass.testCreateParamUsingTypeLabels('test', 'TestParam', paramProps);
+        // Assert
+        expect(aws_cdk_lib_1.CfnParameter).toHaveBeenCalledWith(testClass.scope, 'TestParam', paramProps);
+        expect(result).toBe('string-value');
+    });
+    test('handles undefined paramProps', () => {
+        const testClass = new TestConfigTransformer();
+        // Act
+        const result = testClass.testCreateParamUsingTypeLabels('string:test', 'TestParam', undefined);
+        // Assert
+        expect(aws_cdk_lib_1.CfnParameter).toHaveBeenCalledWith(testClass.scope, 'TestParam', { type: 'String' });
+        expect(result).toBe('string-value');
+    });
+    test('uses paramProps type when no prefix provided', () => {
+        const testClass = new TestConfigTransformer();
+        // Arrange - paramProps has type, but paramBase has no prefix
+        const paramProps = { type: 'Number', default: 42 };
+        // Act
+        const result = testClass.testCreateParamUsingTypeLabels('test', 'TestParam', paramProps);
+        // Assert - Should use paramProps as-is (including the type)
+        expect(aws_cdk_lib_1.CfnParameter).toHaveBeenCalledWith(testClass.scope, 'TestParam', paramProps);
+        // But returns valueAsString because no prefix means default string behavior
+        expect(result).toBe('string-value');
+    });
+    test('prefix overrides paramProps type', () => {
+        const testClass = new TestConfigTransformer();
+        // Arrange - paramProps has type String, but prefix says number
+        const paramProps = { type: 'String', default: 'will-be-overridden' };
+        // Act
+        const result = testClass.testCreateParamUsingTypeLabels('number:test', 'TestParam', paramProps);
+        // Assert - Prefix wins, type is overridden to Number
+        expect(aws_cdk_lib_1.CfnParameter).toHaveBeenCalledWith(testClass.scope, 'TestParam', { ...paramProps, type: 'Number' });
+        expect(result).toBe(123);
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"config-nt.test.js","sourceRoot":"","sources":["config-nt.test.ts"],"names":[],"mappings":";AAAA;;;GAGG;;AAEH,6CAA8D;AAC9D,gCAAqG;AAGrG;;GAEG;AACH,IAAI,CAAC,IAAI,CAAC,aAAa,EAAE,GAAG,EAAE,CAAC,CAAC;IAC9B,YAAY,EAAE,IAAI,CAAC,EAAE,EAAE,CAAC,kBAAkB,CAAC,GAAG,EAAE,CAAC,CAAC;QAChD,aAAa,EAAE,cAAc;QAC7B,aAAa,EAAE,GAAG;QAClB,WAAW,EAAE,CAAC,OAAO,EAAE,OAAO,CAAC;KAChC,CAAC,CAAC;IACH,KAAK,EAAE;QACL,EAAE,EAAE,IAAI,CAAC,EAAE,EAAE,CAAC,eAAe,CAAC;YAC5B,SAAS,EAAE,KAAK;YAChB,MAAM,EAAE,WAAW;YACnB,OAAO,EAAE,cAAc;SACxB,CAAC;KACH;CACF,CAAC,CAAC,CAAC;AACJ,QAAQ,CAAC,iCAAiC,EAAE,GAAG,EAAE;IAC/C,MAAM,qBAAsB,SAAQ,wCAAkC;QAGpE,YAAY,KAA+C;YACzD,KAAK;gBACH,KAAK;oBACJ;wBACC,KAAK,EAAE;4BACL,IAAI,EAAE,EAAU;yBACJ;qBAC6B,CAAC;YAChD,KAAK,CAAC,KAAK,CAAC,CAAC;YACb,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC,KAAK,CAAC;QAC3B,CAAC;QAEM,8BAA8B,CACnC,SAAiB,EACjB,SAAiB,EACjB,UAAyC;YAEzC,OAAO,IAAI,CAAC,0BAA0B,CAAC,SAAS,EAAE,SAAS,EAAE,UAAU,CAAC,CAAC;QAC3E,CAAC;KACF;IAED,UAAU,CAAC,GAAG,EAAE;QACd,IAAI,CAAC,aAAa,EAAE,CAAC;IACvB,CAAC,CAAC,CAAC;IAEH,IAAI,CAAC,wCAAwC,EAAE,GAAG,EAAE;QAClD,MAAM,SAAS,GAAG,IAAI,qBAAqB,CAAC,EAAwD,CAAC,CAAC;QACtG,eAAe;QACf,MAAM,CAAC,GAAG,EAAE;YACV,SAAS,CAAC,8BAA8B,CAAC,aAAa,EAAE,WAAW,EAAE,EAAE,CAAC,CAAC;QAC3E,CAAC,CAAC,CAAC,OAAO,CAAC,gDAAgD,CAAC,CAAC;IAC/D,CAAC,CAAC,CAAC;IAEH,IAAI,CAAC,+DAA+D,EAAE,GAAG,EAAE;QACzE,UAAU;QACV,MAAM,UAAU,GAAG,EAAE,OAAO,EAAE,eAAe,EAAE,CAAC;QAChD,MAAM,SAAS,GAAG,IAAI,qBAAqB,EAAE,CAAC;QAE9C,MAAM;QACN,MAAM,MAAM,GAAG,SAAS,CAAC,8BAA8B,CAAC,aAAa,EAAE,WAAW,EAAE,UAAU,CAAC,CAAC;QAEhG,SAAS;QACT,MAAM,CAAC,0BAAY,CAAC,CAAC,oBAAoB,CAAC,SAAS,CAAC,KAAK,EAAE,WAAW,EAAE,EAAE,GAAG,UAAU,EAAE,IAAI,EAAE,QAAQ,EAAE,CAAC,CAAC;QAC3G,MAAM,CAAC,MAAM,CAAC,CAAC,IAAI,CAAC,cAAc,CAAC,CAAC;IACtC,CAAC,CAAC,CAAC;IAEH,IAAI,CAAC,8DAA8D,EAAE,GAAG,EAAE;QACxE,UAAU;QACV,MAAM,UAAU,GAAG,EAAE,OAAO,EAAE,EAAE,EAAE,CAAC;QACnC,MAAM,SAAS,GAAG,IAAI,qBAAqB,EAAE,CAAC;QAE9C,MAAM;QACN,MAAM,MAAM,GAAG,SAAS,CAAC,8BAA8B,CAAC,aAAa,EAAE,WAAW,EAAE,UAAU,CAAC,CAAC;QAEhG,SAAS;QACT,MAAM,CAAC,0BAAY,CAAC,CAAC,oBAAoB,CAAC,SAAS,CAAC,KAAK,EAAE,WAAW,EAAE,EAAE,GAAG,UAAU,EAAE,IAAI,EAAE,QAAQ,EAAE,CAAC,CAAC;QAC3G,MAAM,CAAC,MAAM,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;IAC3B,CAAC,CAAC,CAAC;IAEH,IAAI,CAAC,0DAA0D,EAAE,GAAG,EAAE;QACpE,MAAM,SAAS,GAAG;YAChB,IAAI,EAAE,EAAU;SACjB,CAAC;QACF,MAAM,SAAS,GAAG,IAAI,qBAAqB,CAAC,EAAE,KAAK,EAAE,SAAS,EAA6C,CAAC,CAAC;QAE7G,UAAU;QACV,MAAM,UAAU,GAAG,EAAE,OAAO,EAAE,aAAa,EAAE,CAAC;QAE9C,MAAM;QACN,MAAM,MAAM,GAAG,SAAS,CAAC,8BAA8B,CAAC,WAAW,EAAE,WAAW,EAAE,UAAU,CAAC,CAAC;QAE9F,SAAS;QACT,MAAM,CAAC,0BAAY,CAAC,CAAC,oBAAoB,CAAC,SAAS,CAAC,KAAK,EAAE,WAAW,EAAE;YACtE,GAAG,UAAU;YACb,IAAI,EAAE,oBAAoB;SAC3B,CAAC,CAAC;QACH,MAAM,CAAC,MAAM,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC;IACrC,CAAC,CAAC,CAAC;IAEH,IAAI,CAAC,kEAAkE,EAAE,GAAG,EAAE;QAC5E,MAAM,SAAS,GAAG,IAAI,qBAAqB,EAAE,CAAC;QAE9C,UAAU;QACV,MAAM,UAAU,GAAG,EAAE,OAAO,EAAE,eAAe,EAAE,CAAC;QAEhD,MAAM;QACN,MAAM,MAAM,GAAG,SAAS,CAAC,8BAA8B,CAAC,MAAM,EAAE,WAAW,EAAE,UAAU,CAAC,CAAC;QAEzF,SAAS;QACT,MAAM,CAAC,0BAAY,CAAC,CAAC,oBAAoB,CAAC,SAAS,CAAC,KAAK,EAAE,WAAW,EAAE,UAAU,CAAC,CAAC;QACpF,MAAM,CAAC,MAAM,CAAC,CAAC,IAAI,CAAC,cAAc,CAAC,CAAC;IACtC,CAAC,CAAC,CAAC;IAEH,IAAI,CAAC,8BAA8B,EAAE,GAAG,EAAE;QACxC,MAAM,SAAS,GAAG,IAAI,qBAAqB,EAAE,CAAC;QAE9C,MAAM;QACN,MAAM,MAAM,GAAG,SAAS,CAAC,8BAA8B,CAAC,aAAa,EAAE,WAAW,EAAE,SAAS,CAAC,CAAC;QAE/F,SAAS;QACT,MAAM,CAAC,0BAAY,CAAC,CAAC,oBAAoB,CAAC,SAAS,CAAC,KAAK,EAAE,WAAW,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE,CAAC,CAAC;QAC5F,MAAM,CAAC,MAAM,CAAC,CAAC,IAAI,CAAC,cAAc,CAAC,CAAC;IACtC,CAAC,CAAC,CAAC;IAEH,IAAI,CAAC,8CAA8C,EAAE,GAAG,EAAE;QACxD,MAAM,SAAS,GAAG,IAAI,qBAAqB,EAAE,CAAC;QAE9C,6DAA6D;QAC7D,MAAM,UAAU,GAAG,EAAE,IAAI,EAAE,QAAQ,EAAE,OAAO,EAAE,EAAE,EAAE,CAAC;QAEnD,MAAM;QACN,MAAM,MAAM,GAAG,SAAS,CAAC,8BAA8B,CAAC,MAAM,EAAE,WAAW,EAAE,UAAU,CAAC,CAAC;QAEzF,4DAA4D;QAC5D,MAAM,CAAC,0BAAY,CAAC,CAAC,oBAAoB,CAAC,SAAS,CAAC,KAAK,EAAE,WAAW,EAAE,UAAU,CAAC,CAAC;QACpF,4EAA4E;QAC5E,MAAM,CAAC,MAAM,CAAC,CAAC,IAAI,CAAC,cAAc,CAAC,CAAC;IACtC,CAAC,CAAC,CAAC;IAEH,IAAI,CAAC,kCAAkC,EAAE,GAAG,EAAE;QAC5C,MAAM,SAAS,GAAG,IAAI,qBAAqB,EAAE,CAAC;QAE9C,+DAA+D;QAC/D,MAAM,UAAU,GAAG,EAAE,IAAI,EAAE,QAAQ,EAAE,OAAO,EAAE,oBAAoB,EAAE,CAAC;QAErE,MAAM;QACN,MAAM,MAAM,GAAG,SAAS,CAAC,8BAA8B,CAAC,aAAa,EAAE,WAAW,EAAE,UAAU,CAAC,CAAC;QAEhG,qDAAqD;QACrD,MAAM,CAAC,0BAAY,CAAC,CAAC,oBAAoB,CAAC,SAAS,CAAC,KAAK,EAAE,WAAW,EAAE,EAAE,GAAG,UAAU,EAAE,IAAI,EAAE,QAAQ,EAAE,CAAC,CAAC;QAC3G,MAAM,CAAC,MAAM,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;IAC3B,CAAC,CAAC,CAAC;AACL,CAAC,CAAC,CAAC","sourcesContent":["/*!\n * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.\n * SPDX-License-Identifier: Apache-2.0\n */\n\nimport { CfnParameter, CfnParameterProps } from 'aws-cdk-lib';\nimport { MdaaConfigParamRefValueTransformer, MdaaConfigParamRefValueTransformerProps } from '../lib';\nimport { Construct, Node } from 'constructs';\n\n/**\n * These tests cover all logic not directly related to the Transformers\n */\njest.mock('aws-cdk-lib', () => ({\n  CfnParameter: jest.fn().mockImplementation(() => ({\n    valueAsString: 'string-value',\n    valueAsNumber: 123,\n    valueAsList: ['item1', 'item2'],\n  })),\n  Stack: {\n    of: jest.fn().mockReturnValue({\n      partition: 'aws',\n      region: 'us-east-1',\n      account: '123456789012',\n    }),\n  },\n}));\ndescribe('Test createParamUsingTypeLabels', () => {\n  class TestConfigTransformer extends MdaaConfigParamRefValueTransformer {\n    public scope: Construct | undefined;\n\n    constructor(props?: MdaaConfigParamRefValueTransformerProps) {\n      props =\n        props ||\n        ({\n          scope: {\n            node: {} as Node,\n          } as Construct,\n        } as MdaaConfigParamRefValueTransformerProps);\n      super(props);\n      this.scope = props.scope;\n    }\n\n    public testCreateParamUsingTypeLabels(\n      paramBase: string,\n      paramName: string,\n      paramProps: CfnParameterProps | undefined,\n    ) {\n      return this.createParamUsingTypeLabels(paramBase, paramName, paramProps);\n    }\n  }\n\n  beforeEach(() => {\n    jest.clearAllMocks();\n  });\n\n  test('throws error when scope is not defined', () => {\n    const testClass = new TestConfigTransformer({} as unknown as MdaaConfigParamRefValueTransformerProps);\n    // Act & Assert\n    expect(() => {\n      testClass.testCreateParamUsingTypeLabels('string:test', 'TestParam', {});\n    }).toThrow('Unable to create params outside of a Construct');\n  });\n\n  test('creates string parameter when paramBase starts with \"string:\"', () => {\n    // Arrange\n    const paramProps = { default: 'default-value' };\n    const testClass = new TestConfigTransformer();\n\n    // Act\n    const result = testClass.testCreateParamUsingTypeLabels('string:test', 'TestParam', paramProps);\n\n    // Assert\n    expect(CfnParameter).toHaveBeenCalledWith(testClass.scope, 'TestParam', { ...paramProps, type: 'String' });\n    expect(result).toBe('string-value');\n  });\n\n  test('creates number parameter when paramBase starts with \"number\"', () => {\n    // Arrange\n    const paramProps = { default: 42 };\n    const testClass = new TestConfigTransformer();\n\n    // Act\n    const result = testClass.testCreateParamUsingTypeLabels('number:test', 'TestParam', paramProps);\n\n    // Assert\n    expect(CfnParameter).toHaveBeenCalledWith(testClass.scope, 'TestParam', { ...paramProps, type: 'Number' });\n    expect(result).toBe(123);\n  });\n\n  test('creates list parameter when paramBase starts with \"list\"', () => {\n    const mockScope = {\n      node: {} as Node,\n    };\n    const testClass = new TestConfigTransformer({ scope: mockScope } as MdaaConfigParamRefValueTransformerProps);\n\n    // Arrange\n    const paramProps = { default: 'item1,item2' };\n\n    // Act\n    const result = testClass.testCreateParamUsingTypeLabels('list:test', 'TestParam', paramProps);\n\n    // Assert\n    expect(CfnParameter).toHaveBeenCalledWith(testClass.scope, 'TestParam', {\n      ...paramProps,\n      type: 'CommaDelimitedList',\n    });\n    expect(result).toBe('item1,item2');\n  });\n\n  test('creates default string parameter when no type prefix is provided', () => {\n    const testClass = new TestConfigTransformer();\n\n    // Arrange\n    const paramProps = { default: 'default-value' };\n\n    // Act\n    const result = testClass.testCreateParamUsingTypeLabels('test', 'TestParam', paramProps);\n\n    // Assert\n    expect(CfnParameter).toHaveBeenCalledWith(testClass.scope, 'TestParam', paramProps);\n    expect(result).toBe('string-value');\n  });\n\n  test('handles undefined paramProps', () => {\n    const testClass = new TestConfigTransformer();\n\n    // Act\n    const result = testClass.testCreateParamUsingTypeLabels('string:test', 'TestParam', undefined);\n\n    // Assert\n    expect(CfnParameter).toHaveBeenCalledWith(testClass.scope, 'TestParam', { type: 'String' });\n    expect(result).toBe('string-value');\n  });\n\n  test('uses paramProps type when no prefix provided', () => {\n    const testClass = new TestConfigTransformer();\n\n    // Arrange - paramProps has type, but paramBase has no prefix\n    const paramProps = { type: 'Number', default: 42 };\n\n    // Act\n    const result = testClass.testCreateParamUsingTypeLabels('test', 'TestParam', paramProps);\n\n    // Assert - Should use paramProps as-is (including the type)\n    expect(CfnParameter).toHaveBeenCalledWith(testClass.scope, 'TestParam', paramProps);\n    // But returns valueAsString because no prefix means default string behavior\n    expect(result).toBe('string-value');\n  });\n\n  test('prefix overrides paramProps type', () => {\n    const testClass = new TestConfigTransformer();\n\n    // Arrange - paramProps has type String, but prefix says number\n    const paramProps = { type: 'String', default: 'will-be-overridden' };\n\n    // Act\n    const result = testClass.testCreateParamUsingTypeLabels('number:test', 'TestParam', paramProps);\n\n    // Assert - Prefix wins, type is overridden to Number\n    expect(CfnParameter).toHaveBeenCalledWith(testClass.scope, 'TestParam', { ...paramProps, type: 'Number' });\n    expect(result).toBe(123);\n  });\n});\n"]}

package/node_modules/@aws-mdaa/config/test/config-nt.test.ts

@@ -0,0 +1,163 @@
+/*!
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { CfnParameter, CfnParameterProps } from 'aws-cdk-lib';
+import { MdaaConfigParamRefValueTransformer, MdaaConfigParamRefValueTransformerProps } from '../lib';
+import { Construct, Node } from 'constructs';
+
+/**
+ * These tests cover all logic not directly related to the Transformers
+ */
+jest.mock('aws-cdk-lib', () => ({
+  CfnParameter: jest.fn().mockImplementation(() => ({
+    valueAsString: 'string-value',
+    valueAsNumber: 123,
+    valueAsList: ['item1', 'item2'],
+  })),
+  Stack: {
+    of: jest.fn().mockReturnValue({
+      partition: 'aws',
+      region: 'us-east-1',
+      account: '123456789012',
+    }),
+  },
+}));
+describe('Test createParamUsingTypeLabels', () => {
+  class TestConfigTransformer extends MdaaConfigParamRefValueTransformer {
+    public scope: Construct | undefined;
+
+    constructor(props?: MdaaConfigParamRefValueTransformerProps) {
+      props =
+        props ||
+        ({
+          scope: {
+            node: {} as Node,
+          } as Construct,
+        } as MdaaConfigParamRefValueTransformerProps);
+      super(props);
+      this.scope = props.scope;
+    }
+
+    public testCreateParamUsingTypeLabels(
+      paramBase: string,
+      paramName: string,
+      paramProps: CfnParameterProps | undefined,
+    ) {
+      return this.createParamUsingTypeLabels(paramBase, paramName, paramProps);
+    }
+  }
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  test('throws error when scope is not defined', () => {
+    const testClass = new TestConfigTransformer({} as unknown as MdaaConfigParamRefValueTransformerProps);
+    // Act & Assert
+    expect(() => {
+      testClass.testCreateParamUsingTypeLabels('string:test', 'TestParam', {});
+    }).toThrow('Unable to create params outside of a Construct');
+  });
+
+  test('creates string parameter when paramBase starts with "string:"', () => {
+    // Arrange
+    const paramProps = { default: 'default-value' };
+    const testClass = new TestConfigTransformer();
+
+    // Act
+    const result = testClass.testCreateParamUsingTypeLabels('string:test', 'TestParam', paramProps);
+
+    // Assert
+    expect(CfnParameter).toHaveBeenCalledWith(testClass.scope, 'TestParam', { ...paramProps, type: 'String' });
+    expect(result).toBe('string-value');
+  });
+
+  test('creates number parameter when paramBase starts with "number"', () => {
+    // Arrange
+    const paramProps = { default: 42 };
+    const testClass = new TestConfigTransformer();
+
+    // Act
+    const result = testClass.testCreateParamUsingTypeLabels('number:test', 'TestParam', paramProps);
+
+    // Assert
+    expect(CfnParameter).toHaveBeenCalledWith(testClass.scope, 'TestParam', { ...paramProps, type: 'Number' });
+    expect(result).toBe(123);
+  });
+
+  test('creates list parameter when paramBase starts with "list"', () => {
+    const mockScope = {
+      node: {} as Node,
+    };
+    const testClass = new TestConfigTransformer({ scope: mockScope } as MdaaConfigParamRefValueTransformerProps);
+
+    // Arrange
+    const paramProps = { default: 'item1,item2' };
+
+    // Act
+    const result = testClass.testCreateParamUsingTypeLabels('list:test', 'TestParam', paramProps);
+
+    // Assert
+    expect(CfnParameter).toHaveBeenCalledWith(testClass.scope, 'TestParam', {
+      ...paramProps,
+      type: 'CommaDelimitedList',
+    });
+    expect(result).toBe('item1,item2');
+  });
+
+  test('creates default string parameter when no type prefix is provided', () => {
+    const testClass = new TestConfigTransformer();
+
+    // Arrange
+    const paramProps = { default: 'default-value' };
+
+    // Act
+    const result = testClass.testCreateParamUsingTypeLabels('test', 'TestParam', paramProps);
+
+    // Assert
+    expect(CfnParameter).toHaveBeenCalledWith(testClass.scope, 'TestParam', paramProps);
+    expect(result).toBe('string-value');
+  });
+
+  test('handles undefined paramProps', () => {
+    const testClass = new TestConfigTransformer();
+
+    // Act
+    const result = testClass.testCreateParamUsingTypeLabels('string:test', 'TestParam', undefined);
+
+    // Assert
+    expect(CfnParameter).toHaveBeenCalledWith(testClass.scope, 'TestParam', { type: 'String' });
+    expect(result).toBe('string-value');
+  });
+
+  test('uses paramProps type when no prefix provided', () => {
+    const testClass = new TestConfigTransformer();
+
+    // Arrange - paramProps has type, but paramBase has no prefix
+    const paramProps = { type: 'Number', default: 42 };
+
+    // Act
+    const result = testClass.testCreateParamUsingTypeLabels('test', 'TestParam', paramProps);
+
+    // Assert - Should use paramProps as-is (including the type)
+    expect(CfnParameter).toHaveBeenCalledWith(testClass.scope, 'TestParam', paramProps);
+    // But returns valueAsString because no prefix means default string behavior
+    expect(result).toBe('string-value');
+  });
+
+  test('prefix overrides paramProps type', () => {
+    const testClass = new TestConfigTransformer();
+
+    // Arrange - paramProps has type String, but prefix says number
+    const paramProps = { type: 'String', default: 'will-be-overridden' };
+
+    // Act
+    const result = testClass.testCreateParamUsingTypeLabels('number:test', 'TestParam', paramProps);
+
+    // Assert - Prefix wins, type is overridden to Number
+    expect(CfnParameter).toHaveBeenCalledWith(testClass.scope, 'TestParam', { ...paramProps, type: 'Number' });
+    expect(result).toBe(123);
+  });
+});

package/node_modules/@aws-mdaa/config/test/config.test.d.ts

@@ -0,0 +1,5 @@
+/*!
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+export {};