fix: ensure xsi:type is set for all metadata operations

Codeneos · Codeneos · commit 1a63abbd8b23 · 2023-02-23T11:59:29.000+01:00
diff --git a/packages/salesforce/src/__tests__/metadataApi.test.ts b/packages/salesforce/src/__tests__/metadataApi.test.ts
@@ -0,0 +1,68 @@
+import { wait } from '@vlocode/util';
+import 'jest';
+import { HttpRequestInfo, MetadataApi, SalesforceConnection } from '../connection';
+import { SoapClient } from '../soapClient';
+
+function mockConnection() {
+    const baseUrl = 'https://test.salesforce.com';
+    const apiRequests = new Array<HttpRequestInfo>();
+    const apiResponses: Record<string, any> = { }
+    async function request<T>(info: HttpRequestInfo): Promise<T> {
+        await wait(5);
+        apiRequests.push({...info});
+        return apiResponses[info.url];
+    }
+    const mock = {
+        apiResponses,
+        apiRequests,
+        request,
+        _baseUrl() { return baseUrl },
+        instanceUrl: baseUrl,
+    };
+    return mock as any as (SalesforceConnection & typeof mock);
+}
+
+function mockSoapClient() {
+    const soapRequests = new Array<{method: string, request: any}>();
+    const soapResponses: Record<string, { body: object }> = { }
+    async function request<T>(method: string, request: object, options?: any): Promise<T> {
+        await wait(5);
+        soapRequests.push({ method, request });
+        return (soapResponses[method] ?? ({ body: {} })) as any as T;
+    }
+    const mock = {
+        soapRequests,
+        soapResponses,
+        request
+    };
+    return mock as any as (SoapClient & typeof mock);
+}
+
+describe('MetadataApi', () => {
+    describe('#createMetadata', () => {
+        it('should include type attribute in create calls', async () => {
+            // Arrange
+            const connection = mockConnection();
+            const soap = mockSoapClient();
+            const sut = new MetadataApi(connection);
+            sut['soap'] = soap;
+
+            // Act
+            await sut.create('CustomMetadata', {
+                label: 'test',
+                fullName: 'test',
+                values: [
+                    { field: 'Test', value: 1 }
+                ]
+            });
+
+            // Assert
+            expect(soap.soapRequests[0].method).toBe('createMetadata');
+            expect(soap.soapRequests[0].request.type).toBe('CustomMetadata');
+            expect(soap.soapRequests[0].request.metadata.length).toBe(1);
+            expect(soap.soapRequests[0].request.metadata[0].$['xsi:type']).toBe('CustomMetadata');
+            expect(soap.soapRequests[0].request.metadata[0].label).toBe('test');
+            expect(soap.soapRequests[0].request.metadata[0].fullName).toBe('test');
+        });
+    });
+});
diff --git a/packages/salesforce/src/__tests__/queryParser.test.ts b/packages/salesforce/src/__tests__/queryParser.test.ts
@@ -2,7 +2,7 @@ import 'jest';
 
 import { QueryFormatter, QueryParser } from '../queryParser';
 
-describe('QueryParser2', () => {
+describe('QueryParser', () => {
 
     describe('#parseQueryCondition', () => {
         it('should parse single condition as string', () => {
diff --git a/packages/salesforce/src/connection/metadata/metadataApi.ts b/packages/salesforce/src/connection/metadata/metadataApi.ts
@@ -67,7 +67,7 @@ export class MetadataApi implements DeploymentApi {
     }
 
     private normalizeMetadata(type: string, metadata: SalesforceMetadata | SalesforceMetadata[]): SalesforceMetadata[] {
-        return asArray(metadata).map(md => setObjectProperty(md, '$.xsi:type', type));
+        return asArray(metadata).map(md => setObjectProperty(md, '$.xsi:type', type, { create: true }));
     }
 
     /**
diff --git a/packages/util/src/__tests__/object.test.ts b/packages/util/src/__tests__/object.test.ts
@@ -45,17 +45,20 @@ describe('util', () => {
         it('should set property at path', () => {
             const obj = { foo: { bar: 'test' } };
             const result = setObjectProperty(obj, 'foo.bar', 'set');
-            expect(result).toEqual({ foo: { bar: 'set' } });
+            expect(result).toStrictEqual({ foo: { bar: 'set' } });
+            expect(obj).toStrictEqual({ foo: { bar: 'set' } });
         });
         it('should not set property at path when parent undefined', () => {
             const obj = { foo: { bar: 'test' } };
             const result: any = setObjectProperty(obj, 'foo.bar.foo.bar', 'set');
-            expect(result).toEqual({ foo: { bar: 'test' } });
+            expect(result).toStrictEqual({ foo: { bar: 'test' } });
+            expect(obj).toStrictEqual({ foo: { bar: 'test' } });
         });
-        it('should set property at path when parent undefined and createWhenNotFound is true', () => {
+        it('should set property at path when parent undefined and create is true', () => {
             const obj = { foo: undefined };
-            const result = setObjectProperty(obj, 'foo.bar.baz.bar', 'set', { createWhenNotFound: true });
-            expect(result).toEqual({ foo: { bar: { baz: { bar: 'set' } } } });
+            const result = setObjectProperty(obj, 'foo.bar.baz.bar', 'set', { create: true });
+            expect(result).toStrictEqual({ foo: { bar: { baz: { bar: 'set' } } } });
+            expect(obj).toStrictEqual({ foo: { bar: { baz: { bar: 'set' } } } });
         });
     });
     describe('#getObjectProperty', () => {
diff --git a/packages/util/src/__tests__/string.test.ts b/packages/util/src/__tests__/string.test.ts
@@ -12,8 +12,8 @@ describe('util', () => {
             // eslint-disable-next-line no-template-curly-in-string
             expect(string.formatString('Foo ${bar} foo', { foo: 'foo'})).toEqual('Foo ${bar} foo');
         });
-        it('should replace values not found in context object', () => {
-            expect(string.formatString('Foo {bar}', { bar: 'foo'})).toEqual('Foo foo');
+        it('should replace values found in context object', () => {
+            expect(string.formatString('Foo {bar} test', { bar: 'foo'})).toEqual('Foo foo test');
         });
         it('should replace values found in context array', () => {
             expect(string.formatString('Foo {1}', ['foo', 'bar'])).toEqual('Foo bar');
@@ -24,6 +24,11 @@ describe('util', () => {
         it('should not replace values in nested path not found in context object', () => {
             expect(string.formatString('Foo {bar.foo}',{ bar: { value: 'bar' }})).toEqual('Foo {bar.foo}');
         });
+        it('should replace values found in context object', () => {
+            const value = `/services/data/v{apiVersion}/query?q=select%20NamespacePrefix%20from%20ApexClass%20where%20name%20%3D%20'DRDataPackService'%20limit%201`;
+            const excpected = `/services/data/v47.0/query?q=select%20NamespacePrefix%20from%20ApexClass%20where%20name%20%3D%20'DRDataPackService'%20limit%201`;
+            expect(string.formatString(value, { apiVersion: '47.0'})).toEqual(excpected);
+        });
     });
 
     describe('#evalExpr', () => {
diff --git a/packages/util/src/__tests__/xml.test.ts b/packages/util/src/__tests__/xml.test.ts
@@ -1,6 +1,35 @@
 import { XML } from "../xml";
 
 describe('xml', () => {
+    describe('#stringify', () => {
+        it('should write attributes when set', () => {
+            const xmlStr = '<tag attr="test"><value>foo</value></tag>';
+            expect(XML.stringify({
+                tag: {
+                    $: { attr: 'test' },
+                    value: 'foo'
+                }
+            }, undefined, { headless: true })).toBe(xmlStr);
+        });
+        it('should include namespace prefixes for attributes and tags', () => {
+            const xmlStr = '<tag xsi:attr="test"><ns:value>foo</ns:value></tag>';
+            expect(XML.stringify({
+                tag: {
+                    $: { 'xsi:attr': 'test' },
+                    ['ns:value']: 'foo'
+                }
+            }, undefined, { headless: true })).toBe(xmlStr);
+        });
+        it('should write tag body with attributes', () => {
+            const xmlStr = '<tag attr="test">foo</tag>';
+            expect(XML.stringify({
+                tag: {
+                    $: { attr: 'test' },
+                    '#text': 'foo'
+                }
+            }, undefined, { headless: true })).toBe(xmlStr);
+        });
+    });
     describe('#parse', () => {
         it('should replace tag-value with attribute nil:true by null', () => {
             const xmlStr = `<test><tag nil='true'></tag></test>`;
diff --git a/packages/util/src/object.ts b/packages/util/src/object.ts
@@ -236,11 +236,11 @@ export function getObjectProperty(obj: any, prop: string) {
  * @param obj Object to set the property on
  * @param prop Property path to set
  * @param value Value to set at the specified path
- * @param options.createWhenNotFound Create an object to be able to set the specified property, otherwise does not set the property specified
+ * @param options.create Create an object to be able to set the specified property, otherwise does not set the property specified
  * @returns The original obj with the property path set to the specified value;
  */
-export function setObjectProperty<T extends object>(obj: T, prop: string, value: any, options?: { createWhenNotFound?: boolean }) : T {
-    if (options?.createWhenNotFound) {
+export function setObjectProperty<T extends object>(obj: T, prop: string, value: any, options?: { create?: boolean }) : T {
+    if (options?.create) {
         obj = obj ?? {} as T; // init object with a default when not set
     }
     
@@ -250,7 +250,7 @@ export function setObjectProperty<T extends object>(obj: T, prop: string, value:
     let target = obj;
     for (const p of propPath) {
         if (target[p] === undefined || target === null) {
-            if (!options?.createWhenNotFound) {
+            if (!options?.create) {
                 return obj;
             }
         }

Original file line number	Diff line number	Diff line change
`@@ -67,7 +67,7 @@ export class MetadataApi implements DeploymentApi {`
`67`	`67`	`}`
`68`	`68`
`69`	`69`	`private normalizeMetadata(type: string, metadata: SalesforceMetadata \| SalesforceMetadata[]): SalesforceMetadata[] {`
`70`		`- return asArray(metadata).map(md => setObjectProperty(md, '$.xsi:type', type));`
	`70`	`+ return asArray(metadata).map(md => setObjectProperty(md, '$.xsi:type', type, { create: true }));`
`71`	`71`	`}`
`72`	`72`
`73`	`73`	`/**`