@lwc/sfdc-compiler-utils 2.19.0

package/src/__tests__/namespace.spec.ts

@@ -0,0 +1,760 @@
+import { getNamespacedIdForResource, getNamespacedIdForType } from '../namespace-utils';
+
+const DEFAULT_NAMESPACE_MAPPING = { c: 'nsC' };
+
+describe('namespace', () => {
+    describe('invalid getNamespacedIdForType invocation', () => {
+        test('should error if "namespaceMapping" is not provided', () => {
+            expect(() => {
+                return getNamespacedIdForType('x/foo', 'module', undefined as any);
+            }).toThrowError(
+                'Failed to apply namespace mapping to "x/foo". Missing required "namespaceMapping" parameter'
+            );
+        });
+
+        test('should error if "moduleName" is not provided', () => {
+            expect(() => {
+                return getNamespacedIdForType(
+                    undefined as any,
+                    'module',
+                    DEFAULT_NAMESPACE_MAPPING
+                );
+            }).toThrowError(
+                'Failed to apply namespace mapping to "undefined". Missing required "moduleName" parameter'
+            );
+        });
+
+        test('should return undefined if resource is missing an "id"', () => {
+            expect(
+                getNamespacedIdForType('apex', 'apex', DEFAULT_NAMESPACE_MAPPING)
+            ).toBeUndefined();
+        });
+    });
+
+    describe('invalid getNamespacedIdForResource invocation', () => {
+        test('should error if "moduleName" is missing', () => {
+            expect(() => {
+                return getNamespacedIdForResource(undefined as any, DEFAULT_NAMESPACE_MAPPING);
+            }).toThrowError(
+                'Failed to apply namespace mapping to "undefined". Missing required "moduleName" parameter'
+            );
+        });
+
+        test('should error if "namespaceMapping" is missing', () => {
+            expect(() => {
+                return getNamespacedIdForResource('c/foo', undefined as any);
+            }).toThrowError(
+                'Failed to apply namespace mapping to "c/foo". Missing required "namespaceMapping" parameter'
+            );
+        });
+
+        test('should return undefined if no namespace mapping was matched', () => {
+            const actual = getNamespacedIdForResource('x/foo', DEFAULT_NAMESPACE_MAPPING);
+            expect(actual).toBeUndefined();
+        });
+
+        test('should return undefined if value contains extra separator', () => {
+            const actual = getNamespacedIdForResource('x//foo', DEFAULT_NAMESPACE_MAPPING);
+            expect(actual).toBeUndefined();
+        });
+
+        test('should return undefined if namespaceMapping does not have "c"', () => {
+            const actual = getNamespacedIdForResource('x/foo', { b: 'nsB' });
+            expect(actual).toBeUndefined();
+        });
+    });
+
+    describe('test noop resources', () => {
+        test('should return undefined when namespace mapping "accessCheck"', () => {
+            const actual = getNamespacedIdForType(
+                '@salesforce/accessCheck',
+                'accessCheck',
+                DEFAULT_NAMESPACE_MAPPING
+            );
+            expect(actual).toBeUndefined();
+        });
+
+        test('should return undefined when namespace mapping "client"', () => {
+            const actual = getNamespacedIdForType(
+                '@salesforce/client',
+                'client',
+                DEFAULT_NAMESPACE_MAPPING
+            );
+            expect(actual).toBeUndefined();
+        });
+
+        test('should return undefined when namespace mapping "commerce"', () => {
+            const actual = getNamespacedIdForType(
+                '@salesforce/commerce/webstoreId',
+                'commerce',
+                DEFAULT_NAMESPACE_MAPPING
+            );
+            expect(actual).toBeUndefined();
+        });
+
+        test('should return undefined when namespace mapping "community"', () => {
+            const actual = getNamespacedIdForType(
+                '@salesforce/community/Id',
+                'community',
+                DEFAULT_NAMESPACE_MAPPING
+            );
+            expect(actual).toBeUndefined();
+        });
+
+        test('should return undefined when namespace mapping "cssvars"', () => {
+            const actual = getNamespacedIdForType(
+                '@salesforce/cssvars/id',
+                'cssvars',
+                DEFAULT_NAMESPACE_MAPPING
+            );
+            expect(actual).toBeUndefined();
+        });
+
+        test('should return undefined when namespace mapping "gate"', () => {
+            const actual = getNamespacedIdForType(
+                '@salesforce/gate/foo.bar',
+                'gate',
+                DEFAULT_NAMESPACE_MAPPING
+            );
+            expect(actual).toBeUndefined();
+        });
+
+        test('should return undefined when namespace mapping "i18n"', () => {
+            const actual = getNamespacedIdForType(
+                '@salesforce/i18n/timezone',
+                'i18n',
+                DEFAULT_NAMESPACE_MAPPING
+            );
+            expect(actual).toBeUndefined();
+        });
+
+        test('should return undefined when namespace mapping "metric"', () => {
+            const actual = getNamespacedIdForType(
+                '@salesforce/metric/foo.bar',
+                'metric',
+                DEFAULT_NAMESPACE_MAPPING
+            );
+            expect(actual).toBeUndefined();
+        });
+
+        test('should return undefined when namespace mapping "internal"', () => {
+            const actual = getNamespacedIdForType(
+                '@salesforce/internal/core.appVersion',
+                'internal',
+                DEFAULT_NAMESPACE_MAPPING
+            );
+            expect(actual).toBeUndefined();
+        });
+
+        test('should return undefined when namespace mapping "site"', () => {
+            const actual = getNamespacedIdForType(
+                '@salesforce/site/Id',
+                'site',
+                DEFAULT_NAMESPACE_MAPPING
+            );
+            expect(actual).toBeUndefined();
+        });
+
+        test('should return undefined when namespace mapping "slds"', () => {
+            const actual = getNamespacedIdForType(
+                '@salesforce/slds/index.css',
+                'slds',
+                DEFAULT_NAMESPACE_MAPPING
+            );
+            expect(actual).toBeUndefined();
+        });
+
+        test('should return undefined when namespace mapping "user"', () => {
+            const actual = getNamespacedIdForType(
+                '@salesforce/user/id',
+                'user',
+                DEFAULT_NAMESPACE_MAPPING
+            );
+            expect(actual).toBeUndefined();
+        });
+
+        test('should return undefined when namespace mapping "userPermission"', () => {
+            const actual = getNamespacedIdForType(
+                '@salesforce/userPermission/perm',
+                'userPermission',
+                DEFAULT_NAMESPACE_MAPPING
+            );
+            expect(actual).toBeUndefined();
+        });
+    });
+
+    describe('namespace resource', () => {
+        test('should return namespacedId for non-salesforce resource', () => {
+            const expected = 'nsC/foo';
+            const actual = getNamespacedIdForType('c/foo', undefined, DEFAULT_NAMESPACE_MAPPING);
+            expect(actual).toBe(expected);
+        });
+
+        test('should return "undefined" when namespace does not fully match "c"', () => {
+            const actual = getNamespacedIdForType('abc-utils', 'module', DEFAULT_NAMESPACE_MAPPING);
+            expect(actual).toBeUndefined();
+        });
+
+        test('should return undefined if namespace match is not at the beginning of the module name', () => {
+            const actual = getNamespacedIdForType(
+                './module/c-inner/property',
+                undefined,
+                DEFAULT_NAMESPACE_MAPPING
+            );
+            expect(actual).toBeUndefined();
+        });
+    });
+
+    describe('namespace label resource', () => {
+        test('should return undefined if type is undefined for salesforce resource', () => {
+            const actual = getNamespacedIdForType('c.foo', undefined, DEFAULT_NAMESPACE_MAPPING);
+            expect(actual).toBeUndefined();
+        });
+
+        test('should return undefined if namespace value is empty', () => {
+            const actual = getNamespacedIdForType('.foo', 'label', DEFAULT_NAMESPACE_MAPPING);
+            expect(actual).toBeUndefined();
+        });
+
+        test('should return undefined if namespace contains extra separator', () => {
+            const actual = getNamespacedIdForType('c..foo', 'label', DEFAULT_NAMESPACE_MAPPING);
+            expect(actual).toBeUndefined();
+        });
+
+        test('should return undefined if resource has namespace but map does not have "c" mapping', () => {
+            const actual = getNamespacedIdForType('c.foo', 'label', { abc: 'nsC' });
+            expect(actual).toBe('c.foo');
+        });
+
+        test('should return existing namespace if default namespace has no mapping', () => {
+            const expected = '@salesforce/label/c.label';
+            const actual = getNamespacedIdForResource('@salesforce/label/c.label', { b: 'nsC' });
+            expect(actual).toBe(expected);
+        });
+
+        test('should replace default namespace', () => {
+            const expected = '@salesforce/label/nsC.label';
+            const actual = getNamespacedIdForResource(
+                '@salesforce/label/c.label',
+                DEFAULT_NAMESPACE_MAPPING
+            );
+            expect(actual).toBe(expected);
+        });
+
+        test('should replace non-default namespace', () => {
+            const expected = '@salesforce/label/nsC.label';
+            const actual = getNamespacedIdForResource('@salesforce/label/custom.label', {
+                custom: 'nsC',
+            });
+            expect(actual).toBe(expected);
+        });
+
+        test('should return namespace if already present', () => {
+            const expected = '@salesforce/label/othernamespace.label';
+            const actual = getNamespacedIdForResource(
+                '@salesforce/label/othernamespace.label',
+                DEFAULT_NAMESPACE_MAPPING
+            );
+            expect(actual).toBe(expected);
+        });
+    });
+
+    describe('namespace resourceUrl resource', () => {
+        test('should add namespace if not present', () => {
+            const expected = '@salesforce/resourceUrl/nsC__resource';
+            const actual = getNamespacedIdForResource(
+                '@salesforce/resourceUrl/resource',
+                DEFAULT_NAMESPACE_MAPPING
+            );
+            expect(actual).toBe(expected);
+        });
+
+        test('should return undefined if namespace value is empty', () => {
+            const actual = getNamespacedIdForResource(
+                '@salesforce/resourceUrl/__resource',
+                DEFAULT_NAMESPACE_MAPPING
+            );
+            expect(actual).toBeUndefined();
+        });
+
+        test('should return undefined if namespace contains extra separator', () => {
+            const actual = getNamespacedIdForResource(
+                '@salesforce/resourceUrl/c____resource',
+                DEFAULT_NAMESPACE_MAPPING
+            );
+            expect(actual).toBeUndefined();
+        });
+
+        test('should replace default namespace', () => {
+            const expected = '@salesforce/resourceUrl/nsC__resource';
+            const actual = getNamespacedIdForResource(
+                '@salesforce/resourceUrl/c__resource',
+                DEFAULT_NAMESPACE_MAPPING
+            );
+            expect(actual).toBe(expected);
+        });
+
+        test('should return existing namespace if default namespace has no mapping', () => {
+            const expected = '@salesforce/resourceUrl/c__resource';
+            const actual = getNamespacedIdForResource('@salesforce/resourceUrl/c__resource', {
+                b: 'nsC',
+            });
+            expect(actual).toBe(expected);
+        });
+
+        test('should replace non-default namespace', () => {
+            const expected = '@salesforce/resourceUrl/nsC__resource';
+            const actual = getNamespacedIdForResource('@salesforce/resourceUrl/abc__resource', {
+                abc: 'nsC',
+            });
+            expect(actual).toBe(expected);
+        });
+
+        test('should return namespace if already present', () => {
+            const expected = '@salesforce/resourceUrl/anotherNs__resource';
+            const actual = getNamespacedIdForResource(
+                '@salesforce/resourceUrl/anotherNs__resource',
+                { c: 'anotherNs' }
+            );
+            expect(actual).toBe(expected);
+        });
+    });
+
+    describe('namespace contentAssetUrl resource', () => {
+        test('should add namespace if not present', () => {
+            const expected = '@salesforce/contentAssetUrl/nsC__asset';
+            const actual = getNamespacedIdForResource(
+                '@salesforce/contentAssetUrl/asset',
+                DEFAULT_NAMESPACE_MAPPING
+            );
+            expect(actual).toBe(expected);
+        });
+
+        test('should return namespace if already present', () => {
+            const expected = '@salesforce/contentAssetUrl/anotherNs__asset';
+            const actual = getNamespacedIdForResource(
+                '@salesforce/contentAssetUrl/anotherNs__asset',
+                { c: 'anotherNs' }
+            );
+            expect(actual).toBe(expected);
+        });
+    });
+
+    describe('namespaced messageChannel resource', () => {
+        test('should return undefined if a non-custom (no __c) messageChannel is missing a namespace', () => {
+            const actual = getNamespacedIdForResource(
+                '@salesforce/messageChannel/message',
+                DEFAULT_NAMESPACE_MAPPING
+            );
+            expect(actual).toBe(undefined);
+        });
+
+        test('should return namespace when present for non-custom (no __c) messageChannels', () => {
+            const expected = '@salesforce/messageChannel/anotherNs__message';
+            const actual = getNamespacedIdForResource(
+                '@salesforce/messageChannel/anotherNs__message',
+                { c: 'anotherNs' }
+            );
+            expect(actual).toBe(expected);
+        });
+
+        test('should add namespace for custom message (__c) types if no namespace present', () => {
+            const expected = '@salesforce/messageChannel/nsC__message__c';
+            const actual = getNamespacedIdForResource(
+                '@salesforce/messageChannel/message__c',
+                DEFAULT_NAMESPACE_MAPPING
+            );
+            expect(actual).toBe(expected);
+        });
+
+        test('should return namespace when present for custom (__c) messageChannels', () => {
+            const expected = '@salesforce/messageChannel/anotherNs__message__c';
+            const actual = getNamespacedIdForResource(
+                '@salesforce/messageChannel/anotherNs__message__c',
+                { c: 'anotherNs' }
+            );
+            expect(actual).toBe(expected);
+        });
+    });
+
+    describe('namespace customPermission resource', () => {
+        test('should add namespace if not present', () => {
+            const expected = '@salesforce/customPermission/nsC__perm';
+            const actual = getNamespacedIdForResource(
+                '@salesforce/customPermission/perm',
+                DEFAULT_NAMESPACE_MAPPING
+            );
+            expect(actual).toBe(expected);
+        });
+
+        test('should return namespace if already present', () => {
+            const expected = '@salesforce/customPermission/anotherNs__perm';
+            const actual = getNamespacedIdForResource(
+                '@salesforce/customPermission/anotherNs__perm',
+                { c: 'anotherNs' }
+            );
+            expect(actual).toBe(expected);
+        });
+    });
+
+    describe('namespace komaci resource', () => {
+        test('should add namespace if not present', () => {
+            const expected = '@salesforce/komaci/nsC__resource';
+            const actual = getNamespacedIdForResource(
+                '@salesforce/komaci/resource',
+                DEFAULT_NAMESPACE_MAPPING
+            );
+            expect(actual).toBe(expected);
+        });
+
+        test('should return namespace if already present', () => {
+            const expected = '@salesforce/komaci/anotherNs__resource';
+            const actual = getNamespacedIdForResource('@salesforce/komaci/anotherNs__resource', {
+                c: 'anotherNs',
+            });
+            expect(actual).toBe(expected);
+        });
+    });
+
+    describe('namespace apex resource', () => {
+        test('should return undefined if the namespace map is missing the default namespace', () => {
+            const actual = getNamespacedIdForResource('@salesforce/apex/MyClass.methodA', {
+                b: 'bNs',
+            });
+            expect(actual).toBeUndefined();
+        });
+
+        test('should return undefined if namespace value is empty', () => {
+            const actual = getNamespacedIdForResource('@salesforce/apex/.methodA', { b: 'bNs' });
+            expect(actual).toBeUndefined();
+        });
+
+        test('should return undefined if namespace contains extra separator', () => {
+            const actual = getNamespacedIdForResource('@salesforce/apex/MyClass..methodA', {
+                b: 'bNs',
+            });
+            expect(actual).toBeUndefined();
+        });
+
+        test('should return undefined if apex resource does not have a method', () => {
+            expect(
+                getNamespacedIdForResource('@salesforce/apex/MyClass', { c: 'bNs' })
+            ).toBeUndefined();
+        });
+
+        test('should add namespace if not present', () => {
+            const expected = '@salesforce/apex/nsC.MyClass.methodA';
+            const actual = getNamespacedIdForResource(
+                '@salesforce/apex/MyClass.methodA',
+                DEFAULT_NAMESPACE_MAPPING
+            );
+            expect(actual).toBe(expected);
+        });
+
+        test('should replace default namespace', () => {
+            const expected = '@salesforce/apex/nsC.MyClass.methodA';
+            const actual = getNamespacedIdForResource(
+                '@salesforce/apex/c.MyClass.methodA',
+                DEFAULT_NAMESPACE_MAPPING
+            );
+            expect(actual).toBe(expected);
+        });
+
+        test('c with no mapping', () => {
+            const actual = getNamespacedIdForResource('@salesforce/apex/c.MyClass.methodA', {});
+            expect(actual).toBe('@salesforce/apex/c.MyClass.methodA');
+        });
+
+        test('should replace non-default namespace', () => {
+            const expected = '@salesforce/apex/nsC.MyClass.methodA';
+            const actual = getNamespacedIdForResource('@salesforce/apex/abc.MyClass.methodA', {
+                abc: 'nsC',
+            });
+            expect(actual).toBe(expected);
+        });
+
+        test('should return namespace if already present', () => {
+            const expected = '@salesforce/apex/anotherNamespace.MyClass.methodA';
+            const actual = getNamespacedIdForResource(
+                '@salesforce/apex/anotherNamespace.MyClass.methodA',
+                { c: 'anotherNamespace' }
+            );
+            expect(actual).toBe(expected);
+        });
+
+        test('should return namespace if already present in resource and map', () => {
+            const expected = '@salesforce/apex/anotherNamespace.MyClass.methodA';
+            const actual = getNamespacedIdForResource(
+                '@salesforce/apex/anotherNamespace.MyClass.methodA',
+                { anotherNamespace: 'anotherNamespace' }
+            );
+            expect(actual).toBe(expected);
+        });
+
+        test('should return namespace if already present and map contains default mapping', () => {
+            const expected = '@salesforce/apex/anotherNamespace.MyClass.methodA';
+            const actual = getNamespacedIdForResource(
+                '@salesforce/apex/anotherNamespace.MyClass.methodA',
+                DEFAULT_NAMESPACE_MAPPING
+            );
+            expect(actual).toBe(expected);
+        });
+
+        test('should return undefined when provided empty namespace mapping', () => {
+            const actual = getNamespacedIdForResource('@salesforce/apex/MyClass.methodA', {});
+            expect(actual).toBeUndefined();
+        });
+    });
+
+    describe('namespace apexContinuation resource', () => {
+        test('should return undefined if the namespace map is missing the default namespace', () => {
+            const actual = getNamespacedIdForResource(
+                '@salesforce/apexContinuation/MyClass.methodA',
+                { b: 'bNs' }
+            );
+            expect(actual).toBeUndefined();
+        });
+
+        test('should return undefined if namespace value is empty', () => {
+            const actual = getNamespacedIdForResource('@salesforce/apexContinuation/.methodA', {
+                b: 'bNs',
+            });
+            expect(actual).toBeUndefined();
+        });
+
+        test('should return undefined if namespace contains extra separator', () => {
+            const actual = getNamespacedIdForResource(
+                '@salesforce/apexContinuation/MyClass..methodA',
+                { b: 'bNs' }
+            );
+            expect(actual).toBeUndefined();
+        });
+
+        test('should return undefined if apex resource does not have a method', () => {
+            expect(
+                getNamespacedIdForResource('@salesforce/apexContinuation/MyClass', { c: 'bNs' })
+            ).toBeUndefined();
+        });
+
+        test('should add namespace if not present', () => {
+            const expected = '@salesforce/apexContinuation/nsC.MyClass.methodA';
+            const actual = getNamespacedIdForResource(
+                '@salesforce/apexContinuation/MyClass.methodA',
+                DEFAULT_NAMESPACE_MAPPING
+            );
+            expect(actual).toBe(expected);
+        });
+
+        test('should replace default namespace', () => {
+            const expected = '@salesforce/apexContinuation/nsC.MyClass.methodA';
+            const actual = getNamespacedIdForResource(
+                '@salesforce/apexContinuation/c.MyClass.methodA',
+                DEFAULT_NAMESPACE_MAPPING
+            );
+            expect(actual).toBe(expected);
+        });
+
+        test('c with no mapping', () => {
+            const actual = getNamespacedIdForResource(
+                '@salesforce/apexContinuation/c.MyClass.methodA',
+                {}
+            );
+            expect(actual).toBe('@salesforce/apexContinuation/c.MyClass.methodA');
+        });
+
+        test('should replace non-default namespace', () => {
+            const expected = '@salesforce/apexContinuation/nsC.MyClass.methodA';
+            const actual = getNamespacedIdForResource(
+                '@salesforce/apexContinuation/abc.MyClass.methodA',
+                { abc: 'nsC' }
+            );
+            expect(actual).toBe(expected);
+        });
+
+        test('should return namespace if already present', () => {
+            const expected = '@salesforce/apexContinuation/anotherNamespace.MyClass.methodA';
+            const actual = getNamespacedIdForResource(
+                '@salesforce/apexContinuation/anotherNamespace.MyClass.methodA',
+                { c: 'anotherNamespace' }
+            );
+            expect(actual).toBe(expected);
+        });
+
+        test('should return namespace if already present in resource and map', () => {
+            const expected = '@salesforce/apexContinuation/anotherNamespace.MyClass.methodA';
+            const actual = getNamespacedIdForResource(
+                '@salesforce/apexContinuation/anotherNamespace.MyClass.methodA',
+                { anotherNamespace: 'anotherNamespace' }
+            );
+            expect(actual).toBe(expected);
+        });
+
+        test('should return namespace if already present and map contains default mapping', () => {
+            const expected = '@salesforce/apexContinuation/anotherNamespace.MyClass.methodA';
+            const actual = getNamespacedIdForResource(
+                '@salesforce/apexContinuation/anotherNamespace.MyClass.methodA',
+                DEFAULT_NAMESPACE_MAPPING
+            );
+            expect(actual).toBe(expected);
+        });
+
+        test('should return undefined when provided empty namespace mapping', () => {
+            const actual = getNamespacedIdForResource(
+                '@salesforce/apexContinuation/MyClass.methodA',
+                {}
+            );
+            expect(actual).toBeUndefined();
+        });
+    });
+
+    describe('namespace schema resource', () => {
+        test('should add namespace if not present', () => {
+            const expected = '@salesforce/schema/nsC__CustomObject__c';
+            const actual = getNamespacedIdForResource(
+                '@salesforce/schema/CustomObject__c',
+                DEFAULT_NAMESPACE_MAPPING
+            );
+            expect(actual).toBe(expected);
+        });
+
+        test('should return undefined if namespace value is empty', () => {
+            const actual = getNamespacedIdForResource(
+                '@salesforce/schema/__CustomObject__c',
+                DEFAULT_NAMESPACE_MAPPING
+            );
+            expect(actual).toBeUndefined();
+        });
+
+        test('should return undefined if namespace contains extra separator', () => {
+            const actual = getNamespacedIdForResource(
+                '@salesforce/schema/c____CustomObject__c',
+                DEFAULT_NAMESPACE_MAPPING
+            );
+            expect(actual).toBeUndefined();
+        });
+
+        test('should add namespace on custom fields on standard objects', () => {
+            const expected = '@salesforce/schema/Account.nsC__CustomField__c';
+            const actual = getNamespacedIdForResource(
+                '@salesforce/schema/Account.CustomField__c',
+                DEFAULT_NAMESPACE_MAPPING
+            );
+            expect(actual).toBe(expected);
+        });
+
+        test('should add namespace on custom relationships on standard object', () => {
+            const expected = '@salesforce/schema/Account.nsC__Relation__r.Name';
+            const actual = getNamespacedIdForResource(
+                '@salesforce/schema/Account.Relation__r.Name',
+                DEFAULT_NAMESPACE_MAPPING
+            );
+            expect(actual).toBe(expected);
+        });
+
+        test('should ignore standard object and relationships', () => {
+            const expected = '@salesforce/schema/Contact.Account.Name';
+            const actual = getNamespacedIdForResource(
+                '@salesforce/schema/Contact.Account.Name',
+                DEFAULT_NAMESPACE_MAPPING
+            );
+            expect(actual).toBe(expected);
+        });
+
+        test('should handle mixed standard and custom relationships', () => {
+            const expected =
+                '@salesforce/schema/nsC__CustomObject__c.nsC__parentContact__r.Account.Name';
+            const actual = getNamespacedIdForResource(
+                '@salesforce/schema/CustomObject__c.parentContact__r.Account.Name',
+                DEFAULT_NAMESPACE_MAPPING
+            );
+            expect(actual).toBe(expected);
+        });
+
+        test('should not add a namespace to a custom object with an existing namespace', () => {
+            const expected = '@salesforce/schema/ns__CustomObject__c';
+            const actual = getNamespacedIdForResource(
+                '@salesforce/schema/ns__CustomObject__c',
+                DEFAULT_NAMESPACE_MAPPING
+            );
+            expect(actual).toBe(expected);
+        });
+
+        test('should replace namespace in a custom object with non-default namespace', () => {
+            const expected = '@salesforce/schema/nsC__CustomObject__c';
+            const actual = getNamespacedIdForResource('@salesforce/schema/ns__CustomObject__c', {
+                ns: 'nsC',
+            });
+            expect(actual).toBe(expected);
+        });
+
+        test('should not add a namespace to a custom field with an existing namespace', () => {
+            const expected = '@salesforce/schema/Account.ns__CustomField__c';
+            const actual = getNamespacedIdForResource(
+                '@salesforce/schema/Account.ns__CustomField__c',
+                DEFAULT_NAMESPACE_MAPPING
+            );
+            expect(actual).toBe(expected);
+        });
+
+        test('should replace namespace in a custom field with a non-default namespace', () => {
+            const expected = '@salesforce/schema/Account.nsC__CustomField__c';
+            const actual = getNamespacedIdForResource(
+                '@salesforce/schema/Account.ns__CustomField__c',
+                { ns: 'nsC' }
+            );
+            expect(actual).toBe(expected);
+        });
+
+        test('should not add a namespace to a custom relationship with an existing namespace', () => {
+            const expected = '@salesforce/schema/Account.ns__Relation__r.Name';
+            const actual = getNamespacedIdForResource(
+                '@salesforce/schema/Account.ns__Relation__r.Name',
+                DEFAULT_NAMESPACE_MAPPING
+            );
+            expect(actual).toBe(expected);
+        });
+
+        test('should replace namespace om a custom relationship with a non-default namespace', () => {
+            const expected = '@salesforce/schema/Account.nsC__Relation__r.Name';
+            const actual = getNamespacedIdForResource(
+                '@salesforce/schema/Account.ns__Relation__r.Name',
+                { ns: 'nsC' }
+            );
+            expect(actual).toBe(expected);
+        });
+
+        test('should return undefined if specified map is empty for one custom object', () => {
+            const actual = getNamespacedIdForResource('@salesforce/schema/Order_Item__c', {});
+            expect(actual).toBeUndefined();
+        });
+
+        test('should return undefined if specified map is empty for one custom object', () => {
+            const actual = getNamespacedIdForResource('@salesforce/schema/Order_Item__c', {});
+            expect(actual).toBeUndefined();
+        });
+
+        test('should return undefined if specified map is empty for two custom objects', () => {
+            const actual = getNamespacedIdForResource('@salesforce/schema/Product__c.MSRP__c', {});
+            expect(actual).toBeUndefined();
+        });
+
+        test('should return undefined if specified map is empty for two custom objects', () => {
+            expect(() => {
+                getNamespacedIdForResource(
+                    '@salesforce/schema/Product__c.MSRP__c',
+                    undefined as any
+                );
+            }).toThrow(
+                'Failed to apply namespace mapping to "@salesforce/schema/Product__c.MSRP__c".' +
+                    ' Missing required "namespaceMapping" parameter'
+            );
+        });
+
+        test('should return undefined if namespace map does not contain the match for two custom objects', () => {
+            const actual = getNamespacedIdForResource('@salesforce/schema/Product__c.MSRP__c', {
+                abd: 'nsC',
+            });
+            expect(actual).toBeUndefined();
+        });
+    });
+});