fix: set an overridden apiVersion on a created connection (#274)

a connection that is created from a username should use the apiVersion passed rather than the
default

Author: shetzel

src/client/metadataTransfer.ts

@@ -4,7 +4,7 @@
  * Licensed under the BSD 3-Clause license.
  * For full license text, see LICENSE.txt file in the repo root or https://opensource.org/licenses/BSD-3-Clause
  */
-import { AuthInfo, Connection } from '@salesforce/core';
+import { AuthInfo, Connection, Logger } from '@salesforce/core';
 import { EventEmitter } from 'events';
 import { ComponentSet } from '../collections';
 import { MetadataTransferError } from '../errors';
@@ -13,20 +13,25 @@ import { MetadataRequestStatus, RequestStatus, MetadataTransferResult } from './
 export interface MetadataTransferOptions {
   usernameOrConnection: string | Connection;
   components: ComponentSet;
+  apiVersion?: string;
 }
 
 export abstract class MetadataTransfer<
   Status extends MetadataRequestStatus,
   Result extends MetadataTransferResult
 > {
   protected components: ComponentSet;
+  protected logger: Logger;
   private signalCancel = false;
   private event = new EventEmitter();
   private usernameOrConnection: string | Connection;
+  private apiVersion: string;
 
-  constructor({ usernameOrConnection, components }: MetadataTransferOptions) {
+  constructor({ usernameOrConnection, components, apiVersion }: MetadataTransferOptions) {
     this.usernameOrConnection = usernameOrConnection;
     this.components = components;
+    this.apiVersion = apiVersion;
+    this.logger = Logger.childFromRoot(this.constructor.name);
   }
 
   /**
@@ -81,6 +86,10 @@ export abstract class MetadataTransfer<
       this.usernameOrConnection = await Connection.create({
         authInfo: await AuthInfo.create({ username: this.usernameOrConnection }),
       });
+      if (this.apiVersion) {
+        this.usernameOrConnection.setApiVersion(this.apiVersion);
+        this.logger.debug(`Overriding apiVersion to: ${this.apiVersion}`);
+      }
     }
     return this.usernameOrConnection;
   }

src/collections/componentSet.ts

@@ -152,6 +152,7 @@ export class ComponentSet extends LazyCollection<MetadataComponent> {
     const operationOptions = Object.assign({}, options, {
       components: this,
       registry: this.registry,
+      apiVersion: this.apiVersion,
     });
 
     return new MetadataApiDeploy(operationOptions);
@@ -166,6 +167,7 @@ export class ComponentSet extends LazyCollection<MetadataComponent> {
     const operationOptions = Object.assign({}, options, {
       components: this,
       registry: this.registry,
+      apiVersion: this.apiVersion,
     });
 
     return new MetadataApiRetrieve(operationOptions);

test/client/metadataTransfer.test.ts

@@ -96,6 +96,32 @@ describe('MetadataTransfer', () => {
     expect(operation.lifecycle.pre.firstCall.args[0]).to.equal(connection);
   });
 
+  it('should initialize a Connection with overridden apiVersion if a username is given', async () => {
+    class TestTransferConnection extends TestTransfer {
+      protected async pre(): Promise<{ id: string }> {
+        const connection = await this.getConnection();
+        return this.lifecycle.pre(connection);
+      }
+    }
+    const apiVersion = '50.0';
+    const testData = new MockTestOrgData();
+    $$.setConfigStubContents('AuthInfoConfig', { contents: await testData.getConfig() });
+    const authInfo = await AuthInfo.create({ username: 'foo@example.com' });
+    env.stub(AuthInfo, 'create').withArgs({ username: 'foo@example.com' }).resolves(authInfo);
+    env.stub(Connection, 'create').withArgs({ authInfo }).resolves(connection);
+    const setApiVersionSpy = env.spy(Connection.prototype, 'setApiVersion');
+    operation = new TestTransferConnection({
+      components: new ComponentSet(),
+      usernameOrConnection: 'foo@example.com',
+      apiVersion,
+    });
+
+    await operation.start();
+
+    expect(operation.lifecycle.pre.firstCall.args[0]).to.equal(connection);
+    expect(setApiVersionSpy.calledWith(apiVersion)).to.equal(true);
+  });
+
   describe('Polling and Event Listeners', () => {
     let listenerStub: SinonStub;
 

test/collections/componentSet.test.ts

@@ -422,6 +422,24 @@ describe('ComponentSet', () => {
       expect(result).to.deep.equal(expectedOperation);
     });
 
+    it('should properly construct a deploy operation with overridden apiVersion', async () => {
+      const connection = await mockConnection($$);
+      const apiVersion = '50.0';
+      const set = ComponentSet.fromSource('.', { registry: mockRegistry, tree });
+      set.apiVersion = apiVersion;
+      const operationArgs = { components: set, usernameOrConnection: connection, apiVersion };
+      const expectedOperation = new MetadataApiDeploy(operationArgs);
+      const constructorStub = env
+        .stub()
+        .withArgs(operationArgs)
+        .callsFake(() => expectedOperation);
+      Object.setPrototypeOf(MetadataApiDeploy, constructorStub);
+
+      const result = await set.deploy({ usernameOrConnection: connection });
+
+      expect(result).to.deep.equal(expectedOperation);
+    });
+
     it('should throw error if there are no source backed components when deploying', async () => {
       const set = await ComponentSet.fromManifestFile('subset.xml', {
         registry: mockRegistry,
@@ -461,6 +479,32 @@ describe('ComponentSet', () => {
       expect(result).to.deep.equal(expectedOperation);
     });
 
+    it('should properly construct a retrieve operation with overridden apiVersion', async () => {
+      const connection = await mockConnection($$);
+      const apiVersion = '50.0';
+      const set = ComponentSet.fromSource('.', { registry: mockRegistry, tree });
+      set.apiVersion = apiVersion;
+      const operationArgs = {
+        apiVersion,
+        components: set,
+        output: join('test', 'path'),
+        usernameOrConnection: connection,
+      };
+      const expectedOperation = new MetadataApiRetrieve(operationArgs);
+      const constructorStub = env
+        .stub()
+        .withArgs(operationArgs)
+        .callsFake(() => expectedOperation);
+      Object.setPrototypeOf(MetadataApiRetrieve, constructorStub);
+
+      const result = await set.retrieve({
+        output: operationArgs.output,
+        usernameOrConnection: connection,
+      });
+
+      expect(result).to.deep.equal(expectedOperation);
+    });
+
     it('should properly construct a retrieve operation with packageName', async () => {
       const connection = await mockConnection($$);
       const set = new ComponentSet([]);